django-nativemojo 0.1.10__py3-none-any.whl

mojo/helpers/logit.py

@@ -0,0 +1,310 @@
+import os
+import sys
+import logging
+import threading
+from decimal import Decimal
+from collections import OrderedDict
+from io import StringIO
+from typing import Optional
+import traceback
+import re
+# import traceback
+# import time
+# from datetime import datetime
+# from binascii import hexlify
+from . import paths
+
+# Resolve paths
+LOG_DIR = paths.LOG_ROOT
+
+# Ensure log directory exists
+os.makedirs(LOG_DIR, exist_ok=True)
+
+# Constants
+MAX_LOG_SIZE = 10 * 1024 * 1024  # 10MB
+LOG_BACKUP_COUNT = 3
+COLOR_LOGS = True
+LOG_MANAGER = None
+
+def get_logger(name, filename=None, debug=False):
+    global LOG_MANAGER
+    if LOG_MANAGER is None:
+        LOG_MANAGER = LogManager()
+    return LOG_MANAGER.get_logger(name, filename, debug)
+
+
+def pretty_print(msg):
+    out = PrettyLogger.pretty_format(msg)
+    print(out)
+
+pp = pretty_print
+
+
+def pretty_format(msg):
+    return PrettyLogger.pretty_format(msg)
+
+
+def color_print(msg, color, end="\n"):
+    ConsoleLogger.print_message(msg, color, end)
+
+
+# Mask sensitive data in the log
+def mask_sensitive_data(text):
+    sensitive_patterns = [
+        r'("?(password|pwd|secret|token|access_token|api_key|authorization)"?\s*[:=]\s*"?)[^",\s]+',
+        r'("?(ssn|credit_card|card_number|pin|cvv)"?\s*[:=]\s*"?)[^",\s]+',
+    ]
+    for pattern in sensitive_patterns:
+        text = re.sub(pattern, r'\1*****', text, flags=re.IGNORECASE)
+    return text
+
+# Utility: Thread-safe lock handler
+class ThreadSafeLock:
+    def __init__(self):
+        self.lock = threading.RLock()
+
+    def __enter__(self):
+        self.lock.acquire()
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.lock.release()
+
+
+# Log Manager to Handle Multiple Loggers
+class LogManager:
+    _instance = None
+
+    def __new__(cls):
+        if cls._instance is None:
+            cls._instance = super(LogManager, cls).__new__(cls)
+            cls._instance.loggers = {}
+            cls._instance.streams = {}
+            cls._instance.master_logger = None
+            cls._instance.lock = ThreadSafeLock()
+        return cls._instance
+
+    def get_logger(self, name, filename=None, debug=False):
+        """Retrieve or create a logger."""
+        with self.lock:
+            if name in self.loggers:
+                return self.loggers[name]
+
+            level = logging.DEBUG if debug else logging.INFO
+            logger = logging.getLogger(name)
+            logger.setLevel(level)
+
+            # Create file handler
+            if filename:
+                log_path = os.path.join(LOG_DIR, filename)
+                file_handler = logging.FileHandler(log_path)
+                file_handler.setFormatter(self._get_formatter())
+                logger.addHandler(file_handler)
+
+            # Capture to master logger if exists
+            if self.master_logger:
+                logger.addHandler(logging.StreamHandler(sys.stdout))
+
+            self.loggers[name] = Logger(name, filename, logger)
+            return self.loggers[name]
+
+    def set_master_logger(self, logger: logging.Logger):
+        """Assign master logger for global logging."""
+        with self.lock:
+            self.master_logger = logger
+
+    def _get_formatter(self) -> logging.Formatter:
+        return logging.Formatter("%(asctime)s - %(levelname)s - %(name)s: %(message)s")
+
+
+# Logger Wrapper
+class Logger:
+    def __init__(self, name, filename, logger):
+        self.name = name
+        self.filename = filename
+        self.logger = logger
+
+    def _build_log(self, *args):
+        output = []
+        for arg in args:
+            if isinstance(arg, dict):
+                output.append("")
+                output.append(PrettyLogger.pretty_format(arg))
+            else:
+                output.append(str(arg))
+        return "\n".join(output)
+
+    def info(self, *args):
+        self.logger.info(self._build_log(*args))
+
+    def debug(self, *args):
+        self.logger.debug(self._build_log(*args))
+
+    def warning(self, *args):
+        self.logger.warning(self._build_log(*args))
+
+    def error(self, *args):
+        self.logger.error(self._build_log(*args))
+
+    def critical(self, *args):
+        self.logger.critical(self._build_log(*args))
+
+    def exception(self, *args):
+        exc_info = sys.exc_info()
+        err = None
+        if exc_info:
+            err = {
+                "type": str(exc_info[0]),
+                "message": str(exc_info[1]),
+                "stack_trace": traceback.format_exception(*exc_info)
+            }
+            pretty_trace = PrettyLogger.pretty_format(err)
+            args = (pretty_trace, *args)
+        self.logger.exception(self._build_log(*args))
+        return err
+
+# Log Formatting with Colors
+class ColorFormatter(logging.Formatter):
+    COLORS = {
+        "DEBUG": "\033[34m",  # Blue
+        "INFO": "\033[32m",  # Green
+        "WARNING": "\033[33m",  # Yellow
+        "ERROR": "\033[31m",  # Red
+        "CRITICAL": "\033[35m",  # Pink
+        "BLUE": "\033[34m",  # Blue
+        "GREEN": "\033[32m",  # Green
+        "YELLOW": "\033[33m",  # Yellow
+        "RED": "\033[31m",  # Red
+        "PINK": "\033[35m",  # Pink
+    }
+    RESET = "\033[0m"
+
+    def format(self, record):
+        log_color = self.COLORS.get(record.levelname, self.RESET)
+        return f"{log_color}{super().format(record)}{self.RESET}"
+
+
+# Utility for Pretty Logging
+class PrettyLogger:
+    @staticmethod
+    def pretty_format(data, max_length=500000) -> str:
+        """Formats complex data structures for logging."""
+        output = StringIO()
+        PrettyLogger._recursive_format(data, output, 0, max_length)
+        return output.getvalue()
+
+    @staticmethod
+    def _recursive_format(data, output=sys.stdout, indent=0, max_length=80):
+        """Recursive function to pretty-print dictionaries and lists with proper indentation and colors."""
+
+        base_indent = " " * indent  # Current level indentation
+        next_indent = " " * (indent + 2)  # Indentation for nested structures
+
+        if isinstance(data, dict):
+            data = OrderedDict(sorted(data.items()))  # Ensure ordered keys
+            output.write("{\n")  # Open dict at current indent
+            last_index = len(data) - 1
+            for i, (key, value) in enumerate(data.items()):
+                output.write(next_indent + f"\033[34m\"{key}\"\033[0m: ")
+                PrettyLogger._recursive_format(value, output, indent + 2, max_length)
+                if i != last_index:
+                    output.write(",")  # Add comma for all but last key-value pair
+                output.write("\n")
+            if indent == 0:
+                base_indent = ""
+            output.write(base_indent + "}")  # Close dict at the correct indent
+        elif isinstance(data, list):
+            output.write("[\n")  # Open list at correct indent
+            last_index = len(data) - 1
+            for i, item in enumerate(data):
+                output.write(next_indent)
+                PrettyLogger._recursive_format(item, output, indent + 2, max_length)
+                if i != last_index:
+                    output.write(",")  # Add comma for all but last item
+                output.write("\n")
+            output.write(base_indent + "]")  # Close list at correct indent
+        elif isinstance(data, Decimal):
+            output.write(f"\033[32m{str(data)}\033[0m")  # Green for Decimal
+        elif isinstance(data, str):
+            output.write(f"\033[31m\"{data}\"\033[0m")  # Red for strings
+        else:
+            output.write(f"\033[33m{str(data)}\033[0m")  # Yellow for other types
+
+    @staticmethod
+    def log_json(data, logger=None):
+        """Logs data in JSON format."""
+        if logger is None:
+            logger = Logger("root")
+        formatted_data = PrettyLogger.pretty_format(data)
+        logger.info(formatted_data)
+
+
+# Console Logger Utility
+class ConsoleLogger:
+    BLACK = "\033[30m"
+    RED = "\033[31m"
+    GREEN = "\033[32m"
+    YELLOW = "\033[33m"
+    PINK = "\033[35m"
+    BLUE = "\033[34m"
+    WHITE = "\033[37m"
+
+    HBLACK = "\033[90m"
+    HRED = "\033[91m"
+    HGREEN = "\033[92m"
+    HYELLOW = "\033[93m"
+    HBLUE = "\033[94m"
+    HPINK = "\033[95m"
+    HWHITE = "\033[97m"
+
+    HEADER = "\033[95m"
+    FAIL = "\033[91m"
+    OFF = "\033[0m"
+    BOLD = "\033[1m"
+    UNDERLINE = "\033[4m"
+
+    @staticmethod
+    def print_message(msg, color_code="\033[32m", end="\n"):
+        """Prints a color-coded message to the console."""
+        sys.stdout.write(f"{color_code}{msg}\033[0m{end}")
+        sys.stdout.flush()
+
+
+# Rotating File Handler
+class RotatingLogger:
+    def __init__(self, log_file="app.log", max_bytes=MAX_LOG_SIZE, backup_count=LOG_BACKUP_COUNT):
+        self.logger = logging.getLogger("RotatingLogger")
+        self.logger.setLevel(logging.INFO)
+
+        handler = logging.handlers.RotatingFileHandler(
+            os.path.join(LOG_DIR, log_file),
+            maxBytes=max_bytes,
+            backupCount=backup_count,
+        )
+        handler.setFormatter(logging.Formatter("%(asctime)s - %(levelname)s - %(message)s"))
+        self.logger.addHandler(handler)
+
+    def log(self, message, level=logging.INFO):
+        self.logger.log(level, message)
+
+
+# Usage Example
+if __name__ == "__main__":
+    print(BASE_DIR)
+    log = Logger("AppLogger", "app.log", debug=True)
+    log.info("🚀 Application started successfully!")
+    log.debug("🔍 Debugging mode enabled")
+    log.warning("⚠️ Warning: Low disk space")
+    log.error("❌ An error occurred while processing request")
+    log.critical("🔥 Critical system failure!")
+
+    # Pretty print a dictionary
+    sample_data = {
+        "user": "John Doe",
+        "email": "john.doe@example.com",
+        "permissions": ["read", "write"],
+        "settings": {"theme": "dark", "notifications": True},
+    }
+    PrettyLogger.log_json(sample_data, log)
+
+    # Console logger
+    ConsoleLogger.print_message("✔ Task completed successfully", "\033[32m")

