django-nativemojo 0.1.10__py3-none-any.whl

mojo/helpers/aws/s3.py

@@ -0,0 +1,268 @@
+from rest import settings
+from objict import objict
+import boto3
+import botocore
+from urllib.parse import urlparse
+import io
+import sys
+from medialib import utils
+import threading
+import tempfile
+import logging
+from typing import Optional, Union, BinaryIO, Dict, List, Any
+
+logger = logging.getLogger(__name__)
+
+class S3Config:
+    """S3 configuration holder with lazy initialization of clients and resources."""
+    def __init__(self, key: str, secret: str):
+        self.key = key
+        self.secret = secret
+        self._resource = None
+        self._client = None
+
+    @property
+    def resource(self):
+        if self._resource is None:
+            self._resource = boto3.resource('s3',
+                                           aws_access_key_id=self.key,
+                                           aws_secret_access_key=self.secret)
+        return self._resource
+
+    @property
+    def client(self):
+        if self._client is None:
+            self._client = boto3.client('s3',
+                                       aws_access_key_id=self.key,
+                                       aws_secret_access_key=self.secret)
+        return self._client
+
+# Initialize the global S3 configuration
+S3 = S3Config(settings.AWS_KEY, settings.AWS_SECRET)
+
+
+class S3Item:
+    """Class representing an S3 object with operations for upload, download, and management."""
+
+    S3_HOST = "https://s3.amazonaws.com"
+
+    def __init__(self, url: str):
+        """
+        Initialize an S3Item from a URL.
+
+        Args:
+            url: S3 URL in the format s3://bucket-name/key
+        """
+        self.url = url
+        parsed_url = urlparse(url)
+        self.bucket_name = parsed_url.netloc
+        self.key = parsed_url.path.lstrip('/')
+        self.object = S3.resource.Object(self.bucket_name, self.key)
+        self.exists = self._check_exists()
+
+    def _check_exists(self) -> bool:
+        """Check if the S3 object exists."""
+        try:
+            self.object.load()
+            return True
+        except botocore.exceptions.ClientError as e:
+            if e.response['Error']['Code'] == "404":
+                return False
+            raise
+
+    def upload(self, file_obj: Union[str, BinaryIO], background: bool = False) -> None:
+        """
+        Upload a file to S3.
+
+        Args:
+            file_obj: File path or file-like object to upload
+            background: Currently unused, kept for backward compatibility
+        """
+        prepared_file = self._prepare_file(file_obj)
+        self.object.upload_fileobj(prepared_file)
+
+    def create_multipart_upload(self) -> str:
+        """
+        Initialize a multipart upload.
+
+        Returns:
+            Upload ID for the multipart upload
+        """
+        self.part_num = 0
+        self.parts = []
+        response = S3.client.create_multipart_upload(
+            Bucket=self.bucket_name,
+            Key=self.key
+        )
+        self.upload_id = response["UploadId"]
+        return self.upload_id
+
+    def upload_part(self, chunk: bytes) -> Dict:
+        """
+        Upload a part in a multipart upload.
+
+        Args:
+            chunk: Bytes to upload as part
+
+        Returns:
+            Dict with part information
+        """
+        self.part_num += 1
+        response = S3.client.upload_part(
+            Bucket=self.bucket_name,
+            Key=self.key,
+            PartNumber=self.part_num,
+            UploadId=self.upload_id,
+            Body=chunk
+        )
+        part_info = {"PartNumber": self.part_num, "ETag": response["ETag"]}
+        self.parts.append(part_info)
+        return part_info
+
+    def complete_multipart_upload(self) -> Dict:
+        """
+        Complete a multipart upload.
+
+        Returns:
+            S3 response
+        """
+        return S3.client.complete_multipart_upload(
+            Bucket=self.bucket_name,
+            Key=self.key,
+            UploadId=self.upload_id,
+            MultipartUpload={"Parts": self.parts}
+        )
+
+    @property
+    def public_url(self) -> str:
+        """Get the public URL for the S3 object."""
+        return f"{self.S3_HOST}/{self.bucket_name}/{self.key}"
+
+    def generate_presigned_url(self, expires: int = 600) -> str:
+        """
+        Generate a presigned URL for the S3 object.
+
+        Args:
+            expires: Expiration time in seconds
+
+        Returns:
+            Presigned URL
+        """
+        return S3.client.generate_presigned_url(
+            'get_object',
+            ExpiresIn=expires,
+            Params={'Bucket': self.bucket_name, 'Key': self.key}
+        )
+
+    def download(self, file_obj: Optional[BinaryIO] = None) -> BinaryIO:
+        """
+        Download the S3 object.
+
+        Args:
+            file_obj: Optional file-like object to download to
+
+        Returns:
+            File-like object containing the downloaded data
+        """
+        if file_obj is None:
+            file_obj = tempfile.NamedTemporaryFile()
+        self.object.download_fileobj(file_obj)
+        if hasattr(file_obj, 'seek'):
+            file_obj.seek(0)
+        return file_obj
+
+    def delete(self) -> None:
+        """Delete the S3 object."""
+        self.object.delete()
+
+    def _prepare_file(self, file_obj: Union[str, BinaryIO]) -> BinaryIO:
+        """
+        Prepare a file object for upload.
+
+        Args:
+            file_obj: File path or file-like object
+
+        Returns:
+            A file-like object ready for upload
+        """
+        if hasattr(file_obj, "read"):
+            return io.BytesIO(file_obj.read().encode() if isinstance(file_obj.read(), str) else file_obj.read())
+
+        try:
+            return open(str(file_obj), "rb")
+        except (IOError, TypeError):
+            pass
+
+        return file_obj
+
+
+
+# Utility functions for common S3 operations
+
+def upload(url: str, file_obj: Union[str, BinaryIO], background: bool = False) -> None:
+    """Upload a file to S3."""
+    S3Item(url).upload(file_obj, background)
+
+
+def view_url_noexpire(url: str, is_secure: bool = False) -> str:
+    """Get a public URL for an S3 object."""
+    return S3Item(url).public_url
+
+
+def view_url(url: str, expires: Optional[int] = 600, is_secure: bool = True) -> str:
+    """
+    Get a URL for an S3 object.
+
+    Args:
+        url: S3 URL
+        expires: Expiration time in seconds, or None for a public URL
+        is_secure: Whether to use HTTPS (currently unused)
+
+    Returns:
+        URL for the S3 object
+    """
+    if expires is None:
+        return view_url_noexpire(url, is_secure)
+    return S3Item(url).generate_presigned_url(expires)
+
+
+def exists(url: str) -> bool:
+    """Check if an S3 object exists."""
+    return S3Item(url).exists
+
+
+def get_file(url: str, file_obj: Optional[BinaryIO] = None) -> BinaryIO:
+    """Download an S3 object to a file."""
+    return S3Item(url).download(file_obj)
+
+
+def delete(url: str) -> None:
+    """
+    Delete an S3 object or prefix.
+
+    If the URL ends with /, all objects under that prefix are deleted.
+    """
+    if url.endswith("/"):
+        parsed_url = urlparse(url)
+        prefix = parsed_url.path.lstrip("/")
+        bucket_name = parsed_url.netloc
+
+        response = S3.client.list_objects_v2(
+            Bucket=bucket_name,
+            Prefix=prefix,
+            MaxKeys=100
+        )
+
+        if 'Contents' in response:
+            for obj in response['Contents']:
+                S3.client.delete_object(
+                    Bucket=bucket_name,
+                    Key=obj['Key']
+                )
+    else:
+        S3Item(url).delete()
+
+
+def path(url: str) -> str:
+    """Extract the path component from a URL."""
+    return urlparse(url).path

