dmart 0.1.9__py3-none-any.whl

utils/generate_email.py

@@ -0,0 +1,38 @@
+import os
+from jinja2 import Environment, FileSystemLoader
+from pathlib import Path
+
+
+def generate_email_from_template(template, data):
+    templates_dir = Path(__file__).resolve().parent / "templates"
+    environment = Environment(
+        loader=FileSystemLoader(str(templates_dir))
+    )
+    match template:
+        case "activation":
+            template = environment.get_template("activation.html.j2")
+            return template.render(
+                name=data.get("name"),
+                msisdn=data.get("msisdn"),
+                shortname=data.get("shortname"),
+                link=data.get("link"),
+            )
+
+        case "reminder":
+            template = environment.get_template("reminder.html.j2")
+            return template.render(
+                name=data.get("name"),
+                link=data.get("link"),
+            )
+        case _:
+            return ""
+
+
+def generate_subject(template):
+    match template:
+        case "activation":
+            return "Welcome to our Platform!"
+        case "reminder":
+            return "[Reminder] Activate Your Account"
+        case _:
+            return ""

utils/helpers.py

@@ -0,0 +1,352 @@
+from copy import deepcopy
+import csv
+from datetime import datetime
+import json
+from pathlib import Path
+from re import sub as re_sub
+from uuid import UUID
+
+import aiofiles
+from jsonschema.validators import _RefResolver as RefResolver  # type: ignore
+
+# TBD from referencing import Registry, Resource
+# TBD import referencing.jsonschema
+from collections.abc import MutableMapping
+from models.enums import Language
+from typing import Any
+from languages.loader import languages
+
+
+def flatten_all(d: MutableMapping, parent_key: str = "", sep: str = ".") -> dict:
+    items: list = []
+    for k, v in d.items():
+        new_key = parent_key + sep + k if parent_key else k
+        if isinstance(v, MutableMapping):
+            items.extend(flatten_all(v, new_key, sep=sep).items())
+        elif isinstance(v, list):
+            items.extend(flatten_all(flatten_list(v), new_key, sep=sep).items())
+        else:
+            items.append((new_key, v))
+    return dict(items)
+
+
+def flatten_dict(d, parent_key='', sep='.'):
+    items = []
+    for k, v in d.items():
+        new_key = f"{parent_key}{sep}{k}" if parent_key else k
+        if isinstance(v, dict):
+            items.extend(flatten_dict(v, new_key, sep=sep).items())
+        else:
+            items.append((new_key, v))
+    return dict(items)
+
+
+def flatten_list(ll: list, key: str | None = None):
+    flattened = {}
+    for idx, item in enumerate(ll):
+        flattened[f"{key}.{idx}" if key else f"{idx}"] = item
+    return flattened
+
+
+def arr_remove_common(arr1: list, arr2: list):
+    for i1 in arr1[:]:
+        if i1 in arr2:
+            arr1.remove(i1)
+            arr2.remove(i1)
+
+    return arr1, arr2
+
+
+def get_removed_items(arr1: list, arr2: list):
+    removed_items = []
+
+    for i1 in arr1:
+        if i1 not in arr2:
+            removed_items.append(i1)
+
+    return removed_items
+
+
+def flatten_list_of_dicts_in_dict(d: dict) -> dict:
+    """
+    example:
+    d = {
+        "key": [
+            {
+                'imsi': '12345',
+                'name': 'Saad Adel'
+            },
+            {
+                'imsi': '556566',
+                'name': 'Saad Adel'
+            }
+        ],
+        "another": "s",
+        "another2": 222,
+    }
+    return {
+        "key.imsi": ['12345', '556566'],
+        "key.name": ['Saad Adel', 'Saad Adel'],
+        "another": "s",
+        "another2": 222,
+    }
+    """
+    flattened_d = deepcopy(d)
+    for parent_key, list_of_dict in d.items():
+        if (
+            isinstance(list_of_dict, list)
+            and len(list_of_dict) > 0
+            and isinstance(list_of_dict[0], dict)
+        ):
+            flattened: dict = {}
+            for dict_item in list_of_dict:
+                for key, value in dict_item.items():
+                    flattened.setdefault(f"{parent_key}.{key}", [])
+                    flattened[f"{parent_key}.{key}"].append(value)
+            flattened_d.pop(parent_key)
+            flattened_d.update(flattened)
+
+    return flattened_d
+
+
+def resolve_schema_references(schema: dict, refs: dict = {}) -> dict:
+    """Resolves and replaces json-schema $refs with the appropriate dict.
+
+    Recursively walks the given schema dict, converting every instance
+    of $ref in a 'properties' structure with a resolved dict.
+
+    This modifies the input schema and also returns it.
+
+    Arguments:
+        schema:
+            the schema dict
+        refs:
+            a dict of <string, dict> which forms a store of referenced schemata
+
+    Returns:
+        schema
+    """
+    refs = refs or {}
+    resolved_schema = _resolve_schema_references(
+        schema, RefResolver("", schema, store=refs)
+    )
+    if "definitions" in resolved_schema:
+        resolved_schema.pop("definitions")
+    return resolved_schema
+
+
+def _resolve_schema_references(schema: dict, resolver) -> dict:
+    if "$ref" in schema:
+        reference_path = schema.pop("$ref", None)
+        resolved = resolver.resolve(reference_path)[1]
+        schema.update(resolved)
+        return _resolve_schema_references(schema, resolver)
+
+    if "properties" in schema:
+        for k, val in schema["properties"].items():
+            schema["properties"][k] = _resolve_schema_references(val, resolver)
+
+    if "patternProperties" in schema:
+        for k, val in schema["patternProperties"].items():
+            schema["patternProperties"][k] = _resolve_schema_references(val, resolver)
+
+    if "items" in schema:
+        schema["items"] = _resolve_schema_references(schema["items"], resolver)
+
+    if "anyOf" in schema:
+        for i, element in enumerate(schema["anyOf"]):
+            schema["anyOf"][i] = _resolve_schema_references(element, resolver)
+
+    if "oneOf" in schema:
+        for i, element in enumerate(schema["oneOf"]):
+            schema["oneOf"][i] = _resolve_schema_references(element, resolver)
+
+    return schema
+
+
+def camel_case(snake_str):
+    words = snake_str.split("_")
+    return "".join(word.title() for word in words)
+
+
+def snake_case(camel_str):
+    return re_sub(r"(?<!^)(?=[A-Z])", "_", camel_str).lower()
+
+
+def divide_chunks(lll, n):
+    """
+    Yield successive n-sized chunks from lll.
+    """
+
+    # looping till length l
+    for i in range(0, len(lll), n):
+        yield lll[i : i + n]
+
+
+def remove_none_dict(target: dict[str, Any] ) -> dict[str, Any]:
+    new_d: dict = {}
+    for key, val in target.items():
+        if val is None:
+            continue
+
+        if isinstance(val, dict) : 
+            new_d[key] = remove_none_dict(val)
+        elif isinstance(val, list):
+            new_d[key] = remove_none_list(val)
+        else:
+            new_d[key] = val
+
+    return new_d
+
+def remove_none_list(target: list):
+    new_l: list = []
+    for val in target:
+        if val is None:
+            continue
+
+        if isinstance(val, dict) : 
+            new_l.append(remove_none_dict(val))
+        elif isinstance(val, list):
+            new_l.append(remove_none_list(val))
+        else:
+            new_l.append(val)
+
+    return new_l
+
+
+def alter_dict_keys(
+    target: dict,
+    include: list | None = None,
+    exclude: list | None = None,
+    parents: str = "",
+):
+    result: dict = {}
+    for k in list(target):
+        search_for = f"{parents}.{k}" if parents else f"{k}"
+        if isinstance(target[k], dict):
+            if include and search_for in include:
+                result[k] = target[k]
+                continue
+            if exclude and search_for in exclude:
+                continue
+            result[k] = alter_dict_keys(
+                target[k], include, exclude, search_for if parents else f"{k}"
+            )
+
+        elif (include and search_for not in include) or (
+            exclude and search_for in exclude
+        ):
+            continue
+
+        else:
+            result[k] = target[k]
+
+    return result
+
+
+def json_flater(data: dict[str, Any]) -> dict[str, Any]:
+    flatened_data = {}
+    for k, v in data.items():
+        if isinstance(v, dict):
+            __flatened_data = json_flater(v)
+            _flatened_data = {
+                key: val for key, val in __flatened_data.items()
+            }  # deep copy to resolve the runtime error
+            _keys = list(_flatened_data.keys())
+            for key in _keys:
+                flatened_data[f"{k}.{key}"] = _flatened_data[key]
+                if k in flatened_data and key in flatened_data[k]:
+                    del flatened_data[k][key]
+        else:
+            flatened_data = {**flatened_data, k: v}
+    return flatened_data
+
+
+def lang_code(lang: Language):
+    match lang:
+        case Language.ar:
+            return "ar"
+        case Language.en:
+            return "en"
+        case Language.ku:
+            return "ku"
+        case Language.fr:
+            return "fr"
+        case Language.tr:
+            return "tr"
+
+
+def replace_message_vars(message: str, dest_data: dict, locale: str):
+    dest_data_dict = flatten_dict(dest_data)
+    for field, value in dest_data_dict.items():
+        if isinstance(value, dict) and locale in value:
+            value = value[locale]
+        if field in ["created_at", "updated_at"]:
+            message = message.replace(
+                f"{{{field}}}",
+                datetime.strptime(str(value), "%Y-%m-%d %H:%M:%S.%f").strftime(
+                    "%Y-%m-%d %H:%M:%S"
+                ),
+            )
+        else:
+            message = message.replace(
+                f"{{{field}}}", languages[Language[locale]].get(str(value), str(value))
+            )
+
+    return re_sub(r"\{\w*.*\}", "", message)
+
+
+def str_to_datetime(str: str, format: str = "%Y-%m-%dT%H:%M:%S.%f"):
+    return datetime.strptime(str, format)
+
+
+def pp(*args, **kwargs):
+    """
+    Pretty Print
+    """
+    print_str = "\n\n================== DUMP DATA ==================\n"
+    if args:
+        for arg in args:
+            print_str += f"\n\narg: {arg}"
+
+    if kwargs:
+        for k, v in kwargs.items():
+            print_str += f"\n\n{k}: {v}"
+
+    print_str += "\n\n_____________________END________________________\n\n"
+    print(print_str)
+
+
+async def csv_file_to_json(csv_file_path: Path) -> list[dict[str, Any]]:
+    data: list[dict[str, Any]] = []
+
+    async with aiofiles.open(
+        csv_file_path, mode="r", encoding="utf-8", newline=""
+    ) as csvf:
+        contents = await csvf.readlines()
+        csvReader = csv.DictReader(contents)
+
+        for row in csvReader:
+            data.append(row)
+
+    return data
+
+def read_jsonl_file(file_path):
+    data = []
+    with open(file_path, 'r') as file:
+        for line in file:
+            data.append(json.loads(line))
+    return data
+
+
+def jq_dict_parser(data):
+    if isinstance(data, dict):
+        return {k: jq_dict_parser(v) for k, v in data.items()}
+    elif isinstance(data, list):
+        return [jq_dict_parser(item) for item in data]
+    elif isinstance(data, UUID):
+        return str(data)
+    elif isinstance(data, datetime):
+        return str(data)
+    else:
+        return data