mojo/helpers/modules.py

@@ -0,0 +1,95 @@
+import importlib
+import pkgutil
+import sys
+
+
+def module_exists(module_name):
+    return pkgutil.find_loader(module_name)
+
+
+def load_module_to_globals(module, memory=None):
+    """
+    Injects all uppercase variables from the given module into the specified namespace.
+
+    Args:
+        module: The module whose variables should be injected.
+        memory (dict, optional): The namespace where variables will be stored.
+                                 Defaults to `globals()`.
+    """
+    if memory is None:
+        memory = globals()
+
+    if isinstance(module, str):
+        module = load_module(module, module)
+
+    # Extract only variables that are ALL CAPS (Django convention for settings)
+    memory.update({key: value for key, value in vars(module).items() if key.isupper()})
+
+
+def load_module(module_name, package=__name__, ignore_errors=True):
+    """
+    Import a module by name and inject its variables into the global namespace.
+
+    Args:
+        module_name (str): The name of the module to be imported.
+        package (str, optional): The package name to use for relative imports. Defaults to the current package.
+
+    Raises:
+        ImportError: If the module cannot be found in the specified package.
+    """
+    if ignore_errors:
+        try:
+            module = importlib.import_module(module_name, package=package)
+            return module
+        except ModuleNotFoundError:
+            pass
+        return None
+    return importlib.import_module(module_name, package=package)
+
+def get_root_module(func, app_root=True):
+    """
+    Get the root (top-level) module of a function.
+
+    :param func: The function to inspect.
+    :return: The root module name (str) or None if not found.
+    """
+    if not hasattr(func, "__module__"):
+        return None  # Not a valid function or method
+
+    # Fully unwrap to get the original function
+    while hasattr(func, "__wrapped__"):
+        func = func.__wrapped__
+
+    module_name = func.__module__  # Get the module where the function is defined
+
+    if module_name not in sys.modules:
+        return None  # The module is not loaded
+
+    parts = module_name.split('.')
+
+    if app_root:
+        # Try to find a module that contains 'models' submodule
+        for i in range(len(parts)-1, -1, -1):
+            potential_root = '.'.join(parts[:i+1])
+            try:
+                if module_exists(f"{potential_root}.models") or module_exists(f"{potential_root}.rest"):
+                    return sys.modules.get(potential_root)
+            except ImportError:
+                continue
+
+    # If no models module found or app_root is False, return top-level module
+    root_module = parts[0]
+    return sys.modules.get(root_module, None)
+
+
+def get_model(app_name, model_name):
+    from django.apps import apps
+    return apps.get_model(app_name, model_name)
+    # # Import the module containing the models
+    # models_module = importlib.import_module(f"{app_name}.models")
+    # # Get the model class from the module
+    # model = getattr(models_module, model_name)
+    # return model
+
+def get_model_instance(app_name, model_name, pk):
+    return get_model(app_name, model_name).objects.filter(id=pk).last()