mojo/helpers/cron.py

@@ -0,0 +1,79 @@
+import datetime
+from typing import Callable, List, Dict, Any
+from mojo.decorators.cron import schedule
+
+def run_now() -> None:
+    """
+    Execute the scheduled functions that match the current time.
+
+    Retrieves the list of functions scheduled to run at the current
+    date and time, and executes each of them.
+    """
+    functions_to_run = find_scheduled_functions()
+    for func in functions_to_run:
+        func()
+
+def find_scheduled_functions() -> List[Callable]:
+    """
+    Find all functions that are scheduled to run at the current time.
+
+    Returns:
+        List[Callable]: A list of callable functions that match the
+        current date and time according to their cron specifications.
+    """
+    if not hasattr(schedule, 'scheduled_functions'):
+        return []
+
+    now = datetime.datetime.now()
+    matching_funcs = []
+
+    for cron_spec in schedule.scheduled_functions:
+        if match_time(now, cron_spec):
+            matching_funcs.append(cron_spec['func'])
+
+    return matching_funcs
+
+def match_time(current_time: datetime.datetime, cron_spec: Dict[str, Any]) -> bool:
+    """
+    Determine if a given time matches a cron-like specification.
+
+    Args:
+        current_time (datetime.datetime): The current date and time.
+        cron_spec (Dict[str, Any]): A dictionary containing the cron
+        specifications to match against.
+
+    Returns:
+        bool: True if the current time matches the cron specification,
+        False otherwise.
+    """
+    cron_field = {
+        'minutes': current_time.minute,
+        'hours': current_time.hour,
+        'days': current_time.day,
+        'months': current_time.month,
+        'weekdays': current_time.weekday()
+    }
+
+    for field, time_value in cron_field.items():
+        if not matches(cron_spec[field], time_value):
+            return False
+    return True
+
+def matches(cron_value: str, actual_value: int) -> bool:
+    """
+    Check if a specific time value matches the corresponding cron pattern.
+
+    Args:
+        cron_value (str): The cron pattern to match, which can be '*'
+        or a list of comma-separated values.
+        actual_value (int): The actual time value to compare.
+
+    Returns:
+        bool: True if the actual value matches the cron pattern,
+        False otherwise.
+    """
+    if cron_value == '*':
+        return True
+    cron_values = cron_value.split(',')
+
+    return str(actual_value) in cron_values

