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

mojo/helpers/aws/sns.py

@@ -0,0 +1,461 @@
+"""
+AWS SNS Helper Module
+
+Provides simple interfaces for managing AWS SNS (Simple Notification Service).
+"""
+
+import json
+import logging
+import boto3
+import botocore
+from typing import Dict, List, Optional, Union, Any
+
+from .client import get_session
+from mojo.helpers.settings import settings
+from mojo.helpers import logit
+
+logger = logit.get_logger(__name__)
+
+
+class SNSTopic:
+    """
+    Simple interface for managing SNS topics.
+    """
+
+    def __init__(self, name: str, access_key: Optional[str] = None,
+                 secret_key: Optional[str] = None, region: Optional[str] = None):
+        """
+        Initialize a topic manager for the specified SNS topic.
+
+        Args:
+            name: The topic name
+            access_key: AWS access key, defaults to settings.AWS_KEY
+            secret_key: AWS secret key, defaults to settings.AWS_SECRET
+            region: AWS region, defaults to settings.AWS_REGION if available
+        """
+        self.name = name
+        self.access_key = access_key or settings.AWS_KEY
+        self.secret_key = secret_key or settings.AWS_SECRET
+        self.region = region or getattr(settings, 'AWS_REGION', 'us-east-1')
+
+        session = get_session(self.access_key, self.secret_key, self.region)
+        self.client = session.client('sns')
+        self.arn = None
+        self.exists = self._check_exists()
+
+    def _check_exists(self) -> bool:
+        """
+        Check if the topic exists and set ARN if it does.
+
+        Returns:
+            True if the topic exists, False otherwise
+        """
+        try:
+            # List topics and check if this one exists
+            response = self.client.list_topics()
+
+            for topic in response.get('Topics', []):
+                topic_arn = topic['TopicArn']
+                if topic_arn.split(':')[-1] == self.name:
+                    self.arn = topic_arn
+                    return True
+
+            return False
+        except botocore.exceptions.ClientError as e:
+            logger.error(f"Error checking topic existence: {e}")
+            return False
+
+    def create(self, display_name: Optional[str] = None,
+               tags: Optional[List[Dict[str, str]]] = None) -> bool:
+        """
+        Create an SNS topic.
+
+        Args:
+            display_name: Display name for the topic
+            tags: Optional tags for the topic
+
+        Returns:
+            True if topic was created, False if it already exists
+        """
+        if self.exists:
+            logger.info(f"Topic {self.name} already exists")
+            return False
+
+        try:
+            # Prepare creation parameters
+            create_params = {'Name': self.name}
+            attributes = {}
+
+            if display_name:
+                attributes['DisplayName'] = display_name
+
+            if attributes:
+                create_params['Attributes'] = attributes
+
+            if tags:
+                create_params['Tags'] = tags
+
+            # Create the topic
+            response = self.client.create_topic(**create_params)
+            self.arn = response['TopicArn']
+            self.exists = True
+            return True
+        except botocore.exceptions.ClientError as e:
+            logger.error(f"Failed to create topic {self.name}: {e}")
+            return False
+
+    def delete(self) -> bool:
+        """
+        Delete the SNS topic.
+
+        Returns:
+            True if successfully deleted, False otherwise
+        """
+        if not self.exists:
+            logger.info(f"Topic {self.name} does not exist")
+            return False
+
+        try:
+            self.client.delete_topic(TopicArn=self.arn)
+            self.arn = None
+            self.exists = False
+            return True
+        except botocore.exceptions.ClientError as e:
+            logger.error(f"Failed to delete topic {self.name}: {e}")
+            return False
+
+    def publish(self, message: str, subject: Optional[str] = None,
+                attributes: Optional[Dict[str, Dict]] = None,
+                message_structure: Optional[str] = None) -> Dict:
+        """
+        Publish a message to the topic.
+
+        Args:
+            message: Message to publish
+            subject: Optional subject for the message
+            attributes: Optional message attributes
+            message_structure: Optional message structure (e.g., 'json')
+
+        Returns:
+            Response dict containing MessageId if successful
+        """
+        if not self.exists:
+            logger.warning(f"Topic {self.name} does not exist")
+            return {'Error': 'Topic does not exist'}
+
+        try:
+            # Prepare publish parameters
+            publish_params = {
+                'TopicArn': self.arn,
+                'Message': message
+            }
+
+            if subject:
+                publish_params['Subject'] = subject
+
+            if attributes:
+                publish_params['MessageAttributes'] = attributes
+
+            if message_structure:
+                publish_params['MessageStructure'] = message_structure
+
+            # Publish the message
+            response = self.client.publish(**publish_params)
+            logger.info(f"Message published successfully with MessageId: {response['MessageId']}")
+            return response
+        except botocore.exceptions.ClientError as e:
+            logger.error(f"Failed to publish message to topic {self.name}: {e}")
+            return {'Error': str(e)}
+
+    def set_attributes(self, attributes: Dict[str, str]) -> bool:
+        """
+        Set topic attributes.
+
+        Args:
+            attributes: Dictionary of attribute name-value pairs
+
+        Returns:
+            True if successful, False otherwise
+        """
+        if not self.exists:
+            logger.warning(f"Topic {self.name} does not exist")
+            return False
+
+        try:
+            self.client.set_topic_attributes(
+                TopicArn=self.arn,
+                AttributeName=list(attributes.keys())[0],  # Can only set one at a time
+                AttributeValue=list(attributes.values())[0]
+            )
+            return True
+        except botocore.exceptions.ClientError as e:
+            logger.error(f"Failed to set attributes for topic {self.name}: {e}")
+            return False
+
+    def get_attributes(self) -> Dict[str, str]:
+        """
+        Get topic attributes.
+
+        Returns:
+            Dictionary of topic attributes
+        """
+        if not self.exists:
+            logger.warning(f"Topic {self.name} does not exist")
+            return {}
+
+        try:
+            response = self.client.get_topic_attributes(TopicArn=self.arn)
+            return response.get('Attributes', {})
+        except botocore.exceptions.ClientError as e:
+            logger.error(f"Failed to get attributes for topic {self.name}: {e}")
+            return {}
+
+    def list_subscriptions(self) -> List[Dict]:
+        """
+        List all subscriptions to this topic.
+
+        Returns:
+            List of subscription dictionaries
+        """
+        if not self.exists:
+            logger.warning(f"Topic {self.name} does not exist")
+            return []
+
+        try:
+            response = self.client.list_subscriptions_by_topic(TopicArn=self.arn)
+            return response.get('Subscriptions', [])
+        except botocore.exceptions.ClientError as e:
+            logger.error(f"Failed to list subscriptions for topic {self.name}: {e}")
+            return []
+
+    @staticmethod
+    def list_all_topics() -> List[Dict]:
+        """
+        List all SNS topics.
+
+        Returns:
+            List of topic dictionaries
+        """
+        client = boto3.client('sns',
+                             aws_access_key_id=settings.AWS_KEY,
+                             aws_secret_access_key=settings.AWS_SECRET,
+                             region_name=getattr(settings, 'AWS_REGION', 'us-east-1'))
+
+        try:
+            response = client.list_topics()
+            return response.get('Topics', [])
+        except botocore.exceptions.ClientError as e:
+            logger.error(f"Failed to list topics: {e}")
+            return []
+
+
+class SNSSubscription:
+    """
+    Simple interface for managing SNS subscriptions.
+    """
+
+    def __init__(self, topic_arn: str, access_key: Optional[str] = None,
+                 secret_key: Optional[str] = None, region: Optional[str] = None):
+        """
+        Initialize a subscription manager for the specified SNS topic.
+
+        Args:
+            topic_arn: The ARN of the topic
+            access_key: AWS access key, defaults to settings.AWS_KEY
+            secret_key: AWS secret key, defaults to settings.AWS_SECRET
+            region: AWS region, defaults to settings.AWS_REGION if available
+        """
+        self.topic_arn = topic_arn
+        self.access_key = access_key or settings.AWS_KEY
+        self.secret_key = secret_key or settings.AWS_SECRET
+        self.region = region or getattr(settings, 'AWS_REGION', 'us-east-1')
+
+        session = get_session(self.access_key, self.secret_key, self.region)
+        self.client = session.client('sns')
+
+    def subscribe(self, protocol: str, endpoint: str,
+                  attributes: Optional[Dict[str, str]] = None,
+                  return_subscription_arn: bool = False) -> Dict:
+        """
+        Subscribe an endpoint to the topic.
+
+        Args:
+            protocol: Protocol to use (http, https, email, sms, sqs, application, lambda)
+            endpoint: Endpoint to subscribe
+            attributes: Optional subscription attributes
+            return_subscription_arn: Whether to return the subscription ARN
+
+        Returns:
+            Response dict containing SubscriptionArn
+        """
+        try:
+            # Prepare subscription parameters
+            subscribe_params = {
+                'TopicArn': self.topic_arn,
+                'Protocol': protocol,
+                'Endpoint': endpoint,
+                'ReturnSubscriptionArn': return_subscription_arn
+            }
+
+            if attributes:
+                subscribe_params['Attributes'] = attributes
+
+            # Create the subscription
+            response = self.client.subscribe(**subscribe_params)
+            logger.info(f"Subscription created: {response.get('SubscriptionArn')}")
+            return response
+        except botocore.exceptions.ClientError as e:
+            logger.error(f"Failed to create subscription: {e}")
+            return {'Error': str(e)}
+
+    def unsubscribe(self, subscription_arn: str) -> bool:
+        """
+        Unsubscribe from the topic.
+
+        Args:
+            subscription_arn: ARN of the subscription to delete
+
+        Returns:
+            True if successful, False otherwise
+        """
+        try:
+            self.client.unsubscribe(SubscriptionArn=subscription_arn)
+            logger.info(f"Subscription {subscription_arn} deleted")
+            return True
+        except botocore.exceptions.ClientError as e:
+            logger.error(f"Failed to delete subscription {subscription_arn}: {e}")
+            return False
+
+    def set_attributes(self, subscription_arn: str,
+                       attribute_name: str, attribute_value: str) -> bool:
+        """
+        Set subscription attributes.
+
+        Args:
+            subscription_arn: ARN of the subscription
+            attribute_name: Name of the attribute to set
+            attribute_value: Value of the attribute
+
+        Returns:
+            True if successful, False otherwise
+        """
+        try:
+            self.client.set_subscription_attributes(
+                SubscriptionArn=subscription_arn,
+                AttributeName=attribute_name,
+                AttributeValue=attribute_value
+            )
+            return True
+        except botocore.exceptions.ClientError as e:
+            logger.error(f"Failed to set attributes for subscription {subscription_arn}: {e}")
+            return False
+
+    def get_attributes(self, subscription_arn: str) -> Dict[str, str]:
+        """
+        Get subscription attributes.
+
+        Args:
+            subscription_arn: ARN of the subscription
+
+        Returns:
+            Dictionary of subscription attributes
+        """
+        try:
+            response = self.client.get_subscription_attributes(
+                SubscriptionArn=subscription_arn
+            )
+            return response.get('Attributes', {})
+        except botocore.exceptions.ClientError as e:
+            logger.error(f"Failed to get attributes for subscription {subscription_arn}: {e}")
+            return {}
+
+    @staticmethod
+    def list_all_subscriptions() -> List[Dict]:
+        """
+        List all SNS subscriptions.
+
+        Returns:
+            List of subscription dictionaries
+        """
+        client = boto3.client('sns',
+                             aws_access_key_id=settings.AWS_KEY,
+                             aws_secret_access_key=settings.AWS_SECRET,
+                             region_name=getattr(settings, 'AWS_REGION', 'us-east-1'))
+
+        try:
+            response = client.list_subscriptions()
+            return response.get('Subscriptions', [])
+        except botocore.exceptions.ClientError as e:
+            logger.error(f"Failed to list subscriptions: {e}")
+            return []
+
+
+# Utility functions
+def create_topic_and_subscribe(topic_name: str, protocol: str, endpoint: str,
+                              display_name: Optional[str] = None) -> Dict:
+    """
+    Create a topic and subscribe an endpoint in one operation.
+
+    Args:
+        topic_name: Name of the topic to create
+        protocol: Protocol to use for subscription
+        endpoint: Endpoint to subscribe
+        display_name: Optional display name for the topic
+
+    Returns:
+        Dict with topic ARN and subscription ARN
+    """
+    result = {}
+
+    # Create the topic
+    topic = SNSTopic(topic_name)
+    if not topic.exists:
+        if not topic.create(display_name=display_name):
+            return {'Error': f"Failed to create topic {topic_name}"}
+
+    result['TopicArn'] = topic.arn
+
+    # Create the subscription
+    subscription = SNSSubscription(topic.arn)
+    response = subscription.subscribe(protocol, endpoint, return_subscription_arn=True)
+
+    if 'Error' in response:
+        result['Error'] = response['Error']
+    else:
+        result['SubscriptionArn'] = response.get('SubscriptionArn')
+
+    return result
+
+
+def publish_message(topic_name: str, message: str, subject: Optional[str] = None) -> Dict:
+    """
+    Publish a message to a topic by name.
+
+    Args:
+        topic_name: Name of the topic
+        message: Message to publish
+        subject: Optional message subject
+
+    Returns:
+        Response dict containing MessageId if successful
+    """
+    topic = SNSTopic(topic_name)
+
+    if not topic.exists:
+        return {'Error': f"Topic {topic_name} does not exist"}
+
+    return topic.publish(message, subject)
+
+
+def get_topic_arn(topic_name: str) -> Optional[str]:
+    """
+    Get the ARN for a topic by name.
+
+    Args:
+        topic_name: Name of the topic
+
+    Returns:
+        Topic ARN if found, None otherwise
+    """
+    topic = SNSTopic(topic_name)
+    return topic.arn if topic.exists else None

mojo/helpers/dates.py

@@ -67,3 +67,21 @@ def subtract(when=None, seconds=None, minutes=None, hours=None, days=None):
 
 def has_time_elsapsed(when, seconds=None, minutes=None, hours=None, days=None):
     return utcnow() >= add(when, seconds, minutes, hours, days)
+
+
+def is_today(when, timezone=None):
+    if timezone is None:
+        timezone = 'UTC'
+
+    # Convert when to the specified timezone
+    if when.tzinfo is None:
+        when = pytz.UTC.localize(when)
+    local_tz = pytz.timezone(timezone)
+    when_local = when.astimezone(local_tz)
+
+    # Get today's date in the specified timezone
+    now_utc = utcnow()
+    now_local = now_utc.astimezone(local_tz)
+
+    # Compare dates
+    return when_local.date() == now_local.date()

mojo/helpers/response.py

@@ -1,4 +1,4 @@
-import ujson
+from objict import objict
 from django.http import HttpResponse
 
 
@@ -10,5 +10,9 @@ class JsonResponse(HttpResponse):
                 'safe parameter to False.'
             )
         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)

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)