howler-api 2.13.0.dev329__py3-none-any.whl

howler/common/random_user.py

@@ -0,0 +1,316 @@
+# Adjective list and noun list from: https://github.com/williexu/random_username
+# Modified to allow the list to be always in memory in a predefined format
+
+import random
+
+ADJECTIVES = [
+    "abject",
+    "accomplished",
+    "adept",
+    "adoring",
+    "adorable",
+    "adventurous",
+    "affectionate",
+    "agreeable",
+    "alert",
+    "amazed",
+    "amazing",
+    "ambitious",
+    "amiable",
+    "amused",
+    "approachable",
+    "ardent",
+    "articulate",
+    "artistic",
+    "attractive",
+    "awed",
+    "awesome",
+    "beautiful",
+    "blissful",
+    "brainy",
+    "brave",
+    "bright",
+    "brilliant",
+    "bubbly",
+    "capable",
+    "charismatic",
+    "charming",
+    "cheerful",
+    "chic",
+    "clean",
+    "colourful",
+    "compassionate",
+    "considerate",
+    "content",
+    "courageous",
+    "courteous",
+    "creative",
+    "cultured",
+    "curious",
+    "cute",
+    "dazzling",
+    "dear",
+    "debonair",
+    "determined",
+    "diligent",
+    "diplomatic",
+    "dynamic",
+    "eager",
+    "ecstatic",
+    "educated",
+    "efficient",
+    "elegant",
+    "empathic",
+    "energetic",
+    "engaging",
+    "enthusiastic",
+    "euphoric",
+    "excellent",
+    "excited",
+    "expert",
+    "fabulous",
+    "faithful",
+    "fantastic",
+    "favourable",
+    "fearless",
+    "fervent",
+    "fit",
+    "focused",
+    "fond",
+    "friendly",
+    "funny",
+    "generous",
+    "gleeful",
+    "gorgeous",
+    "happy",
+    "helpful",
+    "holistic",
+    "honest",
+    "humorous",
+    "imaginative",
+    "incredible",
+    "innocent",
+    "insightful",
+    "intelligent",
+    "inventive",
+    "joyful",
+    "jubilant",
+    "kind",
+    "knowledgeable",
+    "likable",
+    "loving",
+    "loyal",
+    "magnificent",
+    "marvelous",
+    "mellow",
+    "merciful",
+    "nice",
+    "optimistic",
+    "organized",
+    "passionate",
+    "patient",
+    "peaceful",
+    "perfect",
+    "persistent",
+    "pleased",
+    "plucky",
+    "polite",
+    "powerful",
+    "prideful",
+    "productive",
+    "proficient",
+    "qualified",
+    "reliable",
+    "relieved",
+    "remarkable",
+    "resolved",
+    "resourceful",
+    "responsible",
+    "sensible",
+    "sincere",
+    "sleek",
+    "smart",
+    "solid",
+    "spectacular",
+    "splendid",
+    "spirited",
+    "splendid",
+    "stellar",
+    "stunning",
+    "stupendous",
+    "sugary",
+    "super",
+    "superior",
+    "thoughtful",
+    "thrifty",
+    "thrilled",
+    "trusting",
+    "truthful",
+    "trustworthy",
+    "upbeat",
+    "warmhearted",
+    "winged",
+    "witty",
+    "wonderful",
+    "wondrous",
+    "worldly",
+    "zesty",
+]
+
+NOUNS = [
+    "abalone",
+    "antelope",
+    "apples",
+    "apricots",
+    "baboon",
+    "bagels",
+    "basmati",
+    "bass",
+    "bittern",
+    "boa",
+    "boars",
+    "bobolink",
+    "buck",
+    "burritos",
+    "buzzard",
+    "cake",
+    "camel",
+    "cardinal",
+    "caribou",
+    "caviar",
+    "chamois",
+    "cheese",
+    "cheetah",
+    "chile",
+    "chough",
+    "chowder",
+    "clam",
+    "coati",
+    "cockatoo",
+    "coconut",
+    "cod",
+    "cordial",
+    "cow",
+    "crackers",
+    "crane",
+    "cur",
+    "curlew",
+    "dingo",
+    "dinosaur",
+    "dotterel",
+    "doughnut",
+    "dove",
+    "doves",
+    "dunbird",
+    "eagle",
+    "eggs",
+    "eland",
+    "falcon",
+    "ferret",
+    "fish",
+    "flamingo",
+    "garlic",
+    "gelding",
+    "gnu",
+    "granola",
+    "hare",
+    "hawk",
+    "heron",
+    "hoopoe",
+    "hyena",
+    "icecream",
+    "iguana",
+    "jaguar",
+    "kitten",
+    "lapwing",
+    "lemur",
+    "leopard",
+    "lion",
+    "lizard",
+    "llama",
+    "locust",
+    "lollies",
+    "macaw",
+    "mackerel",
+    "magpie",
+    "mallard",
+    "mandrill",
+    "mare",
+    "meerkat",
+    "moth",
+    "muesli",
+    "mussel",
+    "oatmeal",
+    "ocelot",
+    "oil",
+    "orange",
+    "oryx",
+    "otter",
+    "owl",
+    "paella",
+    "pear",
+    "pepper",
+    "pie",
+    "piglet",
+    "plover",
+    "polenta",
+    "ponie",
+    "porpoise",
+    "poultry",
+    "pretzels",
+    "pudding",
+    "pup",
+    "quiche",
+    "raisins",
+    "rat",
+    "relish",
+    "rhino",
+    "rice",
+    "ruffs",
+    "salami",
+    "salt",
+    "sardines",
+    "sausage",
+    "seafowl",
+    "seagull",
+    "seahorse",
+    "shads",
+    "sheep",
+    "smelt",
+    "snail",
+    "snipe",
+    "stork",
+    "swift",
+    "syrup",
+    "tacos",
+    "teal",
+    "termite",
+    "thrush",
+    "thrushe",
+    "tomatoe",
+    "tortoise",
+    "toucan",
+    "truffle",
+    "tuna",
+    "unicorn",
+    "venison",
+    "viper",
+    "wasp",
+    "weaver",
+    "whiting",
+    "widgeon",
+    "wigeon",
+    "wildfowl",
+    "zebra",
+]
+
+
+def random_user(digits=2, delimiter="-"):
+    "Generate a random user"
+    adjective = random.choice(ADJECTIVES)
+    noun = random.choice(NOUNS)
+    if digits > 0:
+        num = str(random.randrange(10**digits))
+        return f"{adjective}{delimiter}{noun}{delimiter}{num}"
+    else:
+        return f"{adjective}{delimiter}{noun}"