mojo/helpers/paths.py

@@ -0,0 +1,63 @@
+import sys
+import socket
+from pathlib import Path
+
+
+def configure_paths(base_dir, depth=2):
+    """
+    Dynamically configure paths based on the provided BASE_DIR.
+    Injects computed paths into the global namespace.
+    """
+    global HOSTNAME, PROJECT_ROOT, VAR_ROOT, BIN_ROOT, LOG_ROOT, CONFIG_ROOT
+    global MEDIA_ROOT, MEDIA_URL, STATIC_ROOT, SITE_STATIC_ROOT, STATIC_DATA_ROOT
+    global STATIC_URL, STATIC_URL_SECURE, APPS_ROOT, APPS_CONFIG_FILE, STATICFILES_DIRS
+
+    # System Info
+    HOSTNAME = socket.gethostname()
+
+    # Define Paths
+    base_path = Path(base_dir).resolve().parents[depth]
+    PROJECT_ROOT = base_path.parent
+    VAR_ROOT = PROJECT_ROOT / "var"
+    BIN_ROOT = PROJECT_ROOT / "bin"
+    APPS_ROOT = PROJECT_ROOT / "apps"
+    CONFIG_ROOT = PROJECT_ROOT / "config"
+    APPS_CONFIG_FILE = APPS_ROOT / "apps.json"
+    LOG_ROOT = VAR_ROOT / "logs"
+
+    # Media Settings
+    MEDIA_ROOT = base_path / "media"
+    MEDIA_URL = "/media/"
+
+    # Static Files Settings
+    STATIC_ROOT = base_path / "static"
+    SITE_STATIC_ROOT = base_path / "site_static"
+    STATIC_DATA_ROOT = SITE_STATIC_ROOT / "json"
+    STATIC_URL = "/static/"
+    STATIC_URL_SECURE = "/static/"
+    STATICFILES_DIRS = [SITE_STATIC_ROOT]
+
+    MEDIA_URL = '/media/'
+    MEDIA_ROOT = base_path / "media"
+
+
+    # Load additional site-packages paths from .site_packages file
+    site_packages_file = PROJECT_ROOT / ".site_packages"
+
+    if site_packages_file.exists():
+        with site_packages_file.open("r") as f:
+            site_packages_paths = [path.strip() for path in f.readlines() if path.strip()]
+
+        for path in site_packages_paths:
+            site_path = Path(path)
+            if site_path.exists() and str(site_path) not in sys.path:
+                sys.path.insert(0, str(site_path))
+
+# To use this, call configure_paths(BASE_DIR) from your Django settings
+
+
+def configure_apps():
+    from objict import objict
+    global INSTALLED_APPS, APPS_CONFIG
+    APPS_CONFIG = objict.fromFile(APPS_CONFIG_FILE)
+    INSTALLED_APPS = APPS_CONFIG.installed

