django-nativemojo 0.1.10__py3-none-any.whl → 0.1.16__py3-none-any.whl

mojo/helpers/redis/pool.py

@@ -0,0 +1,225 @@
+from typing import Optional, List, Set
+from django.db import models
+from .client import get_connection
+
+
+class RedisBasePool:
+    """Simple Redis pool using atomic Redis operations."""
+
+    def __init__(self, pool_key: str, default_timeout: int = 30):
+        """
+        Initialize the Redis pool.
+
+        Args:
+            pool_key: Unique identifier for this pool
+            default_timeout: Default timeout in seconds for blocking operations
+        """
+        self.pool_key = pool_key
+        self.default_timeout = default_timeout
+        self.redis_client = get_connection()
+
+        self.available_list_key = f"{pool_key}:list"
+        self.all_items_set_key = f"{pool_key}:set"
+
+    def add(self, str_id: str) -> bool:
+        """Add an item to the pool."""
+        if not self.redis_client.sismember(self.all_items_set_key, str_id):
+            self.redis_client.sadd(self.all_items_set_key, str_id)
+            self.redis_client.lpush(self.available_list_key, str_id)
+            return True
+        return False
+
+    def remove(self, str_id: str) -> bool:
+        """Remove an item from the pool entirely."""
+        if not self.redis_client.sismember(self.all_items_set_key, str_id):
+            return False
+
+        self.redis_client.srem(self.all_items_set_key, str_id)
+        self.redis_client.lrem(self.available_list_key, 0, str_id)
+        return True
+
+    def clear(self) -> None:
+        """Clear all items from the pool."""
+        self.redis_client.delete(self.available_list_key)
+        self.redis_client.delete(self.all_items_set_key)
+
+    def checkout(self, str_id: str, timeout: Optional[int] = None) -> bool:
+        """Check out a specific item from the pool."""
+        if not self.redis_client.sismember(self.all_items_set_key, str_id):
+            return False
+
+        if timeout is None:
+            removed = self.redis_client.lrem(self.available_list_key, 1, str_id)
+            return removed > 0
+
+        import time
+        start = time.time()
+        while self.redis_client.lrem(self.available_list_key, 1, str_id) == 0:
+            time.sleep(1.0)
+            elapsed = time.time() - start
+            if elapsed > timeout:
+                return False
+        return True
+
+    def checkin(self, str_id: str) -> bool:
+        """Check in an item back to the pool."""
+        if not self.redis_client.sismember(self.all_items_set_key, str_id):
+            return False
+
+        self.redis_client.lpush(self.available_list_key, str_id)
+        return True
+
+    def list_all(self) -> Set[str]:
+        """List all items in the pool."""
+        return self.redis_client.smembers(self.all_items_set_key)
+
+    def list_available(self) -> List[str]:
+        """List available items in the pool."""
+        return self.redis_client.lrange(self.available_list_key, 0, -1)
+
+    def list_checked_out(self) -> Set[str]:
+        """List checked out items."""
+        all_items = self.list_all()
+        available_items = set(self.list_available())
+        return all_items - available_items
+
+    def destroy_pool(self) -> None:
+        """Completely destroy the pool."""
+        self.clear()
+
+    def get_next_available(self, timeout: Optional[int] = None) -> Optional[str]:
+        """Get the next available item from the pool."""
+        timeout = timeout or self.default_timeout
+
+        result = self.redis_client.brpop(self.available_list_key, timeout=timeout)
+        if result:
+            return result[1]
+        return None
+
+
+class RedisModelPool(RedisBasePool):
+    """Django model-specific Redis pool."""
+
+    def __init__(self, model_cls: models.Model, query_dict: dict,
+                 pool_key: str, default_timeout: int = 30):
+        """
+        Initialize the model pool.
+
+        Args:
+            model_cls: Django model class
+            query_dict: Query parameters to filter model instances
+            pool_key: Unique identifier for this pool
+            default_timeout: Default timeout in seconds
+        """
+        super().__init__(pool_key, default_timeout)
+        self.model_cls = model_cls
+        self.query_dict = query_dict
+
+    def init_pool(self) -> None:
+        """Initialize pool with model instances."""
+        self.destroy_pool()
+
+        queryset = self.model_cls.objects.filter(**self.query_dict)
+        for instance in queryset:
+            item = str(instance.pk)
+            if not self.redis_client.sismember(self.all_items_set_key, item):
+                self.redis_client.sadd(self.all_items_set_key, item)
+            self.redis_client.lpush(self.available_list_key, item)
+
+    def add_to_pool(self, instance: models.Model) -> bool:
+        """Add a model instance to the pool."""
+        item = str(instance.pk)
+        if not self.redis_client.sismember(self.all_items_set_key, item):
+            self.redis_client.sadd(self.all_items_set_key, item)
+        self.redis_client.lpush(self.available_list_key, item)
+        return True
+
+    def remove_from_pool(self, instance: models.Model) -> bool:
+        """Remove instance from pool."""
+        item = str(instance.pk)
+        if not self.redis_client.sismember(self.all_items_set_key, item):
+            return False
+
+        self.redis_client.lrem(self.available_list_key, 0, item)
+        self.redis_client.srem(self.all_items_set_key, item)
+        return True
+
+    def get_next_instance(self, timeout: Optional[int] = None) -> Optional[models.Model]:
+        """Get the next available model instance."""
+        if not self.redis_client.exists(self.all_items_set_key):
+            self.init_pool()
+
+        pk = self.get_next_available(timeout)
+        if pk:
+            try:
+                instance = self.model_cls.objects.get(pk=pk)
+
+                # Verify instance still matches criteria
+                for key, value in self.query_dict.items():
+                    if getattr(instance, key) != value:
+                        self.redis_client.srem(self.all_items_set_key, pk)
+                        return self.get_next_instance(timeout)
+
+                return instance
+            except self.model_cls.DoesNotExist:
+                self.redis_client.srem(self.all_items_set_key, pk)
+                return self.get_next_instance(timeout)
+
+        return None
+
+    def get_specific_instance(self, instance: models.Model) -> bool:
+        """Get a specific instance from pool."""
+        item = str(instance.pk)
+        if not self.redis_client.sismember(self.all_items_set_key, item):
+            return False
+
+        removed = self.redis_client.lrem(self.available_list_key, 1, item)
+        return removed > 0
+
+    def return_instance(self, instance: models.Model) -> bool:
+        """Return a model instance to the pool."""
+        item = str(instance.pk)
+        if not self.redis_client.sismember(self.all_items_set_key, item):
+            return False
+
+        self.redis_client.lpush(self.available_list_key, item)
+        return True
+
+
+# Example usage:
+if __name__ == "__main__":
+    # Basic pool
+    pool = RedisBasePool("test_pool")
+
+    # Add items
+    pool.add("item1")
+    pool.add("item2")
+    pool.add("item3")
+
+    print("All items:", pool.list_all())
+    print("Available:", pool.list_available())
+
+    # Get next available
+    item = pool.get_next_available(timeout=5)
+    print(f"Got item: {item}")
+
+    # Return to pool
+    if item:
+        pool.checkin(item)
+
+    # Django model example:
+    # model_pool = RedisModelPool(
+    #     model_cls=MyModel,
+    #     query_dict={"status": "active"},
+    #     pool_key="active_models"
+    # )
+    #
+    # # Initialize pool
+    # model_pool.init_pool()
+    #
+    # # Get instance
+    # instance = model_pool.get_next_instance(timeout=30)
+    # if instance:
+    #     print(f"Got instance: {instance}")
+    #     # Do work...
+    #     model_pool.return_instance(instance)

