django-nativemojo 0.1.10__py3-none-any.whl

mojo/helpers/crypto/sign.py

@@ -0,0 +1,36 @@
+import hmac
+import hashlib
+import json
+from django.conf import settings
+
+
+def generate_signature(data, secret_key=settings.SECRET_KEY):
+    """
+    Generate an HMAC-SHA256 signature for the given data using the secret key.
+
+    :param data: str, bytes, or dict - the data to sign
+    :param secret_key: str or bytes - the shared secret key
+    :return: str - the hex signature
+    """
+    if isinstance(data, dict):
+        data = json.dumps(data, separators=(',', ':'), sort_keys=True)
+    if isinstance(data, str):
+        data = data.encode('utf-8')
+    if isinstance(secret_key, str):
+        secret_key = secret_key.encode('utf-8')
+
+    signature = hmac.new(secret_key, data, hashlib.sha256).hexdigest()
+    return signature
+
+
+def verify_signature(data, signature, secret_key=settings.SECRET_KEY):
+    """
+    Verify an HMAC-SHA256 signature.
+
+    :param data: str, bytes, or dict - the original data
+    :param signature: str - the provided hex signature
+    :param secret_key: str or bytes - the shared secret key
+    :return: bool - True if valid, False otherwise
+    """
+    expected_signature = generate_signature(data, secret_key)
+    return hmac.compare_digest(expected_signature, signature)

mojo/helpers/crypto/too.l.py

@@ -0,0 +1,25 @@
+from mojo.helpers import paths
+import mojo.errors
+from objict import objict
+
+cache = objict()
+
+def get_global_encrypter():
+    return get_privpub("global_encrypter.pub")
+
+def get_global_decrypter():
+    return get_privpub("global_decrypter.priv")
+
+
+def get_privpub(key_file_name):
+    name, ext = key_file_name.split(".")
+    if cache.get(name) is None:
+        key_file = paths.VAR_ROOT / "keys" / f"{key_file_name}"
+        if not key_file.exists():
+            raise mojo.errors.ValueException(f"missing var/keys/{key_file_name}")
+        from mojo.helpers.crypto.privpub import PrivatePublicEncryption
+        if ext == "pub":
+            cache[name] = PrivatePublicEncryption(public_key_file=key_file)
+        else:
+            cache[name] = PrivatePublicEncryption(private_key_file=key_file)
+    return cache[name]

mojo/helpers/crypto/utils.py

@@ -0,0 +1,26 @@
+from Crypto.Random import get_random_bytes
+import string
+
+
+def generate_key(bit_size=128):
+    byte_size = bit_size // 8
+    return random_string(byte_size, allow_special=False)
+
+
+def random_bytes(length):
+    return get_random_bytes(length)
+
+
+def random_string(length, allow_digits=True, allow_chars=True, allow_special=True):
+    characters = ''
+    if allow_digits:
+        characters += string.digits
+    if allow_chars:
+        characters += string.ascii_letters
+    if allow_special:
+        characters += string.punctuation
+
+    if characters == '':
+        raise ValueError("At least one character set (digits, chars, special) must be allowed")
+    random_bytes = get_random_bytes(length)
+    return ''.join(characters[b % len(characters)] for b in random_bytes)

mojo/helpers/daemon.py

