mocap-desktop-gui 0.22.0__py3-none-any.whl → 0.24.6__py3-none-any.whl

move-errors/move_errors/utils/codes.py

@@ -0,0 +1,108 @@
+"""Util methods for move-error codes."""
+import os
+from typing import Any
+
+from move_errors.codes.messages import (
+    UNKNOWN_ERROR_MESSAGE,
+    UNKNOWN_ERROR_SUGGESTION_MESSAGE,
+)
+
+SUGGESTIONS_LITERAL = "suggestions"
+
+
+def get_default_error_code(code: str) -> tuple[dict[str, Any], str, bool, str]:
+    """Get the default error code.
+
+    Args:
+        code: The error code.
+
+    Returns:
+        The default error code tuple.
+    """
+    return (
+        {
+            "suggestions": [
+                UNKNOWN_ERROR_SUGGESTION_MESSAGE,
+            ],
+        },
+        code,
+        True,
+        UNKNOWN_ERROR_MESSAGE,
+    )
+
+
+def get_default_pydantic_error_code(code: str) -> tuple[dict[str, Any], str, bool, str]:
+    """Get the default error code for pydantic errors.
+
+    Args:
+        code: The error code.
+
+    Returns:
+        The default error code tuple.
+    """
+    return (
+        {
+            SUGGESTIONS_LITERAL: [
+                "Please verify that you've provided the correct data.",
+                "Please refer to the data key for invalid data related to this error.",
+                "{0} {1}.".format(
+                    "Please check the api documentation for the correct data format at",
+                    "https://move-ai.github.io/move-ugc-api/schema/",
+                ),
+            ],
+        },
+        code,
+        True,
+        # This message will most likely be overridden by the pydantic error message
+        "Data validation failed.",
+    )
+
+
+def get_default_error_code404(code: str) -> tuple[dict[str, Any], str, bool, str]:
+    """Get the default error code for not found errors.
+
+    Args:
+        code: The error code.
+
+    Returns:
+        The default error code tuple.
+    """
+    service: str = os.getenv("SERVICE_NAME", "Move.ai")
+    return (
+        {
+            SUGGESTIONS_LITERAL: [
+                "Please verify that the resource you're requesting exists.",
+            ],
+        },
+        code,
+        True,
+        # This message will most likely be overridden by the pydantic error message
+        f"Resource not found in {service}.",
+    )
+
+
+def get_default_bad_request_error_code(
+    code: str,
+) -> tuple[dict[str, Any], str, bool, str]:
+    """Get the default error code for bad requests.
+
+    This is typically used for internal bad requests.
+
+    Args:
+        code: The error code.
+
+    Returns:
+        The default error code tuple.
+    """
+    return (
+        {
+            SUGGESTIONS_LITERAL: [
+                "Please verify that you've provided the correct data.",
+            ],
+        },
+        code,
+        # By default, don't display this error to the user, as it's an internal error
+        # This can be overridden on api by api basis.
+        False,
+        "Bad request.",
+    )

move-errors/move_errors/utils/engine.py

@@ -0,0 +1,46 @@
+"""Operation name to engine error code mapping."""
+import importlib
+import inspect
+import os
+from pathlib import Path
+from types import ModuleType
+
+from move_errors.codes import engine
+from move_errors.codes.base import BaseErrorCode
+
+# The engine error codes mapping.
+# This allows the engine to provide an operation name and for us to then map that
+# to the correct error code class.
+codes = {}
+
+
+def _build_code_for_module(module: ModuleType) -> None:
+    """Build the error code mapping for the module.
+
+    Args:
+        module: The module to build the codes for.
+    """
+    ops_classes = inspect.getmembers(module, inspect.isclass)
+    for ops_class_name, ops_class in ops_classes:
+        # Ensure that we only load classes that are named with `Ops`
+        is_ops_error_code_class = issubclass(ops_class, (BaseErrorCode,))
+        if ops_class_name.startswith("Ops") and is_ops_error_code_class:
+            codes[str(ops_class.operation_name())] = ops_class
+
+
+def _init() -> None:
+    """Initialise the engine error codes dynamically.
+
+    We don't want to have to remember to add ops error codes and classes. Therefore,
+    build the list dynamically. This functionality is inspired by requests.status_codes
+    """
+    for module_name in os.listdir(os.path.dirname(inspect.getfile(engine))):
+        if module_name.startswith("ops_"):
+            # Ensure that we only import modules that begin with `ops_`
+            imported_sub_module = importlib.import_module(
+                "{0}.{1}".format(engine.__name__, Path(module_name).stem),
+            )
+            _build_code_for_module(imported_sub_module)
+
+
+_init()

