touchdesigner-mcp-server 0.4.0-alpha.0 → 0.4.0-alpha.2

package/td/modules/td_server/openapi_server/test/__init__.py

@@ -1,16 +0,0 @@
-import logging
-
-import connexion
-from flask_testing import TestCase
-
-from openapi_server.encoder import JSONEncoder
-
-
-class BaseTestCase(TestCase):
-
-    def create_app(self):
-        logging.getLogger('connexion.operation').setLevel('ERROR')
-        app = connexion.App(__name__, specification_dir='../openapi/')
-        app.app.json_encoder = JSONEncoder
-        app.add_api('openapi.yaml', pythonic_params=True)
-        return app.app

package/td/modules/td_server/openapi_server/test/test_default_controller.py

@@ -1,201 +0,0 @@
-import unittest
-
-from flask import json
-
-from openapi_server.models.create_node200_response import CreateNode200Response  # noqa: E501
-from openapi_server.models.create_node_request import CreateNodeRequest  # noqa: E501
-from openapi_server.models.delete_node200_response import DeleteNode200Response  # noqa: E501
-from openapi_server.models.exec_node_method200_response import ExecNodeMethod200Response  # noqa: E501
-from openapi_server.models.exec_node_method_request import ExecNodeMethodRequest  # noqa: E501
-from openapi_server.models.exec_python_script200_response import ExecPythonScript200Response  # noqa: E501
-from openapi_server.models.exec_python_script_request import ExecPythonScriptRequest  # noqa: E501
-from openapi_server.models.get_node_detail200_response import GetNodeDetail200Response  # noqa: E501
-from openapi_server.models.get_nodes200_response import GetNodes200Response  # noqa: E501
-from openapi_server.models.get_td_info200_response import GetTdInfo200Response  # noqa: E501
-from openapi_server.models.get_td_python_class_details200_response import GetTdPythonClassDetails200Response  # noqa: E501
-from openapi_server.models.get_td_python_classes200_response import GetTdPythonClasses200Response  # noqa: E501
-from openapi_server.models.update_node200_response import UpdateNode200Response  # noqa: E501
-from openapi_server.models.update_node_request import UpdateNodeRequest  # noqa: E501
-from openapi_server.test import BaseTestCase
-
-
-class TestDefaultController(BaseTestCase):
-    """DefaultController integration test stubs"""
-
-    def test_create_node(self):
-        """Test case for create_node
-
-        Create a new node
-        """
-        create_node_request = openapi_server.CreateNodeRequest()
-        headers = { 
-            'Accept': 'application/json',
-            'Content-Type': 'application/json',
-        }
-        response = self.client.open(
-            '/api/nodes',
-            method='POST',
-            headers=headers,
-            data=json.dumps(create_node_request),
-            content_type='application/json')
-        self.assert200(response,
-                       'Response body is : ' + response.data.decode('utf-8'))
-
-    def test_delete_node(self):
-        """Test case for delete_node
-
-        Delete an existing node
-        """
-        query_string = [('nodePath', 'node_path_example')]
-        headers = { 
-            'Accept': 'application/json',
-        }
-        response = self.client.open(
-            '/api/nodes',
-            method='DELETE',
-            headers=headers,
-            query_string=query_string)
-        self.assert200(response,
-                       'Response body is : ' + response.data.decode('utf-8'))
-
-    def test_exec_node_method(self):
-        """Test case for exec_node_method
-
-        Call a method of the specified node
-        """
-        exec_node_method_request = openapi_server.ExecNodeMethodRequest()
-        headers = { 
-            'Accept': 'application/json',
-            'Content-Type': 'application/json',
-        }
-        response = self.client.open(
-            '/api/td/nodes/exec',
-            method='POST',
-            headers=headers,
-            data=json.dumps(exec_node_method_request),
-            content_type='application/json')
-        self.assert200(response,
-                       'Response body is : ' + response.data.decode('utf-8'))
-
-    def test_exec_python_script(self):
-        """Test case for exec_python_script
-
-        Execute python code on the server
-        """
-        exec_python_script_request = openapi_server.ExecPythonScriptRequest()
-        headers = { 
-            'Accept': 'application/json',
-            'Content-Type': 'application/json',
-        }
-        response = self.client.open(
-            '/api/td/server/exec',
-            method='POST',
-            headers=headers,
-            data=json.dumps(exec_python_script_request),
-            content_type='application/json')
-        self.assert200(response,
-                       'Response body is : ' + response.data.decode('utf-8'))
-
-    def test_get_node_detail(self):
-        """Test case for get_node_detail
-
-        Get node detail
-        """
-        query_string = [('nodePath', 'node_path_example')]
-        headers = { 
-            'Accept': 'application/json',
-        }
-        response = self.client.open(
-            '/api/nodes/detail',
-            method='GET',
-            headers=headers,
-            query_string=query_string)
-        self.assert200(response,
-                       'Response body is : ' + response.data.decode('utf-8'))
-
-    def test_get_nodes(self):
-        """Test case for get_nodes
-
-        Get nodes in the path
-        """
-        query_string = [('parentPath', 'parent_path_example'),
-                        ('pattern', '*'),
-                        ('includeProperties', False)]
-        headers = { 
-            'Accept': 'application/json',
-        }
-        response = self.client.open(
-            '/api/nodes',
-            method='GET',
-            headers=headers,
-            query_string=query_string)
-        self.assert200(response,
-                       'Response body is : ' + response.data.decode('utf-8'))
-
-    def test_get_td_info(self):
-        """Test case for get_td_info
-
-        Get TouchDesigner information
-        """
-        headers = { 
-            'Accept': 'application/json',
-        }
-        response = self.client.open(
-            '/api/td/server/td',
-            method='GET',
-            headers=headers)
-        self.assert200(response,
-                       'Response body is : ' + response.data.decode('utf-8'))
-
-    def test_get_td_python_class_details(self):
-        """Test case for get_td_python_class_details
-
-        Get details of a specific Python class or module
-        """
-        headers = { 
-            'Accept': 'application/json',
-        }
-        response = self.client.open(
-            '/api/td/classes/{class_name}'.format(class_name='class_name_example'),
-            method='GET',
-            headers=headers)
-        self.assert200(response,
-                       'Response body is : ' + response.data.decode('utf-8'))
-
-    def test_get_td_python_classes(self):
-        """Test case for get_td_python_classes
-
-        Get a list of Python classes and modules
-        """
-        headers = { 
-            'Accept': 'application/json',
-        }
-        response = self.client.open(
-            '/api/td/classes',
-            method='GET',
-            headers=headers)
-        self.assert200(response,
-                       'Response body is : ' + response.data.decode('utf-8'))
-
-    def test_update_node(self):
-        """Test case for update_node
-
-        Update node properties
-        """
-        update_node_request = openapi_server.UpdateNodeRequest()
-        headers = { 
-            'Accept': 'application/json',
-            'Content-Type': 'application/json',
-        }
-        response = self.client.open(
-            '/api/nodes/detail',
-            method='PATCH',
-            headers=headers,
-            data=json.dumps(update_node_request),
-            content_type='application/json')
-        self.assert200(response,
-                       'Response body is : ' + response.data.decode('utf-8'))
-
-
-if __name__ == '__main__':
-    unittest.main()

