balabs-kit 0.0.3__py3-none-any.whl → 0.0.6__py3-none-any.whl

bakit/__init__.py

@@ -1 +1,7 @@
-__version__ = "0.0.3"
+from . import settings
+from .init import init_bakit
+
+__all__ = ["init_bakit", "settings"]
+
+
+__version__ = "0.0.6"

bakit/arq/__init__.py

@@ -0,0 +1,5 @@
+from .decorators import task
+from .task_loader import collect_cron_jobs_and_functions
+from .worker import build_worker
+
+__all__ = ["build_worker", "collect_cron_jobs_and_functions", "task"]

bakit/arq/decorators.py

@@ -0,0 +1,92 @@
+import asyncio
+import logging
+from contextlib import contextmanager
+from functools import wraps
+
+import sentry_sdk
+
+from bakit import settings
+from bakit.utils.metrics import timer
+
+log = logging.getLogger(__name__)
+
+
+@contextmanager
+def _handle_exceptions():
+    """
+    Decorator to handle ARQ job timeouts and report them to Sentry.
+
+    When ARQ times out a job, it raises asyncio.CancelledError. This decorator
+    catches that exception, reports it to Sentry with appropriate tags, and
+    re-raises it to maintain the expected behavior.
+
+    This is needed because ARQ's CancelledError also cancels sentry's coroutine that
+    would send an error to sentry
+    """
+    try:
+        yield
+    except asyncio.CancelledError as e:
+        sentry_sdk.capture_exception(e)
+        raise
+    except Exception:
+        raise
+
+
+def task(name=None):
+    """
+    Decorator for async task functions
+
+    This decorator wraps async functions to automatically:
+    - Track execution time using the timer context manager
+    - Handle exceptions (including asyncio.CancelledError) via handle_exceptions
+    - Handle enabling/disabling the task via redis
+
+    The decorator is designed for use with background task systems like ARQ, where
+    timing and proper exception handling are crucial for monitoring and reliability.
+
+    Args:
+        name (str, optional): Custom name for the task. If not provided, uses the
+            function's __name__ attribute. This name is used for metrics labeling
+            as "task.{name}".
+
+    Returns:
+        callable: The decorated async function with timing and exception handling.
+
+    Usage:
+        # Without parameters (uses function name)
+        @task
+        async def my_background_task():
+            await some_async_operation()
+
+        # With custom name
+        @task(name="custom_task_name")
+        async def my_background_task():
+            await some_async_operation()
+    """
+
+    def decorator(func):
+        task_name = name or func.__name__
+
+        @wraps(func)
+        async def wrapper(ctx, *args, **kwargs):
+            redis = ctx.get("redis")
+            if redis:
+                task_disabled = await redis.sismember(
+                    settings.ARQ_CRON_DISABLED_KEY, task_name
+                )
+                if task_disabled:
+                    log.info(f"Task {task_name} is disabled. Skipping.")
+                    return
+
+            with timer(f"task.{task_name}"), _handle_exceptions():
+                return await func(ctx, *args, **kwargs)
+
+        return wrapper
+
+    # support both @task and @task("name")
+    if callable(name):
+        func = name
+        name = None
+        return decorator(func)
+
+    return decorator

bakit/arq/task_loader.py

@@ -0,0 +1,44 @@
+from importlib import import_module
+
+from arq import func
+
+
+def _load_task_modules(task_packages):
+    modules = []
+    for pkg in task_packages:
+        modules.append(import_module(f"{pkg}.tasks"))
+    return modules
+
+
+def _normalize_fn_to_dotted(fn):
+    if isinstance(fn, str):
+        return fn
+    return "{}.{}".format(fn.__module__, getattr(fn, "__name__", fn.__class__.__name__))
+
+
+def collect_cron_jobs_and_functions(task_packages):
+    cron_jobs = []
+    functions = []
+
+    for module in _load_task_modules(task_packages):
+        # also allow optional explicit FUNCTIONS = [callable, ...]
+        extra_funcs = getattr(module, "FUNCTIONS", [])
+        for fn in extra_funcs:
+            # replace name so if we have two functions with the same name in different
+            # modules, it still works
+            functions.append(func(_normalize_fn_to_dotted(fn)))
+
+        # Each tasks.py should define CRON_JOBS = [cron(...), ...]
+        jobs = getattr(module, "CRON_JOBS", [])
+
+        for job in jobs:
+            # Set ID of the job, used to enforce job uniqueness
+            if not job.job_id:
+                job.job_id = job.name
+
+            # replace name so if we have two functions with the same name in different
+            # modules, it still works
+            job.name = f"cron:{_normalize_fn_to_dotted(job.coroutine)}"
+            cron_jobs.append(job)
+
+    return cron_jobs, functions

bakit/arq/worker.py

