django-nativemojo 0.1.10__py3-none-any.whl

mojo/serializers/models.py

@@ -0,0 +1,165 @@
+import ujson
+from django.db.models import ForeignKey, OneToOneField
+from django.db.models.query import QuerySet
+from django.http import HttpResponse
+import datetime
+from mojo.helpers import logit
+
+logger = logit.get_logger("serializer", "serializer.log")
+
+class GraphSerializer:
+    """
+    Custom serializer for Django models and QuerySets that applies `RestMeta.GRAPHS` dynamically.
+    Supports nested relationships and different serialization graphs.
+    """
+
+    def __init__(self, instance, graph="default", many=False):
+        """
+        :param instance: Model instance or QuerySet.
+        :param graph: The graph type to use (e.g., "default", "list").
+        :param many: Boolean, if `True`, serializes a QuerySet.
+        """
+        self.graph = graph
+        self.qset = None
+        # If it's a QuerySet, mark `many=True`
+        if isinstance(instance, QuerySet):
+            self.many = True
+            self.qset = instance
+            self.instance = list(instance)  # Convert QuerySet to list for iteration
+        else:
+            self.many = many
+            self.instance = instance
+
+    def serialize(self):
+        """
+        Serializes a single model instance or a QuerySet.
+        """
+        if self.many:
+            return [self._serialize_instance(obj) for obj in self.instance]
+        return self._serialize_instance(self.instance)
+
+    def _serialize_instance(self, obj):
+        """
+        Serializes a single model instance based on `RestMeta.GRAPHS`.
+        """
+        if not hasattr(obj, "RestMeta") or not hasattr(obj.RestMeta, "GRAPHS"):
+            logger.warning("RestMeta not found")
+            return self._model_to_dict_custom(obj, fields=[field.name for field in obj._meta.fields])
+
+        graph_config = obj.RestMeta.GRAPHS.get(self.graph)
+        if graph_config is None and self.graph != "default":
+            self.graph = "default"
+            graph_config = obj.RestMeta.GRAPHS.get(self.graph)
+
+        # If graph is not defined or None, assume all fields should be included
+        if graph_config is None:
+            logger.warning(f"graph '{self.graph}' not found for {obj.__class__.__name__}")
+            return self._model_to_dict_custom(obj, fields=[field.name for field in obj._meta.fields])
+        else:
+            logger.info(f"{obj.__class__.__name__}:{self.graph}", graph_config)
+        data = self._model_to_dict_custom(obj, fields=graph_config.get("fields", None))  # Convert normal fields
+
+        # Process extra fields (methods, metadata, etc.)
+        extra_fields = graph_config.get("extra", [])
+        for field in extra_fields:
+            if isinstance(field, tuple):  # Handle renamed method serialization
+                method_name, alias = field
+            else:
+                method_name, alias = field, field
+            if hasattr(obj, method_name):
+                attr = getattr(obj, method_name)
+                data[alias] = attr() if callable(attr) else attr
+
+        # Process related model graphs (ForeignKeys, OneToOneFields)
+        related_graphs = graph_config.get("graphs", {})
+        for related_field, sub_graph in related_graphs.items():
+            related_obj = getattr(obj, related_field, None)
+            if related_obj is not None:
+                # Determine if the field is a ForeignKey or OneToOneField
+                field_obj = obj._meta.get_field(related_field)
+                if isinstance(field_obj, (ForeignKey, OneToOneField)):
+                    # Serialize related model using its corresponding graph
+                    logger.warning(f"graph '{sub_graph}' for {related_obj.__class__.__name__}")
+                    data[related_field] = GraphSerializer(related_obj, graph=sub_graph).serialize()
+
+        return data
+
+    def _model_to_dict_custom(self, obj, fields=None):
+        """
+        Custom serialization method for Django model instances.
+        """
+        data = {}
+        for field in obj._meta.fields:
+            # logger.info(field, type(field), isinstance(field, (ForeignKey, OneToOneField)))
+            if fields and field.name not in fields:
+                continue
+
+            field_value = getattr(obj, field.name)
+
+            # Handle DateTimeField serialization to epoch
+            if isinstance(field_value, datetime.datetime):
+                data[field.name] = int(field_value.timestamp())
+            # Handle date serialization to ISO format
+            elif isinstance(field_value, datetime.date):
+                data[field.name] = field_value.isoformat()
+            elif field_value is not None and isinstance(field, (ForeignKey, OneToOneField)):
+                data[field.name] = field_value.id
+            else:
+                data[field.name] = field_value
+        # logger.info(data)
+        return data
+
+    def to_json(self, **kwargs):
+        """Returns JSON output of the serialized data."""
+        data = self.serialize()
+        if self.many:
+            data = dict(data=data, status=True,
+                size=len(data), graph=self.graph)
+        else:
+            data = dict(data=data, status=True, graph=self.graph)
+        data.update(dict(kwargs))
+        out = ujson.dumps(data)
+        return out
+
+    def to_response(self, request, **kwargs):
+        """
+        Determines the response format based on the client's Accept header.
+        """
+        # accept_header = request.headers.get('Accept', '')
+        # if 'text/html' in accept_header or 'text/plain' in accept_header:
+        #     json_data = self.to_json()
+        #     # Wrap JSON in HTML with basic formatting for color
+        #     response_data = f"""
+        #     <html>
+        #     <head>
+        #     <style>
+        #         body {{ font-family: monospace; }}
+        #         .string {{ color: green; }}
+        #         .number {{ color: blue; }}
+        #         .boolean {{ color: purple; }}
+        #         .null {{ color: red; }}
+        #         .key {{ color: brown; font-weight: bold; }}
+        #     </style>
+        #     </head>
+        #     <body>
+        #     <pre>{self._colorize_json(json_data)}</pre>
+        #     </body>
+        #     </html>
+        #     """
+        #     return HttpResponse(response_data, content_type='text/html')
+        # else:
+        return HttpResponse(self.to_json(**kwargs), content_type='application/json')
+
+    def _colorize_json(self, json_data):
+        """Returns JSON data with HTML span wrappers for colors."""
+        import re
+
+        # Match string values and wrap them in span
+        json_data = re.sub(r'(".*?")', r'<span class="string">\1</span>', json_data)
+        # Match numbers and wrap them in span
+        json_data = re.sub(r'\b(-?\d+\.\d+|-?\d+)\b', r'<span class="number">\1</span>', json_data)
+        # Match boolean and null values
+        json_data = re.sub(r'\b(true|false|null)\b', r'<span class="\1">\1</span>', json_data)
+        # Match key strings
+        json_data = re.sub(r'(\s*".*?")\s*:', r'<span class="key">\1</span>:', json_data)
+        return json_data

