statezero 0.1.0b4__py3-none-any.whl → 0.1.0b6__py3-none-any.whl

statezero/adaptors/django/actions.py

@@ -0,0 +1,171 @@
+import os
+from django.apps import apps
+from rest_framework.response import Response
+from rest_framework import fields
+from statezero.core.actions import action_registry
+
+
+class DjangoActionSchemaGenerator:
+    """Django-specific action schema generator that matches StateZero model schema format"""
+
+    @staticmethod
+    def generate_actions_schema():
+        """Generate schema for all registered actions matching StateZero model schema format"""
+        actions_schema = {}
+        all_app_configs = list(apps.get_app_configs())
+
+        for action_name, action_config in action_registry.get_actions().items():
+            func = action_config.get("function")
+            if not func:
+                raise ValueError(
+                    f"Action '{action_name}' is missing a function and cannot be processed."
+                )
+
+            func_path = os.path.abspath(func.__code__.co_filename)
+            found_app = None
+
+            for app_config in all_app_configs:
+                app_path = os.path.abspath(app_config.path)
+                if func_path.startswith(app_path + os.sep):
+                    if not found_app or len(app_path) > len(
+                        os.path.abspath(found_app.path)
+                    ):
+                        found_app = app_config
+
+            if not found_app:
+                raise LookupError(
+                    f"Action '{action_name}' from file '{func_path}' does not belong to any "
+                    f"installed Django app. Please ensure the parent app is in INSTALLED_APPS."
+                )
+
+            app_name = found_app.label
+            docstring = action_config.get("docstring")
+
+            schema_info = {
+                "action_name": action_name,
+                "app": app_name,
+                "title": action_name.replace("_", " ").title(),
+                "docstring": docstring,
+                "class_name": "".join(
+                    word.capitalize() for word in action_name.split("_")
+                ),
+                "input_properties": DjangoActionSchemaGenerator._get_serializer_schema(
+                    action_config["serializer"]
+                ),
+                "response_properties": DjangoActionSchemaGenerator._get_serializer_schema(
+                    action_config["response_serializer"]
+                ),
+                "permissions": [
+                    perm.__name__ for perm in action_config.get("permissions", [])
+                ],
+            }
+            actions_schema[action_name] = schema_info
+
+        return Response({"actions": actions_schema, "count": len(actions_schema)})
+
+    @staticmethod
+    def _get_serializer_schema(serializer_class):
+        if not serializer_class:
+            return {}
+        try:
+            serializer_instance = serializer_class()
+            properties = {}
+            for field_name, field in serializer_instance.fields.items():
+                field_info = {
+                    "type": DjangoActionSchemaGenerator._get_field_type(field),
+                    "title": getattr(field, "label")
+                    or field_name.replace("_", " ").title(),
+                    "required": field.required,
+                    "description": getattr(field, "help_text", None),
+                    "nullable": getattr(field, "allow_null", False),
+                    "format": DjangoActionSchemaGenerator._get_field_format(field),
+                    "max_length": getattr(field, "max_length", None),
+                    "choices": DjangoActionSchemaGenerator._get_field_choices(field),
+                    "default": DjangoActionSchemaGenerator._get_field_default(field),
+                    "validators": [],
+                    "max_digits": getattr(field, "max_digits", None),
+                    "decimal_places": getattr(field, "decimal_places", None),
+                    "read_only": field.read_only,
+                    "ref": None,
+                }
+                if hasattr(field, "max_value") and field.max_value is not None:
+                    field_info["max_value"] = field.max_value
+                if hasattr(field, "min_value") and field.min_value is not None:
+                    field_info["min_value"] = field.min_value
+                if hasattr(field, "min_length") and field.min_length is not None:
+                    field_info["min_length"] = field.min_length
+                properties[field_name] = field_info
+            return properties
+        except Exception as e:
+            return {"error": f"Could not inspect serializer: {str(e)}"}
+
+    @staticmethod
+    def _get_field_type(field):
+        type_mapping = {
+            fields.BooleanField: "boolean",
+            fields.CharField: "string",
+            fields.EmailField: "string",
+            fields.URLField: "string",
+            fields.UUIDField: "string",
+            fields.IntegerField: "integer",
+            fields.FloatField: "number",
+            fields.DecimalField: "string",
+            fields.DateField: "string",
+            fields.DateTimeField: "string",
+            fields.TimeField: "string",
+            fields.JSONField: "object",
+            fields.DictField: "object",
+            fields.ListField: "array",
+        }
+        return type_mapping.get(type(field), "string")
+
+    @staticmethod
+    def _get_field_format(field):
+        format_mapping = {
+            fields.EmailField: "email",
+            fields.URLField: "uri",
+            fields.UUIDField: "uuid",
+            fields.DateField: "date",
+            fields.DateTimeField: "date-time",
+            fields.TimeField: "time",
+        }
+        return format_mapping.get(type(field))
+
+    @staticmethod
+    def _get_field_choices(field):
+        if hasattr(field, "choices") and field.choices:
+            choices = field.choices
+            
+            # Handle dict format: {'low': 'Low', 'high': 'High'}
+            if isinstance(choices, dict):
+                return list(choices.keys())
+            
+            # Handle list/tuple format: [('low', 'Low'), ('high', 'High')]
+            elif isinstance(choices, (list, tuple)):
+                try:
+                    return [choice[0] for choice in choices]
+                except (IndexError, TypeError) as e:
+                    raise ValueError(
+                        f"Invalid choice format for field '{field}'. Expected list of tuples "
+                        f"like [('value', 'display')], but got: {choices}. Error: {e}"
+                    )
+            
+            # Handle unexpected format
+            else:
+                raise ValueError(
+                    f"Unsupported choice format for field '{field}'. Expected dict or list of tuples, "
+                    f"but got {type(choices)}: {choices}"
+                )
+        
+        return None
+
+    @staticmethod
+    def _get_field_default(field):
+        if hasattr(field, "default"):
+            default = field.default
+            if default is fields.empty:
+                return None
+            if callable(default):
+                return None
+            return default
+        return None

