django-nativemojo 0.1.10__py3-none-any.whl

mojo/apps/notify/utils/parsing.py

@@ -0,0 +1,202 @@
+from io import StringIO
+import email
+import re
+from email.utils import parseaddr, parsedate_to_datetime, getaddresses
+from email.header import decode_header
+from objict import objict
+
+
+def decode_payload(part):
+    """
+    Decode the email part payload.
+
+    Args:
+        part (email.message.Part): The email part.
+
+    Returns:
+        str: The decoded payload as a string.
+    """
+    charset = part.get_content_charset() or 'utf-8'
+    return str(part.get_payload(decode=True), charset, 'replace')
+
+
+def parse_attachment(message_part):
+    """
+    Parse an email message part for attachments.
+
+    Args:
+        message_part (email.message.Part): The email message part.
+
+    Returns:
+        objict: An object representing the attachment, or None if not applicable.
+    """
+    content_disposition = message_part.get("Content-Disposition")
+    content_type = message_part.get_content_type()
+
+    if not content_disposition and content_type == "multipart/alternative":
+        return None
+
+    attachment = objict({
+        'dispositions': [],
+        'disposition': None,
+        'payload': message_part.get_payload(decode=False),
+        'charset': message_part.get_content_charset(),
+        'content_type': content_type,
+        'encoding': message_part.get("Content-Transfer-Encoding", "utf8"),
+        'content': None,
+        'name': None,
+        'create_date': None,
+        'mod_date': None,
+        'read_date': None,
+    })
+
+    dispositions = []
+    if content_disposition:
+        dispositions = content_disposition.strip().split(";")
+        attachment['dispositions'] = dispositions
+        attachment['disposition'] = dispositions[0]
+
+    if attachment['disposition'] in [None, "inline"] and attachment['content_type'] in ["text/plain", "text/html"]:
+        attachment.content = decode_payload(message_part)
+
+    if content_disposition:
+        for param in dispositions[1:]:
+            name, value = param.split("=")
+            name, value = name.strip().lower(), value.strip().strip('"\'')
+            if name == "filename":
+                attachment.name = value
+            elif name in ["create-date", "creation-date"]:
+                attachment.create_date = value
+            elif name == "modification-date":
+                attachment.mod_date = value
+            elif name == "read-date":
+                attachment.read_date = value
+
+    return attachment
+
+
+def to_file_object(attachment):
+    """
+    Convert an attachment to a file-like object.
+
+    Args:
+        attachment (objict): The attachment object.
+
+    Returns:
+        StringIO: A StringIO object representing the attachment payload.
+    """
+    obj = StringIO(to_string(attachment['payload']))
+    obj.name = attachment['name']
+    obj.size = len(attachment['payload'])  # 'size' is not typically an attribute of StringIO, but is set here for compatibility
+    return obj
+
+
+def parse_addresses(input_string, force_name=False, emails_only=False):
+    """
+    Parse email addresses from a string.
+
+    Args:
+        input_string (str): The input string containing email addresses.
+        force_name (bool): Force inclusion of the domain as the name if no name is present.
+        emails_only (bool): Return only email addresses if True, otherwise return detailed information.
+
+    Returns:
+        list: A list of parsed email information or email addresses.
+    """
+    if not input_string:
+        return []
+
+    email_pattern = r'[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}'
+    emails = re.findall(email_pattern, input_string)
+
+    parsed_emails = []
+    for addr in emails:
+        addr = addr.strip().lower()
+        name_match = re.search(r'([a-zA-Z\s]+)?\s*<{}>'.format(re.escape(addr)), input_string)
+        name = name_match.group(1).strip() if name_match and name_match.group(1) else (addr.split('@')[1] if force_name else None)
+        full_email = f"{name} <{addr}>" if name else addr
+        parsed_emails.append(objict(name=name, email=addr, full_email=full_email))
+
+    return [email.email for email in parsed_emails] if emails_only else parsed_emails
+
+
+def to_string(value):
+    """
+    Convert various types of values to a string.
+
+    Args:
+        value: The value to be converted.
+
+    Returns:
+        str: The string representation of the input value.
+    """
+    if isinstance(value, bytes):
+        return value.decode()
+    if isinstance(value, bytearray):
+        return value.decode("utf-8")
+    if isinstance(value, (int, float)):
+        return str(value)
+    return value
+
+
+def parse_raw_message(msg_obj):
+    """
+    Parse an email message and return a dictionary with its components.
+
+    Args:
+        msg_obj (str or email.message.Message): The email message object or its string representation.
+
+    Returns:
+        objict: A dictionary-like object containing email components.
+    """
+    if isinstance(msg_obj, str):
+        msg_obj = email.message_from_string(msg_obj)
+
+    subject, message, body, html = None, None, None, None
+    attachments, body_parts, html_parts = [], [], []
+
+    if msg_obj.get('Subject'):
+        decoded_fragments = decode_header(msg_obj['Subject'])
+        subject = ''.join(
+            str(s, enc or 'utf-8', 'replace')
+            for s, enc in decoded_fragments
+        )
+
+    for part in msg_obj.walk():
+        attachment = parse_attachment(part)
+        if attachment:
+            if attachment.get('content'):
+                (html_parts if attachment['content_type'] == "text/html" else body_parts).append(attachment.content)
+            else:
+                attachments.append(attachment)
+
+    if body_parts:
+        body = ''.join(body_parts).strip()
+        message = '\n'.join(
+            line.strip() for line in body.split('\n') if not line.startswith('>') or (blocks := 0) < 3
+        ).strip()
+
+    html = ''.join(html_parts) if html_parts else None
+
+    from_addr = parseaddr(msg_obj.get('From', ''))
+
+    date_time = None
+    if msg_obj.get('Date'):
+        date_time = parsedate_to_datetime(msg_obj['Date'])
+        if date_time:
+            date_time = date_time.replace(tzinfo=None)
+
+    return objict({
+        'subject': subject.strip() if subject else '',
+        'body': body,
+        'sent_at': date_time,
+        'message': message,
+        'html': html,
+        'from_email': from_addr[1],
+        'from_name': from_addr[0],
+        'to': msg_obj.get("To"),
+        'to_addrs': getaddresses(msg_obj.get_all("To", [])),
+        'cc': msg_obj.get("Cc"),
+        'cc_addrs': getaddresses(msg_obj.get_all("Cc", [])),
+        'attachments': attachments,
+    })