mojo/helpers/crypto/__init__.py

@@ -0,0 +1,4 @@
+from .aes import encrypt, decrypt
+from .utils import random_bytes, random_string
+from .hash import hash
+from .sign import generate_signature as sign, verify_signature as verify

mojo/helpers/crypto/aes.py

@@ -0,0 +1,60 @@
+import json
+from base64 import b64encode, b64decode
+from Crypto.Cipher import AES
+from Crypto.Protocol.KDF import PBKDF2
+from Crypto.Random import get_random_bytes
+from objict import objict
+import mojo.errors
+
+PBKDF2_ITERATIONS = 100_000
+SALT_LENGTH = 16
+NONCE_LENGTH = 12
+TAG_LENGTH = 16
+
+
+def encrypt(data, password):
+    if isinstance(data, dict):
+        data = json.dumps(data)
+    if not isinstance(data, str):
+        raise mojo.errors.ValueException("Data must be a string or dictionary")
+
+    data_bytes = data.encode('utf-8')
+    salt = get_random_bytes(SALT_LENGTH)
+    key = derive_key(password, salt)
+    cipher = AES.new(key, AES.MODE_GCM, nonce=get_random_bytes(NONCE_LENGTH))
+
+    ciphertext, tag = cipher.encrypt_and_digest(data_bytes)
+
+    # Final payload: [salt | nonce | tag | ciphertext]
+    payload = salt + cipher.nonce + tag + ciphertext
+    return b64encode(payload).decode('utf-8')
+
+def decrypt(enc_data_b64, password, ignore_errors=True):
+    raw = b64decode(enc_data_b64)
+
+    salt = raw[:SALT_LENGTH]
+    nonce = raw[SALT_LENGTH:SALT_LENGTH + NONCE_LENGTH]
+    tag = raw[SALT_LENGTH + NONCE_LENGTH:SALT_LENGTH + NONCE_LENGTH + TAG_LENGTH]
+    ciphertext = raw[SALT_LENGTH + NONCE_LENGTH + TAG_LENGTH:]
+
+    key = derive_key(password, salt)
+    cipher = AES.new(key, AES.MODE_GCM, nonce=nonce)
+
+    if ignore_errors:
+        try:
+            decrypted = cipher.decrypt_and_verify(ciphertext, tag)
+        except ValueError:
+            return None
+    else:
+        decrypted = cipher.decrypt_and_verify(ciphertext, tag)
+
+    decrypted_str = decrypted.decode('utf-8')
+
+    try:
+        return objict.from_json(decrypted_str)
+    except Exception:
+        return decrypted_str
+
+
+def derive_key(password, salt, key_length=32):
+    return PBKDF2(password, salt, dkLen=key_length, count=PBKDF2_ITERATIONS)

mojo/helpers/crypto/hash.py