package/td/modules/td_server/openapi_server/typing_utils.py

@@ -1,30 +0,0 @@
-import sys
-
-if sys.version_info < (3, 7):
-    import typing
-
-    def is_generic(klass):
-        """ Determine whether klass is a generic class """
-        return type(klass) == typing.GenericMeta
-
-    def is_dict(klass):
-        """ Determine whether klass is a Dict """
-        return klass.__extra__ == dict
-
-    def is_list(klass):
-        """ Determine whether klass is a List """
-        return klass.__extra__ == list
-
-else:
-
-    def is_generic(klass):
-        """ Determine whether klass is a generic class """
-        return hasattr(klass, '__origin__')
-
-    def is_dict(klass):
-        """ Determine whether klass is a Dict """
-        return klass.__origin__ == dict
-
-    def is_list(klass):
-        """ Determine whether klass is a List """
-        return klass.__origin__ == list

package/td/modules/td_server/openapi_server/util.py

@@ -1,147 +0,0 @@
-import datetime
-
-import typing
-from openapi_server import typing_utils
-
-
-def _deserialize(data, klass):
-    """Deserializes dict, list, str into an object.
-
-    :param data: dict, list or str.
-    :param klass: class literal, or string of class name.
-
-    :return: object.
-    """
-    if data is None:
-        return None
-
-    if klass in (int, float, str, bool, bytearray):
-        return _deserialize_primitive(data, klass)
-    elif klass == object:
-        return _deserialize_object(data)
-    elif klass == datetime.date:
-        return deserialize_date(data)
-    elif klass == datetime.datetime:
-        return deserialize_datetime(data)
-    elif typing_utils.is_generic(klass):
-        if typing_utils.is_list(klass):
-            return _deserialize_list(data, klass.__args__[0])
-        if typing_utils.is_dict(klass):
-            return _deserialize_dict(data, klass.__args__[1])
-    else:
-        return deserialize_model(data, klass)
-
-
-def _deserialize_primitive(data, klass):
-    """Deserializes to primitive type.
-
-    :param data: data to deserialize.
-    :param klass: class literal.
-
-    :return: int, long, float, str, bool.
-    :rtype: int | long | float | str | bool
-    """
-    try:
-        value = klass(data)
-    except UnicodeEncodeError:
-        value = data
-    except TypeError:
-        value = data
-    return value
-
-
-def _deserialize_object(value):
-    """Return an original value.
-
-    :return: object.
-    """
-    return value
-
-
-def deserialize_date(string):
-    """Deserializes string to date.
-
-    :param string: str.
-    :type string: str
-    :return: date.
-    :rtype: date
-    """
-    if string is None:
-      return None
-    
-    try:
-        from dateutil.parser import parse
-        return parse(string).date()
-    except ImportError:
-        return string
-
-
-def deserialize_datetime(string):
-    """Deserializes string to datetime.
-
-    The string should be in iso8601 datetime format.
-
-    :param string: str.
-    :type string: str
-    :return: datetime.
-    :rtype: datetime
-    """
-    if string is None:
-      return None
-    
-    try:
-        from dateutil.parser import parse
-        return parse(string)
-    except ImportError:
-        return string
-
-
-def deserialize_model(data, klass):
-    """Deserializes list or dict to model.
-
-    :param data: dict, list.
-    :type data: dict | list
-    :param klass: class literal.
-    :return: model object.
-    """
-    instance = klass()
-
-    if not instance.openapi_types:
-        return data
-
-    for attr, attr_type in instance.openapi_types.items():
-        if data is not None \
-                and instance.attribute_map[attr] in data \
-                and isinstance(data, (list, dict)):
-            value = data[instance.attribute_map[attr]]
-            setattr(instance, attr, _deserialize(value, attr_type))
-
-    return instance
-
-
-def _deserialize_list(data, boxed_type):
-    """Deserializes a list and its elements.
-
-    :param data: list to deserialize.
-    :type data: list
-    :param boxed_type: class literal.
-
-    :return: deserialized list.
-    :rtype: list
-    """
-    return [_deserialize(sub_data, boxed_type)
-            for sub_data in data]
-
-
-def _deserialize_dict(data, boxed_type):
-    """Deserializes a dict and its elements.
-
-    :param data: dict to deserialize.
-    :type data: dict
-    :param boxed_type: class literal.
-
-    :return: deserialized dict.
-    :rtype: dict
-    """
-    return {k: _deserialize(v, boxed_type)
-            for k, v in data.items() }