@@ -0,0 +1,70 @@
+# ruff: noqa: E402
+import asyncio
+import contextlib
+import logging
+
+import sentry_sdk
+from sentry_sdk.integrations.logging import LoggingIntegration
+from tortoise import Tortoise
+
+from bakit import settings
+
+sentry_sdk.init(
+    dsn=settings.SENTRY_DSN,
+    max_breadcrumbs=20,
+    integrations=[
+        LoggingIntegration(level=logging.INFO, event_level=logging.WARNING),
+    ],
+)
+# Import all bakit stuff after settings and after Sentry has been initialized to
+# captcure any errors/warning in sentry if they happen during imports
+
+from bakit.utils import metrics
+
+
+async def _report_queue_size(ctx):
+    redis = ctx["redis"]
+    queue = redis.default_queue_name
+    sanitized_queue_name = queue.replace(".", "_").replace(":", "_")
+    metric_name = f"arq.queue.size.{sanitized_queue_name}"
+    while True:
+        n = await redis.zcard(queue)  # ARQ stores jobs in a ZSET per queue
+        metrics.gauge(metric_name, n)
+        await asyncio.sleep(10)
+
+
+async def on_startup(ctx):
+    await Tortoise.init(config=settings.TORTOISE_ORM)
+    ctx["metrics_task"] = asyncio.create_task(_report_queue_size(ctx))
+
+
+async def on_shutdown(ctx):
+    await Tortoise.close_connections()
+
+    metrics_task = ctx.get("metrics_task")
+    if metrics_task:
+        metrics_task.cancel()
+        with contextlib.suppress(asyncio.CancelledError):
+            await metrics_task
+
+
+def build_worker(config):
+    if not isinstance(config, dict):
+        raise TypeError("Config must be a dictionary")
+
+    cfg = {
+        "on_startup": on_startup,
+        "on_shutdown": on_shutdown,
+        # Don't keep result of the job as we use unique job_id on cron jobs to avoid
+        # scheduling the same job multiple times at the same time. If keep_result is
+        # set, and the job fails, the new job will not be able to be rescheduled until
+        # keep_result expires
+        "keep_result": 0,
+        "max_jobs": 6,
+        "queue_read_limit": 12,  # keep at 2x max_jobs
+        "job_timeout": 15 * 60,  # max time per job,
+        "job_completion_wait": 8 * 60,  # wait 8 minutes for completion
+        "graceful_shutdown_timeout": 9 * 60,  # total shutdown time
+    }
+    cfg.update(config)
+    return type("ARQWorker", (), cfg)

bakit/cli.py

