django-nativemojo 0.1.10__py3-none-any.whl

mojo/apps/metrics/rest/base.py

@@ -0,0 +1,152 @@
+from mojo import decorators as md
+from mojo.apps import metrics
+from mojo.helpers.response import JsonResponse
+import mojo.errors
+
+import datetime
+@md.POST('record', docs={
+    "summary": "Record metrics data",
+    "description": "Records metrics data for specified slug for the specified account, increments by 1 each call.",
+    "parameters": [
+        {
+            "name": "slug",
+            "in": "body",
+            "required": True,
+            "schema": {"type": "string"},
+            "description": "Unique identifier for the metric to be recorded."
+        },
+        {
+            "name": "account",
+            "in": "body",
+            "required": False,
+            "schema": {"type": "string", "default": "public"},
+            "description": "Account identifier (e.g., 'public', 'global', or 'group_<id>')."
+        },
+        {
+            "name": "count",
+            "in": "body",
+            "required": False,
+            "schema": {"type": "integer", "default": 1},
+            "description": "The count by which the metric data should be incremented."
+        },
+        {
+            "name": "min_granularity",
+            "in": "body",
+            "required": False,
+            "schema": {"type": "string", "default": "hours"},
+            "description": "Minimum granularity of the metric (e.g., 'hours')."
+        },
+        {
+            "name": "max_granularity",
+            "in": "body",
+            "required": False,
+            "schema": {"type": "string", "default": "years"},
+            "description": "Maximum granularity of the metric (e.g., 'years')."
+        }
+    ]
+})
+@md.requires_params("slug")
+def on_metrics_record(request):
+    account = request.DATA.get("account", "public")
+    count = request.DATA.get_typed("count", default=1, typed=int)
+    min_granularity = request.DATA.get("min_granularity", "hours")
+    max_granularity = request.DATA.get("max_granularity", "years")
+    if account != "public":
+        perms = metrics.get_write_perms(account)
+        if not perms:
+            raise mojo.errors.PermissionDeniedException()
+        if perms != "public":
+            if not request.user.is_authenticated or not request.user.has_permission(perms):
+                raise mojo.errors.PermissionDeniedException()
+    metrics.record(request.DATA.slug, count=count, min_granularity=min_granularity,
+        max_granularity=max_granularity)
+    return JsonResponse(dict(status=True))
+
+
+@md.GET('fetch', docs={
+    "summary": "Fetch metrics data",
+    "description": "Retrieves metrics data for specified slugs within a given date range and granularity.",
+    "parameters": [
+        {
+            "name": "slugs",
+            "in": "query",
+            "required": True,
+            "schema": {"type": "array", "items": {"type": "string"}},
+            "description": "List of slugs to fetch metrics for."
+        },
+        {
+            "name": "dt_start",
+            "in": "query",
+            "schema": {"type": "string", "format": "date-time"},
+            "description": "Start date and time for the data range."
+        },
+        {
+            "name": "dt_end",
+            "in": "query",
+            "schema": {"type": "string", "format": "date-time"},
+            "description": "End date and time for the data range."
+        },
+        {
+            "name": "account",
+            "in": "query",
+            "schema": {"type": "string"},
+            "description": "Account identifier (e.g., 'public', 'global', or 'group_<id>')."
+        },
+        {
+            "name": "granularity",
+            "in": "query",
+            "schema": {"type": "string", "default": "hours"},
+            "description": "Granularity of the data (e.g., 'hours')."
+        }
+    ],
+    "responses": {
+        "200": {
+            "description": "Successful response with metrics data.",
+            "content": {
+                "application/json": {
+                    "example": {
+                        "response": {
+                            "data": {
+                                "data": {
+                                    "slug": "c3",
+                                    "values": [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+                                },
+                                "periods": [
+                                    "03:00", "04:00", "05:00", "06:00", "07:00",
+                                    "08:00", "09:00", "10:00", "11:00", "12:00",
+                                    "13:00", "14:00"
+                                ]
+                            },
+                            "status": True
+                        },
+                        "status_code": 200
+                    }
+                }
+            }
+        }
+    }
+})
+@md.requires_params("slugs")
+def on_metrics_data(request):
+    """
+    TODO add support for group based permissions where account == "group_<id>"
+    """
+    dt_start = request.DATA.get_typed("dt_start", typed=datetime.datetime)
+    dt_end = request.DATA.get_typed("dt_end", typed=datetime.datetime)
+    account = request.DATA.get("account", "public")
+    granularity = request.DATA.get("granularity", "hours")
+    if account == "global":
+        if not request.user.is_authenticated or not request.user.has_permission("view_metrics"):
+            raise mojo.errors.PermissionDeniedException()
+    elif account != "public":
+        perms = metrics.get_view_perms(account)
+        if not perms:
+            raise mojo.errors.PermissionDeniedException()
+        if perms and not request.user.has_permission(perms):
+            raise mojo.errors.PermissionDeniedException()
+    slugs = request.DATA.get_typed("slugs", typed=list)
+    if len(slugs) == 1:
+        slugs = slugs[0]
+    records = metrics.fetch(slugs, dt_start=dt_start, dt_end=dt_end,
+        granularity=granularity, account=account, with_labels=True)
+    return JsonResponse(dict(status=True, data=records))

mojo/apps/metrics/utils.py

@@ -0,0 +1,227 @@
+import time
+from datetime import timedelta
+import datetime
+from mojo.helpers.settings import settings
+from mojo.helpers import dates
+
+GRANULARITIES = ['minutes', 'hours', 'days', 'weeks', 'months', 'years']
+GRANULARITY_PREFIX_MAP = {
+    'minutes': 'min',
+    'hours': 'hr',
+    'days': 'day',
+    'weeks': 'wk',
+    'months': 'mon',
+    'years': 'yr'
+}
+
+GRANULARITY_EXPIRES_DAYS = {
+    'minutes': 1,  # 24 hours?
+    'hours': 3,  # 72 hours?
+    'days': 360,
+    'weeks': 360,
+    'months': None,
+    'years': None
+}
+
+GRANULARITY_OFFSET_MAP = {
+    'minutes': timedelta(minutes=1),
+    'hours': timedelta(hours=1),
+    'days': timedelta(days=1),
+    'weeks': timedelta(weeks=1),
+    'months': 'months',
+    'years': 'years'
+}
+
+GRANULARITY_END_MAP = {
+    'minutes': timedelta(minutes=29),
+    'hours': timedelta(hours=11),
+    'days': timedelta(days=11),
+    'weeks': timedelta(weeks=11),
+    'months': timedelta(days=12*30),
+    'years': timedelta(days=11*360)
+}
+
+
+DEFAULT_MIN_GRANULARITY = settings.get("METRICS_DEFAULT_MIN_GRANULARITY", "hours")
+DEFAULT_MAX_GRANULARITY = settings.get("METRICS_DEFAULT_MAX_GRANULARITY", "years")
+
+METRICS_TIMEZONE = settings.get("METRICS_TIMEZONE", "America/Los_Angeles")
+
+def generate_granularities(min_granularity=DEFAULT_MIN_GRANULARITY,
+                           max_granularity=DEFAULT_MAX_GRANULARITY):
+    """
+    Generate a list of granularities between a minimum and maximum level.
+
+    Args:
+        min_granularity (str): The minimum granularity level.
+        max_granularity (str): The maximum granularity level.
+
+    Returns:
+        list: A list of granularities from min_granularity to max_granularity.
+
+    Raises:
+        ValueError: If the specified granularities are invalid or
+        min_granularity is greater than max_granularity.
+    """
+    all_granularities = ['minutes', 'hours', 'days', 'weeks', 'months', 'years']
+
+    if min_granularity not in all_granularities or max_granularity not in all_granularities:
+        raise ValueError(
+            "Invalid granularity. Choose from 'minutes', 'hours', 'days', "
+            "'weeks', 'months', 'years'."
+        )
+
+    min_index = all_granularities.index(min_granularity)
+    max_index = all_granularities.index(max_granularity)
+    if min_index > max_index:
+        raise ValueError("min_granularity must be less than or equal to max_granularity.")
+    return all_granularities[min_index:max_index + 1]
+
+
+def generate_slug(slug, date, granularity, account="global"):
+    """
+    Generate a slug for a given date and granularity.
+
+    Args:
+        date: The date to format.
+        granularity (str): The granularity level for the slug.
+        *args: Additional strings to include in the slug prefix, separated by
+        colons.
+
+    Returns:
+        str: A formatted slug.
+
+    Raises:
+        ValueError: If the specified granularity is invalid for slug generation.
+    """
+    if granularity not in ['minutes', 'hours', 'days', 'weeks', 'months', 'years']:
+        raise ValueError("Invalid granularity for slug generation.")
+    gran_prefix = GRANULARITY_PREFIX_MAP.get(granularity)
+    if granularity == 'minutes':
+        date_slug = date.strftime('%Y-%m-%dT%H-%M')
+    elif granularity == 'hours':
+        date_slug = date.strftime('%Y-%m-%dT%H')
+    elif granularity == 'days':
+        date_slug = date.strftime('%Y-%m-%d')
+    elif granularity == 'weeks':
+        date_slug = date.strftime('%Y-%U')
+    elif granularity == 'months':
+        date_slug = date.strftime('%Y-%m')
+    elif granularity == 'years':
+        date_slug = date.strftime('%Y')
+    else:
+        raise ValueError("Unhandled granularity.")
+    prefix = generate_slug_prefix(slug, account)
+    return f"{prefix}:{gran_prefix}:{date_slug}"
+
+
+def generate_slug_prefix(slug, account):
+    # this is the slug without the date
+    slug = normalize_slug(slug)
+    return f"mets:{account}::{slug}"
+
+
+def generate_slugs_for_range(slug, dt_start, dt_end, granularity, account="global"):
+    """
+    Generate slugs for dates in a specified range with the given granularity.
+
+    Args:
+        slug (str): The base slug to use in generating slugs for the range.
+        dt_start (datetime): The start date of the range.
+        dt_end (datetime): The end date of the range.
+        granularity (str): The granularity level for iteration.
+
+    Returns:
+        list: A list of generated slugs for each date/time in the range at the specified granularity.
+
+    Raises:
+        ValueError: If the specified granularity is invalid.
+    """
+
+
+    if granularity not in GRANULARITY_OFFSET_MAP:
+        raise ValueError("Invalid granularity for slug generation.")
+    dt_start, dt_end = get_date_range(dt_start, dt_end, granularity)
+    current = dt_start
+    slugs = []
+
+    if granularity in ['minutes', 'hours', 'days', 'weeks']:
+        delta = GRANULARITY_OFFSET_MAP[granularity]
+        while current <= dt_end:
+            slugs.append(generate_slug(slug, current, granularity, account))
+            current += delta
+    elif granularity == 'months':
+        while current <= dt_end:
+            slugs.append(generate_slug(slug, current, granularity, account))
+            current = datetime.datetime(current.year + (current.month // 12), ((current.month % 12) + 1), 1, tzinfo=current.tzinfo)
+    elif granularity == 'years':
+        while current <= dt_end:
+            slugs.append(generate_slug(slug, current, granularity, account))
+            current = datetime.datetime(current.year + 1, 1, 1, tzinfo=current.tzinfo)
+    return slugs
+
+
+def generate_category_slug(account, category):
+    return f"mets:{account}:c:{category}"
+
+
+def generate_category_key(account):
+    return f"mets:{account}:cats"
+
+def generate_slugs_key(account):
+    return f"mets:{account}:slugs"
+
+
+def generate_perm_write_key(account):
+    return f"mets:{account}:perm:w"
+
+
+def generate_perm_view_key(account):
+    return f"mets:{account}:perm:v"
+
+
+def normalize_slug(slug):
+    return slug.replace(':', '|')
+
+
+def periods_from_dr_slugs(slugs):
+    if isinstance(slugs, (list, set)):
+        result = []
+        for s in slugs:
+            result.append(period_from_dr_slug(s))
+        return result
+
+def period_from_dr_slug(slug):
+    parts = slug.split(":")
+    gran_lbl = parts[-2]
+    period = parts[-1]
+    if gran_lbl == GRANULARITY_PREFIX_MAP["hours"]:
+        return f"{period[-2:]}:00"
+    if gran_lbl == GRANULARITY_PREFIX_MAP["minutes"]:
+        return period[-5:].replace('-', ':')
+    return period
+
+
+def get_expires_at(granularity, slug, category=None):
+    days = GRANULARITY_EXPIRES_DAYS.get(granularity, None)
+    if days is None:
+        return None
+    return int(time.time() + (days * 24 * 60 * 60))
+
+def normalize_datetime(when, timezone=None):
+    if when is not None and when.tzinfo is not None:
+        return when
+    if timezone is None:
+        timezone = METRICS_TIMEZONE
+    return dates.get_local_time(timezone, when)
+
+
+def get_date_range(dt_start, dt_end, granularity):
+    if dt_start is None and dt_end is None:
+        dt_end = normalize_datetime(None)
+        dt_start = dt_end - GRANULARITY_END_MAP[granularity]
+    elif dt_end is None:
+        dt_end = dt_start + GRANULARITY_END_MAP[granularity]
+    elif dt_start is None:
+        dt_start = dt_end - GRANULARITY_END_MAP[granularity]
+    return dt_start, dt_end

mojo/apps/notify/README.md

@@ -0,0 +1,91 @@
+# AWS SES (Simple Email Service)
+
+AWS SES is an email sending and receiving service provided by **Amazon Web Services**. It provides a robust and scalable platform for marketers and developers to send marketing, transactional, and notification emails.
+
+## How it Works:
+
+### 1. **Email Sending**:
+To send emails, users first authenticate themselves using SMTP (Simple Mail Transfer Protocol) credentials or a standard AWS SDK. After authentication, users send a request to SES that contains the content of their email and information about who should receive it. SES then sends the email on the user's behalf.
+
+
+## INBOX SETUP
+
+### Setup IAM user with SES Sending permissions
+
+```json
+{
+    "Version": "2012-10-17",
+    "Statement": [
+        {
+            "Effect": "Allow",
+            "Action": "ses:SendRawEmail",
+            "Resource": "*"
+        }
+    ]
+}
+```
+
+
+
+#### Store credentials in settings.core.email
+
+```
+SES_ACCESS_KEY = "***"
+SES_SECRET_KEY = "***"
+SES_REGION = "us-east-1"
+
+EMAIL_S3_BUCKET = "YOUR_EMAIL_BUCKET"
+EMAIL_USE_TLS = True
+EMAIL_HOST = 'email-smtp.us-east-1.amazonaws.com'
+EMAIL_HOST_USER = '***'
+EMAIL_HOST_PASSWORD = '***'
+EMAIL_PORT = 587
+```
+
+
+
+### Goto AWS SES Admin
+
+DNS Records needs to include
+
+
+
+| Type | Name           | Priority | Value                                         |
+| :--- | :------------- | -------- | :-------------------------------------------- |
+| MX   | mail.DOMAIN.io | 10       | **feedback**-smtp.us-east-1.amazon**ses**.com |
+| MX   | @              | 10       | **inbound**-smtp.us-east-1.amazon**aws**.com  |
+| TXT  | mail.DOMAIN.io |          | "v=spf1 include:amazonses.com ~all"           |
+
+
+
+## Setup Email Receiving
+
+```
+{
+  "Version": "2012-10-17",
+  "Statement": [
+    {
+      "Sid": "AllowSESPuts",
+      "Effect": "Allow",
+      "Principal": {
+        "Service": "ses.amazonaws.com"
+      },
+      "Action": "s3:PutObject",
+      "Resource": "arn:aws:s3:::AWSDOC-EXAMPLE-BUCKET/*",
+      "Condition": {
+        "StringEquals": {
+          "aws:Referer": "111122223333"
+        }
+      }
+    }
+  ]
+}
+```
+
+
+https://aws.amazon.com/premiumsupport/knowledge-center/ses-receive-inbound-emails/
+
+
+
+
+