@@ -0,0 +1,59 @@
+from Crypto.Hash import SHA256
+from Crypto.Random import get_random_bytes
+import hmac
+import hashlib
+from django.conf import settings
+
+
+def hash(value, salt=settings.SECRET_KEY):
+    """
+    Returns a SHA-256 hash of the input value (string, int, or dict), optionally salted.
+
+    :param value: str, int, or dict - the input to be hashed
+    :param salt: Optional[str or bytes] - a salt to strengthen the hash
+    :return: str - the hex digest of the hash
+    """
+    if isinstance(value, dict):
+        # Sort the dictionary and prepare a string representation
+        value_str = str(sorted(value.items())).encode('utf-8')
+    elif isinstance(value, (str, int)):
+        value_str = str(value).encode('utf-8')
+    else:
+        raise TypeError("Only strings, integers, or dictionaries are allowed.")
+
+    # Use provided salt or generate one
+    if salt is None:
+        salt = get_random_bytes(16)
+    elif isinstance(salt, str):
+        salt = salt.encode('utf-8')
+
+    # Combine salt and value
+    hasher = hashlib.sha256()
+    hasher.update(salt + value_str)
+    return hasher.hexdigest()
+
+
+def hash_digits(digits, secret_key):
+    """Hashes the digits using a derived salt without storing it."""
+    salt = derive_salt(digits, secret_key)
+    hash_obj = hashlib.sha256(salt + digits.encode())
+    return hash_obj.hexdigest()
+
+
+def derive_salt(digits, secret_key):
+    """Derives a salt from the last 8 digits of the DIGITs using HMAC."""
+    last_8_digits = digits[-8:]
+    if isinstance(secret_key, str):  # Ensure secret_key is bytes
+        secret_key = secret_key.encode()
+    return hmac.new(secret_key, last_8_digits.encode(), hashlib.sha256).digest()[:16]  # Use first 16 bytes
+
+
+def hash_to_hex(input_string):
+    if not isinstance(input_string, str):
+        raise ValueError("Input must be a string")
+    # Create a new SHA-256 hasher
+    hasher = hashlib.sha256()
+    # Update the hasher with the input string encoded to bytes
+    hasher.update(input_string.encode('utf-8'))
+    # Return the hexadecimal representation of the hash
+    return hasher.hexdigest()

mojo/helpers/crypto/privpub/__init__.py

@@ -0,0 +1 @@
+from .hybrid import PrivatePublicEncryption

mojo/helpers/crypto/privpub/hybrid.py

@@ -0,0 +1,97 @@
+import base64
+import binascii
+import json
+from nacl.public import PrivateKey, PublicKey, SealedBox
+from nacl.encoding import Base64Encoder
+from nacl.exceptions import CryptoError
+
+
+class PrivatePublicEncryption:
+    def __init__(self, private_key=None, public_key=None, private_key_file=None, public_key_file=None):
+        self.private_key = self._load_key(private_key, private_key_file, is_private=True)
+        self.public_key = self._load_key(public_key, public_key_file, is_private=False)
+
+        if self.private_key and not self.public_key:
+            self.public_key = self.private_key.public_key
+
+    def _load_key(self, key, key_file, is_private):
+        if key_file:
+            with open(key_file, 'r') as f:
+                key = f.read().strip()
+
+        if key:
+            if isinstance(key, str):
+                key_bytes = Base64Encoder.decode(key)
+            elif isinstance(key, bytes):
+                key_bytes = key
+            else:
+                raise ValueError("Key must be a base64 string or bytes")
+
+            return PrivateKey(key_bytes) if is_private else PublicKey(key_bytes)
+        return None
+
+    def generate_public_key(self, make_new=False):
+        if self.public_key is None or make_new:
+            if not self.private_key:
+                self.private_key = PrivateKey.generate()
+            self.public_key = self.private_key.public_key
+        return self.public_key
+
+    def encrypt(self, data):
+        self.generate_public_key()
+        return self.encrypt_to_b64(data)
+
+    def decrypt(self, data, as_string=True):
+        return self.decrypt_from_b64(data, as_string)
+
+    def encrypt_to_b64(self, data):
+        encrypted_bytes = encrypt_with_public_key(data, self.public_key)
+        return base64.b64encode(encrypted_bytes).decode('utf-8')
+
+    def decrypt_from_b64(self, data, as_string=True):
+        decoded = base64.b64decode(data)
+        return decrypt_with_private_key(decoded, self.private_key, as_string)
+
+    def encrypt_to_hex(self, data):
+        encrypted_bytes = encrypt_with_public_key(data, self.public_key)
+        return binascii.hexlify(encrypted_bytes).decode('utf-8')
+
+    def decrypt_from_hex(self, data, as_string=True):
+        decoded = binascii.unhexlify(data)
+        return decrypt_with_private_key(decoded, self.private_key, as_string)
+
+
+def generate_private_key():
+    return PrivateKey.generate()
+
+
+def generate_public_key(private_key):
+    if isinstance(private_key, str):
+        private_key = PrivateKey(Base64Encoder.decode(private_key))
+    return private_key.public_key
+
+
+def encrypt_with_public_key(data, public_key):
+    if isinstance(public_key, str):
+        public_key = PublicKey(Base64Encoder.decode(public_key))
+
+    if isinstance(data, (dict, list)):
+        data = json.dumps(data)
+    if isinstance(data, str):
+        data = data.encode('utf-8')
+
+    sealed_box = SealedBox(public_key)
+    return sealed_box.encrypt(data)
+
+
+def decrypt_with_private_key(data, private_key, as_string=True):
+    if isinstance(private_key, str):
+        private_key = PrivateKey(Base64Encoder.decode(private_key))
+
+    sealed_box = SealedBox(private_key)
+    try:
+        decrypted = sealed_box.decrypt(data)
+        decoded = decrypted.decode('utf-8')
+        return json.loads(decoded) if as_string else decrypted
+    except (CryptoError, json.JSONDecodeError):
+        return decrypted.decode('utf-8') if as_string else decrypted

