How to Programmatically Access Methods and Types with SUDS: Inspect SOAP Service Methods and Determine Factory Object Types for Dynamic UI Form Generation in Python

pip install suds-jurko  

from suds.client import Client  
 
# Public calculator service WSDL (adds/subtracts numbers)  
wsdl_url = "http://www.dneonline.com/calculator.asmx?WSDL"  
 
# Create a SUDS client  
client = Client(wsdl_url)  
 
# Print basic service info (optional but helpful for debugging)  
print("Service Name:", client.wsdl.services[0].name)  
print("Port Name:", client.wsdl.services[0].ports[0].name)  
print("Endpoint URL:", client.wsdl.services[0].ports[0].location)  

# Get all methods for the first port of the first service  
methods = client.wsdl.services[0].ports[0].methods  
print("Available Methods:", list(methods.keys()))  

# Inspect the "Add" method  
method_name = "Add"  
method = methods[method_name]  
 
# Get input parameters (SOAP body parts)  
input_parts = method.soap.input.body.parts  
 
# Extract parameter names and types  
params = []  
for part in input_parts:  
    # part.element is the XSD element defining the parameter  
    param_name = part.element.name  
    param_type = part.element.type.name  # e.g., "int"  
    params.append({"name": param_name, "type": param_type})  
 
print(f"Parameters for {method_name}: {params}")  

<!-- Excerpt from WSDL -->  
<xsd:complexType name="Person">  
  <xsd:sequence>  
    <xsd:element name="Name" type="xsd:string"/>  
    <xsd:element name="Age" type="xsd:int"/>  
  </xsd:sequence>  
</xsd:complexType>  

# Create a Person object via the factory  
person = client.factory.create("Person")  
person.Name = "Alice"  
person.Age = 30  
 
print(person)  # Output: Person(Name='Alice', Age=30)  

def get_type_definition(type_name):  
    """Retrieve the XSD type definition for a given type name."""  
    for schema in client.wsdl.types:  
        type_def = schema.get_type(type_name)  
        if type_def:  
            return type_def  
    return None  
 
# Get definition for "Person"  
person_type = get_type_definition("Person")  
print("Person Type Definition:", person_type)  

def get_type_fields(type_def):  
    """Extract fields (name, type, required) from a complex type definition."""  
    fields = []  
    for child in type_def.children():  
        # Child is an XSD element (e.g., <xsd:element name="Name" type="xsd:string"/>)  
        field_name = child.name  
        field_type = child.type.name  
        is_required = child.min_occurs > 0  # min_occurs=1 means required  
        fields.append({  
            "name": field_name,  
            "type": field_type,  
            "required": is_required  
        })  
    return fields  
 
# Get fields for "Person"  
person_fields = get_type_fields(person_type)  
print("Person Fields:", person_fields)  

import tkinter as tk  
from tkinter import ttk  
 
def create_input_widget(parent, field):  
    """Create a Tkinter widget for a field based on its type."""  
    frame = ttk.Frame(parent)  
    frame.pack(fill="x", padx=5, pady=2)  
 
    # Label (show field name and required status)  
    label_text = f"{field['name']} {'*' if field['required'] else ''}"  
    ttk.Label(frame, text=label_text).pack(side="left", padx=5)  
 
    # Widget based on type  
    if field["type"] in ["string", "int", "float", "date"]:  
        widget = ttk.Entry(frame)  
        widget.pack(side="left", fill="x", expand=True, padx=5)  
    elif field["type"] == "boolean":  
        widget = ttk.Checkbutton(frame)  
        widget.pack(side="left", padx=5)  
    else:  
        # Assume complex type: recursively generate fields  
        widget = ttk.LabelFrame(frame, text=field["type"])  
        widget.pack(side="left", fill="x", expand=True, padx=5)  
        complex_type = get_type_definition(field["type"])  
        if complex_type:  
            complex_fields = get_type_fields(complex_type)  
            for sub_field in complex_fields:  
                create_input_widget(widget, sub_field)  
    return widget  
 
def generate_form(method_name):  
    """Generate a Tkinter form for a SOAP method."""  
    root = tk.Tk()  
    root.title(f"SOAP Method: {method_name}")  
 
    # Get method parameters  
    method = client.wsdl.services[0].ports[0].methods[method_name]  
    input_parts = method.soap.input.body.parts  
 
    # Generate widgets for each parameter  
    widgets = {}  
    for part in input_parts:  
        param_name = part.element.name  
        param_type = part.element.type.name  
 
        # Check if parameter is a complex type  
        type_def = get_type_definition(param_type)  
        if type_def and type_def.complex:  
            # Complex type: generate nested fields  
            fields = get_type_fields(type_def)  
            for field in fields:  
                widgets[field["name"]] = create_input_widget(root, field)  
        else:  
            # Simple type: generate basic widget  
            field = {  
                "name": param_name,  
                "type": param_type,  
                "required": part.element.min_occurs > 0  
            }  
            widgets[param_name] = create_input_widget(root, field)  
 
    # Add a "Submit" button (to call the SOAP method)  
    ttk.Button(root, text="Submit", command=lambda: submit_form(method_name, widgets)).pack(pady=10)  
 
    root.mainloop()  
 
def submit_form(method_name, widgets):  
    """Extract values from widgets and call the SOAP method."""  
    # Extract input values (simplified: assumes widgets are Entry/Checkbutton)  
    params = {}  
    for name, widget in widgets.items():  
        if isinstance(widget, ttk.Entry):  
            params[name] = widget.get()  
        elif isinstance(widget, ttk.Checkbutton):  
            params[name] = widget.get()  
 
    # Call the SOAP method (e.g., client.service.Add(intA=1, intB=2))  
    result = getattr(client.service, method_name)(**params)  
    print(f"Result: {result}")  

def is_enum(type_def):  
    """Check if a type is an enumeration."""  
    return hasattr(type_def, "restriction") and hasattr(type_def.restriction, "enumeration")  
 
def get_enum_values(type_def):  
    """Get allowed values for an enum type."""  
    return [enum.value for enum in type_def.restriction.enumeration]