@@ -0,0 +1,186 @@
+import importlib
+import pkgutil
+import time
+from datetime import UTC, datetime
+from pathlib import Path
+
+import asyncclick as click
+from discord import Color, Embed
+from tortoise import Tortoise
+
+from bakit import settings
+from bakit.utils.discord import send_webhook_embed
+
+__all__ = ["BakitCommand", "BakitGroup", "autodiscover_and_attach"]
+
+
+async def _send_discord_embed(embed):
+    embed.set_footer(text=f"{settings.APP_NAME} one-off tasks")
+    await send_webhook_embed(settings.WATCHTOWER_WEBHOOK_URL, embed)
+
+
+async def _run_one_off_with_notifications(ctx, invoke_fn):
+    cmd = "{} {}".format(
+        ctx.command_path,
+        " ".join(f"--{k}={v}" for k, v in ctx.params.items()) if ctx.params else "",
+    )
+    click.echo(cmd)
+
+    def _make_embed(text, color):
+        description = f"{text} - `{cmd}`"
+        return Embed(description=description, color=color, timestamp=datetime.now(UTC))
+
+    await _send_discord_embed(_make_embed("🟣 Task starting", Color.purple()))
+    started = time.monotonic()
+    try:
+        result = await invoke_fn(ctx)
+    except Exception as e:
+        await _send_discord_embed(_make_embed(f"🔴 Task failed: {e}", Color.red()))
+        raise
+    else:
+        elapsed = time.monotonic() - started
+        await _send_discord_embed(
+            _make_embed(f"🟢 Task done in {elapsed:.1f}s", Color.green())
+        )
+    return result
+
+
+class BakitCommand(click.Command):
+    async def invoke(self, ctx):
+        await Tortoise.init(config=settings.TORTOISE_ORM)
+
+        try:
+            if settings.IS_ONE_OFF_CMD:
+                return await _run_one_off_with_notifications(ctx, super().invoke)
+
+            else:
+                return await super().invoke(ctx)
+        finally:
+            await Tortoise.close_connections()
+
+
+class BakitGroup(click.Group):
+    command_class = BakitCommand
+
+
+def _wrap_tree(cmd):
+    # If it's already wrapped, return as-is
+    if isinstance(cmd, (BakitCommand, BakitGroup)):
+        return cmd
+
+    # Wrap groups by rebuilding them as BakitGroup
+    if isinstance(cmd, click.Group):
+        new_grp = BakitGroup(
+            name=cmd.name,
+            commands={},
+            callback=cmd.callback,
+            params=list(cmd.params),
+            help=cmd.help,
+            epilog=cmd.epilog,
+            short_help=cmd.short_help,
+            options_metavar=cmd.options_metavar,
+            add_help_option=cmd.add_help_option,
+            no_args_is_help=cmd.no_args_is_help,
+            hidden=getattr(cmd, "hidden", False),
+            deprecated=getattr(cmd, "deprecated", False),
+            invoke_without_command=getattr(cmd, "invoke_without_command", False),
+            context_settings=getattr(cmd, "context_settings", None),
+        )
+
+        for name, sub in cmd.commands.items():
+            new_grp.add_command(_wrap_tree(sub), name=name)
+
+        return new_grp
+
+    # Wrap leaf commands by rebuilding them as BakitCommand (preserves args/options)
+    if isinstance(cmd, click.Command):
+        return BakitCommand(
+            name=cmd.name,
+            callback=cmd.callback,
+            params=list(cmd.params),
+            help=cmd.help,
+            epilog=cmd.epilog,
+            short_help=cmd.short_help,
+            options_metavar=cmd.options_metavar,
+            add_help_option=cmd.add_help_option,
+            no_args_is_help=cmd.no_args_is_help,
+            hidden=getattr(cmd, "hidden", False),
+            deprecated=getattr(cmd, "deprecated", False),
+            context_settings=getattr(cmd, "context_settings", None),
+        )
+
+    return cmd
+
+
+def _make_wrapper_command(mod, cmd_name):
+    cmd = getattr(mod, "cmd", None)
+
+    if not cmd:
+        return
+
+    if not isinstance(cmd, click.core.BaseCommand):
+        raise TypeError(
+            f"Invalid `cmd` in module '{mod.__name__}': expected a Click command/group "
+            f"instance, got {type(cmd).__name__}.\n"
+            "Fix: define `cmd` using @click.command() or @click.group()."
+        )
+
+    # Ensure the command has a stable name when mounted under the scripts group
+    if not getattr(cmd, "name", None):
+        cmd.name = cmd_name
+
+    return _wrap_tree(cmd)
+
+
+def _load_scripts_group(base_pkg, pkg_name):
+    # Create the group from package name`myproject package`
+    grp = click.Group(name=pkg_name)
+
+    if base_pkg == "src":
+        scripts_pkg = f"{pkg_name}.scripts"
+    else:
+        scripts_pkg = f"{base_pkg}.{pkg_name}.scripts"
+
+    try:
+        scripts_mod = importlib.import_module(scripts_pkg)
+    except ModuleNotFoundError:
+        # package exists but no scripts package
+        return None
+
+    # Discover script modules under <package>/scripts/*.py
+    for m in pkgutil.iter_modules(scripts_mod.__path__):
+        if m.ispkg or m.name.startswith("_"):
+            continue
+
+        full_name = f"{scripts_pkg}.{m.name}"
+        mod = importlib.import_module(full_name)
+        cmd = _make_wrapper_command(mod, cmd_name=m.name)
+        if cmd:
+            grp.add_command(cmd, name=m.name)
+
+    return grp
+
+
+def _iter_immediate_packages(root_dir):
+    # Find immediate subfolders of the package containing cli.py
+    for p in root_dir.iterdir():
+        if not p.is_dir():
+            continue
+        if p.name.startswith(("_", ".")):
+            continue
+        if (p / "__init__.py").exists() and (p / "scripts/").exists():
+            yield p.name
+
+
+def autodiscover_and_attach(base_pkg, base_file, cli):
+    if not base_pkg:
+        # If running as a script (python cli.py), fall back to directory name.
+        # Prefer running as a module / console script so __package__ is set.
+        base_pkg = Path(base_file).resolve().parent.name
+
+    root_dir = Path(base_file).resolve().parent
+
+    for pkg_name in _iter_immediate_packages(root_dir):
+        grp = _load_scripts_group(base_pkg, pkg_name)
+        if grp:
+            cli.add_command(grp, name=pkg_name)

bakit/config.py