mojo/helpers/request.py

@@ -1,5 +1,9 @@
 from objict import objict, nobjict
 from .request_parser import RequestDataParser
+from mojo.helpers.settings import settings
+
+DUID_HEADER = settings.get('DUID_HEADER', 'X-Mojo-UID').replace('-', '_').upper()
+DUID_HEADER = f"HTTP_{DUID_HEADER}"
 
 REQUEST_PARSER = RequestDataParser()
 
@@ -43,6 +47,10 @@ def get_remote_ip(request):
 
 def get_device_id(request):
     # Look for 'buid' or 'duid' in GET parameters
+    duid = request.META.get(DUID_HEADER, None)
+    if duid:
+        return duid
+
     for key in ['__buid__', 'duid', "buid"]:
         if key in request.GET:
             return request.GET[key]

mojo/helpers/response.py

@@ -1,4 +1,4 @@
-import ujson
+from objict import objict
 from django.http import HttpResponse
 
 
@@ -8,7 +8,19 @@ class JsonResponse(HttpResponse):
             raise TypeError(
                 'In order to allow non-dict objects to be serialized set the '
                 'safe parameter to False.'
+                f'Invalid data type: {type(data)}'
             )
         kwargs.setdefault('content_type', 'application/json')
-        data = ujson.dumps(data)
+        if not isinstance(data, objict):
+            data = objict.from_dict(data)
+        if "code" not in data:
+            data.code = status
+        data = data.to_json(as_string=True)
         super().__init__(content=data, status=status, **kwargs)