mojo/apps/notify/utils/render.py

@@ -0,0 +1,144 @@
+from django.template.loader import render_to_string
+from email.mime.multipart import MIMEMultipart
+from email.mime.text import MIMEText
+from email.mime.application import MIMEApplication
+from mojo.helpers.settings import settings
+import os
+from objict import objict
+from mailman.models.template import MailTemplate
+import csv
+from io import StringIO
+import re
+
+
+def create_message(sender, recipients, subject, text=None, html=None, attachments=None, replyto=None):
+    """
+    Prepares an email message with given parameters.
+
+    :param sender: The sender of the email.
+    :param recipients: Can be a single email (string), or multiple emails (list or tuple).
+    :param subject: Subject of the email.
+    :param text: Plain text content of the email.
+    :param html: HTML content of the email.
+    :param attachments: List of attachments, can be strings or bytes.
+    :param replyto: Email for reply-to address.
+    :return: An object containing email details.
+    """
+    recipients = _parse_recipients(recipients)
+    attachments = attachments or []
+
+    message = objict(sender=sender, recipients=recipients)
+    message.msg = create_multipart_message(sender, recipients, subject, text, html, attachments, replyto)
+    return message
+
+def _parse_recipients(recipients):
+    """
+    Parses recipients input into a list of emails.
+
+    :param recipients: Can be a single email (string) or delimited string (comma/semicolon), or a list/tuple.
+    :return: List of email strings.
+    """
+    if isinstance(recipients, str):
+        if ',' in recipients:
+            recipients = [t.strip() for t in recipients.split(',')]
+        elif ';' in recipients:
+            recipients = [t.strip() for t in recipients.split(';')]
+        else:
+            recipients = [recipients]
+    elif not isinstance(recipients, (tuple, list)):
+        recipients = [recipients]
+    return recipients
+
+def create_multipart_message(sender, recipients, subject, text=None, html=None, attachments=None, replyto=None):
+    """
+    Helper function to create a MIME multipart message with text, HTML, and attachments.
+
+    :param sender: Email sender.
+    :param recipients: List of recipient emails.
+    :param subject: Subject of the email.
+    :param text: Text content of the email.
+    :param html: HTML content of the email.
+    :param attachments: List of attachments.
+    :param replyto: Reply-to email address.
+    :return: A prepared MIMEMultipart message.
+    """
+    multipart_content_subtype = 'alternative' if text and html else 'mixed'
+    msg = MIMEMultipart(multipart_content_subtype)
+    msg['Subject'] = subject
+    msg['From'] = sender
+    msg['To'] = ', '.join(recipients)
+    if replyto:
+        msg.add_header('reply-to', replyto)
+
+    if text:
+        msg.attach(MIMEText(text, 'plain'))
+    if html:
+        # Remove non-ASCII characters to prevent encoding issues
+        html = html.encode('ascii', 'ignore').decode('ascii')
+        msg.attach(MIMEText(html, 'html'))
+
+    for index, atch in enumerate(attachments or [], start=1):
+        if isinstance(atch, (str, bytes)):
+            atch = objict(name=f"attachment{index}.txt", data=atch, mimetype="text/plain")
+        part = MIMEApplication(atch.data)
+        part.add_header('Content-Type', atch.mimetype)
+        part.add_header('Content-Disposition', 'attachment', filename=os.path.basename(atch.name))
+        msg.attach(part)
+
+    return msg
+
+def render_template(template_name, context, group=None):
+    """
+    Renders an email template with a provided context.
+
+    :param template_name: Name of the template.
+    :param context: Context to render the template.
+    :param group: Template group filter (optional).
+    :return: Rendered template as string or None.
+    """
+    context.update({
+        "SITE_LABEL": settings.SITE_LABEL,
+        "BASE_URL": settings.BASE_URL,
+        "SITE_LOGO": settings.SITE_LOGO,
+        "SERVER_NAME": settings.SERVER_NAME,
+        "UNSUBSCRIBE_URL": settings.get("UNSUBSCRIBE_URL", f"{settings.BASE_URL}/api/account/unsubscribe"),
+        "version": settings.VERSION,
+        "COMPANY_NAME": settings.get("COMPANY_NAME", context.get("COMPANY_NAME", ""))
+    })
+
+    if template_name.endswith(("html", ".txt")):
+        return render_to_string(template_name, context)
+
+    qset = MailTemplate.objects.filter(name=template_name)
+    if group is not None:
+        qset = qset.filter(group=group)
+
+    mtemp = qset.last()
+    return mtemp.render(context) if mtemp else None
+
+def generate_csv(qset, fields, name):
+    """
+    Generates a CSV from a queryset.
+
+    :param qset: Queryset containing data.
+    :param fields: Fields to include in CSV.
+    :param name: Name for the CSV file.
+    :return: An object with CSV data and metadata.
+    """
+    csv_io = StringIO()
+    csvwriter = csv.writer(csv_io)
+
+    csvwriter.writerow(fields)
+    for row in qset.values_list(*fields):
+        csvwriter.writerow(map(str, row))
+
+    return objict(name=name, file=csv_io, data=csv_io.getvalue(), mimetype="text/csv")
+
+def is_html(text):
+    """
+    Determine if the provided string contains HTML.
+
+    :param text: The text to be checked.
+    :return: True if HTML tags are found, False otherwise.
+    """
+    return bool(re.search(r'<[a-zA-Z0-9]+>.*?<\/[a-zA-Z0-9]+>', text))