@@ -0,0 +1,126 @@
+import re
+from copy import deepcopy
+from types import SimpleNamespace
+
+_APP_NAME_RE = re.compile(r"^[A-Za-z]+$")
+
+
+class Settings:
+    """
+    Settings proxy so it doesn't matter where and how settings are imported
+    they still point to the correct settings after they're initialized
+    """
+
+    _wrapped = None
+
+    def init(self, real_settings):
+        self._wrapped = real_settings
+
+    def __getattr__(self, name):
+        if self._wrapped is None:
+            raise RuntimeError("Settings not initialized")
+        return getattr(self._wrapped, name)
+
+
+settings = Settings()
+
+
+def load_settings(env, configure_settings):
+    base = _default_settings(env)
+    base_copy = deepcopy(base)
+
+    if configure_settings is not None:
+        final_dict = configure_settings(base_copy, env)
+        if final_dict is None:
+            raise RuntimeError("configure_settings must return a dict of settings")
+    else:
+        final_dict = base_copy
+
+    settings.init(SimpleNamespace(**final_dict))
+    return settings
+
+
+def _default_settings(env):
+    app_name = env("APP_NAME")
+    if not _APP_NAME_RE.fullmatch(app_name):
+        raise RuntimeError(
+            "Invalid APP_NAME. Must contain only letters A-Z or a-z, "
+            "no spaces, numbers, or symbols."
+        )
+
+    default_log_level = env("DEFAULT_LOG_LEVEL", default="WARNING")
+    app_log_level = env("APP_LOG_LEVEL", default="INFO")
+    tortoise_log_level = env("TORTOISE_LOG_LEVEL", default="WARNING")
+    arq_log_level = env("ARQ_LOG_LEVEL", default="INFO")
+    generic_log_level = env("GENERIC_LOG_LEVEL", default="WARNING")
+
+    return {
+        "APP_NAME": app_name,
+        "CORS_ORIGINS": [
+            re.compile(r"^http://(localhost|127\.0\.0\.1):\d+$"),
+            re.compile(r"^https://(\S+\.)?vercel\.app$"),
+            re.compile(r"^https://(\S+\.)?blockanalitica\.com$"),
+        ],
+        "CORS_METHODS": ["GET", "POST", "PUT", "DELETE", "OPTIONS"],
+        "SENTRY_DSN": env("SENTRY_DSN", ""),
+        "STATSD_HOST": env("STATSD_HOST", ""),
+        "STATSD_PORT": env("STATSD_PORT", default=8125),
+        "STATSD_PREFIX": env("STATSD_PREFIX", default=app_name.lower()),
+        "REDIS_HOST": env("REDIS_HOST", ""),
+        "REDIS_PORT": env.int("REDIS_PORT", 6379),
+        "REDIS_DB": env.int("REDIS_DB", 2),
+        "CACHE_MIDDLEWARE_SECONDS": 5,
+        "CACHE_MIDDLEWARE_ENABLED": env.bool("CACHE_MIDDLEWARE_ENABLED", False),
+        "ARQ_CRON_DISABLED_KEY": f"{app_name.lower()}:arq:cron:disabled",
+        "DEFAULT_LOG_LEVEL": env("DEFAULT_LOG_LEVEL", default="WARNING"),
+        "APP_LOG_LEVEL": env("APP_LOG_LEVEL", default="INFO"),
+        "TORTOISE_LOG_LEVEL": env("TORTOISE_LOG_LEVEL", default="WARNING"),
+        "ARQ_LOG_LEVEL": env("ARQ_LOG_LEVEL", default="INFO"),
+        "GENERIC_LOG_LEVEL": env("GENERIC_LOG_LEVEL", default="WARNING"),
+        "LOGGING_CONFIG": {
+            "version": 1,
+            "disable_existing_loggers": False,
+            "formatters": {
+                "default": {
+                    "format": (
+                        "[%(asctime)s] %(name)s {%(module)s:%(lineno)d} "
+                        "PID=%(process)d [%(levelname)s] - %(message)s"
+                    ),
+                },
+            },
+            "handlers": {
+                "console": {
+                    "level": "DEBUG",
+                    "class": "logging.StreamHandler",
+                    "stream": "ext://sys.stdout",
+                    "formatter": "default",
+                },
+            },
+            "root": {
+                "level": default_log_level,
+                "handlers": ["console"],
+            },
+            "loggers": {
+                "bakit": {
+                    "propagate": True,
+                    "level": app_log_level,
+                },
+                "core": {
+                    "propagate": True,
+                    "level": app_log_level,
+                },
+                "tortoise": {
+                    "propagate": True,
+                    "level": tortoise_log_level,
+                },
+                "arq": {
+                    "propagate": True,
+                    "level": arq_log_level,
+                },
+                "asyncio": {
+                    "propagate": True,
+                    "level": generic_log_level,
+                },
+            },
+        },
+    }

bakit/init.py

@@ -0,0 +1,38 @@
+import logging.config
+import os
+from decimal import getcontext
+from pathlib import Path
+
+from environs import Env
+
+from bakit.config import load_settings
+
+
+def init_bakit(configure_settings=None, env_overrides=None):
+    """
+    Initialize the bakit runtime for the current process.
+
+    This function is the single required entrypoint for all projects using bakit.
+    It must be called exactly once, and as early as possible, from each
+    executable entrypoint (e.g. server, worker, CLI).
+    """
+
+    env = Env()
+    # Need to pass in a path, otherwise it doesn't detect the correct path
+    env.read_env(Path(os.getcwd()) / ".env")
+
+    # Enable overriding env variables after they've been read from .env file
+    if env_overrides and isinstance(env_overrides, dict):
+        for key, value in env_overrides.items():
+            os.environ[key] = value
+
+    # Increase global Decimal precision to avoid InvalidOperation errors during
+    # quantize(). The default context precision (28 digits) is too low for our values
+    # which can exceed 28 significant digits (e.g., 14 integer + 18 fractional).
+    getcontext().prec = 60
+
+    # Load settings from env
+    settings = load_settings(env, configure_settings)
+
+    # Set up logging config
+    logging.config.dictConfig(settings.LOGGING_CONFIG)

bakit/sanic/app.py

@@ -1,3 +1,5 @@
+import hashlib
+import hmac
 from pathlib import Path
 
 from orjson import dumps
