import tkinter as tk
from tkinter import ttk, messagebox
import json
import xml.etree.ElementTree as ET
import xml.dom.minidom
import re
from collections import OrderedDict
try:
import jsonpath_ng
JSONPATH_AVAILABLE = True
except ImportError:
JSONPATH_AVAILABLE = False
try:
import lxml.etree as lxml_ET
LXML_AVAILABLE = True
except ImportError:
LXML_AVAILABLE = False
class JSONXMLTool:
def __init__(self, parent_app):
self.app = parent_app
self.logger = parent_app.logger if hasattr(parent_app, 'logger') else None
def get_default_settings(self):
"""Return default settings for the JSON/XML tool."""
return {
"operation": "json_to_xml",
"json_indent": 2,
"xml_indent": 2,
"preserve_attributes": True,
"sort_keys": False,
"array_wrapper": "item",
"root_element": "root",
"jsonpath_query": "$",
"xpath_query": "//*"
}
def create_widgets(self, parent, settings):
"""Create the JSON/XML tool interface."""
main_frame = ttk.Frame(parent)
main_frame.pack(fill=tk.BOTH, expand=True, padx=5, pady=5)
# Store reference for font application
self.main_frame = main_frame
# Top row: Operation and Settings side by side
top_row_frame = ttk.Frame(main_frame)
top_row_frame.pack(fill=tk.X, pady=(0, 10))
# Left side - Operation selection
operation_frame = ttk.LabelFrame(top_row_frame, text="Operation")
operation_frame.pack(side=tk.LEFT, fill=tk.BOTH, expand=True, padx=(0, 5))
self.operation_var = tk.StringVar(value=settings.get("operation", "json_to_xml"))
operations = [
("json_to_xml", "JSON to XML"),
("xml_to_json", "XML to JSON"),
("json_prettify", "JSON Prettify"),
("xml_prettify", "XML Prettify"),
("json_validate", "JSON Validate"),
("xml_validate", "XML Validate"),
("json_minify", "JSON Minify"),
("xml_minify", "XML Minify"),
("jsonpath_query", "JSONPath Query"),
("xpath_query", "XPath Query")
]
# Create operation buttons in a grid
for i, (value, text) in enumerate(operations):
row = i // 2
col = i % 2
ttk.Radiobutton(operation_frame, text=text, variable=self.operation_var,
value=value, command=self.on_operation_change).grid(
row=row, column=col, sticky="w", padx=5, pady=2)
# Right side - Settings frame
settings_frame = ttk.LabelFrame(top_row_frame, text="Settings")
settings_frame.pack(side=tk.LEFT, fill=tk.BOTH, expand=True, padx=(5, 0))
# JSON/XML formatting settings
format_frame = ttk.Frame(settings_frame)
format_frame.pack(fill=tk.X, padx=5, pady=5)
ttk.Label(format_frame, text="JSON Indent:").grid(row=0, column=0, sticky="w", padx=(0, 5))
self.json_indent_var = tk.StringVar(value=str(settings.get("json_indent", 2)))
ttk.Spinbox(format_frame, from_=0, to=8, width=5, textvariable=self.json_indent_var).grid(row=0, column=1, sticky="w", padx=(0, 10))
ttk.Label(format_frame, text="XML Indent:").grid(row=0, column=2, sticky="w", padx=(0, 5))
self.xml_indent_var = tk.StringVar(value=str(settings.get("xml_indent", 2)))
ttk.Spinbox(format_frame, from_=0, to=8, width=5, textvariable=self.xml_indent_var).grid(row=0, column=3, sticky="w")
# Element naming
naming_frame = ttk.Frame(settings_frame)
naming_frame.pack(fill=tk.X, padx=5, pady=5)
ttk.Label(naming_frame, text="Array Item Name:").grid(row=0, column=0, sticky="w", padx=(0, 5))
self.array_wrapper_var = tk.StringVar(value=settings.get("array_wrapper", "item"))
ttk.Entry(naming_frame, textvariable=self.array_wrapper_var, width=8).grid(row=0, column=1, sticky="w", padx=(0, 10))
ttk.Label(naming_frame, text="Root Element:").grid(row=0, column=2, sticky="w", padx=(0, 5))
self.root_element_var = tk.StringVar(value=settings.get("root_element", "root"))
ttk.Entry(naming_frame, textvariable=self.root_element_var, width=8).grid(row=0, column=3, sticky="w")
# Options frame (full width below)
options_frame = ttk.LabelFrame(main_frame, text="Options")
options_frame.pack(fill=tk.X, pady=(0, 10))
# Conversion options and AI generation buttons
options_content_frame = ttk.Frame(options_frame)
options_content_frame.pack(fill=tk.X, padx=5, pady=5)
# Left side - checkboxes
checkbox_frame = ttk.Frame(options_content_frame)
checkbox_frame.pack(side=tk.LEFT, fill=tk.Y)
self.preserve_attributes_var = tk.BooleanVar(value=settings.get("preserve_attributes", True))
ttk.Checkbutton(checkbox_frame, text="Preserve XML Attributes",
variable=self.preserve_attributes_var).pack(anchor="w", pady=2)
self.sort_keys_var = tk.BooleanVar(value=settings.get("sort_keys", False))
ttk.Checkbutton(checkbox_frame, text="Sort JSON Keys",
variable=self.sort_keys_var).pack(anchor="w", pady=2)
# Right side - AI generation buttons
ai_frame = ttk.Frame(options_content_frame)
ai_frame.pack(side=tk.RIGHT, fill=tk.Y)
ttk.Button(ai_frame, text="Generate JSON with AI",
command=self.generate_json_with_ai).pack(side=tk.LEFT, padx=(0, 5))
ttk.Button(ai_frame, text="Generate XML with AI",
command=self.generate_xml_with_ai).pack(side=tk.LEFT)
# Query frame (for JSONPath and XPath)
self.query_frame = ttk.LabelFrame(main_frame, text="Query")
self.query_frame.pack(fill=tk.X, pady=(0, 10))
ttk.Label(self.query_frame, text="JSONPath:").grid(row=0, column=0, sticky="w", padx=5, pady=2)
self.jsonpath_var = tk.StringVar(value=settings.get("jsonpath_query", "$"))
ttk.Entry(self.query_frame, textvariable=self.jsonpath_var, width=40).grid(row=0, column=1, sticky="ew", padx=5, pady=2)
ttk.Label(self.query_frame, text="XPath:").grid(row=1, column=0, sticky="w", padx=5, pady=2)
self.xpath_var = tk.StringVar(value=settings.get("xpath_query", "//*"))
ttk.Entry(self.query_frame, textvariable=self.xpath_var, width=40).grid(row=1, column=1, sticky="ew", padx=5, pady=2)
self.query_frame.columnconfigure(1, weight=1)
# Process button
process_frame = ttk.Frame(main_frame)
process_frame.pack(fill=tk.X, pady=(0, 5))
ttk.Button(process_frame, text="Process", command=self.process_data).pack(side=tk.LEFT)
# Status label
self.status_label = ttk.Label(process_frame, text="Ready", foreground="green")
self.status_label.pack(side=tk.LEFT, padx=(10, 0))
# Initially hide query frame
self.on_operation_change()
# Apply current font settings if available
try:
if hasattr(self.app, 'get_best_font'):
text_font_family, text_font_size = self.app.get_best_font("text")
font_tuple = (text_font_family, text_font_size)
# Apply to Entry widgets
for child in main_frame.winfo_children():
self._apply_font_to_children(child, font_tuple)
except:
pass # Use default font if font settings not available
return main_frame
def _apply_font_to_children(self, widget, font_tuple):
"""Recursively apply font to Entry widgets."""
try:
if isinstance(widget, (tk.Entry, ttk.Entry)):
widget.configure(font=font_tuple)
# Recursively check children
if hasattr(widget, 'winfo_children'):
for child in widget.winfo_children():
self._apply_font_to_children(child, font_tuple)
except:
pass
def apply_font_to_widgets(self, font_tuple):
"""Apply font to all Entry widgets in the tool."""
try:
# Apply to the main frame and all its children
if hasattr(self, 'main_frame'):
self._apply_font_to_children(self.main_frame, font_tuple)
except Exception as e:
if self.logger:
self.logger.debug(f"Error applying font to JSON/XML tool widgets: {e}")
def generate_json_with_ai(self):
"""Switch to AI Tools and generate JSON with AI."""
try:
# Switch to AI Tools
self.app.tool_var.set("AI Tools")
self.app.on_tool_selected()
# Find next empty input tab
next_tab = self._find_next_empty_tab()
if next_tab is not None:
# Switch to the empty tab
self.app.input_notebook.select(next_tab)
# Insert the prompt
prompt = "Please generate Identity JSON file"
self.app.input_tabs[next_tab].text.delete("1.0", tk.END)
self.app.input_tabs[next_tab].text.insert("1.0", prompt)
if self.logger:
self.logger.info("Switched to AI Tools with JSON generation prompt")
else:
# Use current tab if no empty tab found
current_tab = self.app.input_notebook.index(self.app.input_notebook.select())
prompt = "Please generate Identity JSON file"
self.app.input_tabs[current_tab].text.delete("1.0", tk.END)
self.app.input_tabs[current_tab].text.insert("1.0", prompt)
except Exception as e:
if self.logger:
self.logger.error(f"Error switching to AI Tools for JSON generation: {e}")
def generate_xml_with_ai(self):
"""Switch to AI Tools and generate XML with AI."""
try:
# Switch to AI Tools
self.app.tool_var.set("AI Tools")
self.app.on_tool_selected()
# Find next empty input tab
next_tab = self._find_next_empty_tab()
if next_tab is not None:
# Switch to the empty tab
self.app.input_notebook.select(next_tab)
# Insert the prompt
prompt = "Please generate Identity XML file"
self.app.input_tabs[next_tab].text.delete("1.0", tk.END)
self.app.input_tabs[next_tab].text.insert("1.0", prompt)
if self.logger:
self.logger.info("Switched to AI Tools with XML generation prompt")
else:
# Use current tab if no empty tab found
current_tab = self.app.input_notebook.index(self.app.input_notebook.select())
prompt = "Please generate Identity XML file"
self.app.input_tabs[current_tab].text.delete("1.0", tk.END)
self.app.input_tabs[current_tab].text.insert("1.0", prompt)
except Exception as e:
if self.logger:
self.logger.error(f"Error switching to AI Tools for XML generation: {e}")
def _find_next_empty_tab(self):
"""Find the next empty input tab."""
try:
for i, tab in enumerate(self.app.input_tabs):
content = tab.text.get("1.0", tk.END).strip()
if not content:
return i
return None
except:
return None
def on_operation_change(self):
"""Handle operation selection change."""
operation = self.operation_var.get()
# Show/hide query frame based on operation
if operation in ["jsonpath_query", "xpath_query"]:
self.query_frame.pack(fill=tk.X, pady=(0, 10))
else:
self.query_frame.pack_forget()
def process_data(self):
"""Process the data based on selected operation."""
try:
# Get input text from current active input tab
current_input_tab = self.app.input_notebook.index(self.app.input_notebook.select())
input_text = self.app.input_tabs[current_input_tab].text.get("1.0", tk.END).strip()
if not input_text:
self.status_label.config(text="Error: No input text", foreground="red")
return
operation = self.operation_var.get()
result = ""
if operation == "json_to_xml":
result = self.json_to_xml(input_text)
elif operation == "xml_to_json":
result = self.xml_to_json(input_text)
elif operation == "json_prettify":
result = self.json_prettify(input_text)
elif operation == "xml_prettify":
result = self.xml_prettify(input_text)
elif operation == "json_validate":
result = self.json_validate(input_text)
elif operation == "xml_validate":
result = self.xml_validate(input_text)
elif operation == "json_minify":
result = self.json_minify(input_text)
elif operation == "xml_minify":
result = self.xml_minify(input_text)
elif operation == "jsonpath_query":
result = self.jsonpath_query(input_text)
elif operation == "xpath_query":
result = self.xpath_query(input_text)
# Set output text to current active output tab
current_output_tab = self.app.output_notebook.index(self.app.output_notebook.select())
self.app.output_tabs[current_output_tab].text.config(state="normal")
self.app.output_tabs[current_output_tab].text.delete("1.0", tk.END)
self.app.output_tabs[current_output_tab].text.insert("1.0", result)
self.app.output_tabs[current_output_tab].text.config(state="disabled")
self.status_label.config(text="Success", foreground="green")
except Exception as e:
error_msg = f"Error: {str(e)}"
# Set error message to output tab
current_output_tab = self.app.output_notebook.index(self.app.output_notebook.select())
self.app.output_tabs[current_output_tab].text.config(state="normal")
self.app.output_tabs[current_output_tab].text.delete("1.0", tk.END)
self.app.output_tabs[current_output_tab].text.insert("1.0", error_msg)
self.app.output_tabs[current_output_tab].text.config(state="disabled")
self.status_label.config(text="Error", foreground="red")
if self.logger:
self.logger.error(f"JSON/XML Tool error: {e}")
def json_to_xml(self, json_text):
"""Convert JSON to XML."""
try:
data = json.loads(json_text)
root_name = self.root_element_var.get() or "root"
root = ET.Element(root_name)
self._dict_to_xml(data, root)
# Pretty print
rough_string = ET.tostring(root, encoding='unicode')
reparsed = xml.dom.minidom.parseString(rough_string)
indent = " " * int(self.xml_indent_var.get())
return reparsed.toprettyxml(indent=indent).split('\n', 1)[1] # Remove XML declaration
except json.JSONDecodeError as e:
raise Exception(f"Invalid JSON: {e}")
except Exception as e:
raise Exception(f"JSON to XML conversion failed: {e}")
def _dict_to_xml(self, data, parent):
"""Recursively convert dictionary to XML elements."""
if isinstance(data, dict):
for key, value in data.items():
if key.startswith('@') and self.preserve_attributes_var.get():
# Handle attributes
parent.set(key[1:], str(value))
else:
element = ET.SubElement(parent, self._sanitize_xml_name(key))
self._dict_to_xml(value, element)
elif isinstance(data, list):
array_name = self.array_wrapper_var.get() or "item"
for item in data:
element = ET.SubElement(parent, array_name)
self._dict_to_xml(item, element)
else:
parent.text = str(data)
def _sanitize_xml_name(self, name):
"""Sanitize name for XML element."""
# Replace invalid characters with underscores
name = re.sub(r'[^a-zA-Z0-9_-]', '_', str(name))
# Ensure it starts with a letter or underscore
if name and not name[0].isalpha() and name[0] != '_':
name = '_' + name
return name or 'element'
def xml_to_json(self, xml_text):
"""Convert XML to JSON."""
try:
root = ET.fromstring(xml_text)
data = self._xml_to_dict(root)
indent = int(self.json_indent_var.get()) if self.json_indent_var.get() != "0" else None
sort_keys = self.sort_keys_var.get()
return json.dumps(data, indent=indent, sort_keys=sort_keys, ensure_ascii=False)
except ET.ParseError as e:
raise Exception(f"Invalid XML: {e}")
except Exception as e:
raise Exception(f"XML to JSON conversion failed: {e}")
def _xml_to_dict(self, element):
"""Recursively convert XML element to dictionary."""
result = {}
# Add attributes with @ prefix if preserving attributes
if element.attrib and self.preserve_attributes_var.get():
for key, value in element.attrib.items():
result[f'@{key}'] = value
# Handle child elements
children = list(element)
if children:
child_dict = {}
for child in children:
child_data = self._xml_to_dict(child)
if child.tag in child_dict:
# Convert to array if multiple elements with same tag
if not isinstance(child_dict[child.tag], list):
child_dict[child.tag] = [child_dict[child.tag]]
child_dict[child.tag].append(child_data)
else:
child_dict[child.tag] = child_data
result.update(child_dict)
# Handle text content
if element.text and element.text.strip():
if result: # If we have attributes or children, use special key for text
result['#text'] = element.text.strip()
else: # If no attributes or children, return text directly
return element.text.strip()
return result if result else None
def json_prettify(self, json_text):
"""Prettify JSON."""
try:
data = json.loads(json_text)
indent = int(self.json_indent_var.get()) if self.json_indent_var.get() != "0" else None
sort_keys = self.sort_keys_var.get()
return json.dumps(data, indent=indent, sort_keys=sort_keys, ensure_ascii=False)
except json.JSONDecodeError as e:
raise Exception(f"Invalid JSON: {e}")
def xml_prettify(self, xml_text):
"""Prettify XML."""
try:
root = ET.fromstring(xml_text)
rough_string = ET.tostring(root, encoding='unicode')
reparsed = xml.dom.minidom.parseString(rough_string)
indent = " " * int(self.xml_indent_var.get())
pretty = reparsed.toprettyxml(indent=indent)
# Remove empty lines and clean up
lines = [line for line in pretty.split('\n') if line.strip()]
return '\n'.join(lines)
except ET.ParseError as e:
raise Exception(f"Invalid XML: {e}")
def json_validate(self, json_text):
"""Validate JSON and return detailed results."""
try:
data = json.loads(json_text)
# Basic validation info
result = "✅ JSON is valid!\n\n"
result += f"Type: {type(data).__name__}\n"
if isinstance(data, dict):
result += f"Keys: {len(data)}\n"
result += f"Top-level keys: {list(data.keys())[:10]}" # Show first 10 keys
if len(data) > 10:
result += f" ... and {len(data) - 10} more"
elif isinstance(data, list):
result += f"Items: {len(data)}\n"
if data:
result += f"First item type: {type(data[0]).__name__}"
result += f"\n\nFormatted JSON:\n{json.dumps(data, indent=2, ensure_ascii=False)}"
return result
except json.JSONDecodeError as e:
return f"❌ Invalid JSON!\n\nError: {e}\n\nLine {e.lineno}, Column {e.colno}\n\nTip: Check for missing quotes, commas, or brackets around the error location."
def xml_validate(self, xml_text):
"""Validate XML and return detailed results."""
try:
root = ET.fromstring(xml_text)
result = "✅ XML is valid!\n\n"
result += f"Root element: <{root.tag}>\n"
result += f"Attributes: {len(root.attrib)}\n"
result += f"Child elements: {len(list(root))}\n"
# Count all elements
all_elements = root.findall('.//*')
result += f"Total elements: {len(all_elements) + 1}\n" # +1 for root
# Show element types
element_types = {}
for elem in [root] + all_elements:
element_types[elem.tag] = element_types.get(elem.tag, 0) + 1
result += f"\nElement types:\n"
for tag, count in sorted(element_types.items()):
result += f" <{tag}>: {count}\n"
return result
except ET.ParseError as e:
return f"❌ Invalid XML!\n\nError: {e}\n\nSuggestions:\n- Check for unclosed tags\n- Ensure proper nesting\n- Verify attribute quotes\n- Check for invalid characters in element names"
def json_minify(self, json_text):
"""Minify JSON by removing whitespace."""
try:
data = json.loads(json_text)
return json.dumps(data, separators=(',', ':'), ensure_ascii=False)
except json.JSONDecodeError as e:
raise Exception(f"Invalid JSON: {e}")
def xml_minify(self, xml_text):
"""Minify XML by removing whitespace."""
try:
root = ET.fromstring(xml_text)
# Remove whitespace from all elements
for elem in root.iter():
if elem.text:
elem.text = elem.text.strip() or None
if elem.tail:
elem.tail = elem.tail.strip() or None
return ET.tostring(root, encoding='unicode')
except ET.ParseError as e:
raise Exception(f"Invalid XML: {e}")
def jsonpath_query(self, json_text):
"""Execute JSONPath query."""
if not JSONPATH_AVAILABLE:
return "❌ JSONPath not available. Install with: pip install jsonpath-ng"
try:
data = json.loads(json_text)
query = self.jsonpath_var.get() or "$"
from jsonpath_ng import parse
jsonpath_expr = parse(query)
matches = jsonpath_expr.find(data)
result = f"JSONPath Query: {query}\n"
result += f"Matches found: {len(matches)}\n\n"
if matches:
for i, match in enumerate(matches):
result += f"Match {i + 1}:\n"
result += f" Path: {match.full_path}\n"
result += f" Value: {json.dumps(match.value, indent=2, ensure_ascii=False)}\n\n"
else:
result += "No matches found."
return result
except json.JSONDecodeError as e:
raise Exception(f"Invalid JSON: {e}")
except Exception as e:
raise Exception(f"JSONPath query failed: {e}")
def xpath_query(self, xml_text):
"""Execute XPath query."""
try:
if LXML_AVAILABLE:
# Use lxml for better XPath support
root = lxml_ET.fromstring(xml_text.encode())
query = self.xpath_var.get() or "//*"
matches = root.xpath(query)
else:
# Fallback to basic ElementTree (limited XPath support)
root = ET.fromstring(xml_text)
query = self.xpath_var.get() or ".//*"
matches = root.findall(query)
result = f"XPath Query: {query}\n"
result += f"Matches found: {len(matches)}\n\n"
if matches:
for i, match in enumerate(matches):
result += f"Match {i + 1}:\n"
if hasattr(match, 'tag'):
result += f" Element: <{match.tag}>\n"
if match.attrib:
result += f" Attributes: {match.attrib}\n"
if match.text and match.text.strip():
result += f" Text: {match.text.strip()}\n"
else:
result += f" Value: {match}\n"
result += "\n"
else:
result += "No matches found."
if not LXML_AVAILABLE:
result += "\n\nNote: Using basic XPath support. Install lxml for advanced XPath features: pip install lxml"
return result
except ET.ParseError as e:
raise Exception(f"Invalid XML: {e}")
except Exception as e:
raise Exception(f"XPath query failed: {e}")
def get_settings(self):
"""Get current settings."""
return {
"operation": self.operation_var.get(),
"json_indent": self.json_indent_var.get(),
"xml_indent": self.xml_indent_var.get(),
"preserve_attributes": self.preserve_attributes_var.get(),
"sort_keys": self.sort_keys_var.get(),
"array_wrapper": self.array_wrapper_var.get(),
"root_element": self.root_element_var.get(),
"jsonpath_query": self.jsonpath_var.get(),
"xpath_query": self.xpath_var.get()
}
# Static utility functions for BaseTool
def _json_prettify_static(text, indent=2):
"""Prettify JSON without UI dependencies."""
try:
data = json.loads(text)
return json.dumps(data, indent=indent, ensure_ascii=False)
except json.JSONDecodeError as e:
return f"Invalid JSON: {e}"
def _json_minify_static(text):
"""Minify JSON without UI dependencies."""
try:
data = json.loads(text)
return json.dumps(data, separators=(',', ':'), ensure_ascii=False)
except json.JSONDecodeError as e:
return f"Invalid JSON: {e}"
def _json_validate_static(text):
"""Validate JSON without UI dependencies."""
try:
json.loads(text)
return "✓ Valid JSON"
except json.JSONDecodeError as e:
return f"✗ Invalid JSON: {e}"
def _xml_prettify_static(text, indent=2):
"""Prettify XML without UI dependencies."""
try:
root = ET.fromstring(text)
rough_string = ET.tostring(root, encoding='unicode')
reparsed = xml.dom.minidom.parseString(rough_string)
pretty = reparsed.toprettyxml(indent=" " * indent)
lines = [line for line in pretty.split('\n') if line.strip()]
return '\n'.join(lines)
except ET.ParseError as e:
return f"Invalid XML: {e}"
def _xml_minify_static(text):
"""Minify XML without UI dependencies."""
try:
root = ET.fromstring(text)
return ET.tostring(root, encoding='unicode')
except ET.ParseError as e:
return f"Invalid XML: {e}"
def _xml_validate_static(text):
"""Validate XML without UI dependencies."""
try:
ET.fromstring(text)
return "✓ Valid XML"
except ET.ParseError as e:
return f"✗ Invalid XML: {e}"
# BaseTool-compatible wrapper
try:
from tools.base_tool import ToolWithOptions
from typing import Dict, Any
class JSONXMLToolV2(ToolWithOptions):
"""
BaseTool-compatible version of JSONXMLTool.
"""
TOOL_NAME = "JSON/XML Tool"
TOOL_DESCRIPTION = "Convert, prettify, minify, and validate JSON/XML"
TOOL_VERSION = "2.0.0"
OPTIONS = [
("JSON Prettify", "json_prettify"),
("JSON Minify", "json_minify"),
("JSON Validate", "json_validate"),
("XML Prettify", "xml_prettify"),
("XML Minify", "xml_minify"),
("XML Validate", "xml_validate"),
]
OPTIONS_LABEL = "Operation"
USE_DROPDOWN = True
DEFAULT_OPTION = "json_prettify"
def process_text(self, input_text: str, settings: Dict[str, Any]) -> str:
"""Process text using the specified JSON/XML operation."""
mode = settings.get("mode", "json_prettify")
indent = settings.get("indent", 2)
if mode == "json_prettify":
return _json_prettify_static(input_text, indent)
elif mode == "json_minify":
return _json_minify_static(input_text)
elif mode == "json_validate":
return _json_validate_static(input_text)
elif mode == "xml_prettify":
return _xml_prettify_static(input_text, indent)
elif mode == "xml_minify":
return _xml_minify_static(input_text)
elif mode == "xml_validate":
return _xml_validate_static(input_text)
else:
return input_text
except ImportError:
pass