mojo/apps/tasks/README.md

@@ -0,0 +1,118 @@
+# Taskit
+
+Taskit is a task management and processing library that uses Redis to handle task states across multiple channels. It provides a flexible and efficient way to publish, execute, and track tasks. Taskit is built with Django and is intended to be used in projects where distributed or asynchronous task execution is required.
+
+## Table of Contents
+
+- [Features](#features)
+- [Installation](#installation)
+- [Configuration](#configuration)
+- [Usage](#usage)
+  - [Publishing Tasks](#publishing-tasks)
+  - [Monitoring Tasks](#monitoring-tasks)
+  - [Advanced Usage](#advanced-usage)
+- [API Endpoints](#api-endpoints)
+- [Command Line Interface](#command-line-interface)
+- [License](#license)
+
+## Features
+
+- Asynchronous task management using Redis-backed storage.
+- Support for multiple channels to organize and prioritize tasks.
+- Task lifecycle management including pending, running, completed, and error states.
+- Built-in REST API for monitoring task statuses.
+- Thread pool executor for concurrent task execution.
+
+
+## Configuration
+
+Ensure your Django project is set up to use Taskit by configuring the necessary settings and Redis connection. Update your `settings.py` file:
+
+```python
+# settings.py
+
+TASKIT_CHANNELS = ['channel1', 'channel2', 'broadcast']
+REDIS_HOST = 'localhost'
+REDIS_PORT = 6379
+```
+
+## Usage
+
+### Publishing Tasks
+
+To publish a new task, use the `TaskManager` instance provided by Taskit:
+
+```python
+from taskit.manager import TaskManager
+
+channels = ['channel1', 'channel2']
+task_manager = TaskManager(channels)
+
+def my_task_function(task_data):
+    data = task_data.data
+    print(f"Processing data: {data}")
+
+task_data = {'key': 'value'}
+task_id = task_manager.publish('module.my_task_function', task_data, channel='channel1')
+
+print(f"Task {task_id} published to channel1")
+```
+
+### Monitoring Tasks
+
+Taskit includes a REST API for checking the status of tasks:
+
+- `GET /status` - Summary of all tasks across all channels.
+- `GET /pending` - List of pending tasks.
+- `GET /completed` - List of completed tasks.
+- `GET /running` - List of tasks currently running.
+- `GET /errors` - List of tasks that encountered errors.
+
+### Advanced Usage
+
+Use the `TaskEngine` to start the task processing engine. This engine will listen for tasks on the specified channels and execute them using a thread pool:
+
+```python
+from taskit.runner import TaskEngine
+
+engine = TaskEngine(['channel1', 'channel2'], max_workers=10)
+engine.run()
+```
+
+You can also leverage the daemon capabilities by using CLI commands like `--start` and `--stop` to manage the task engine:
+
+```sh
+python manage.py taskit --start
+```
+
+## API Endpoints
+
+Taskit provides several Django REST API endpoints for managing tasks:
+
+- **Status:** `GET /status/` - Get the overall status of the task system.
+- **Pending Tasks:** `GET /pending/` - Retrieve all pending tasks.
+- **Completed Tasks:** `GET /completed/` - Retrieve all completed tasks.
+- **Running Tasks:** `GET /running/` - Retrieve all running tasks.
+- **Error Tasks:** `GET /errors/` - Retrieve tasks that encountered errors.
+
+## Command Line Interface
+
+Taskit also offers CLI support for managing the task engine:
+
+```sh
+python manage.py taskit --help
+```
+
+Options:
+- `--start`: Start the task engine daemon.
+- `--stop`: Stop the task engine daemon.
+- `-f, --foreground`: Run the task engine in the foreground.
+- `-v, --verbose`: Enable verbose logging for more detailed output.
+
+## License
+
+This project is licensed under the MIT License. See the LICENSE file for details.
+
+---
+
+This README file provides a comprehensive overview and instructions for using Taskit. Please feel free to ask further questions or raise issues in the GitHub repository.

mojo/apps/tasks/__init__.py

@@ -0,0 +1,11 @@
+from mojo.helpers.settings import settings
+
+
+def get_manager():
+    from .manager import TaskManager
+    return TaskManager(settings.TASKIT_CHANNELS)
+
+
+def publish(channel, function, data, expires=1800):
+    man = get_manager()
+    return man.publish(function, data, channel=channel, expires=expires)