@@ -0,0 +1,94 @@
+import os
+import sys
+import signal
+
+class Daemon:
+    """
+    A simple base class for creating a Linux daemon process without using third-party daemon libraries.
+    """
+    def __init__(self, name, var_path=None):
+        self.name = name
+        self.var_path = var_path
+        if var_path is not None:
+            self.pid_file = os.path.join(var_path, name, f"{name}.pid")
+            self.log_file = os.path.join(var_path, name, f"{name}.log")
+            self.error_file = os.path.join(var_path, name, "errors.log")
+        else:
+            self.pid_file = f"{name}.pid"
+            self.log_file = f"{name}.log"
+            self.error_file = "errors.log"
+        self.running = True
+
+    def daemonize(self):
+        """Daemonizes the process using the double-fork technique."""
+        if os.fork() > 0:
+            sys.exit(0)  # Exit parent
+        os.chdir("/")
+        os.setsid()  # Become session leader
+        os.umask(0)
+        if os.fork() > 0:
+            sys.exit(0)  # Exit second parent
+        # Redirect standard file descriptors
+        sys.stdout.flush()
+        sys.stderr.flush()
+        with open(self.log_file, "a", buffering=1) as log, open(self.error_file, "a", buffering=1) as err:
+            os.dup2(log.fileno(), sys.stdout.fileno())
+            os.dup2(err.fileno(), sys.stderr.fileno())
+        self.write_pid()
+        self.register_signal_handlers()
+
+    def write_pid(self):
+        """Writes the process ID to a PID file."""
+        with open(self.pid_file, "w") as f:
+            f.write(str(os.getpid()) + "\n")
+
+    def remove_pid(self):
+        """Removes the PID file upon shutdown."""
+        if os.path.exists(self.pid_file):
+            os.remove(self.pid_file)
+
+    def register_signal_handlers(self):
+        """Registers signal handlers for graceful shutdown."""
+        signal.signal(signal.SIGTERM, self.handle_signal)
+        signal.signal(signal.SIGINT, self.handle_signal)
+
+    def handle_signal(self, signum, frame):
+        """Handles termination signals to shut down cleanly."""
+        self.running = False
+        if signum == signal.SIGTERM:
+            self.cleanup()
+            sys.exit(0)
+
+    def cleanup(self):
+        """Override this method for custom cleanup actions before shutdown."""
+        self.remove_pid()
+
+    def start(self):
+        """Starts the daemon process."""
+        if os.path.exists(self.pid_file):
+            sys.exit(1)
+        self.daemonize()
+        self.run()
+
+    def get_pid(self):
+        """Returns the process ID of the running daemon."""
+        try:
+            with open(self.pid_file, "r") as f:
+                return int(f.read().strip())
+        except FileNotFoundError:
+            return None
+
+    def stop(self, force=False):
+        """Stops the running daemon by sending SIGTERM or SIGINT based on the force option."""
+        try:
+            pid = self.get_pid()
+            os.kill(pid, signal.SIGINT if force else signal.SIGTERM)
+            self.remove_pid()
+        except FileNotFoundError:
+            pass
+        except ProcessLookupError:
+            self.remove_pid()
+
+    def run(self):
+        """Override this method in subclasses to define the daemon's main loop."""
+        raise NotImplementedError("You must override the run() method!")

mojo/helpers/dates.py

@@ -0,0 +1,69 @@
+from datetime import datetime, timedelta
+import pytz
+import objict
+from .settings import settings
+
+
+def parse_datetime(value, timezone=None):
+    date = objict.parse_date(value)
+    if date.tzinfo is None:
+        date = pytz.UTC.localize(date)
+    if timezone is not None:
+        local_tz = pytz.timezone(timezone)
+    else:
+        local_tz = pytz.UTC
+    return date.astimezone(local_tz)
+
+
+def get_local_day(timezone, dt_utc=None):
+    if dt_utc is None:
+        dt_utc = datetime.now(tz=pytz.UTC)
+    local_tz = pytz.timezone(timezone)
+    local_dt = dt_utc.astimezone(local_tz)
+    start_of_day = local_tz.localize(datetime(
+        local_dt.year, local_dt.month, local_dt.day, 0, 0, 0))
+    end_of_day = start_of_day + timedelta(days=1)
+    return start_of_day.astimezone(pytz.UTC), end_of_day.astimezone(pytz.UTC)
+
+def get_local_time(timezone, dt_utc=None):
+    """Convert a passed in datetime to the group's timezone."""
+    if dt_utc is None:
+        dt_utc = datetime.now(tz=pytz.UTC)
+    if dt_utc.tzinfo is None:
+        dt_utc = pytz.UTC.localize(dt_utc)
+    local_tz = pytz.timezone(timezone)
+    return dt_utc.astimezone(local_tz)
+
+def utcnow():
+    """look at django setting to get proper datetime aware or not"""
+    if settings.USE_TZ:
+        return datetime.now(tz=pytz.UTC)
+    return datetime.utcnow()
+
+
+def add(when=None, seconds=None, minutes=None, hours=None, days=None):
+    if when is None:
+        when = utcnow()
+    elapsed_time = timedelta(
+        seconds=seconds or 0,
+        minutes=minutes or 0,
+        hours=hours or 0,
+        days=days or 0
+    )
+    return when + elapsed_time
+
+
+def subtract(when=None, seconds=None, minutes=None, hours=None, days=None):
+    if when is None:
+        when = utcnow()
+    elapsed_time = timedelta(
+        seconds=seconds or 0,
+        minutes=minutes or 0,
+        hours=hours or 0,
+        days=days or 0
+    )
+    return when - elapsed_time
+
+
+def has_time_elsapsed(when, seconds=None, minutes=None, hours=None, days=None):
+    return utcnow() >= add(when, seconds, minutes, hours, days)