howler/common/swagger.py

@@ -0,0 +1,117 @@
+import inspect
+import re
+from functools import wraps
+from typing import Any, Callable, Optional, cast
+
+from flasgger import utils
+
+
+def monkey_patched_parse(obj, process_doc, endpoint=None, verb=None):
+    """We monkey patch flasgger's built-in parse-docstring to work better with our format"""
+    short_desc: Optional[str] = None
+    long_desc: Optional[str] = None
+
+    doc = inspect.getdoc(obj)
+
+    if doc:
+        short_desc = doc.splitlines()[0]
+        long_desc = f"```\n{doc}\n```"
+
+    return short_desc, long_desc, None
+
+
+utils.parse_docstring = monkey_patched_parse
+
+
+RESPONSES = {
+    status_code: {
+        "description": "Something went wrong with your request",
+        "schema": {
+            "type": "object",
+            "properties": {
+                "api_response": {"type": "string"},
+                "api_error_message": {"type": "string"},
+                "api_warning": {"type": "string"},
+                "api_server_version": {"type": "string"},
+                "api_status_code": {"type": "integer"},
+            },
+            "example": {
+                "api_response": "Example response",
+                "api_error_message": "Example error",
+                "api_warning": "Example warning",
+                "api_server_version": "1.0",
+                "api_status_code": status_code,
+            },
+        },
+    }
+    for status_code in [400, 401, 403, 404]
+}
+
+
+def generate_swagger_docs(responses: dict[int, str] = {}):  # noqa: C901
+    "Generate swagger documentation for a given endpoint"
+
+    def decorator(function: Callable):  # noqa: ANN202
+        "Decorator function for generating the swagger docs"
+        func_signature = inspect.signature(function)
+        func_doc = inspect.getdoc(function)
+        if module := inspect.getmodule(function):
+            module_name = module.__name__
+        func_path = f"{module_name}.{function.__name__}" if module_name else function.__name__
+
+        path_params = [
+            {
+                "name": param,
+                "in": "path",
+                "type": "string",
+            }
+            for param in func_signature.parameters
+            if param not in ["kwargs", "_"] and not param.startswith("_")
+        ]
+
+        query_params: list[dict[str, Any]] = []
+        if func_doc:
+            for section in func_doc.split("\n\n"):
+                lines = section.splitlines()
+                if not lines[0].lower().endswith("arguments:"):
+                    continue
+
+                lines = [re.sub(r" =>.+", "", line).strip() for line in lines[1:]]
+
+                for line in lines:
+                    if line.lower() == "none" or "=>" not in line:
+                        continue
+
+                    if ": " in line:
+                        name, type = line.split(": ")
+                    else:
+                        name = line
+                        type = None
+
+                    query_params.append({"name": name, "in": "query", "type": type})
+
+        tags: list[str] = []
+        if module := inspect.getmodule(function):
+            tags.append(module.__name__.split(".")[-1].capitalize())
+
+        cast(Any, function).specs_dict = {
+            "parameters": [*path_params, *query_params],
+            "responses": {
+                "200": {
+                    "description": responses.get(200, "Request succeeded"),
+                    "schema": (None),
+                },
+                **RESPONSES,
+            },
+            "summary": "test",
+            "tags": tags,
+            "operationId": func_path,
+        }
+
+        @wraps(function)
+        def wrapper(*args, **kwargs):
+            return function(*args, **kwargs)
+
+        return wrapper
+
+    return decorator