utils/hypercorn_config.py

@@ -0,0 +1,12 @@
+from utils.settings import settings
+from os import cpu_count
+from fastapi.logger import logger
+from utils.logger import logging_schema
+
+
+bind = [f"{settings.listening_host}:{settings.listening_port}"]
+workers = cpu_count()
+backlog = 200
+worker_class = "asyncio"
+logconfig_dict = logging_schema
+errorlog = logger

utils/internal_error_code.py

@@ -0,0 +1,60 @@
+class InternalErrorCode:
+    NOT_ALLOWED = 401
+    UNPROCESSABLE_ENTITY = 424
+    INVALID_IDENTIFIER = 420
+    INVALID_CONFIRMATION = 427
+    SHORTNAME_ALREADY_EXIST = 400
+    SHORTNAME_DOES_NOT_EXIST = 404
+    INVALID_DATA = 402
+    SOMETHING_WRONG = 430
+    INVALID_HEALTH_CHECK = 403
+    INVALID_APP_KEY = 555
+    INVALID_ROUTE = 230
+    OBJECT_NOT_FOUND = 220
+    INVALID_SPACE_NAME = 203
+    CANNT_DELETE = 204
+    ALREADY_EXIST_SPACE_NAME = 205
+    MISSING_DATA = 202
+    NOT_ALLOWED_LOCATION = 206
+    PROVID_SOURCE_PATH = 222
+    MISSING_DESTINATION_OR_SHORTNAME = 213
+    EMAIL_OR_MSISDN_REQUIRED = 207
+    MISSING_METADATA = 208
+    MISSING_FILTER_SHORTNAMES = 209
+    WORKFLOW_BODY_NOT_FOUND = 218
+    NOT_SUPPORTED_TYPE = 217
+    SOME_SUPPORTED_TYPE = 219
+    TICKET_ALREADY_CLOSED = 299
+    INVALID_TICKET_STATUS = 300
+    DIR_NOT_FOUND = 22
+    LOCK_UNAVAILABLE = 30
+    LOCKED_ENTRY = 31
+    QR_ERROR = 14
+    QR_EXPIRED = 15
+    QR_INVALID = 16
+    INVALID_INVITATION = 125
+    INVALID_PASSWORD_RULES = 17
+    INVALID_USERNAME_AND_PASS = 10
+    USER_ACCOUNT_LOCKED = 110
+    USER_ISNT_VERIFIED = 11
+    PASSWORD_NOT_VALIDATED = 13
+    PASSWORD_RESET_ERROR = 102
+    UNMATCHED_DATA = 19
+    CONFLICT = 409
+    USERNAME_NOT_EXIST = 18
+    OTP_INVALID = 307
+    OTP_EXPIRED = 308
+    OTP_FAILED = 104
+    OTP_ISSUE = 100
+    OTP_NEEDED = 115
+    OTP_RESEND_BLOCKED = 103
+    INVALID_STANDALONE_DATA = 107
+    ONE_ARGUMENT_ALLOWED = 101
+    DATA_SHOULD_BE_UNIQUE = 415
+    INVALID_TOKEN = 47
+    EXPIRED_TOKEN = 48
+    NOT_AUTHENTICATED = 49
+    SESSION = 50
+    OBJECT_NOT_SAVED = 51
+    JQ_TIMEOUT = 120
+    JQ_ERROR = 121