mojo/helpers/dns/godaddy.py

@@ -0,0 +1,62 @@
+# aws_tools/godaddy.py
+
+import requests
+from objict import objict
+BASE_URL = "https://api.godaddy.com/v1"
+
+class DNSManager:
+    def __init__(self, api_key, api_secret):
+        self.api_key = api_key
+        self.api_secret = api_secret
+
+    def _headers(self):
+        return {
+            "Authorization": f"sso-key {self.api_key}:{self.api_secret}",
+            "Content-Type": "application/json",
+            "Accept": "application/json"
+        }
+
+    def get_domains(self, status="ACTIVE"):
+        url = f"{BASE_URL}/domains"
+        params = {"statuses": status} if status else {}
+        resp = requests.get(url, headers=self._headers(), params=params)
+        # resp.raise_for_status()
+        return objict(resp.json())
+
+    def get_domain_info(self, domain):
+        url = f"{BASE_URL}/domains/{domain}"
+        resp = requests.get(url, headers=self._headers())
+        # resp.raise_for_status()
+        return objict(resp.json())
+
+    def is_domain_active(self, domain):
+        info = self.get_domain_info(domain)
+        return info.status == "ACTIVE"
+
+    def get_record(self, domain, record_type, name):
+        url = f"{BASE_URL}/domains/{domain}/records/{record_type}/{name}"
+        resp = requests.get(url, headers=self._headers())
+        # resp.raise_for_status()
+        return objict(resp.json())
+
+    def get_records(self, domain):
+        url = f"{BASE_URL}/domains/{domain}/records"
+        resp = requests.get(url, headers=self._headers())
+        # resp.raise_for_status()
+        return objict(resp.json())
+
+    def edit_record(self, domain, record_type, name, data, ttl):
+        url = f"{BASE_URL}/domains/{domain}/records/{record_type}/{name}"
+        payload = [{"data": data, "ttl": ttl}]
+        resp = requests.put(url, headers=self._headers(), json=payload)
+        # resp.raise_for_status()
+        return objict(resp.json()) if resp.content else {"status": "success"}
+
+    def add_record(self, domain, record_type, name, data, ttl):
+        return self.edit_record(domain, record_type, name, data, ttl)
+
+    def bulk_add_records(self, domain, records):
+        url = f"{BASE_URL}/domains/{domain}/records"
+        resp = requests.patch(url, headers=self._headers(), json=records)
+        # resp.raise_for_status()
+        return objict(resp.json()) if resp.content else {"status": "success"}

mojo/helpers/filetypes.py