statezero/adaptors/django/apps.py

@@ -27,27 +27,46 @@ class StateZeroDjangoConfig(DjangoAppConfig):
 
     def ready(self):
         # Import crud modules which register models in the registry.
-        if hasattr(settings, 'CONFIG_FILE_PREFIX'):
+        if hasattr(settings, "CONFIG_FILE_PREFIX"):
             config_file_prefix: str = settings.CONFIG_FILE_PREFIX
-            config_file_prefix = config_file_prefix.replace('.py', '')
-            if (not isinstance(config_file_prefix, str)) or (len(config_file_prefix) < 1):
-                raise ValueError(f"If provided, CONFIG_FILE_PREFIX must be a string with at least one character. In your settings.py it is set to {settings.CONFIG_FILE_PREFIX}. Either delete the setting completely or use a valid file name like 'crud'")
+            config_file_prefix = config_file_prefix.replace(".py", "")
+            if (not isinstance(config_file_prefix, str)) or (
+                len(config_file_prefix) < 1
+            ):
+                raise ValueError(
+                    f"If provided, CONFIG_FILE_PREFIX must be a string with at least one character. In your settings.py it is set to {settings.CONFIG_FILE_PREFIX}. Either delete the setting completely or use a valid file name like 'crud'"
+                )
         else:
             config_file_prefix = "crud"
         for app_config_instance in apps.get_app_configs():
             module_name = f"{app_config_instance.name}.{config_file_prefix}"
             try:
                 importlib.import_module(module_name)
-                logger.debug(f"Imported {config_file_prefix} module from {app_config_instance.name}")
+                logger.debug(
+                    f"Imported {config_file_prefix} module from {app_config_instance.name}"
+                )
+            except ModuleNotFoundError:
+                pass
+
+        # Import actions modules which register actions in the action registry.
+        from statezero.core.actions import action_registry
+
+        for app_config_instance in apps.get_app_configs():
+            actions_module_name = f"{app_config_instance.name}.actions"
+            try:
+                importlib.import_module(actions_module_name)
+                logger.debug(f"Imported actions module from {app_config_instance.name}")
             except ModuleNotFoundError:
                 pass
 
         # Once all the apps are imported, initialize StateZero and provide the registry to the event bus.
         config.initialize()
-        config.validate_exposed_models(registry) # Raises an exception if a non StateZero model is implicitly exposed
+        config.validate_exposed_models(
+            registry
+        )  # Raises an exception if a non StateZero model is implicitly exposed
         config.event_bus.set_registry(registry)
 
-        # Print the list of published models (from registry) to confirm StateZero is running.
+        # Print the list of published models and actions to confirm StateZero is running.
         try:
             published_models = []
             for model in registry._models_config.keys():
@@ -55,20 +74,43 @@ class StateZeroDjangoConfig(DjangoAppConfig):
                 model_name = model.__name__
                 published_models.append(model_name)
 
+            # Get registered actions
+            registered_actions = list(action_registry.get_actions().keys())
+
+            # Build base message for models
             if published_models:
-                base_message = (
+                models_message = (
                     "[bold green]StateZero is exposing models:[/bold green] [bold yellow]"
                     + ", ".join(published_models)
-                    + "[/bold yellow]"  
+                    + "[/bold yellow]"
                 )
             else:
-                base_message = "[bold yellow]StateZero is running but no models are registered.[/bold yellow]"
+                models_message = "[bold yellow]StateZero is running but no models are registered.[/bold yellow]"
+
+            # Build message for actions (limit to first 10 to avoid cluttering console)
+            if registered_actions:
+                displayed_actions = registered_actions[:10]
+                actions_message = (
+                    "\n[bold green]StateZero is exposing actions:[/bold green] [bold cyan]"
+                    + ", ".join(displayed_actions)
+                )
+                if len(registered_actions) > 10:
+                    actions_message += (
+                        f" [dim](and {len(registered_actions) - 10} more)[/dim]"
+                    )
+                actions_message += "[/bold cyan]"
+            else:
+                actions_message = (
+                    "\n[bold yellow]No actions are registered.[/bold yellow]"
+                )
+
+            base_message = models_message + actions_message
 
             # Append the npm command instruction only in debug mode.
-            if published_models and settings.DEBUG:
+            if (published_models or registered_actions) and settings.DEBUG:
                 npm_message = (
-                    "\n[bold blue]Next step:[/bold blue] Run [italic]npm run sync-models[/italic] in your frontend project directory "
-                    "to generate or update the client-side code corresponding to these models. "
+                    "\n[bold blue]Next step:[/bold blue] Run [italic]npm run sync[/italic] in your frontend project directory "
+                    "to generate or update the client-side code corresponding to these models and actions. "
                     "Note: This command should only be executed in a development environment."
                 )
                 message = base_message + npm_message
@@ -85,13 +127,11 @@ class StateZeroDjangoConfig(DjangoAppConfig):
                 final_message = demarcation + message + demarcation
                 logger.info(final_message)
         except Exception as e:
-            error_message = (
-                f"[bold red]Error retrieving published models: {e}[/bold red]"
-            )
+            error_message = f"[bold red]Error retrieving published models and actions: {e}[/bold red]"
             if console:
                 final_message = Panel(error_message, expand=False)
                 console.print(final_message)
             else:
                 demarcation = "\n" + "-" * 50 + "\n"
                 final_message = demarcation + error_message + demarcation
-                logger.info(final_message)
+                logger.info(final_message)