mojo/helpers/crypto/privpub/rsa.py

@@ -0,0 +1,104 @@
+from Crypto import Random
+from Crypto.PublicKey import RSA
+from Crypto.Cipher import AES, PKCS1_OAEP
+import base64
+import binascii
+import json
+from io import BytesIO
+from contextlib import closing
+
+
+class PrivatePublicEncryption:
+    def __init__(self, private_key=None, public_key=None, private_key_file=None, public_key_file=None):
+        self.private_key = self._load_key(private_key, private_key_file)
+        self.public_key = self._load_key(public_key, public_key_file)
+
+    def _load_key(self, key, key_file):
+        if key_file:
+            with open(key_file, 'r') as f:
+                key = f.read()
+        if isinstance(key, str):
+            return RSA.import_key(key)
+        return key
+
+    def generate_public_key(self, make_new=False):
+        if self.public_key is None or make_new:
+            self.public_key = generate_public_key(self.private_key)
+        return self.public_key
+
+    def encrypt(self, data):
+        self.generate_public_key()
+        return self.encrypt_to_b64(data)
+
+    def decrypt(self, data, as_string=True):
+        return self.decrypt_from_b64(data, as_string)
+
+    def encrypt_to_b64(self, data):
+        ebytes = encrypt_with_public_key(data, self.public_key)
+        return base64.b64encode(ebytes).decode('utf-8')
+
+    def decrypt_from_b64(self, data, as_string=True):
+        data = base64.b64decode(data)
+        return decrypt_with_private_key(data, self.private_key, as_string)
+
+    def encrypt_to_hex(self, data):
+        ebytes = encrypt_with_public_key(data, self.public_key)
+        return binascii.hexlify(ebytes).decode('utf-8')
+
+    def decrypt_from_hex(self, data, as_string=True):
+        data = binascii.unhexlify(data)
+        return decrypt_with_private_key(data, self.private_key, as_string)
+
+
+def generate_private_key(size=2048):
+    return RSA.generate(size)
+
+
+def generate_public_key(private_key):
+    if isinstance(private_key, str):
+        private_key = RSA.import_key(private_key)
+    return private_key.publickey()
+
+
+def encrypt_with_public_key(data, public_key):
+    if isinstance(public_key, str):
+        public_key = RSA.import_key(public_key)
+
+    if isinstance(data, (dict, list)):
+        data = json.dumps(data)
+
+    if isinstance(data, str):
+        data = data.encode('utf-8')
+
+    session_key = Random.get_random_bytes(16)
+    cipher_rsa = PKCS1_OAEP.new(public_key)
+    enc_session_key = cipher_rsa.encrypt(session_key)
+
+    cipher_aes = AES.new(session_key, AES.MODE_EAX)
+    ciphertext, tag = cipher_aes.encrypt_and_digest(data)
+
+    with closing(BytesIO()) as output:
+        for x in (enc_session_key, cipher_aes.nonce, tag, ciphertext):
+            output.write(x)
+        return output.getvalue()
+
+
+def decrypt_with_private_key(data, private_key, as_string=True):
+    if isinstance(private_key, str):
+        private_key = RSA.import_key(private_key)
+        if isinstance(data, str):
+            data = data.encode('utf-8')
+        if isinstance(data, bytes):
+            data = BytesIO(data)
+
+    enc_session_key, nonce, tag, ciphertext = (
+        data.read(x) for x in (private_key.size_in_bytes(), 16, 16, -1)
+    )
+
+    cipher_rsa = PKCS1_OAEP.new(private_key)
+    session_key = cipher_rsa.decrypt(enc_session_key)
+
+    cipher_aes = AES.new(session_key, AES.MODE_EAX, nonce)
+    decrypted_data = cipher_aes.decrypt_and_verify(ciphertext, tag)
+
+    return decrypted_data.decode('utf-8') if as_string else decrypted_data