package/td/modules/td_server/requirements.txt

@@ -1,13 +0,0 @@
-connexion[swagger-ui] >= 2.6.0; python_version>="3.6"
-# 2.3 is the last version that supports python 3.4-3.5
-connexion[swagger-ui] <= 2.3.0; python_version=="3.5" or python_version=="3.4"
-# prevent breaking dependencies from advent of connexion>=3.0
-connexion[swagger-ui] <= 2.14.2; python_version>"3.4"
-# connexion requires werkzeug but connexion < 2.4.0 does not install werkzeug
-# we must peg werkzeug versions below to fix connexion
-# https://github.com/zalando/connexion/pull/1044
-werkzeug == 0.16.1; python_version=="3.5" or python_version=="3.4"
-swagger-ui-bundle >= 0.0.2
-python_dateutil >= 2.6.0
-setuptools >= 21.0.0
-Flask == 2.1.1

package/td/modules/td_server/setup.py

@@ -1,37 +0,0 @@
-import sys
-from setuptools import setup, find_packages
-
-NAME = "openapi_server"
-VERSION = "1.0.0"
-
-# To install the library, run the following
-#
-# python setup.py install
-#
-# prerequisite: setuptools
-# http://pypi.python.org/pypi/setuptools
-
-REQUIRES = [
-    "connexion>=2.0.2",
-    "swagger-ui-bundle>=0.0.2",
-    "python_dateutil>=2.6.0"
-]
-
-setup(
-    name=NAME,
-    version=VERSION,
-    description="TouchDesigner API",
-    author_email="",
-    url="",
-    keywords=["OpenAPI", "TouchDesigner API"],
-    install_requires=REQUIRES,
-    packages=find_packages(),
-    package_data={'': ['openapi/openapi.yaml']},
-    include_package_data=True,
-    entry_points={
-        'console_scripts': ['openapi_server=openapi_server.__main__:main']},
-    long_description="""\
-    OpenAPI schema for generating TouchDesigner API client code
-    """
-)
-