howler/config.py

@@ -0,0 +1,64 @@
+import os
+
+from flask_caching import Cache
+
+from howler.common import loader
+from howler.odm.models.config import config
+from howler.remote.datatypes import get_client
+from howler.remote.datatypes.user_quota_tracker import UserQuotaTracker
+
+#################################################################
+# Configuration
+
+CLASSIFICATION = loader.get_classification()
+
+AUDIT = config.ui.audit
+
+SECRET_KEY = config.ui.secret_key
+DEBUG = config.ui.debug
+MAX_CLASSIFICATION = CLASSIFICATION.UNRESTRICTED
+
+HWL_UNSECURED_UI = os.environ.get("HWL_UNSECURED_UI", "false").lower() == "true"
+HWL_USE_REST_API = os.environ.get("HWL_USE_REST_API", "true").lower() == "true"
+HWL_USE_WEBSOCKET_API = os.environ.get("HWL_USE_WEBSOCKET_API", "false").lower() == "true"
+HWL_USE_JOB_SYSTEM = os.environ.get("HWL_USE_JOB_SYSTEM", "false").lower() == "true"
+HWL_ENABLE_RULES = os.environ.get("HWL_ENABLE_RULES", "false").lower() == "true"
+HWL_ENABLE_COVERAGE = os.environ.get("HWL_ENABLE_COVERAGE", "false").lower() == "true"
+HWL_PLUGIN_DIRECTORY = os.environ.get("HWL_PLUGIN_DIRECTORY", "/etc/howler/plugins")
+
+
+def get_version() -> str:
+    """The version of the HOWLER API
+
+    Returns:
+        str: The howler version
+    """
+    return os.environ.get("HOWLER_VERSION", "this is not the version you are looking for")
+
+
+def get_commit() -> str:
+    """The commit of the currently deployed Howler API
+
+    Returns:
+        str: The commit of the currently deployed image
+    """
+    return os.environ.get("COMMIT_HASH", "this is not the commit you are looking for")
+
+
+def get_branch() -> str:
+    """The branch of the current Howler Image
+
+    Returns:
+        str: The current branch
+    """
+    return os.environ.get("BRANCH", "this is not the branch you are looking for")
+
+
+redis_persistent = get_client(config.core.redis.persistent.host, config.core.redis.persistent.port, False)
+redis = get_client(config.core.redis.nonpersistent.host, config.core.redis.nonpersistent.port, False)
+
+
+cache = Cache(config={"CACHE_TYPE": "SimpleCache"})
+
+# TRACKERS
+QUOTA_TRACKER = UserQuotaTracker("quota", timeout=60 * 2, redis=redis)  # 2 Minutes timeout