@@ -0,0 +1,128 @@
+EXTENSION_TO_MIME = {
+    # Documents
+    '.pdf': 'application/pdf',
+    '.doc': 'application/msword',
+    '.docx': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+    '.xls': 'application/vnd.ms-excel',
+    '.xlsx': 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+    '.ppt': 'application/vnd.ms-powerpoint',
+    '.pptx': 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+    '.csv': 'text/csv',
+    '.tsv': 'text/tab-separated-values',
+    '.txt': 'text/plain',
+    '.rtf': 'application/rtf',
+    '.odt': 'application/vnd.oasis.opendocument.text',
+    '.ods': 'application/vnd.oasis.opendocument.spreadsheet',
+    '.md': 'text/markdown',
+    '.epub': 'application/epub+zip',
+    '.ics': 'text/calendar',
+
+    # Images
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.png': 'image/png',
+    '.gif': 'image/gif',
+    '.bmp': 'image/bmp',
+    '.webp': 'image/webp',
+    '.tiff': 'image/tiff',
+    '.svg': 'image/svg+xml',
+    '.heic': 'image/heic',
+    '.ico': 'image/vnd.microsoft.icon',
+
+    # Audio
+    '.mp3': 'audio/mpeg',
+    '.wav': 'audio/wav',
+    '.ogg': 'audio/ogg',
+    '.m4a': 'audio/mp4',
+    '.flac': 'audio/flac',
+
+    # Video
+    '.mp4': 'video/mp4',
+    '.mov': 'video/quicktime',
+    '.avi': 'video/x-msvideo',
+    '.wmv': 'video/x-ms-wmv',
+    '.webm': 'video/webm',
+    '.mkv': 'video/x-matroska',
+
+    # Archives
+    '.zip': 'application/zip',
+    '.tar': 'application/x-tar',
+    '.gz': 'application/gzip',
+    '.rar': 'application/vnd.rar',
+    '.7z': 'application/x-7z-compressed',
+    '.tar.gz': 'application/gzip',  # Special case
+    '.tgz': 'application/gzip',
+    '.bz2': 'application/x-bzip2',
+    '.tar.bz2': 'application/x-bzip2',
+
+    # Code / Data
+    '.json': 'application/json',
+    '.xml': 'application/xml',
+    '.html': 'text/html',
+    '.htm': 'text/html',
+    '.css': 'text/css',
+    '.js': 'application/javascript',
+    '.py': 'text/x-python',
+    '.java': 'text/x-java-source',
+    '.c': 'text/x-c',
+    '.cpp': 'text/x-c++',
+    '.ts': 'application/typescript',
+    '.yml': 'application/x-yaml',
+    '.yaml': 'application/x-yaml',
+    '.sql': 'application/sql',
+
+    # Fonts
+    '.woff': 'font/woff',
+    '.woff2': 'font/woff2',
+    '.ttf': 'font/ttf',
+    '.otf': 'font/otf',
+
+    # Misc
+    '.apk': 'application/vnd.android.package-archive',
+    '.exe': 'application/vnd.microsoft.portable-executable',
+    '.dmg': 'application/x-apple-diskimage',
+    '.bat': 'application/x-bat',
+    '.sh': 'application/x-sh',
+    '.pdfa': 'application/pdf',
+    '.webmanifest': 'application/manifest+json',
+}
+
+def parse_extension(filename):
+    """
+    Extract the extension from a filename, handling both single and double extensions,
+    and return the extension along with the filename without the extension.
+
+    Parameters:
+    filename (str): The name of the file for which to extract the extension.
+
+    Returns:
+    tuple: A tuple containing the extracted extension (or an empty string if no valid
+           extension is found) and the filename without the extension.
+    """
+    filename = filename.lower()
+    parts = filename.rsplit('.', 2)  # Max 2 splits: base.name.ext1.ext2
+    if len(parts) == 3:
+        double_ext = f".{parts[-2]}.{parts[-1]}"
+        if double_ext in EXTENSION_TO_MIME:
+            return double_ext, '.'.join(parts[:-1])
+    ext = f".{parts[-1]}" if '.' in filename else ''
+    base_filename = parts[0] if len(parts) == 1 else '.'.join(parts[:-1])
+    return ext, base_filename
+
+def guess_type(filename):
+    """
+    Guess the MIME type of a file based on its extension.
+
+    This function attempts to determine the MIME type of a file by examining
+    its extension. It can handle both single and double extensions, such as
+    ".tar.gz" or ".tar.bz2".
+
+    Parameters:
+    filename (str): The name of the file whose MIME type needs to be guessed.
+
+    Returns:
+    str: The guessed MIME type if found in EXTENSION_TO_MIME mapping, or
+         'application/octet-stream' as a default fallback.
+    """
+    ext, _ = parse_extension(filename)
+    return EXTENSION_TO_MIME.get(ext, 'application/octet-stream')