move-errors/move_errors/utils/fastapi.py

@@ -0,0 +1,36 @@
+"""Define Error Handlers."""
+import httpx
+from starlette.requests import Request
+from starlette.responses import JSONResponse
+
+from move_errors.exceptions import MoveError
+
+
+def move_error_handler(
+    request: Request,
+    exc: MoveError,
+) -> JSONResponse:
+    """Exception Handler for Move Error.
+
+    Args:
+        request: Request object.
+        exc: Exception object.
+
+    Returns:
+        JSONResponse: JSON response when MoveError is raised.
+    """
+    status_code = httpx.codes.BAD_REQUEST
+    if isinstance(exc.data, dict) and exc.data.get("status_code"):
+        status_code = exc.data["status_code"]
+    return JSONResponse(
+        status_code=status_code,
+        content={
+            "error": {
+                "code": exc.code.code,
+                "message": exc.message,
+                "info": exc.info,
+                "data": exc.data or {},
+                "is_display": exc.is_display,
+            },
+        },
+    )

move-errors/move_errors/utils/repository.py

@@ -0,0 +1,82 @@
+"""Move errors repository."""
+import importlib
+import inspect
+import os
+from enum import Enum
+from itertools import chain
+from pathlib import Path
+from types import ModuleType
+from typing import Type
+
+from move_errors.codes import engine, internal_services, public_apis
+from move_errors.codes.base import BaseErrorCode
+from move_errors.codes.engine.base import BaseEngineOpsErrorCode
+
+
+def _import_all_error_codes_by_submodule(
+    module: ModuleType,
+) -> None:
+    """Import all error codes by submodule.
+
+    Args:
+        module (ModuleType): The module to import the error codes from.
+    """
+    for submodule in os.listdir(os.path.dirname(inspect.getfile(module))):
+        importlib.import_module(
+            "{0}.{1}".format(module.__name__, Path(submodule).stem),
+        )
+
+
+def _get_child_error_codes(
+    base_class: Type[BaseErrorCode],
+    exclude_list: list[Type[BaseErrorCode]] | None = None,
+) -> list[Type[BaseErrorCode]]:
+    """Get all the child error codes of the given base class.
+
+    Args:
+        base_class (Type[BaseErrorCode]):
+            The base class to get the child error codes for.
+        exclude_list (list[Type[BaseErrorCode]], optional):
+            The list of error codes to exclude. Defaults to ().
+
+    Returns:
+        list[Type[BaseErrorCode]]: The list of child error codes.
+    """
+    return [
+        code_class
+        for code_class in base_class.__subclasses__()
+        if code_class not in (exclude_list or [])
+    ]
+
+
+def _build_unified_enum() -> Enum:
+    """Build the unified error codes enum.
+
+    Returns:
+        Enum: The unified error codes enum.
+    """
+    chained_codes = chain.from_iterable(  # type: ignore[var-annotated]
+        _get_child_error_codes(  # type: ignore[arg-type]
+            BaseErrorCode,
+            exclude_list=[BaseEngineOpsErrorCode],
+        ),
+    )
+    engine_chained_codes = chain.from_iterable(  # type: ignore[var-annotated]
+        _get_child_error_codes(BaseEngineOpsErrorCode),  # type: ignore[arg-type]
+    )
+    chained_codes = chain(chained_codes, engine_chained_codes)
+    return Enum(
+        "MoveErrorCodes",
+        [(code.name, code.value) for code in chained_codes],
+    )
+
+
+def _init() -> None:
+    """Initialise the error codes dynamically."""
+    _import_all_error_codes_by_submodule(internal_services)
+    _import_all_error_codes_by_submodule(public_apis)
+    _import_all_error_codes_by_submodule(engine)
+
+
+_init()
+MoveErrorCodes = _build_unified_enum()