package/td/modules/td_server/test-requirements.txt

@@ -1,4 +0,0 @@
-pytest~=7.1.0
-pytest-cov>=2.8.1
-pytest-randomly>=1.2.3
-Flask-Testing==0.8.1

package/td/modules/td_server/tox.ini

@@ -1,11 +0,0 @@
-[tox]
-envlist = py3
-skipsdist=True
-
-[testenv]
-deps=-r{toxinidir}/requirements.txt
-     -r{toxinidir}/test-requirements.txt
-     {toxinidir}
-
-commands=
-   pytest --cov=openapi_server

package/td/modules/utils/config.py

@@ -1,7 +0,0 @@
-"""
-TouchDesigner MCP Web Server Configuration Module
-Provides API endpoint definitions and HTTP status code settings
-"""
-
-# Enable LogLevel.DEBUG logging
-DEBUG = True

package/td/modules/utils/error_handling.py

@@ -1,104 +0,0 @@
-"""
-Error handling utilities for TouchDesigner MCP Web server
-Provides standardized error categorization, formatting, and handling
-"""
-
-import functools
-import traceback
-from enum import Enum
-from typing import Callable, Optional, TypeVar
-
-from utils.logging import log_message
-from utils.result import Result, error_result
-from utils.types import LogLevel
-
-T = TypeVar("T")
-
-
-class ErrorCategory(Enum):
-    """
-    Error categories for better classification and handling
-    """
-
-    INTERNAL = "INTERNAL"
-    VALIDATION = "VALIDATION"
-    NOT_FOUND = "NOT_FOUND"
-    PERMISSION = "PERMISSION"
-    NETWORK = "NETWORK"
-    EXTERNAL = "EXTERNAL"
-
-    def __str__(self) -> str:
-        return self.value
-
-
-def categorize_error(exception: Exception) -> ErrorCategory:
-    """
-    Categorize an exception based on its type and message
-
-    Args:
-        exception: The exception to categorize
-
-    Returns:
-        Appropriate ErrorCategory
-    """
-    error_message = str(exception).lower()
-
-    if isinstance(exception, ValueError):
-        return ErrorCategory.VALIDATION
-    elif isinstance(exception, FileNotFoundError):
-        return ErrorCategory.NOT_FOUND
-    elif "not found" in error_message or "doesn't exist" in error_message:
-        return ErrorCategory.NOT_FOUND
-    elif "permission" in error_message or "access denied" in error_message:
-        return ErrorCategory.PERMISSION
-    elif "network" in error_message or "connection" in error_message:
-        return ErrorCategory.NETWORK
-    elif "external" in error_message or "service unavailable" in error_message:
-        return ErrorCategory.EXTERNAL
-
-    return ErrorCategory.INTERNAL
-
-
-def format_error(message: str, category: Optional[ErrorCategory] = None) -> str:
-    """
-    Format an error message with its category
-
-    Args:
-        message: The error message
-        category: Error category (defaults to INTERNAL)
-
-    Returns:
-        Formatted error message
-    """
-    if category is None:
-        category = ErrorCategory.INTERNAL
-
-    return f"{category}: {message}"
-
-
-def handle_service_errors(func: Callable[..., Result]) -> Callable[..., Result]:
-    """
-    Decorator to handle errors in service methods and convert them to Result type
-
-    Args:
-        func: The service method to decorate
-
-    Returns:
-        Wrapped function that catches exceptions and returns Result
-    """
-
-    @functools.wraps(func)
-    def wrapper(*args, **kwargs) -> Result:
-        try:
-            return func(*args, **kwargs)
-        except Exception as e:
-            category = categorize_error(e)
-
-            func_name = func.__name__
-            log_message(f"Error in {func_name}: {str(e)}", LogLevel.ERROR)
-            log_message(traceback.format_exc(), LogLevel.DEBUG)
-
-            error_message = format_error(str(e), category)
-            return error_result(error_message, {"errorCategory": category})
-
-    return wrapper

