statezero 0.1.0b1__py3-none-any.whl

statezero/core/context_storage.py

@@ -0,0 +1,4 @@
+import contextvars
+
+# This context variable holds the current operation id.
+current_operation_id = contextvars.ContextVar("current_operation_id", default=None)

statezero/core/event_bus.py

@@ -0,0 +1,175 @@
+from statezero.core.context_storage import current_operation_id
+import logging
+from typing import Any, Type, Union, List
+from fastapi.encoders import jsonable_encoder
+
+from statezero.core.interfaces import AbstractEventEmitter, AbstractORMProvider
+from statezero.core.types import ActionType, ORMModel, ORMQuerySet
+
+logger = logging.getLogger(__name__)
+
+
+class EventBus:
+    def __init__(
+        self,
+        broadcast_emitter: AbstractEventEmitter,
+        orm_provider: AbstractORMProvider = None,
+    ) -> None:
+        """
+        Initialize the EventBus with a broadcast emitter.
+
+        Parameters:
+        -----------
+        broadcast_emitter: AbstractEventEmitter
+            Emitter responsible for broadcasting events to clients
+        orm_provider : AbstractORMProvider
+            The orm provider to be used to get the default namespace for events
+        """
+        self.broadcast_emitter: AbstractEventEmitter = broadcast_emitter
+        self.orm_provider = orm_provider
+
+    def set_registry(self, registry):
+        """Set the model registry after initialization if needed."""
+        from statezero.core.config import Registry
+
+        self.registry: Registry = registry
+
+    def emit_event(self, action_type: ActionType, instance: Any) -> None:
+        """
+        Emit an event for a model instance to appropriate namespaces.
+
+        Parameters:
+        -----------
+        action_type: ActionType
+            The type of event (CREATE, UPDATE, DELETE)
+        instance: Any
+            The model instance that triggered the event
+        """
+        # Unused actions, no need to broadcast
+        if action_type in (ActionType.PRE_DELETE, ActionType.PRE_UPDATE):
+            return
+
+        if not self.broadcast_emitter or not self.orm_provider:
+            return
+
+        try:
+            # Get model class and registry config
+            model_class = instance.__class__
+            model_config = None
+
+            # Use the registry to get model config
+            if self.registry:
+                try:
+                    model_config = self.registry.get_config(model_class)
+                except ValueError:
+                    pass
+
+            default_namespace = self.orm_provider.get_model_name(model_class)
+            namespaces = [default_namespace]
+
+            # Create payload data from instance
+            model_name = self.orm_provider.get_model_name(instance)
+            pk_field_name = instance._meta.pk.name
+            pk_value = instance.pk
+
+            data = {
+                "event": action_type.value,
+                "model": model_name,
+                "operation_id": current_operation_id.get(),
+                "instances": [pk_value],
+                "pk_field_name": pk_field_name,
+            }
+
+            for namespace in namespaces:
+                try:
+                    # Emit data to this namespace
+                    self.broadcast_emitter.emit(
+                        namespace, action_type, jsonable_encoder(data)
+                    )
+                except Exception as e:
+                    logger.exception(
+                        "Error emitting to namespace %s for event %s: %s",
+                        namespace,
+                        action_type,
+                        e,
+                    )
+        except Exception as e:
+            logger.exception(
+                "Error in broadcast emitter dispatching event %s for instance %s: %s",
+                action_type,
+                instance,
+                e,
+            )
+
+    def emit_bulk_event(
+        self, action_type: ActionType, instances: Union[List[Any], ORMQuerySet]
+    ) -> None:
+        """
+        Emit a bulk event for multiple instances.
+
+        Parameters:
+        -----------
+        action_type: ActionType
+            The type of bulk event (e.g., BULK_UPDATE, BULK_DELETE)
+        instances: Union[List[Any], ORMQuerySet]
+            The instances affected by the bulk operation (can be a list or queryset)
+        """
+        # Convert QuerySet to list if needed
+        if hasattr(instances, "all") and callable(getattr(instances, "all")):
+            instances = list(instances)
+
+        if not instances:
+            return
+
+        # Get the model class from the first instance
+        first_instance = instances[0]
+        model_class = first_instance.__class__
+
+        if not self.broadcast_emitter or not self.orm_provider:
+            return
+
+        try:
+            # Get model config
+            model_config = None
+            if hasattr(self, "registry"):
+                try:
+                    model_config = self.registry.get_config(model_class)
+                except (ValueError, AttributeError):
+                    pass
+
+            default_namespace = self.orm_provider.get_model_name(model_class)
+
+            # Create payload data from instances
+            model_name = self.orm_provider.get_model_name(first_instance)
+            pk_field_name = first_instance._meta.pk.name
+            pks = [instance.pk for instance in instances]
+
+            data = {
+                "event": action_type.value,
+                "model": model_name,
+                "operation_id": current_operation_id.get(),
+                "instances": pks,
+                "pk_field_name": pk_field_name,
+            }
+
+            # Create a dictionary to group instances by namespace
+            namespaces = ["global", default_namespace]
+
+            for namespace in namespaces:
+                try:
+                    # Emit data to this namespace
+                    self.broadcast_emitter.emit(
+                        namespace, action_type, jsonable_encoder(data)
+                    )
+                except Exception as e:
+                    logger.exception(
+                        "Error emitting bulk event to namespace %s: %s",
+                        namespace,
+                        e,
+                    )
+        except Exception as e:
+            logger.exception(
+                "Error in broadcast emitter dispatching bulk event %s: %s",
+                action_type,
+                e,
+            )

