aspyx-service 0.11.2__py3-none-any.whl

aspyx_service/generator/json_schema_generator.py

@@ -0,0 +1,197 @@
+from typing import get_type_hints, get_origin, get_args, Any
+import json
+
+from pydantic import BaseModel
+
+from aspyx.reflection import TypeDescriptor
+
+
+class JSONSchemaGenerator:
+    """
+    Generates a JSON Schema-based service descriptor for framework-agnostic
+    service discovery and handshaking between systems.
+    """
+
+    PRIMITIVES = {
+        str: {"type": "string"},
+        int: {"type": "integer"},
+        float: {"type": "number"},
+        bool: {"type": "boolean"},
+        type(None): {"type": "null"},
+    }
+
+    def __init__(self, service_manager):
+        self.service_manager = service_manager
+        self.type_defs: dict[str, dict] = {}  # Stores reusable type definitions
+        self.processed_types: set[type] = set()  # Track processed types to avoid duplicates
+
+    def _get_type_name(self, typ: type) -> str:
+        """Get a unique name for a type."""
+        if hasattr(typ, '__name__'):
+            return typ.__name__
+        return str(typ)
+
+    def _process_type(self, typ: type) -> dict:
+        """
+        Process a type and return its JSON Schema representation.
+        Complex types are added to type_defs and referenced via $ref.
+        """
+        # Handle None type
+        if typ is type(None):
+            return {"type": "null"}
+
+        # Handle primitives
+        if typ in self.PRIMITIVES:
+            return self.PRIMITIVES[typ].copy()
+
+        # Handle Optional types (Union[X, None])
+        origin = get_origin(typ)
+        if origin is type(None) or origin is type(None).__class__:
+            return {"type": "null"}
+
+        # Handle Union types
+        if origin is Union or (hasattr(types, 'UnionType') and origin is types.UnionType):
+            args = get_args(typ)
+            # Check if it's Optional (Union with None)
+            if type(None) in args:
+                non_none_args = [arg for arg in args if arg is not type(None)]
+                if len(non_none_args) == 1:
+                    # This is Optional[X]
+                    schema = self._process_type(non_none_args[0])
+                    return {"anyOf": [schema, {"type": "null"}]}
+            # Regular union
+            return {"anyOf": [self._process_type(arg) for arg in args]}
+
+        # Handle List/Sequence types
+        if origin in (list, List) or (hasattr(collections.abc, 'Sequence') and origin is collections.abc.Sequence):
+            args = get_args(typ)
+            item_type = args[0] if args else Any
+            return {
+                "type": "array",
+                "items": self._process_type(item_type)
+            }
+
+        # Handle Dict types
+        if origin in (dict, Dict):
+            args = get_args(typ)
+            if len(args) >= 2:
+                return {
+                    "type": "object",
+                    "additionalProperties": self._process_type(args[1])
+                }
+            return {"type": "object"}
+
+        # Handle Pydantic models
+        if isinstance(typ, type) and issubclass(typ, BaseModel):
+            type_name = self._get_type_name(typ)
+
+            # Add to type_defs if not already processed
+            if typ not in self.processed_types:
+                self.processed_types.add(typ)
+                schema = typ.model_json_schema()
+                # Remove $defs from individual schemas to avoid nesting
+                if '$defs' in schema:
+                    nested_defs = schema.pop('$defs')
+                    self.type_defs.update(nested_defs)
+                self.type_defs[type_name] = schema
+
+            return {"$ref": f"#/$defs/{type_name}"}
+
+        # Fallback for unknown types
+        return {"type": "object", "description": f"Unknown type: {typ}"}
+
+    def _extract_method_info(self, method_desc) -> dict:
+        """Extract parameter and return type information from a method."""
+        method_info = {
+            "description": method_desc.method.__doc__ or "",
+            "parameters": {
+                "type": "object",
+                "properties": {},
+                "required": []
+            }
+        }
+
+        # Process parameters
+        for param in method_desc.params:
+            if param.name == 'self':
+                continue
+
+            param_schema = self._process_type(param.type)
+            method_info["parameters"]["properties"][param.name] = param_schema
+
+            # Check if parameter is required (not Optional)
+            origin = get_origin(param.type)
+            args = get_args(param.type)
+            is_optional = origin is Union and type(None) in args
+
+            # Check if parameter has a default value
+            has_default = hasattr(param, 'default') and param.default is not None
+
+            if not is_optional and not has_default:
+                method_info["parameters"]["required"].append(param.name)
+
+        # If no required parameters, remove the empty list
+        if not method_info["parameters"]["required"]:
+            del method_info["parameters"]["required"]
+
+        # Process return type
+        if method_desc.return_type and method_desc.return_type is not type(None):
+            method_info["returns"] = self._process_type(method_desc.return_type)
+        else:
+            method_info["returns"] = {"type": "null"}
+
+        return method_info
+
+    def generate(self) -> dict:
+        """
+        Generate a JSON Schema-based service descriptor.
+
+        Returns a dictionary with:
+        - services: Dictionary of service definitions
+        - $defs: Reusable type definitions
+        """
+        schema = {
+            "schemaVersion": "1.0.0",
+            "services": {},
+            "$defs": {}
+        }
+
+        for service_name, service in self.service_manager.descriptors_by_name.items():
+            if service.is_component():
+                continue
+
+            descriptor = TypeDescriptor.for_type(service.type)
+
+            service_schema = {
+                "name": service_name,
+                "type": self._get_type_name(service.type),
+                "description": service.type.__doc__ or "",
+                "methods": {}
+            }
+
+            # Process all methods
+            for method_desc in descriptor.get_methods():
+                method_name = method_desc.method.__name__
+
+                # Skip private methods
+                if method_name.startswith('_'):
+                    continue
+
+                service_schema["methods"][method_name] = self._extract_method_info(method_desc)
+
+            schema["services"][service_name] = service_schema
+
+        # Add all collected type definitions
+        schema["$defs"] = self.type_defs
+
+        return schema
+
+    def to_json(self, indent: int = 2) -> str:
+        """Generate and serialize the schema to JSON."""
+        return json.dumps(self.generate(), indent=indent)
+
+
+# Import required types
+from typing import Union, List, Dict
+import types
+import collections.abc