mojo/helpers/redis.py

@@ -0,0 +1,10 @@
+from redis import ConnectionPool, StrictRedis
+from mojo.helpers.settings import settings
+REDIS_POOL = None
+
+
+def get_connection():
+    global REDIS_POOL
+    if REDIS_POOL is None:
+        REDIS_POOL = ConnectionPool(**settings.REDIS_DB)
+    return StrictRedis(connection_pool=REDIS_POOL)

mojo/helpers/request.py

@@ -0,0 +1,89 @@
+from objict import objict, nobjict
+from .request_parser import RequestDataParser
+
+REQUEST_PARSER = RequestDataParser()
+
+def parse_request_data(request):
+    """
+    Consolidates all GET, POST, JSON body, and FILE data into one objict dict.
+    Handles dotted keys and repeated fields.
+    """
+    return REQUEST_PARSER.parse(request)
+
+
+# Additional helper function for debugging
+def debug_request_data(request):
+    """
+    Debug version that shows step-by-step processing
+    """
+    print("=== DEBUG REQUEST PARSING ===")
+    print(f"Method: {request.method}")
+    print(f"Content-Type: {getattr(request, 'content_type', 'Not set')}")
+    print(f"GET: {dict(request.GET)}")
+    print(f"POST: {dict(request.POST)}")
+    print(f"FILES: {list(request.FILES.keys())}")
+
+    result = parse_request_data(request)
+    print(f"Final result: {result}")
+    return result
+
+
+def get_referer(request):
+    return request.META.get('HTTP_REFERER')
+
+
+def get_remote_ip(request):
+    x_forwarded_for = request.META.get('HTTP_X_FORWARDED_FOR')
+    if x_forwarded_for:
+        ip = x_forwarded_for.split(',')[0]
+    else:
+        ip = request.META.get('REMOTE_ADDR')
+    return ip
+
+
+def get_device_id(request):
+    # Look for 'buid' or 'duid' in GET parameters
+    for key in ['__buid__', 'duid', "buid"]:
+        if key in request.GET:
+            return request.GET[key]
+
+    # Look for 'buid' or 'duid' in POST parameters
+    for key in ['buid', 'duid']:
+        if key in request.POST:
+            return request.POST[key]
+
+    return None
+
+def get_user_agent(request):
+    return request.META.get("HTTP_USER_AGENT", "")
+
+
+def parse_user_agent(text):
+    """
+    returns:
+        {
+          'user_agent': {
+            'family': 'Mobile Safari',
+            'major': '13',
+            'minor': '5',
+            'patch': None
+          },
+          'os': {
+            'family': 'iOS',
+            'major': '13',
+            'minor': '5',
+            'patch': None,
+            'patch_minor': None
+          },
+          'device': {
+            'family': 'iPhone',
+            'brand': None,
+            'model': None
+          },
+          'string': '...original UA string...'
+        }
+    """
+    if not isinstance(text, str):
+        text = get_user_agent(text)
+    from ua_parser import user_agent_parser
+    return objict.from_dict(user_agent_parser.Parse(text))