howler/cronjobs/__init__.py

@@ -0,0 +1,29 @@
+import importlib
+import os
+from pathlib import Path
+
+from apscheduler.schedulers.background import BackgroundScheduler
+from pytz import timezone
+
+from howler.common.logging import get_logger
+
+logger = get_logger(__file__)
+
+scheduler = BackgroundScheduler(timezone=timezone(os.getenv("SCHEDULER_TZ", "America/Toronto")))
+
+
+def setup_jobs():
+    "Dynamically import and initialize all cronjobs in this folder"
+    module_path = Path(__file__).parent
+    modules_to_import = [_file for _file in os.listdir(module_path) if _file.endswith(".py") and _file != "__init__.py"]
+
+    for module in modules_to_import:
+        try:
+            job = importlib.import_module(f"howler.cronjobs.{module.replace('.py', '')}")
+
+            job.setup_job(scheduler)
+        except Exception as e:
+            logger.critical("Error when initializing %s - %s", module, e)
+
+    if scheduler.state != 1:
+        scheduler.start()

howler/cronjobs/retention.py

@@ -0,0 +1,61 @@
+import os
+from datetime import datetime, timedelta
+from typing import Any
+
+from apscheduler.schedulers.base import BaseScheduler
+from apscheduler.triggers.cron import CronTrigger
+from pytz import timezone
+
+from howler.common.logging import get_logger
+from howler.config import DEBUG, config
+
+logger = get_logger(__file__)
+
+
+def execute():
+    """Delete any hits older than the configured time"""
+    from howler.common.loader import datastore
+
+    delta_kwargs = {str(config.system.retention.limit_unit): config.system.retention.limit_amount}
+
+    cutoff = (datetime.now() - timedelta(**delta_kwargs)).strftime("%Y-%m-%d")
+
+    logger.debug("Removing hits older than %s", cutoff)
+
+    ds = datastore()
+
+    ds.hit.delete_by_query(f"event.created:{{* TO {cutoff}}} OR howler.expiry:{{* TO now}}")
+
+    ds.hit.commit()
+
+    logger.debug("Deletion complete")
+
+
+def setup_job(sched: BaseScheduler):
+    """Initialize the retention job"""
+    if not config.system.retention.enabled:
+        if not DEBUG or config.system.type == "production":
+            logger.warning("Retention cronjob disabled! This is not recommended for a production settings.")
+
+        return
+
+    logger.debug(f"Initializing retention cronjob with cron {config.system.retention.crontab}")
+
+    if DEBUG:
+        _kwargs: dict[str, Any] = {"next_run_time": datetime.now()}
+    else:
+        _kwargs = {}
+
+    if sched.get_job("retention"):
+        logger.debug("Retention job already running!")
+        return
+
+    sched.add_job(
+        id="retention",
+        func=execute,
+        trigger=CronTrigger.from_crontab(
+            config.system.retention.crontab, timezone=timezone(os.getenv("SCHEDULER_TZ", "America/Toronto"))
+        ),
+        **_kwargs,
+    )
+    logger.debug("Initialization complete")