aspyx_service/generator/openapi_generator.py

@@ -0,0 +1,120 @@
+from typing import TypeVar
+
+from pydantic import BaseModel
+from fastapi.openapi.models import OpenAPI, Info, PathItem, Operation, Response, Parameter, RequestBody, \
+    MediaType
+
+from aspyx.reflection import TypeDescriptor
+from aspyx_service import rest
+from aspyx_service.restchannel import RestChannel
+
+T = TypeVar("T")
+
+class OpenAPIGenerator:
+    PRIMITIVES = {
+        str: {"type": "string"},
+        int: {"type": "integer", "format": "int32"},
+        float: {"type": "number", "format": "float"},
+        bool: {"type": "boolean"},
+    }
+
+    def __init__(self, service_manager):
+        self.service_manager = service_manager
+        self.rest_channel: RestChannel = service_manager.environment.get(RestChannel)
+        self.schemas: dict[type, dict] = {}
+
+    def _get_schema_for_type(self, typ: type) -> dict:
+        if typ in self.schemas:
+            return self.schemas[typ]
+
+        if typ in self.PRIMITIVES:
+            schema = self.PRIMITIVES[typ]
+        elif isinstance(typ, type) and issubclass(typ, BaseModel):
+            schema = typ.model_json_schema()
+        else:
+            schema = {"type": "object"}
+
+        self.schemas[typ] = schema
+        return schema
+
+    def generate(self) -> OpenAPI:
+        from fastapi.openapi.models import Components
+
+        openapi = OpenAPI(
+            openapi="3.1.0",
+            info=Info(title="My API", version="1.0.0"),
+            paths={},
+            components=Components(schemas={}),
+        )
+
+        for service_name, service in self.service_manager.descriptors_by_name.items():
+            if service.is_component():
+                continue
+
+            descriptor = TypeDescriptor.for_type(service.type)
+
+            if not descriptor.has_decorator(rest):
+                continue
+
+            print(service.type)
+
+            for method_desc in descriptor.get_methods():
+                call = self.rest_channel.get_call(service.type, method_desc.method)
+
+                #if call.type != "get":
+                #    continue
+
+                path_item: PathItem = openapi.paths.get(call.url_template, PathItem())
+                operation = Operation(
+                    responses={"200": Response(description="Success")},
+                    parameters=[],
+                )
+
+                # Add path parameters
+                for name in call.path_param_names:
+                    # get type hint
+                    hint = next((p.type for p in method_desc.params if p.name == name), str)
+                    operation.parameters.append(
+                        Parameter(
+                            name=name,
+                            **{"in": "path"},  # Use dict unpacking to avoid keyword conflict
+                            required=True,
+                            schema=self._get_schema_for_type(hint),
+                        )
+                    )
+
+                # Add query parameters
+                for name in call.query_param_names:
+                    hint = next((p.type for p in method_desc.params if p.name == name), str)
+                    operation.parameters.append(
+                        Parameter(
+                            name=name,
+                            **{"in": "query"},  # Use dict unpacking to avoid keyword conflict
+                            required=True,
+                            schema=self._get_schema_for_type(hint),
+                        )
+                    )
+
+                # Add request body
+                if call.body_param_name:
+                    hint = next((p.type for p in method_desc.params if p.name == call.body_param_name), dict)
+                    operation.request_body = RequestBody(
+                        required=True,
+                        content={"application/json": MediaType(schema=self._get_schema_for_type(hint))}
+                    )
+
+                # attach operation to HTTP method
+                setattr(path_item, call.type.lower(), operation)
+                openapi.paths[call.url_template] = path_item
+
+        # attach all cached schemas
+        openapi.components.schemas = {k.__name__: v for k, v in self.schemas.items()}
+
+        return openapi
+
+    def to_json(self, indent: int = 2) -> str:
+        return self.generate().model_dump_json(
+            indent=indent,
+            exclude_none=True,
+            by_alias=True
+        )

aspyx_service/healthcheck.py