@@ -9,13 +11,19 @@ from tortoise.contrib.sanic import register_tortoise
 from bakit import settings
 from bakit.sanic.listeners import setup_cache_listener, setup_sentry_listener
 from bakit.sanic.middlewares import cache_middleware_request, cache_middleware_response
-from bakit.settings import APP_NAME, LOGGING_CONFIG, TORTOISE_ORM
 from bakit.utils.metrics import view_metrics
 
 STATIC_DIR = Path(__file__).resolve().parent / "static"
 
+_SENTRY_DEBUG_DIGEST = (
+    "b2cded34bf480236d91e54b631185347f52321b1fdc8c40b89ca507d3a1458ee"
+)
+_SENTRY_DEBUG_KEY = b"sentry-debug-v1"
 
-def create_base_app(app_name=APP_NAME, log_config=LOGGING_CONFIG, is_testing=False):
+
+def create_base_app(
+    app_name=settings.APP_NAME, log_config=settings.LOGGING_CONFIG, is_testing=False
+):
     app = Sanic(app_name, strict_slashes=True, log_config=log_config, dumps=dumps)
     app.config.FALLBACK_ERROR_FORMAT = "json"
 
@@ -36,17 +44,34 @@ def create_base_app(app_name=APP_NAME, log_config=LOGGING_CONFIG, is_testing=Fal
     app.register_middleware(cache_middleware_request, "request")
     app.register_middleware(cache_middleware_response, "response")
 
-    # /ping/ endpoint is needed for load balancer health checks. Do not remove
+    # /ping/ endpoint is needed for load balancer health checks. Do not remove.
     @app.route("/ping/", methods=["GET"])
     @view_metrics()
     async def health(request):
         return text("pong", status=200)
 
+    # /sentry-debug/ endpoint is used for testing sentry integration. Do not remove.
+    @app.route("/sentry-debug/", methods=["GET"])
+    @view_metrics()
+    async def sentry_debug(request):
+        secret = request.args.get("secret")
+        if not secret:
+            return text("not found", status=404)
+
+        digest = hmac.new(
+            _SENTRY_DEBUG_KEY, secret.encode(), hashlib.sha256
+        ).hexdigest()
+        if not hmac.compare_digest(digest, _SENTRY_DEBUG_DIGEST):
+            return text("not found", status=404)
+
+        a = 1 / 0
+        return text(str(a), status=500)
+
     # Setup Tortoise ORM
     if not is_testing:
         register_tortoise(
             app,
-            config=TORTOISE_ORM,
+            config=settings.TORTOISE_ORM,
             generate_schemas=False,
         )
 

bakit/settings.py

@@ -1,103 +1,6 @@
-import re
-import sys
+from bakit.config import settings
 
-from environs import Env
 
-env = Env()
-
-APP_NAME = env("APP_NAME")
-
-CORS_ORIGINS = [
-    re.compile(r"^http://(localhost|127\.0\.0\.1):\d+$"),
-    re.compile(r"^https://(\S+\.)?vercel\.app$"),
-    re.compile(r"^https://(\S+\.)?blockanalitica\.com$"),
-]
-CORS_METHODS = ["GET", "POST", "PUT", "DELETE", "OPTIONS"]
-
-
-TORTOISE_ORM = {
-    "connections": {
-        "default": env("APP_DB_URL"),
-    },
-    "apps": {
-        "core": {
-            "models": [],
-            "default_connection": "default",
-        },
-    },
-}
-
-
-SENTRY_DSN = env("SENTRY_DSN", "")
-
-STATSD_HOST = env("STATSD_HOST", "")
-STATSD_PORT = env("STATSD_PORT", default=8125)
-STATSD_PREFIX = env("STATSD_PREFIX", default=APP_NAME)
-
-REDIS_HOST = env("REDIS_HOST", "")
-REDIS_PORT = env.int("REDIS_PORT", 6379)
-REDIS_DB = env.int("REDIS_DB", 2)
-
-CACHE_MIDDLEWARE_SECONDS = 5
-CACHE_MIDDLEWARE_ENABLED = env.bool("CACHE_MIDDLEWARE_ENABLED", False)
-
-APP_LOG_LEVEL = env("APP_LOG_LEVEL", default="INFO")
-TORTOISE_LOG_LEVEL = env("TORTOISE_LOG_LEVEL", default="WARNING")
-DEFAULT_LOG_LEVEL = env("DEFAULT_LOG_LEVEL", default="WARNING")
-ARQ_LOG_LEVEL = env("ARQ_LOG_LEVEL", default="INFO")
-CHAIN_HARVESTER_LOG_LEVEL = env("CHAIN_HARVESTER_LOG_LEVEL", default="WARNING")
-
-LOGGING_CONFIG = {
-    "version": 1,
-    "disable_existing_loggers": False,
-    "formatters": {
-        "default": {
-            "format": (
-                "[%(asctime)s] %(name)s {%(module)s:%(lineno)d} "
-                "PID=%(process)d [%(levelname)s] - %(message)s"
-            ),
-        },
-    },
-    "handlers": {
-        "console": {
-            "level": "DEBUG",
-            "class": "logging.StreamHandler",
-            "stream": sys.stdout,
-            "formatter": "default",
-        },
-    },
-    "loggers": {
-        "bakit": {
-            "propagate": True,
-            "level": APP_LOG_LEVEL,
-        },
-        "core": {
-            "propagate": True,
-            "level": APP_LOG_LEVEL,
-        },
-        "tortoise": {
-            "propagate": True,
-            "level": TORTOISE_LOG_LEVEL,
-        },
-        "tortoise.db_client": {
-            "propagate": True,
-            "level": TORTOISE_LOG_LEVEL,
-        },
-        "arq": {
-            "propagate": True,
-            "level": ARQ_LOG_LEVEL,
-        },
-        "arq.worker": {
-            "propagate": True,
-            "level": ARQ_LOG_LEVEL,
-        },
-        "chain_harvester": {
-            "propagate": True,
-            "level": CHAIN_HARVESTER_LOG_LEVEL,
-        },
-        "": {
-            "level": DEFAULT_LOG_LEVEL,
-            "handlers": ["console"],
-        },
-    },
-}
+def __getattr__(name):
+    # This makes `from bakit.settings import MY_SETTING` to work
+    return getattr(settings, name)

bakit/shell.py

@@ -1,24 +1,26 @@
 # ruff: noqa: T100
-import asyncio
 import os
 
+from IPython.core.async_helpers import get_asyncio_loop
 from IPython.terminal.embed import InteractiveShellEmbed
 from tortoise import Tortoise
 
+from bakit import settings
 
-def start_ipython_shell(orm_config, extra_ns=None, banner=None):
+
+def start_ipython_shell(extra_ns=None, banner=None):
     """
     Async shell helper:
-    - initializes Tortoise with orm_config
     - starts IPython if available (with top-level await support)
     - falls back to stdlib interactive shell otherwise
     - always closes DB connections when done
     """
-    asyncio.run(Tortoise.init(config=orm_config))
 
     if banner is None:
         banner = "Tortoise shell. If IPython is installed, top-level await should work."
 
+    loop = get_asyncio_loop()
+
     ns = {
         "Tortoise": Tortoise,
         "os": os,
@@ -27,7 +29,8 @@ def start_ipython_shell(orm_config, extra_ns=None, banner=None):
         ns.update(extra_ns)
 
     try:
+        loop.run_until_complete(Tortoise.init(config=settings.TORTOISE_ORM))
         shell = InteractiveShellEmbed(banner2=banner)
         shell(local_ns=ns, global_ns=ns)
     finally:
-        asyncio.run(Tortoise.close_connections())
+        loop.run_until_complete(Tortoise.close_connections())

bakit/utils/db.py

@@ -1,10 +1,7 @@
-import logging
 from contextlib import asynccontextmanager
 
 from tortoise.connection import connections
 
-log = logging.getLogger(__name__)
-
 
 def _convert_named_placeholders(sql, sql_vars):
     sql_vars = sql_vars or []

bakit/utils/discord.py

@@ -0,0 +1,27 @@
+import datetime
+
+import aiohttp
+from discord import Webhook
+from discord.embeds import Embed
+
+
+async def send_webhook_embed(webhook_url, embed):
+    """
+    Send an embed to a Discord webhook (async).
+
+    Args:
+        webhook_url (str): The Discord webhook URL.
+        embed (discord.Embed): Title of the embed.
+    """
+
+    async with aiohttp.ClientSession() as session:
+        webhook = Webhook.from_url(webhook_url, session=session)
+        await webhook.send(embed=embed)
+
+
+def make_embed(description, color):
+    return Embed(
+        description=description,
+        color=color,
+        timestamp=datetime.datetime.now(datetime.UTC),
+    )

bakit/utils/metrics.py

@@ -5,11 +5,18 @@ import statsd
 
 from bakit import settings
 
-statsd_client = statsd.StatsClient(
-    settings.STATSD_HOST,
-    settings.STATSD_PORT,
-    settings.STATSD_PREFIX,
-)
+_statsd_client = None
+
+
+def get_statsd_client():
+    global _statsd_client
+    if _statsd_client is None:
+        _statsd_client = statsd.StatsClient(
+            settings.STATSD_HOST,
+            settings.STATSD_PORT,
+            settings.STATSD_PREFIX,
+        )
+    return _statsd_client
 
 
 def multinetworktimerd(key):
@@ -90,7 +97,7 @@ def timer(key):
     >>> with metrics.timer('unique_key'):
     ...     time.sleep(1)
     """
-    statsd_timer = statsd_client.timer(str(key))
+    statsd_timer = get_statsd_client().timer(str(key))
     statsd_timer.start()
     try:
         yield
@@ -111,7 +118,7 @@ def raw_timer(key, value):
     if not isinstance(value, int | float):
         return None
 
-    return statsd_client.timing(str(key), value)
+    return get_statsd_client().timing(str(key), value)
 
 
 def increment(key, delta=1, subname=None):
@@ -128,7 +135,7 @@ def increment(key, delta=1, subname=None):
     if subname:
         name += f".{subname}"
 
-    return statsd_client.incr(name, delta)
+    return get_statsd_client().incr(name, delta)
 
 
 def decrement(key, delta=1, subname=None):
@@ -146,7 +153,7 @@ def decrement(key, delta=1, subname=None):
     if subname:
         name += f".{subname}"
 
-    return statsd_client.decr(name, delta)
+    return get_statsd_client().decr(name, delta)
 
 
 def gauge(key, value=1, subname=None):
@@ -164,8 +171,8 @@ def gauge(key, value=1, subname=None):
     # We never use the relative changes behaviour so attempt to always make it do the
     # set value behaviour instead.
     if value < 0:
-        statsd_client.gauge(name, 0)
-    return statsd_client.gauge(name, value)
+        get_statsd_client().gauge(name, 0)
+    return get_statsd_client().gauge(name, value)
 
 
 def function_long_name(func, extra=None):
@@ -180,11 +187,11 @@ def auto_named_statsd_timer(function_to_decorate):
 
     @wraps(function_to_decorate)
     def incr_and_call(*args, **kwargs):
-        statsd_client.incr(call_name)
+        get_statsd_client().incr(call_name)
         return function_to_decorate(*args, **kwargs)
 
     timer_name = function_long_name(function_to_decorate, "time")
-    named_decorator = statsd_client.timer(timer_name)
+    named_decorator = get_statsd_client().timer(timer_name)
 
     return named_decorator(incr_and_call)
 
@@ -218,9 +225,9 @@ def view_metrics_context(endpoint_name=None, instance=None):
         else:
             metric_base = "views.unknown.context"
 
-    statsd_client.incr(f"{metric_base}.hits")
+    get_statsd_client().incr(f"{metric_base}.hits")
 
-    with statsd_client.timer(f"{metric_base}.response_time"):
+    with get_statsd_client().timer(f"{metric_base}.response_time"):
         yield
 
 
@@ -252,10 +259,10 @@ def view_metrics(endpoint_name=None):
                 method_name = func.__name__
                 metric_base = f"views.{cls_name}.{method_name}"
 
-            statsd_client.incr(f"{metric_base}.hits")
+            get_statsd_client().incr(f"{metric_base}.hits")
 
             # Time the function execution
-            with statsd_client.timer(f"{metric_base}.response_time"):
+            with get_statsd_client().timer(f"{metric_base}.response_time"):
                 return await func(*args, **kwargs)
 
         return wrapper

{balabs_kit-0.0.3.dist-info → balabs_kit-0.0.6.dist-info}/METADATA

@@ -1,17 +1,19 @@
 Metadata-Version: 2.4
 Name: balabs-kit
-Version: 0.0.3
+Version: 0.0.6
 Author-email: tsifrer <3967564+tsifrer@users.noreply.github.com>
 License-Expression: Apache-2.0
 Requires-Python: >=3.13
 Requires-Dist: aiocache[redis]>=0.12.3
+Requires-Dist: aiohttp>=3.13.3
 Requires-Dist: asyncclick>=8.3.0.7
 Requires-Dist: asyncpg>=0.31.0
+Requires-Dist: discord-py>=2.6.4
 Requires-Dist: environs>=14.5.0
 Requires-Dist: ipython>=9.8.0
 Requires-Dist: nest-asyncio>=1.6.0
 Requires-Dist: orjson>=3.11.5
-Requires-Dist: sentry-sdk>=2.47.0
+Requires-Dist: sentry-sdk>=2.48.0
 Requires-Dist: statsd>=4.0.1
 Requires-Dist: tortoise-orm>=0.25.1
 Requires-Dist: uvloop>=0.22.1

balabs_kit-0.0.6.dist-info/RECORD

@@ -0,0 +1,26 @@
+bakit/__init__.py,sha256=dnDjSjL-qpabXupvZ0e5TLbs82lAxd77oZfZ4DVoWaM,114
+bakit/cli.py,sha256=0CLBgNFrFWK4qXtdatZMN_S-ocULqC85qSHiuS7o-qY,5893
+bakit/config.py,sha256=32ADsCi2qSwHJCRGU8jXzlRCwLpHZwixWcv_9Vmw6o0,4348
+bakit/init.py,sha256=uzkB22ZcZEC_eC8tGDfiJ_AfRlymVfqGhj7zvyGdoi8,1301
+bakit/settings.py,sha256=F4mA53W63VasDpAXUFDfdw9LA28U6t-4vkIMThy3taI,159
+bakit/shell.py,sha256=FWUU9FdyCeNh2drDV7AOz8nZf3Dazidt4yRDvL8tFZg,973
+bakit/arq/__init__.py,sha256=hd4_47_SC9DBII5jxkvpahPFDl0plsFkUo0kVVabwUo,190
+bakit/arq/decorators.py,sha256=kdxyCpOotEPhB-D0IDSDfWflulNBq_s_CyjH4z61oBo,2705
+bakit/arq/task_loader.py,sha256=vzzS3Fa0wzyRRsbb-3PiES61LBFleAHfOA_E9gjjUno,1417
+bakit/arq/worker.py,sha256=rxSKC4b0hxYLSuLS3rCBr_pqcSYPtd4o-jLu8-pnHDw,2217
+bakit/sanic/__init__.py,sha256=wxdGII3_XK2gmES3h5Kt28CVgND-kWvfam-e3IK3IhU,64
+bakit/sanic/app.py,sha256=wTe7eO-aI1027MC7GA7MlBUL7TXi1RwJY8TSoMP5Big,2466
+bakit/sanic/decorators.py,sha256=R4qyynBiB6BGoFzoCOYxtqGyjQ-VWY83A7T62XMXNmo,630
+bakit/sanic/listeners.py,sha256=U828FErgb4IzTPswrOtHiaBSmudkIhcbBESj4LN3CA8,1111
+bakit/sanic/middlewares.py,sha256=yNuZ_8JzdzJsEEv8adA8DZwMgfARpKIGbXhNRFrcolw,2536
+bakit/sanic/views.py,sha256=0V2rqVZ6zrCkodNvu0AH4VYUn1RHiLYJMTdiX3rLKWM,11934
+bakit/sanic/static/favicon.ico,sha256=O053tj32xBSw6b3qd7LjQe0-PoJ0oxrHvPX7pbz6csE,15406
+bakit/sanic/static/favicon.png,sha256=QBRACJH47kTn6J42ta2r-tY4eQBLer2vqDGxF4ZPJi4,223
+bakit/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+bakit/utils/db.py,sha256=aKL20rB8aBxb26wUHmPDIOwcwE46_ypqckcWw_EEu08,1551
+bakit/utils/discord.py,sha256=o575uH8DY9o01lp7uxFgxjhs-CfvmQ3lIPE4Vru6Ikk,651
+bakit/utils/metrics.py,sha256=ggQkoTmi8fL_H_cIQrzvrDIp8lGCwGIaB_aMFJs0RXQ,7551
+bakit/utils/sql_helpers.py,sha256=JhgA7WPZQb-LFfjW_fXYRnc2yS0p-kxGzSNaX9cSULE,2046
+balabs_kit-0.0.6.dist-info/METADATA,sha256=UkDt8mOrxvxTmvr0vNirNAMhFYO8mirWGgXKkeJaO7w,994
+balabs_kit-0.0.6.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+balabs_kit-0.0.6.dist-info/RECORD,,

balabs_kit-0.0.3.dist-info/RECORD

@@ -1,18 +0,0 @@
-bakit/__init__.py,sha256=4GZKi13lDTD25YBkGakhZyEQZWTER_OWQMNPoH_UM2c,22
-bakit/settings.py,sha256=AusdP9EtOBDBuNvcK3gieKyKTD_f6lAz44-AQxvR73s,2612
-bakit/shell.py,sha256=jW7cnGbJc60sOmA_jgnCWKaE9Pm6QOvoYtTsPQVuma4,889
-bakit/sanic/__init__.py,sha256=wxdGII3_XK2gmES3h5Kt28CVgND-kWvfam-e3IK3IhU,64
-bakit/sanic/app.py,sha256=M6vF1480Ya9Xon-9YbWJCluyrIAQoQga_SrDo2814NM,1737
-bakit/sanic/decorators.py,sha256=R4qyynBiB6BGoFzoCOYxtqGyjQ-VWY83A7T62XMXNmo,630
-bakit/sanic/listeners.py,sha256=U828FErgb4IzTPswrOtHiaBSmudkIhcbBESj4LN3CA8,1111
-bakit/sanic/middlewares.py,sha256=yNuZ_8JzdzJsEEv8adA8DZwMgfARpKIGbXhNRFrcolw,2536
-bakit/sanic/views.py,sha256=0V2rqVZ6zrCkodNvu0AH4VYUn1RHiLYJMTdiX3rLKWM,11934
-bakit/sanic/static/favicon.ico,sha256=O053tj32xBSw6b3qd7LjQe0-PoJ0oxrHvPX7pbz6csE,15406
-bakit/sanic/static/favicon.png,sha256=QBRACJH47kTn6J42ta2r-tY4eQBLer2vqDGxF4ZPJi4,223
-bakit/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-bakit/utils/db.py,sha256=xknEFED-kZisn4sPZP7IlSk1-5-0LaGGtUXqqdoFfSw,1601
-bakit/utils/metrics.py,sha256=osCYEllEHe7aPxJBNvdRO-O7UaRuIMyxWfm_W0FNPgQ,7306
-bakit/utils/sql_helpers.py,sha256=JhgA7WPZQb-LFfjW_fXYRnc2yS0p-kxGzSNaX9cSULE,2046
-balabs_kit-0.0.3.dist-info/METADATA,sha256=XCjrGlkS6qTsv4chWeyxG_hfrIAqzOlnNa5P_xcVUcg,930
-balabs_kit-0.0.3.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-balabs_kit-0.0.3.dist-info/RECORD,,