onvif-python 0.2.11__tar.gz → 0.3.1__tar.gz

{onvif_python-0.2.11 → onvif_python-0.3.1}/LICENSE.md

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2025 Nirsimetri Technologies®
+Copyright (c) 2025-2026 Nirsimetri Technologies®
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

onvif_python-0.3.1/PKG-INFO

@@ -0,0 +1,103 @@
+Metadata-Version: 2.4
+Name: onvif-python
+Version: 0.3.1
+Summary: A modern Python library for ONVIF-compliant devices
+Author-email: Nirsimetri Technologies® <open@nirsimetri.com>
+Maintainer: Kaburagi
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/nirsimetri/onvif-python
+Project-URL: Documentation, https://deepwiki.com/nirsimetri/onvif-python
+Project-URL: Changelog, https://github.com/nirsimetri/onvif-python/releases
+Keywords: onvif,Camera,onvif-python,ip-camera,cctv,soap,surveillance,cctv cameras,soap-client,onvif-client,onvif-library,onvif-specifications
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Console
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Information Technology
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Security
+Classifier: Topic :: Multimedia :: Video
+Classifier: Topic :: Multimedia :: Sound/Audio
+Classifier: Topic :: Communications
+Classifier: Topic :: Text Processing :: Markup :: XML
+Classifier: Natural Language :: English
+Classifier: Natural Language :: Indonesian
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE.md
+Requires-Dist: zeep>=4.3.0
+Requires-Dist: requests>=2.32.0
+Requires-Dist: pyreadline3>=3.5.4; sys_platform == "win32"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: black; extra == "dev"
+Requires-Dist: mypy; extra == "dev"
+Requires-Dist: isort; extra == "dev"
+Requires-Dist: pylint; extra == "dev"
+Requires-Dist: docformatter; extra == "dev"
+Dynamic: license-file
+
+<h1 align="center">ONVIF Python</h1>
+
+<div align="center">
+<a href="https://app.codacy.com/gh/nirsimetri/onvif-python/dashboard?utm_source=gh&utm_medium=referral&utm_content=&utm_campaign=Badge_grade"><img src="https://img.shields.io/codacy/grade/bff08a94e4d447b690cea49c6594826d?style=plastic&logo=codacy&label=Code%20Quality"/></a>
+<a href="https://pypi.org/project/onvif-python/"><img alt="PyPI Version" src="https://img.shields.io/badge/Version-0.3.1-orange?logo=python&logoColor=white&color=yellow&style=plastic"></a>
+<a href="https://pepy.tech/projects/onvif-python"><img alt="Pepy Total Downloads" src="https://img.shields.io/pepy/dt/onvif-python?logo=pypi&logoColor=white&label=Downloads&color=red&style=plastic"></a>
+<br>
+<a href="https://github.com/nirsimetri/onvif-python/actions/workflows/python-app.yml"><img alt="Build" src="https://github.com/nirsimetri/onvif-python/actions/workflows/python-app.yml/badge.svg?branch=main"></a>
+<a href="https://github.com/nirsimetri/onvif-python/actions/workflows/python-publish.yml"><img alt="Upload Python Package" src="https://github.com/nirsimetri/onvif-python/actions/workflows/python-publish.yml/badge.svg"></a>
+</div>
+
+<h1 align="center">
+  <img src="https://raw.githubusercontent.com/nirsimetri/onvif-python/refs/heads/main/assets/images/carbon_onvif.png" alt="onvif" width="700px">
+  <br>
+</h1>
+
+**This project provides a comprehensive and developer-friendly Python library for working with ONVIF-compliant devices.** It is designed to be reliable, easy to integrate, and flexible enough to support a wide range of ONVIF profiles and services.  
+
+**[ONVIF](https://www.onvif.org) (Open Network Video Interface Forum)** is a global standard for the interface of IP-based physical security products, including network cameras, video recorders, and related systems.  
+
+Behind the scenes, ONVIF communication relies on **[SOAP](https://en.wikipedia.org/wiki/SOAP) (Simple Object Access Protocol)**; an [XML](https://en.wikipedia.org/wiki/XML)-based messaging protocol with strict schema definitions ([WSDL](https://en.wikipedia.org/wiki/Web_Services_Description_Language)/[XSD](https://en.wikipedia.org/wiki/XML_Schema_(W3C))). SOAP ensures interoperability, but when used directly it can be verbose, complex, and error-prone.  
+
+This library simplifies that process by wrapping SOAP communication into a clean, Pythonic API. You no longer need to handle low-level XML parsing, namespaces, or security tokens manually; the library takes care of it, letting you focus on building functionality.
+
+## Who Is It For?
+- **Individual developers** exploring ONVIF or building hobby projects  
+- **Companies** building video intelligence, analytics, or VMS platforms  
+- **Security integrators** who need reliable ONVIF interoperability across devices
+
+## Requirements
+
+- **Python**: 3.9 or higher
+- **Dependencies**:
+  - [`zeep>=4.3.0`](https://github.com/mvantellingen/python-zeep) - SOAP client for ONVIF communication
+  - [`requests>=2.32.0`](https://github.com/psf/requests) - HTTP library for network requests
+
+## Installation
+
+From official [PyPI](https://pypi.org/project/onvif-python/):
+```bash
+pip install --upgrade onvif-python
+```
+Or clone this repository and install locally:
+```bash
+git clone https://github.com/nirsimetri/onvif-python
+cd onvif-python
+pip install .
+```
+
+## Documentation
+
+For complete guide, including usage examples and API references, please visit the [Documentation Page](https://nirsimetri.github.io/onvif-python/).
+
+## License
+
+This project is licensed under the MIT License. See [LICENSE](./LICENSE.md) for details.

onvif_python-0.3.1/README.md

@@ -0,0 +1,56 @@
+<h1 align="center">ONVIF Python</h1>
+
+<div align="center">
+<a href="https://app.codacy.com/gh/nirsimetri/onvif-python/dashboard?utm_source=gh&utm_medium=referral&utm_content=&utm_campaign=Badge_grade"><img src="https://img.shields.io/codacy/grade/bff08a94e4d447b690cea49c6594826d?style=plastic&logo=codacy&label=Code%20Quality"/></a>
+<a href="https://pypi.org/project/onvif-python/"><img alt="PyPI Version" src="https://img.shields.io/badge/Version-0.3.1-orange?logo=python&logoColor=white&color=yellow&style=plastic"></a>
+<a href="https://pepy.tech/projects/onvif-python"><img alt="Pepy Total Downloads" src="https://img.shields.io/pepy/dt/onvif-python?logo=pypi&logoColor=white&label=Downloads&color=red&style=plastic"></a>
+<br>
+<a href="https://github.com/nirsimetri/onvif-python/actions/workflows/python-app.yml"><img alt="Build" src="https://github.com/nirsimetri/onvif-python/actions/workflows/python-app.yml/badge.svg?branch=main"></a>
+<a href="https://github.com/nirsimetri/onvif-python/actions/workflows/python-publish.yml"><img alt="Upload Python Package" src="https://github.com/nirsimetri/onvif-python/actions/workflows/python-publish.yml/badge.svg"></a>
+</div>
+
+<h1 align="center">
+  <img src="https://raw.githubusercontent.com/nirsimetri/onvif-python/refs/heads/main/assets/images/carbon_onvif.png" alt="onvif" width="700px">
+  <br>
+</h1>
+
+**This project provides a comprehensive and developer-friendly Python library for working with ONVIF-compliant devices.** It is designed to be reliable, easy to integrate, and flexible enough to support a wide range of ONVIF profiles and services.  
+
+**[ONVIF](https://www.onvif.org) (Open Network Video Interface Forum)** is a global standard for the interface of IP-based physical security products, including network cameras, video recorders, and related systems.  
+
+Behind the scenes, ONVIF communication relies on **[SOAP](https://en.wikipedia.org/wiki/SOAP) (Simple Object Access Protocol)**; an [XML](https://en.wikipedia.org/wiki/XML)-based messaging protocol with strict schema definitions ([WSDL](https://en.wikipedia.org/wiki/Web_Services_Description_Language)/[XSD](https://en.wikipedia.org/wiki/XML_Schema_(W3C))). SOAP ensures interoperability, but when used directly it can be verbose, complex, and error-prone.  
+
+This library simplifies that process by wrapping SOAP communication into a clean, Pythonic API. You no longer need to handle low-level XML parsing, namespaces, or security tokens manually; the library takes care of it, letting you focus on building functionality.
+
+## Who Is It For?
+- **Individual developers** exploring ONVIF or building hobby projects  
+- **Companies** building video intelligence, analytics, or VMS platforms  
+- **Security integrators** who need reliable ONVIF interoperability across devices
+
+## Requirements
+
+- **Python**: 3.9 or higher
+- **Dependencies**:
+  - [`zeep>=4.3.0`](https://github.com/mvantellingen/python-zeep) - SOAP client for ONVIF communication
+  - [`requests>=2.32.0`](https://github.com/psf/requests) - HTTP library for network requests
+
+## Installation
+
+From official [PyPI](https://pypi.org/project/onvif-python/):
+```bash
+pip install --upgrade onvif-python
+```
+Or clone this repository and install locally:
+```bash
+git clone https://github.com/nirsimetri/onvif-python
+cd onvif-python
+pip install .
+```
+
+## Documentation
+
+For complete guide, including usage examples and API references, please visit the [Documentation Page](https://nirsimetri.github.io/onvif-python/).
+
+## License
+
+This project is licensed under the MIT License. See [LICENSE](./LICENSE.md) for details.

onvif_python-0.3.1/onvif/__init__.py

@@ -0,0 +1,25 @@
+"""ONVIF Python."""
+
+from onvif.cli import main as ONVIFCLI
+from onvif.client import ONVIFClient
+from onvif.operator import CacheMode
+from onvif.utils import (
+    ONVIFWSDL,
+    ONVIFDiscovery,
+    ONVIFErrorHandler,
+    ONVIFOperationException,
+    ONVIFParser,
+    ZeepPatcher,
+)
+
+__all__ = [
+    "ONVIFClient",
+    "CacheMode",
+    "ONVIFWSDL",
+    "ONVIFOperationException",
+    "ONVIFErrorHandler",
+    "ZeepPatcher",
+    "ONVIFCLI",
+    "ONVIFDiscovery",
+    "ONVIFParser",
+]

onvif_python-0.3.1/onvif/cli/__init__.py

@@ -0,0 +1,5 @@
+"""ONVIF CLI."""
+
+from onvif.cli.main import main
+
+__all__ = ["main"]

onvif_python-0.3.1/onvif/cli/__main__.py

@@ -0,0 +1,7 @@
+#!/usr/bin/env python3
+"""ONVIF CLI entry point for python -m onvif.cli."""
+
+from onvif.cli.main import main
+
+if __name__ == "__main__":
+    main()

onvif_python-0.3.1/onvif/cli/helpers/__init__.py

@@ -0,0 +1,21 @@
+"""ONVIF CLI helpers."""
+
+from onvif.cli.helpers.discovery import discover_devices, select_device_interactive
+from onvif.cli.helpers.execution import execute_command, setup_warning_format
+from onvif.cli.helpers.files import save_output_to_file
+from onvif.cli.helpers.products import search_products
+from onvif.cli.helpers.wsdl_parser import (
+    get_method_documentation,
+    get_operation_type_info,
+)
+
+__all__ = [
+    "search_products",
+    "save_output_to_file",
+    "discover_devices",
+    "select_device_interactive",
+    "execute_command",
+    "setup_warning_format",
+    "get_method_documentation",
+    "get_operation_type_info",
+]

onvif_python-0.3.1/onvif/cli/helpers/discovery.py

@@ -0,0 +1,124 @@
+"""ONVIF discovery helpers."""
+
+from onvif.cli.utils import colorize
+from onvif.utils import ONVIFDiscovery
+
+
+def discover_devices(
+    timeout: int = 4,
+    interface: str | None = None,
+    prefer_https: bool = False,
+    filter_term: str | None = None,
+) -> list:
+    """Discover ONVIF devices on the network using WS-Discovery.
+
+    Args:
+        timeout (int): Discovery timeout in seconds
+        interface (str | None): Network interface to use for discovery
+        prefer_https (bool): If True, prioritize HTTPS XAddrs when available
+        filter_term (str | None): Optional search term to filter devices by types or scopes
+
+    Returns:
+        List of discovered devices with connection info
+    """
+    # Use ONVIFDiscovery class
+    discovery = ONVIFDiscovery(timeout=timeout, interface=interface)
+
+    print(f"\n{colorize('Discovering ONVIF devices on network...', 'yellow')}")
+    print(f"Network interface: {colorize(discovery.get_local_ip(), 'white')}")
+    print(f"Timeout: {timeout}s")
+    if filter_term:
+        print(f"Filter: {colorize(filter_term, 'yellow')}")
+    print()
+
+    devices = discovery.discover(prefer_https=prefer_https, search=filter_term)
+
+    return devices
+
+
+def select_device_interactive(devices: list) -> tuple[str, int, bool] | None:
+    """Display devices and allow user to select one interactively.
+
+    Args:
+        devices (list): Discovered devices
+
+    Returns:
+        Tuple of (host, port, use_https) or None if cancelled
+    """
+    if not devices:
+        print(f"\n{colorize('No ONVIF devices found.', 'red')}")
+        return None
+
+    print(f"{colorize(f'Found {len(devices)} ONVIF device(s):', 'green')}")
+
+    for idx, device in enumerate(devices, 1):
+        idx_str = colorize(f"[{idx}]", "yellow")
+        protocol = "https" if device.get("use_https", False) else "http"
+        host_port = f"{device['host']}:{device['port']}"
+        protocol_indicator = (
+            colorize("🔒 HTTPS", "green")
+            if device.get("use_https", False)
+            else colorize("HTTP", "white")
+        )
+        print(f"\n{idx_str} {colorize(host_port, 'yellow')} ({protocol_indicator})")
+
+        # Remove uuid: or urn:uuid: prefix from EPR
+        epr_display = device["epr"]
+        if epr_display.startswith("urn:uuid:"):
+            epr_display = epr_display.replace("urn:uuid:", "")
+        elif epr_display.startswith("uuid:"):
+            epr_display = epr_display.replace("uuid:", "")
+        print(f"    [uuid] {epr_display}")
+
+        if device["xaddrs"]:
+            xaddrs_parts = [f"[{xaddr}]" for xaddr in device["xaddrs"]]
+            print(f"    [xaddrs] {' '.join(xaddrs_parts)}")
+
+        if device["types"]:
+            types_parts = [f"[{t}]" for t in device["types"]]
+            print(f"    [types] {' '.join(types_parts)}")
+
+        if device["scopes"]:
+            scope_parts = []
+            for scope in device["scopes"]:
+                # Remove the prefix "onvif://www.onvif.org/" if present
+                if scope.startswith("onvif://www.onvif.org/"):
+                    simplified = scope.replace("onvif://www.onvif.org/", "")
+                    scope_parts.append(f"[{simplified}]")
+                else:
+                    # Keep other scopes as-is (e.g., http:123)
+                    scope_parts.append(f"[{scope}]")
+
+            if scope_parts:
+                print(f"    [scopes] {' '.join(scope_parts)}")
+
+    # Simple selection (without arrow keys for cross-platform compatibility)
+    while True:
+        try:
+            selection = input(
+                f"\nSelect device number {colorize(f'1-{len(devices)}', 'white')} or {colorize('q', 'white')} to quit: "
+            )
+
+            if selection.lower() == "q":
+                return None
+
+            idx = int(selection)
+            if 1 <= idx <= len(devices):
+                selected = devices[idx - 1]
+                protocol = "https" if selected.get("use_https", False) else "http"
+                host_port = f"{selected['host']}:{selected['port']}"
+                print(
+                    f"\n{colorize('Selected:', 'green')} {colorize(protocol, 'cyan')}://{colorize(host_port, 'yellow')}"
+                )
+                return (
+                    selected["host"],
+                    selected["port"],
+                    selected.get("use_https", False),
+                )
+            else:
+                print(colorize("Invalid selection. Please try again.", "red"))
+
+        except ValueError:
+            print(colorize("Invalid input. Please enter a number.", "red"))
+        except (EOFError, KeyboardInterrupt):
+            return None

onvif_python-0.3.1/onvif/cli/helpers/execution.py

@@ -0,0 +1,57 @@
+"""ONVIF command execution helpers."""
+
+import warnings
+from typing import Any
+
+from onvif.cli.utils import colorize, parse_json_params
+from onvif.client import ONVIFClient
+
+
+def execute_command(
+    client: ONVIFClient,
+    service_name: str,
+    method_name: str,
+    params_str: str | None = None,
+) -> Any:
+    """Execute a single ONVIF command.
+
+    Args:
+        client (ONVIFClient): ONVIFClient instance
+        service_name (str): Selected service for command execution
+        method_name (str): Method to execute by service
+        params_str (str | None): Provided params for method execution
+
+    Returns:
+        The operation response printed in terminal
+    """
+    # Get service instance
+    try:
+        service = getattr(client, service_name.lower())()
+    except AttributeError as e:
+        raise ValueError(f"{colorize('Unknown service:', 'red')} {service_name}") from e
+
+    # Get method
+    try:
+        method = getattr(service, method_name)
+    except AttributeError as e:
+        raise ValueError(
+            f"{colorize('Unknown method', 'red')} '{method_name}' for service '{service_name}'"
+        ) from e
+
+    # Parse parameters
+    params = parse_json_params(params_str) if params_str else {}
+
+    # Execute method
+    return method(**params)
+
+
+def setup_warning_format() -> None:
+    """Setup custom warning format to show clean, concise warnings."""
+
+    def custom_warning_format(
+        message, category, filename, lineno, line=None
+    ):  # pylint: disable=unused-argument
+        # Show only the warning message without file path and line number
+        return f"{category.__name__}: {message}\n"
+
+    warnings.formatwarning = custom_warning_format

onvif_python-0.3.1/onvif/cli/helpers/files.py

@@ -0,0 +1,189 @@
+"""File processing helpers."""
+
+import json
+import os
+import sys
+from datetime import datetime, timezone
+from typing import Any
+
+from onvif.cli.utils import colorize
+from onvif.client import ONVIFClient
+
+
+def save_output_to_file(
+    result: Any, output_path: str, debug_mode: bool, client: ONVIFClient
+) -> None:
+    """Save command output to file in appropriate format based on file extension.
+
+    Args:
+        result (Any): The ONVIF command result
+        output_path (str): Path to output file
+        debug_mode (bool): Whether debug mode is enabled (for XML capture)
+        client (ONVIFClient): ONVIFClient instance (for accessing XML plugin)
+    """
+    try:
+        # Determine output format based on file extension
+        _, ext = os.path.splitext(output_path.lower())
+
+        if ext == ".json":
+            # Prepare output data
+            output_data = {}
+
+            # JSON format
+            output_data["result"] = _serialize_for_json(result)
+            output_data["timestamp"] = datetime.now(timezone.utc).isoformat()
+            output_data["raw_result"] = str(result)  # Add raw string as fallback
+
+            # Add XML data if debug mode is enabled and XML plugin is available
+            if debug_mode and client.xml_plugin:
+                output_data["debug"] = {
+                    "last_request_xml": client.xml_plugin.last_sent_xml,
+                    "last_response_xml": client.xml_plugin.last_received_xml,
+                    "last_operation": client.xml_plugin.last_operation,
+                }
+
+            with open(output_path, "w", encoding="utf-8") as f:
+                json.dump(output_data, f, indent=2, ensure_ascii=False)
+
+        elif ext == ".xml":
+            # XML format - prioritize raw SOAP XML over parsed result
+            if client.xml_plugin and client.xml_plugin.last_received_xml:
+                # Save the raw SOAP response XML with minimal wrapper
+                content = f"""<?xml version="1.0" encoding="UTF-8"?>
+<!-- ONVIF SOAP Response -->
+<!-- Timestamp: {datetime.now(timezone.utc).isoformat()} -->
+<!-- Operation: {client.xml_plugin.last_operation or 'Unknown'} -->
+
+{client.xml_plugin.last_received_xml}
+"""
+            else:
+                # Fallback: Simple XML wrapper for the parsed result
+                content = f"""<?xml version="1.0" encoding="UTF-8"?>
+<!-- ONVIF Command Output (Parsed Result) -->
+<!-- Timestamp: {datetime.now(timezone.utc).isoformat()} -->
+<!-- Note: Raw SOAP XML not available. Enable --debug for full SOAP capture. -->
+<onvif_result>
+<![CDATA[
+{result!s}
+]]>
+</onvif_result>
+"""
+
+            with open(output_path, "w", encoding="utf-8") as f:
+                f.write(content)
+
+        else:
+            # Plain text format (default)
+            content = "ONVIF Command Output\n"
+            content += f"Timestamp: {datetime.now(timezone.utc).isoformat()}\n"
+            content += f"{'='*50}\n\n"
+            content += str(result)
+
+            # Add debug information if available
+            if debug_mode and client.xml_plugin:
+                content += f"\n\n{'='*50}\n"
+                content += "DEBUG INFORMATION\n"
+                content += f"{'='*50}\n"
+                if client.xml_plugin.last_operation:
+                    content += f"Operation: {client.xml_plugin.last_operation}\n\n"
+                if client.xml_plugin.last_sent_xml:
+                    content += "SOAP Request:\n"
+                    content += client.xml_plugin.last_sent_xml + "\n\n"
+                if client.xml_plugin.last_received_xml:
+                    content += "SOAP Response:\n"
+                    content += client.xml_plugin.last_received_xml + "\n"
+
+            with open(output_path, "w", encoding="utf-8") as f:
+                f.write(content)
+
+    except (AttributeError, ValueError, OSError) as e:
+        print(f"{colorize('Error saving output:', 'red')} {e}", file=sys.stderr)
+        # Still print the result to console if file save fails
+        print(str(result))
+
+
+def _serialize_for_json(obj: Any) -> Any:
+    """Recursively serialize ONVIF objects for JSON output.
+
+    Args:
+        obj: Object to serialize
+
+    Returns:
+        JSON-serializable representation of the object
+    """
+    if obj is None:
+        return None
+    elif isinstance(obj, (str, int, float, bool)):
+        return obj
+    elif isinstance(obj, datetime):
+        return obj.isoformat()
+    elif isinstance(obj, (list, tuple)):
+        return [_serialize_for_json(item) for item in obj]
+    elif isinstance(obj, dict):
+        return {key: _serialize_for_json(value) for key, value in obj.items()}
+
+    # Check if this is a Zeep object (has _xsd_type attribute)
+    elif hasattr(obj, "_xsd_type"):
+        result = {}
+        # Try to get all elements from XSD type
+        if hasattr(obj._xsd_type, "elements"):  # pylint: disable=protected-access
+            for (
+                elem_name,
+                _,
+            ) in obj._xsd_type.elements:  # pylint: disable=protected-access
+                try:
+                    value = getattr(obj, elem_name, None)
+                    if value is not None:
+                        result[elem_name] = _serialize_for_json(value)
+                except (AttributeError, TypeError):
+                    # Skip elements that can't be accessed or have type issues
+                    pass
+
+        # Also try regular attributes
+        for attr_name in dir(obj):
+            if not attr_name.startswith("_") and not callable(
+                getattr(obj, attr_name, None)
+            ):
+                try:
+                    attr_value = getattr(obj, attr_name)
+                    if attr_value is not None and attr_name not in result:
+                        result[attr_name] = _serialize_for_json(attr_value)
+                except (AttributeError, TypeError):
+                    # Skip attributes that can't be accessed or have type issues
+                    pass
+
+        return result
+
+    elif hasattr(obj, "__dict__"):
+        # Handle regular objects with attributes
+        result = {}
+        for key, value in obj.__dict__.items():
+            if not key.startswith("_"):  # Skip private attributes
+                result[key] = _serialize_for_json(value)
+
+        # If result is empty, try to get attributes using dir()
+        if not result:
+            for attr_name in dir(obj):
+                if not attr_name.startswith("_") and not callable(
+                    getattr(obj, attr_name, None)
+                ):
+                    try:
+                        attr_value = getattr(obj, attr_name)
+                        if attr_value is not None:
+                            result[attr_name] = _serialize_for_json(attr_value)
+                    except (AttributeError, TypeError):
+                        # Skip attributes that can't be accessed or have type issues
+                        pass
+
+        return result
+    elif hasattr(obj, "_value_1"):
+        # Handle zeep objects with special structure
+        return _serialize_for_json(obj._value_1)  # pylint: disable=protected-access
+    else:
+        # Try to convert to dict using vars() if available
+        try:
+            obj_dict = vars(obj)
+            return _serialize_for_json(obj_dict)
+        except TypeError:
+            # Fallback to string representation
+            return str(obj)