mojo/serializers/openapi.py

@@ -0,0 +1,188 @@
+from mojo.helpers.settings import settings
+from mojo.decorators.http import URLPATTERN_METHODS
+from django.apps import apps
+from mojo.helpers.response import JsonResponse
+
+
+API_PREFIX = "/".join([settings.get("MOJO_PREFIX", "api/").rstrip("/"), ""])
+
+def generate_openapi_schema(title="Mojo API", version=settings.VERSION, description="Auto-generated schema"):
+    paths = {}
+
+    for key, view_func in URLPATTERN_METHODS.items():
+        try:
+            method, pattern = view_func.__url__
+            app_name = view_func.__app_name__
+        except AttributeError:
+            continue
+
+        docs = getattr(view_func, "__docs__", {})
+        clean_pattern = pattern.strip("^$").strip("/")
+
+        # Normalize to always use base + detail route if ALL method
+        if method.lower() == "all":
+            path_parts = clean_pattern.split("/")
+            model_slug = path_parts[-1]
+            list_path = f"{API_PREFIX}/{app_name}/{model_slug}".replace("//", "/")
+            detail_path = f"{list_path}/{{pk}}"
+
+            model_cls = resolve_model_from_pattern(app_name, model_slug)
+            if model_cls:
+                paths[list_path] = generate_model_rest_docs(model_cls, is_detail_route=False)
+                paths[detail_path] = generate_model_rest_docs(model_cls, is_detail_route=True)
+            continue
+
+        # Fallback: treat as-is
+        full_path = f"{API_PREFIX}/{app_name}/{clean_pattern}".replace("//", "/")
+        if not full_path.startswith("/"):
+            full_path = "/" + full_path
+
+        if full_path not in paths:
+            paths[full_path] = {}
+
+        op = method.lower()
+        base_parameters = docs.get("parameters", [])
+        if "{pk}" in full_path:
+            base_parameters.insert(0, {
+                "name": "pk",
+                "in": "path",
+                "required": True,
+                "schema": {"type": "integer"}
+            })
+
+        paths[full_path][op] = {
+            "summary": docs.get("summary", f"{method} {full_path}"),
+            "description": docs.get("description", ""),
+            "parameters": base_parameters,
+            "responses": docs.get("responses", {
+                "200": {"description": "Successful response"}
+            })
+        }
+
+    return {
+        "openapi": "3.0.0",
+        "info": {
+            "title": title,
+            "version": version,
+            "description": description,
+        },
+        "paths": paths
+    }
+
+def resolve_model_from_pattern(app_name, model_slug):
+    try:
+        model_cls = apps.get_model(app_name, model_slug.capitalize())
+        return model_cls
+    except LookupError:
+        return None
+
+def generate_model_rest_docs(model_cls, is_detail_route=False):
+    from django.db import models
+    base_parameters = [
+        {"name": "graph", "in": "query", "schema": {"type": "string", "default": "default"}},
+    ]
+
+    list_parameters = base_parameters + [
+        {"name": "size", "in": "query", "schema": {"type": "integer"}},
+        {"name": "start", "in": "query", "schema": {"type": "integer"}},
+        {"name": "sort", "in": "query", "schema": {"type": "string"}},
+        {"name": "dr_start", "in": "query", "schema": {"type": "string", "format": "date-time"}},
+        {"name": "dr_end", "in": "query", "schema": {"type": "string", "format": "date-time"}},
+        {"name": "dr_field", "in": "query", "schema": {"type": "string"}},
+    ]
+
+    for field in model_cls._meta.fields:
+        list_parameters.append({
+            "name": field.name,
+            "in": "query",
+            "schema": {"type": map_field_type(field)}
+        })
+
+    post_schema = {
+        "type": "object",
+        "properties": {
+            f.name: {"type": map_field_type(f)}
+            for f in model_cls._meta.fields if not f.auto_created
+        }
+    }
+
+    ops = {}
+
+    if is_detail_route:
+        detail_parameters = [{
+            "name": "pk",
+            "in": "path",
+            "required": True,
+            "schema": {"type": "integer"}
+        }] + base_parameters
+
+        ops["get"] = {
+            "summary": f"Retrieve a single {model_cls.__name__}",
+            "parameters": detail_parameters,
+            "responses": {
+                "200": {"description": "Graph-based model serialization"}
+            }
+        }
+        ops["post"] = {
+            "summary": f"Update a {model_cls.__name__} instance",
+            "parameters": detail_parameters,
+            "requestBody": {
+                "required": True,
+                "content": {
+                    "application/json": {"schema": post_schema}
+                }
+            },
+            "responses": {
+                "200": {"description": "Updated model instance"}
+            }
+        }
+        ops["delete"] = {
+            "summary": f"Delete a {model_cls.__name__} instance",
+            "parameters": detail_parameters,
+            "responses": {
+                "204": {"description": "Deleted successfully"}
+            }
+        }
+    else:
+        ops["get"] = {
+            "summary": f"List {model_cls.__name__} instances",
+            "parameters": list_parameters,
+            "responses": {
+                "200": {"description": "List of model instances using graph serialization"}
+            }
+        }
+        ops["post"] = {
+            "summary": f"Create a new {model_cls.__name__} instance",
+            "parameters": base_parameters,
+            "requestBody": {
+                "required": True,
+                "content": {
+                    "application/json": {"schema": post_schema}
+                }
+            },
+            "responses": {
+                "200": {"description": "Created model instance"}
+            }
+        }
+
+    return ops
+
+def map_field_type(field):
+    from django.db import models
+    if isinstance(field, models.IntegerField):
+        return "integer"
+    elif isinstance(field, models.BooleanField):
+        return "boolean"
+    elif isinstance(field, models.DateTimeField):
+        return "string"
+    elif isinstance(field, models.DateField):
+        return "string"
+    return "string"
+
+
+def openapi_schema_view(request):
+    if settings.OPENAPI_DOCS_KEY is None:
+        return JsonResponse(dict(status=False, error="disabled"), status=404)
+    if settings.OPENAPI_DOCS_KEY != request.GET.get("key", ""):
+        return JsonResponse(dict(status=False, error="permission denied"), status=403)
+    return JsonResponse(generate_openapi_schema())