utils/jwt.py

@@ -0,0 +1,124 @@
+from time import time
+from typing import Optional, Any
+
+from fastapi import Request, status
+from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
+
+import jwt
+import models.api as api
+from utils.internal_error_code import InternalErrorCode
+from utils.settings import settings
+from data_adapters.adapter import data_adapter as db
+
+
+def decode_jwt(token: str) -> dict[str, Any]:
+    decoded_token: dict
+    try:
+        decoded_token = jwt.decode(
+            token, settings.jwt_secret, algorithms=[settings.jwt_algorithm]
+        )
+    except Exception:
+        raise api.Exception(
+            status.HTTP_401_UNAUTHORIZED,
+            api.Error(type="jwtauth", code=InternalErrorCode.INVALID_TOKEN, message="Invalid Token [1]"),
+        )
+    if (
+            not decoded_token
+            or "data" not in decoded_token
+            or "expires" not in decoded_token
+    ):
+        raise api.Exception(
+            status.HTTP_401_UNAUTHORIZED,
+            api.Error(type="jwtauth", code=InternalErrorCode.INVALID_TOKEN, message="Invalid Token [2]"),
+        )
+    if decoded_token["expires"] <= time():
+        raise api.Exception(
+            status.HTTP_401_UNAUTHORIZED,
+            api.Error(type="jwtauth", code=InternalErrorCode.EXPIRED_TOKEN, message="Expired Token"),
+        )
+
+    if (
+            isinstance(decoded_token["data"], dict)
+            and decoded_token["data"].get("shortname") is not None
+    ):
+        return decoded_token["data"]
+    else:
+        raise api.Exception(
+            status.HTTP_401_UNAUTHORIZED,
+            api.Error(type="jwtauth", code=InternalErrorCode.INVALID_TOKEN, message="Invalid Token [3]"),
+        )
+
+
+class JWTBearer():
+    is_required: bool = True
+    http_bearer: HTTPBearer
+
+    def __init__(self, auto_error: bool = True, is_required: bool = True):
+        self.http_bearer = HTTPBearer(auto_error=auto_error)
+        self.is_required = is_required
+
+    async def __call__(self, request: Request) -> str | None:
+        user_shortname: str | None = None
+        auth_token: str | None = None
+        try:
+            # Handle token received in Auth header
+            credentials: Optional[HTTPAuthorizationCredentials] = await self.http_bearer.__call__(request)
+            if credentials and credentials.scheme == "Bearer":
+                auth_token = credentials.credentials
+
+        except Exception:
+            # Handle token received in the cookie
+            auth_token = request.cookies.get("auth_token")
+
+        if not auth_token:
+            raise api.Exception(
+                status.HTTP_401_UNAUTHORIZED,
+                api.Error(type="jwtauth", code=InternalErrorCode.NOT_AUTHENTICATED, message="Not authenticated [1]"),
+            )
+
+        decoded = decode_jwt(auth_token)
+        user_shortname = decoded["shortname"]
+        if not user_shortname:
+            raise api.Exception(
+                status.HTTP_401_UNAUTHORIZED,
+                api.Error(type="jwtauth", code=InternalErrorCode.NOT_AUTHENTICATED, message="Not authenticated [2]"),
+            )
+
+        if decoded["type"] != 'bot' and settings.session_inactivity_ttl:
+            _, user_session_token = await db.get_user_session(user_shortname, auth_token)
+            if not isinstance(user_session_token, str):
+                raise api.Exception(
+                    status.HTTP_401_UNAUTHORIZED,
+                    api.Error(
+                        type="jwtauth", code=InternalErrorCode.NOT_AUTHENTICATED, message="Not authenticated [3]"
+                    ),
+                )
+
+        return user_shortname 
+
+class GetJWTToken:
+    http_bearer: HTTPBearer
+    def __init__(self, auto_error: bool = True):
+        self.http_bearer = HTTPBearer(auto_error=auto_error)
+
+    async def __call__(self, request: Request) -> str | None:
+        try:
+            credentials: Optional[HTTPAuthorizationCredentials] = await self.http_bearer.__call__(request)
+            if credentials and credentials.scheme == "Bearer":
+                return credentials.credentials
+        except Exception:
+            return request.cookies.get("auth_token")
+        return None
+
+
+def generate_jwt(data: dict, expires: int = 86400) -> str:
+    payload = {"data": data, "expires": time() + expires}
+    return jwt.encode(payload, settings.jwt_secret, algorithm=settings.jwt_algorithm)
+
+
+async def sign_jwt(data: dict, expires: int = 86400) -> str:
+    token = generate_jwt(data, expires)
+    if data["type"] != "bot" and settings.session_inactivity_ttl:
+        await db.set_user_session(data["shortname"], token)
+    return token
+