+
+
+def error(message, status=400):
+    return JsonResponse(objict(error=message), status=status)
+
+def success(data, status=200):
+    return JsonResponse(objict(status=True, data=data), status=status)

mojo/helpers/settings/__init__.py

@@ -0,0 +1,2 @@
+from .helper import load_settings_profile, settings
+from .parser import load_settings_config

mojo/helpers/{settings.py → settings/helper.py}

@@ -1,5 +1,5 @@
 import importlib
-from typing import Any, Union
+from typing import Any
 
 UNKNOWN = Ellipsis
 
@@ -16,42 +16,6 @@ def load_settings_profile(context):
     modules.load_module_to_globals("settings.defaults", context)
     modules.load_module_to_globals(f"settings.{profile}", context)
 
-def load_settings_config(context):
-    # Load config from django.conf file
-    from mojo.helpers import paths
-    config_path = paths.VAR_ROOT / "django.conf"
-    if not config_path.exists():
-        raise Exception(f"Required configuration file not found: {config_path}")
-
-    with open(config_path, 'r') as file:
-        for line in file:
-            if '=' in line:
-                key, value = line.strip().split('=', 1)
-                value = value.strip()
-                if value.startswith('"') and value.endswith('"'):
-                    value = value[1:-1]
-                elif value.startswith("'") and value.endswith("'"):
-                    value = value[1:-1]
-                if value.startswith('f"') or value.startswith("f'"):
-                    value = eval(value)
-                elif value.lower() == 'true':
-                    value = True
-                elif value.lower() == 'false':
-                    value = False
-                else:
-                    try:
-                        if '.' in value:
-                            value = float(value)
-                        else:
-                            value = int(value)
-                    except ValueError:
-                        pass
-                context[key.strip()] = value
-
-    if context.get("ALLOW_ADMIN_SITE", True):
-        if "django.contrib.admin" not in context["INSTALLED_APPS"]:
-            context["INSTALLED_APPS"].insert(0, "django.contrib.admin")
-
 
 class SettingsHelper:
     """

mojo/helpers/settings/parser.py

@@ -0,0 +1,132 @@
+class DjangoConfigLoader:
+    """
+    A clean, expandable class for loading Django configuration from django.conf files.
+    """
+
+    def __init__(self, config_path=None):
+        """
+        Initialize the config loader.
+
+        :param config_path: Path to the django.conf file. If None, uses default VAR_ROOT path.
+        """
+        if config_path is None:
+            from mojo.helpers import paths
+            self.config_path = paths.VAR_ROOT / "django.conf"
+        else:
+            self.config_path = config_path
+
+    def load_config(self, context):
+        """
+        Load configuration from django.conf file into the provided context.
+
+        :param context: Dictionary to load configuration values into.
+        :raises Exception: If the required configuration file is not found.
+        """
+        self._validate_config_file()
+        self._parse_config_file(context)
+        self._apply_admin_site_config(context)
+
+    def _validate_config_file(self):
+        """Validate that the configuration file exists."""
+        if not self.config_path.exists():
+            raise Exception(f"Required configuration file not found: {self.config_path}")
+
+    def _parse_config_file(self, context):
+        """Parse the configuration file and populate the context."""
+        with open(self.config_path, 'r') as file:
+            for line in file:
+                if '=' in line:
+                    key, value = line.strip().split('=', 1)
+                    parsed_value = self._parse_value(value.strip())
+                    context[key.strip()] = parsed_value
+
+    def _parse_value(self, value):
+        """
+        Parse a configuration value string into the appropriate Python type.
+
+        :param value: String value to parse.
+        :return: Parsed value with appropriate type.
+        """
+        if self._is_list_value(value):
+            return self._parse_list_value(value)
+        elif self._is_quoted_string(value):
+            return self._parse_quoted_string(value)
+        elif self._is_f_string(value):
+            return eval(value)
+        elif self._is_boolean(value):
+            return self._parse_boolean(value)
+        else:
+            return self._parse_numeric_or_string(value)
+
+    def _is_list_value(self, value):
+        """Check if value is a list format."""
+        return value.startswith('[') and value.endswith(']')
+
+    def _is_quoted_string(self, value):
+        """Check if value is a quoted string."""
+        return ((value.startswith('"') and value.endswith('"')) or
+                (value.startswith("'") and value.endswith("'")))
+
+    def _is_f_string(self, value):
+        """Check if value is an f-string."""
+        return value.startswith('f"') or value.startswith("f'")
+
+    def _is_boolean(self, value):
+        """Check if value is a boolean."""
+        return value.lower() in ('true', 'false')
+
+    def _parse_list_value(self, value):
+        """Parse a list value string into a Python list."""
+        list_content = value[1:-1].strip()
+        if not list_content:
+            return []
+
+        items = []
+        for item in list_content.split(','):
+            item = item.strip()
+            parsed_item = self._parse_list_item(item)
+            items.append(parsed_item)
+        return items
+
+    def _parse_list_item(self, item):
+        """Parse an individual list item."""
+        if self._is_quoted_string(item):
+            return item[1:-1]  # Remove quotes
+        else:
+            return self._parse_numeric_or_string(item)
+
+    def _parse_quoted_string(self, value):
+        """Parse a quoted string by removing the quotes."""
+        return value[1:-1]
+
+    def _parse_boolean(self, value):
+        """Parse a boolean string."""
+        return value.lower() == 'true'
+
+    def _parse_numeric_or_string(self, value):
+        """Parse a value as numeric if possible, otherwise return as string."""
+        try:
+            if '.' in value:
+                return float(value)
+            else:
+                return int(value)
+        except ValueError:
+            return value
+
+    def _apply_admin_site_config(self, context):
+        """Apply Django admin site configuration if enabled."""
+        if context.get("ALLOW_ADMIN_SITE", True):
+            installed_apps = context.get("INSTALLED_APPS", [])
+            if "django.contrib.admin" not in installed_apps:
+                installed_apps.insert(0, "django.contrib.admin")
+                context["INSTALLED_APPS"] = installed_apps
+
+
+def load_settings_config(context):
+    """
+    Load Django configuration from django.conf file.
+
+    :param context: Dictionary to load configuration values into.
+    """
+    loader = DjangoConfigLoader()
+    loader.load_config(context)

mojo/middleware/auth.py

@@ -23,4 +23,4 @@ class AuthenticationMiddleware(MiddlewareMixin):
         if error is not None:
             return JsonResponse({'error': error}, status=401)
         request.user = user
-        user.touch()
+        user.track(request)

mojo/middleware/cors.py

@@ -0,0 +1,40 @@
+from django.http import HttpResponse
+from mojo.helpers.settings import settings
+
+DUID_HEADER = settings.get('DUID_HEADER', 'X-Mojo-UID')
+
+# middleware/cors.py
+class CORSMiddleware:
+    def __init__(self, get_response):
+        self.get_response = get_response
+
+    def __call__(self, request):
+        # Handle preflight requests
+        if request.method == 'OPTIONS':
+            response = HttpResponse()
+        else:
+            response = self.get_response(request)
+
+        # Always allow all origins
+        response['Access-Control-Allow-Origin'] = '*'
+
+        # Allow credentials if needed (note: can't use * origin with credentials)
+        # response['Access-Control-Allow-Credentials'] = 'true'
+
+        # Allow all methods to minimize preflight requests
+        response['Access-Control-Allow-Methods'] = 'GET, POST, PUT, PATCH, DELETE, HEAD, OPTIONS'
+
+        # Allow common headers to minimize preflight requests
+        response['Access-Control-Allow-Headers'] = (
+            'Accept, Accept-Encoding, Authorization, Content-Type, '
+            'Origin, User-Agent, X-Requested-With, X-CSRFToken, '
+            f'X-API-Key, {DUID_HEADER}, Cache-Control, Pragma'
+        )
+
+        # Long preflight cache (24 hours)
+        response['Access-Control-Max-Age'] = '86400'
+
+        # Expose headers that frontend might need
+        response['Access-Control-Expose-Headers'] = 'Content-Disposition, X-Total-Count'
+
+        return response