mojo/urls.py

@@ -0,0 +1,38 @@
+import importlib
+import os
+from django.urls import path, include
+from mojo.helpers.settings import settings
+from mojo.helpers import modules
+
+MOJO_API_MODULE = settings.get("MOJO_API_MODULE", "rest")
+
+urlpatterns = []
+
+def load_mojo_modules():
+    # load the module to load its patterns
+    rest_module = modules.load_module(f"mojo.{MOJO_API_MODULE}", ignore_errors=False)
+    add_urlpatterns("mojo", prefix="")
+
+    for app in settings.INSTALLED_APPS:
+        module_name = f"{app}.{MOJO_API_MODULE}"
+        if not modules.module_exists(module_name):
+            continue
+        rest_module = modules.load_module(module_name, ignore_errors=False)
+        if rest_module:
+            app_name = app
+            if "." in app:
+                app_name = app.split('.')[-1]
+            prefix = getattr(rest_module, 'APP_NAME', app_name)
+            add_urlpatterns(app, prefix)
+
+def add_urlpatterns(app, prefix):
+    app_module = modules.load_module(app)
+    if len(prefix) > 1:
+        prefix += "/"
+    if not hasattr(app_module, "urlpatterns"):
+        print(f"{app} has no api routes")
+        return
+    urls = path(prefix, include(app_module))
+    urlpatterns.append(urls)
+
+load_mojo_modules()