package/td/modules/utils/logging.py

@@ -1,23 +0,0 @@
-"""
-Logging module for TouchDesigner MCP Web server
-"""
-
-from datetime import datetime
-
-from utils.types import LogLevel
-
-from .config import DEBUG
-
-
-def log_message(message: str, level: LogLevel = LogLevel.INFO) -> None:
-    """Log a message using the appropriate logging mechanism"""
-
-    if not DEBUG and level == LogLevel.DEBUG:
-        return
-
-    time_stamp = datetime.now().strftime("%Y%m%d_%H:%M:%S.%f")[
-        :-3
-    ] + datetime.now().strftime("%z")
-    prefix = f"{time_stamp} [{level}]"
-    full_message = f"{prefix}\t{message}"
-    print(full_message)

package/td/modules/utils/result.py

@@ -1,40 +0,0 @@
-"""
-Result pattern utilities for TouchDesigner MCP Web server
-Provides utility functions for handling success and failure results
-"""
-
-from typing import Any, Dict, Optional
-
-from .types import Result
-
-
-def success_result(data: Any) -> Result:
-    """
-    Create a success result with data
-
-    Args:
-        data: The success result data
-
-    Returns:
-        Result dictionary with success flag and data
-    """
-    return {"success": True, "data": data, "error": None}
-
-
-def error_result(message: str, metadata: Optional[Dict[str, Any]] = None) -> Result:
-    """
-    Create an error result with message and optional metadata
-
-    Args:
-        message: The error message
-        metadata: Optional additional error metadata
-
-    Returns:
-        Result dictionary with error information
-    """
-    result = {"success": False,"data": None,  "error": message}
-
-    if metadata:
-        result.update(metadata)
-
-    return result