@@ -0,0 +1,194 @@
+"""
+health checks
+"""
+from __future__ import annotations
+
+import asyncio
+import logging
+import time
+from enum import Enum
+from typing import Any, Callable, Type, Optional
+
+from aspyx.di import injectable, Environment, inject_environment, on_init
+from aspyx.reflection import Decorators, TypeDescriptor
+
+
+def health_checks():
+    """
+    Instances of classes that are annotated with @health_checks contain healt mehtods.
+    """
+    def decorator(cls):
+        Decorators.add(cls, health_checks)
+
+        #if not Providers.is_registered(cls):
+        #    Providers.register(ClassInstanceProvider(cls, True, "singleton"))
+
+        HealthCheckManager.types.append(cls)
+
+        return cls
+
+    return decorator
+
+def health_check(name="", cache = 0, fail_if_slower_than = 0):
+    """
+    Methods annotated with `@health_check` specify health checks that will be executed.
+    """
+    def decorator(func):
+        Decorators.add(func, health_check, name, cache, fail_if_slower_than)
+        return func
+
+    return decorator
+
+class HealthStatus(Enum):
+    """
+    A enum specifying the health status of a service. The values are:
+
+    - `OK` service is healthy
+    - `WARNING` service has some problems
+    - `CRITICAL` service is unhealthy
+    """
+    OK = 1
+    WARNING = 2
+    ERROR = 3
+
+    def __str__(self):
+        return self.name
+
+
+@injectable()
+class HealthCheckManager:
+    """
+    The health manager is able to run all registered health checks and is able to return an overall status.
+    """
+    logger = logging.getLogger("aspyx.service.health")
+
+    # local classes
+
+    class Check:
+        def __init__(self, name: str, cache: int, fail_if_slower_than: int, instance: Any, callable: Callable):
+            self.name = name
+            self.cache = cache
+            self.callable = callable
+            self.instance = instance
+            self.fail_if_slower_than = fail_if_slower_than
+            self.last_check = 0
+
+            self.last_value : Optional[HealthCheckManager.Result] = None
+
+        async def run(self, result: HealthCheckManager.Result):
+            now = time.time()
+
+            if self.cache > 0 and self.last_check is not None and now - self.last_check < self.cache:
+                result.copy_from(self.last_value)
+                return
+
+            self.last_check = now
+            self.last_value = result
+
+            if asyncio.iscoroutinefunction(self.callable):
+                await self.callable(self.instance, result)
+            else:
+                await asyncio.to_thread(self.callable, self.instance, result)
+
+            spent = time.time() - now
+
+            if result.status == HealthStatus.OK and 0 < self.fail_if_slower_than < spent:
+                result.status = HealthStatus.ERROR
+                result.details = f"spent {spent:.3f}s"
+
+
+    class Result:
+        def __init__(self, name: str):
+            self.status = HealthStatus.OK
+            self.name = name
+            self.details = ""
+
+        def copy_from(self, value: HealthCheckManager.Result):
+            self.status  = value.status
+            self.details = value.details
+
+        def set_status(self, status: HealthStatus, details =""):
+            self.status = status
+            self.details = details
+
+        def to_dict(self):
+            result = {
+                "name": self.name,
+                "status": str(self.status),
+            }
+
+            if self.details:
+                result["details"] = self.details
+
+            return result
+
+    class Health:
+        def __init__(self, status: HealthStatus = HealthStatus.OK):
+            self.status = status
+            self.results : list[HealthCheckManager.Result] = []
+
+        def to_dict(self):
+            return {
+                "status": str(self.status),
+                "checks": [result.to_dict() for result in self.results]
+            }
+
+    # class data
+
+    types : list[Type] = []
+
+    # constructor
+
+    def __init__(self):
+        self.environment : Optional[Environment] = None
+        self.checks: list[HealthCheckManager.Check] = []
+
+    # check
+
+    async def check(self) -> HealthCheckManager.Health:
+        """
+        run all registered health checks and return an overall result.
+        Returns: the overall result.
+
+        """
+        self.logger.info("Checking health...")
+
+        health = HealthCheckManager.Health()
+
+        tasks = []
+        for check in self.checks:
+            result = HealthCheckManager.Result(check.name)
+            health.results.append(result)
+            tasks.append(check.run(result))
+
+        await asyncio.gather(*tasks)
+
+        for result in health.results:
+            if result.status.value > health.status.value:
+                health.status = result.status
+
+        return health
+
+    # public
+
+    @inject_environment()
+    def set_environment(self, environment: Environment):
+        self.environment = environment
+
+    @on_init()
+    def setup(self):
+        for type in self.types:
+            descriptor = TypeDescriptor(type).for_type(type)
+            instance = self.environment.get(type)
+
+            for method in descriptor.get_methods():
+                if method.has_decorator(health_check):
+                    decorator = method.get_decorator(health_check)
+
+                    name = decorator.args[0]
+                    cache = decorator.args[1]
+                    fail_if_slower_than = decorator.args[2]
+                    if len(name) == 0:
+                        name = method.get_name()
+
+                    self.checks.append(HealthCheckManager.Check(name, cache, fail_if_slower_than, instance, method.method))