mojo/ws4redis/README.md

@@ -0,0 +1,174 @@
+# Websocket HOWTO
+
+## Authentication
+
+### JWT
+
+Requires an existing JWT token that has gone through authentication process via rest
+
+```json
+{
+    "action": "auth",
+    "kind": "jwt",
+    "token": "..."
+}
+```
+
+
+
+### Model Authentication
+
+You can implement custom authentication flows via a model by using the WS4REDIS_AUTHENTICATORS in your django settings.py.
+
+##### WS4REDIS_AUTHENTICATORS
+
+```python
+WS4REDIS_AUTHENTICATORS = {
+    "mymodel": "myapp.MyModel"
+}
+```
+
+In your Model you will need to add the following class methods.
+
+This method is used by the async/websocket service to authenticate.
+If the model can authenticate the connection it should return dict with kind and pk of the model that is authenticaed.
+
+
+
+##### authWS4RedisConnection
+
+This method will authenticate the model, or return None if authentication failed.
+
+```python
+@classmethod
+def authWS4RedisConnection(cls, auth_data):
+    if auth_data and auth_data.token:
+        terminal = cls.objects.filter(token=auth_data.token).last()
+        if terminal is not None:
+            # we now return the terminal credentials to the framework
+            return UberDict(
+                kind="terminal",
+                pk=terminal.id,
+                uuid=terminal.tid,
+                token=auth_data.token,
+                only_one=True,  # only allows one connection at a time
+                instance=terminal)
+    return None
+```
+
+
+
+##### canPublishTo
+
+Add this to your Model to validate messages from this connection to be sent to this channel.
+
+```python
+@classmethod
+def canPublishTo(cls, credentials, msg):
+    if credentials:
+        return True
+    return False
+```
+
+
+
+##### WS4REDIS_CHANNELS
+
+Map channels to models
+
+```python
+WS4REDIS_CHANNELS = {
+    "group": "account.Group",
+    "chat": "chat.Room",
+}
+```
+
+
+
+##### onWS4RedisMessage
+
+Add this to your Model to allow for handling of messages sent to this channel.
+
+```python
+@classmethod
+def onWS4RedisMessage(cls, credentials, msg):
+    if msg.action == "status":
+      cls.createStatusRecord(msg)
+
+```
+
+
+
+### URL Params
+
+You can also use params in the url of the websocket.  
+
+**THIS IS NOT RECOMMENDED as the url params are not encrypted and can be easily snooped.**
+
+Include something like the follow in your django settings.py:
+
+```python
+def URL_AUTHENTICATOR(ws_con):
+    from objict import objict
+    token = ws_con.request.GET.get("token", None)
+    session_key = ws_con.request.GET.get("session_key", None)
+    if token is not None:
+      # this example assume the token is used for terminal auth
+      # you will still need to implement the Custom Auth flows to handle this
+    	ws_con.on_auth(objict(kind="terminal", token=token))
+		elif session_key is not None:
+      # or alternative is a session
+    	ws_con.on_auth(objict(kind="session", token=session_key))
+
+```
+
+
+
+## Subscribe
+
+```json
+{
+    "action": "subscribe",
+    "channel": "group",
+    "pk": 3,
+}
+```
+
+### Security
+
+In settins WS4REDIS_CHANNELS, map your channel to a model.
+The model should have a classmethod for canSubscribeTo that returns a list of pk they can subscribe to.
+
+
+## UnSubscribe
+
+```json
+{
+    "action": "unsubscribe",
+    "channel": "group",
+    "pk": 3,
+}
+```
+
+
+## Publish / Send To
+
+```json
+{
+    "action": "publish",
+    "channel": "group",
+    "pk": 3,
+    "message": "..."
+}
+```
+
+### Security
+
+In settins WS4REDIS_CHANNELS, map your channel to a model.
+The model should have a classmethod for canPublishTo that returns a list of pk they can publish to.
+
+
+## Custom Messages
+
+If an unknown action is sent with a channel then the framework will call onWS4RedisMessage on the channel model.
+

mojo/ws4redis/__init__.py

@@ -0,0 +1,2 @@
+# -*- coding: utf-8 -*-
+__version__ = '1.1.8'