statezero 0.1.0b4__tar.gz → 0.1.0b6__tar.gz

{statezero-0.1.0b4 → statezero-0.1.0b6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: statezero
-Version: 0.1.0b4
+Version: 0.1.0b6
 Summary: Connect your Python backend to a modern JavaScript SPA frontend with 90% less complexity.
 Author-email: Robert <robert.herring@statezero.dev>
 Project-URL: homepage, https://www.statezero.dev
@@ -222,7 +222,7 @@ npm i @statezero/core
 ### Generate TypeScript Models
 
 ```bash
-npx statezero sync-models
+npx statezero sync
 ```
 
 ## Why Choose StateZero Over...

{statezero-0.1.0b4 → statezero-0.1.0b6}/README.md

@@ -192,7 +192,7 @@ npm i @statezero/core
 ### Generate TypeScript Models
 
 ```bash
-npx statezero sync-models
+npx statezero sync
 ```
 
 ## Why Choose StateZero Over...

{statezero-0.1.0b4 → statezero-0.1.0b6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "statezero"
-version = "0.1.0b4"
+version = "0.1.0b6"
 description = "Connect your Python backend to a modern JavaScript SPA frontend with 90% less complexity."
 readme = "README.md"
 license = { file = "LICENSE" }

statezero-0.1.0b6/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-0.1.0b6/statezero/adaptors/django/apps.py

@@ -0,0 +1,137 @@
+import importlib
+import logging
+import os
+
+from django.apps import AppConfig as DjangoAppConfig
+from django.apps import apps
+from django.conf import settings
+
+from statezero.adaptors.django.config import config, registry
+
+# Attempt to import Rich for nicer console output.
+try:
+    from rich.console import Console
+    from rich.panel import Panel
+
+    console = Console()
+except ImportError:
+    console = None
+
+logger = logging.getLogger(__name__)
+
+
+class StateZeroDjangoConfig(DjangoAppConfig):
+    name = "statezero.adaptors.django"
+    verbose_name = "StateZero Django Integration"
+    label = "statezero"
+
+    def ready(self):
+        # Import crud modules which register models in the registry.
+        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'"
+                )
+        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}"
+                )
+            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.event_bus.set_registry(registry)
+
+        # Print the list of published models and actions to confirm StateZero is running.
+        try:
+            published_models = []
+            for model in registry._models_config.keys():
+                # Use the ORM provider's get_model_name to get the namespaced model name.
+                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:
+                models_message = (
+                    "[bold green]StateZero is exposing models:[/bold green] [bold yellow]"
+                    + ", ".join(published_models)
+                    + "[/bold yellow]"
+                )
+            else:
+                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 or registered_actions) and settings.DEBUG:
+                npm_message = (
+                    "\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
+            else:
+                message = base_message
+
+            # Use Rich Panel for a boxed display if Rich is available.
+            if console:
+                final_message = Panel(message, expand=False)
+                console.print(final_message)
+            else:
+                # Fallback to simple demarcation lines if Rich isn't available.
+                demarcation = "\n" + "-" * 50 + "\n"
+                final_message = demarcation + message + demarcation
+                logger.info(final_message)
+        except Exception as e:
+            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)