statezero/core/event_emitters.py

@@ -0,0 +1,60 @@
+import json
+import logging
+from typing import Callable, Type, Dict, List, Any, Optional
+
+from statezero.core.context_storage import current_operation_id
+from statezero.core.interfaces import AbstractEventEmitter
+from statezero.core.types import ActionType, ORMModel, RequestType
+
+logger = logging.getLogger(__name__)
+
+
+class ConsoleEventEmitter(AbstractEventEmitter):
+    def __init__(self) -> None:
+        pass
+
+    def has_permission(self, request: RequestType, namespace: str) -> bool:
+        return True
+
+    def emit(
+        self, 
+        namespace: str,
+        event_type: ActionType, 
+        data: Dict[str, Any]
+    ) -> None:
+        logger.info(f"Event emitted to namespace '{namespace}': {json.dumps(data)}")
+
+    def authenticate(self, request: RequestType) -> None:
+        channel = request.data.get("channel_name")
+        socket_id = request.data.get("socket_id")
+        logger.debug(f"Console authentication for channel '{channel}' and socket_id '{socket_id}'")
+
+
+class PusherEventEmitter(AbstractEventEmitter):
+    def __init__(
+        self,
+        pusher_client,
+    ) -> None:
+        self.pusher_client = pusher_client
+
+    def has_permission(self, request: RequestType, namespace: str) -> bool:
+        return True
+
+    def emit(
+        self, 
+        namespace: str,
+        event_type: ActionType, 
+        data: Dict[str, Any]
+    ) -> None:
+        channel = f"private-{namespace}"
+        
+        try:
+            self.pusher_client.trigger(channel, event_type.value, data)
+        except Exception as e:
+            logger.error(f"Error emitting event '{event_type.value}' on channel '{channel}': {e}")
+
+    def authenticate(self, request: RequestType) -> dict:
+        channel = request.data.get("channel_name")
+        socket_id = request.data.get("socket_id")
+        logger.debug(f"Pusher authentication for channel '{channel}' and socket_id '{socket_id}'")
+        return self.pusher_client.authenticate(channel=channel, socket_id=socket_id)

statezero/core/exceptions.py

@@ -0,0 +1,106 @@
+from dataclasses import dataclass
+from typing import Dict, List, Optional, Union
+
+
+@dataclass
+class ErrorDetail:
+    message: str
+    code: str
+
+    def __str__(self) -> str:
+        return self.message
+
+    def __repr__(self) -> str:
+        return f"ErrorDetail(message={self.message!r}, code={self.code!r})"
+
+
+class StateZeroError(Exception):
+    """Base exception for all StateZero errors."""
+
+    status_code: int = 500
+    default_detail: Union[str, Dict, List] = "A server error occurred."
+    default_code: str = "error"
+
+    def __init__(
+        self,
+        detail: Optional[Union[str, Dict, List]] = None,
+        code: Optional[str] = None,
+    ):
+        detail = detail if detail is not None else self.default_detail
+        self.detail = self._normalize_detail(detail, code or self.default_code)
+        super().__init__(str(self.detail))
+
+    def _normalize_detail(
+        self, detail: Union[str, Dict, List], code: Optional[str]
+    ) -> Union[ErrorDetail, Dict, List]:
+        """Convert details to ErrorDetail objects recursively."""
+        if isinstance(detail, str):
+            return ErrorDetail(detail, code or self.default_code)
+        elif isinstance(detail, dict):
+            return {
+                key: self._normalize_detail(value, code)
+                for key, value in detail.items()
+            }
+        elif isinstance(detail, list):
+            return [self._normalize_detail(item, code) for item in detail]
+        return detail
+
+
+class ValidationError(StateZeroError):
+    """Error raised for invalid input. Corresponds to HTTP 400."""
+
+    status_code = 400
+    default_detail = "Invalid input."
+    default_code = "validation_error"
+
+    def __init__(self, detail: Optional[Union[Dict, List]] = None):
+        super().__init__(detail, self.default_code)
+
+
+class NotFound(StateZeroError):
+    """Error raised when an object is not found. Corresponds to HTTP 404."""
+
+    status_code = 404
+    default_detail = "Not found."
+    default_code = "not_found"
+
+    def __init__(self, detail: Optional[str] = None):
+        super().__init__(detail, self.default_code)
+
+
+class PermissionDenied(StateZeroError):
+    """Error raised for permission issues. Corresponds to HTTP 403."""
+
+    status_code = 403
+    default_detail = "Permission denied."
+    default_code = "permission_denied"
+
+    def __init__(self, detail: Optional[str] = None):
+        super().__init__(detail, self.default_code)
+
+
+class MultipleObjectsReturned(StateZeroError):
+    """Error raised when multiple objects are returned but only one was expected."""
+
+    status_code = 400
+    default_detail = "Multiple objects returned."
+    default_code = "multiple_objects_returned"
+
+    def __init__(self, detail: Optional[str] = None):
+        super().__init__(detail, self.default_code)
+
+
+class ASTValidationError(StateZeroError):
+    """Error raised for invalid query syntax (AST issues)."""
+
+    status_code = 400
+    default_detail = "Query syntax error."
+    default_code = "ast_validation_error"
+
+    def __init__(self, detail: Optional[Union[Dict, List, str]] = None):
+        super().__init__(detail, self.default_code)
+
+
+class ConfigError(Exception):
+    """Error raised for configuration issues."""
+    pass