api-shared 0.0.1__tar.gz → 0.0.2__tar.gz

{api_shared-0.0.1 → api_shared-0.0.2}/PKG-INFO

@@ -1,18 +1,14 @@
 Metadata-Version: 2.3
 Name: api-shared
-Version: 0.0.1
+Version: 0.0.2
 Summary: Shared dependencies for both api and the worker services.
-Requires-Dist: pyyaml>=6.0.1
+Requires-Dist: hatchet-sdk[otel]>=1.24
 Requires-Dist: httpx>=0.28.1
-Requires-Dist: logfire[redis,httpx,system-metrics]>=3.12.0
+Requires-Dist: logfire[httpx,system-metrics]>=3.12.0
 Requires-Dist: loguru>=0.7.3
 Requires-Dist: opentelemetry-distro[otlp]>=0.52b0
 Requires-Dist: opentelemetry-instrumentation-logging>=0.52b0
-Requires-Dist: opentelemetry-instrumentation-redis>=0.52b0
 Requires-Dist: pydantic-settings>=2.8.1
-Requires-Dist: taskiq-aio-pika>=0.4.1
-Requires-Dist: taskiq-redis>=1.0.4
-Requires-Dist: taskiq[opentelemetry]>=0.12.1
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 

{api_shared-0.0.1 → api_shared-0.0.2}/pyproject.toml

@@ -1,23 +1,27 @@
 [project]
 name = "api-shared"
-version = "0.0.1"
+version = "0.0.2"
 description = "Shared dependencies for both api and the worker services."
 readme = "README.md"
 requires-python = ">=3.11"
 dependencies = [
-    "pyyaml>=6.0.1",
+    "hatchet-sdk[otel]>=1.24",
     "httpx>=0.28.1",
-    "logfire[redis,httpx,system-metrics]>=3.12.0",
+    "logfire[httpx,system-metrics]>=3.12.0",
     "loguru>=0.7.3",
     "opentelemetry-distro[otlp]>=0.52b0",
     "opentelemetry-instrumentation-logging>=0.52b0",
-    "opentelemetry-instrumentation-redis>=0.52b0",
     "pydantic-settings>=2.8.1",
-    "taskiq-aio-pika>=0.4.1",
-    "taskiq-redis>=1.0.4",
-    "taskiq[opentelemetry]>=0.12.1",
 ]
 
+[dependency-groups]
+test = [
+    "pytest>=8.3.3",
+]
+
+[tool.uv]
+default-groups = ["test"]
+
 [build-system]
 requires = ["uv_build>=0.9,<0.14"]
 build-backend = "uv_build"

api_shared-0.0.2/src/api_shared/core/settings.py

@@ -0,0 +1,62 @@
+from enum import StrEnum
+from typing import Annotated
+
+from pydantic import AfterValidator, AnyHttpUrl, Field, PlainValidator, TypeAdapter
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+AnyHttpUrlAdapter = TypeAdapter(AnyHttpUrl)
+
+CustomHttpUrlStr = Annotated[
+    str,
+    PlainValidator(AnyHttpUrlAdapter.validate_strings),
+    AfterValidator(lambda x: str(x).rstrip("/")),
+]
+
+
+class Environment(StrEnum):
+    """Possible environments."""
+
+    DEV = "dev"
+    TEST = "test"
+    PROD = "prod"
+
+
+class OLTPLogMethod(StrEnum):
+    NONE = "none"
+    MANUAL = "manual"
+    LOGFIRE = "logfire"
+
+
+class SharedBaseSettings(BaseSettings):
+    """Base settings class with common configuration shared across all services."""
+
+    ENVIRONMENT: Environment = Field(
+        default=Environment.DEV,
+        description="Application environment (dev, test, prod).",
+    )
+    OLTP_LOG_METHOD: OLTPLogMethod = Field(
+        default=OLTPLogMethod.NONE,
+        description="OpenTelemetry logging method (none, manual, logfire).",
+    )
+    OTLP_ENDPOINT: CustomHttpUrlStr | None = Field(
+        default=None,
+        description="OpenTelemetry GRPC endpoint for OTLP exporter.",
+    )
+    OLTP_STD_LOGGING_ENABLED: bool = Field(
+        default=False,
+        description="Enable standard logging integration with OpenTelemetry.",
+    )
+    HATCHET_WORKER_SLOTS: int = Field(
+        default=100,
+        ge=1,
+        description="Maximum number of concurrent Hatchet workflow slots for a worker.",
+    )
+
+    model_config = SettingsConfigDict(
+        env_file=".env",
+        env_file_encoding="utf-8",
+        extra="ignore",
+    )
+
+
+settings = SharedBaseSettings()  # type: ignore[call-arg]

api_shared-0.0.2/src/api_shared/core/telemetry.py

@@ -0,0 +1,52 @@
+import logfire
+from opentelemetry import trace
+from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter
+from opentelemetry.instrumentation.logging import LoggingInstrumentor
+from opentelemetry.sdk.resources import (
+    DEPLOYMENT_ENVIRONMENT,
+    SERVICE_NAME,
+    TELEMETRY_SDK_LANGUAGE,
+    Resource,
+)
+from opentelemetry.sdk.trace import TracerProvider
+from opentelemetry.sdk.trace.export import BatchSpanProcessor
+
+from api_shared.core.settings import OLTPLogMethod
+
+
+def setup_opentelemetry_worker(settings):
+    """Setup OpenTelemetry instrumentation for worker."""
+    if settings.OLTP_LOG_METHOD == OLTPLogMethod.NONE:
+        return
+
+    if settings.OLTP_LOG_METHOD == OLTPLogMethod.LOGFIRE:
+        logfire.configure(environment=settings.ENVIRONMENT.value)
+        logfire.instrument_system_metrics()
+        logfire.instrument_httpx()
+
+        # FIXME: Breaks the loguru logger format. Fix this
+        # if settings.OLTP_STD_LOGGING_ENABLED is True:
+        #     logger.configure(handlers=[logfire.loguru_handler()])
+
+        return
+
+    resource = Resource(
+        attributes={
+            SERVICE_NAME: getattr(settings, "PROJECT_NAME", "api-template-worker"),
+            TELEMETRY_SDK_LANGUAGE: "python",
+            DEPLOYMENT_ENVIRONMENT: settings.ENVIRONMENT,
+        },
+    )
+    trace_provider = TracerProvider(resource=resource)
+    otlp_exporter = OTLPSpanExporter(endpoint=settings.OTLP_ENDPOINT, insecure=True)
+    trace_provider.add_span_processor(BatchSpanProcessor(otlp_exporter))
+    if getattr(settings, "OLTP_STD_LOGGING_ENABLED", False):
+        LoggingInstrumentor().instrument(tracer_provider=trace_provider)
+    trace.set_tracer_provider(trace_provider)
+
+
+# TODO: Does this need in the worker?
+def stop_opentelemetry(settings) -> None:  # pragma: no cover
+    """Disables opentelemetry instrumentation."""
+    if settings.OLTP_LOG_METHOD in [OLTPLogMethod.NONE, OLTPLogMethod.LOGFIRE]:
+        return

api_shared-0.0.2/src/api_shared/hatchet_client.py

@@ -0,0 +1,23 @@
+from functools import cache
+
+from hatchet_sdk import Hatchet
+from hatchet_sdk.opentelemetry.instrumentor import HatchetInstrumentor
+from opentelemetry.trace import get_tracer_provider
+
+from api_shared.core.settings import OLTPLogMethod, settings
+
+
+@cache
+def get_hatchet() -> Hatchet:
+    """Return a singleton Hatchet client.
+
+    DI wires higher-level objects (e.g., `ExternalRunner`), while this cache
+    avoids re-creating the underlying Hatchet client and its connections.
+    """
+    hatchet = Hatchet(debug=settings.ENVIRONMENT == "dev")
+    if settings.OLTP_LOG_METHOD != OLTPLogMethod.NONE:
+        HatchetInstrumentor(tracer_provider=get_tracer_provider()).instrument()
+    return hatchet
+
+
+__all__ = ["get_hatchet"]

api_shared-0.0.2/src/api_shared/tasks/general/__init__.py

@@ -0,0 +1,27 @@
+from api_shared.tasks.general.complex_task import (
+    LONG_RUNNING_PROCESS_TASK,
+    LongRunningProcessInput,
+    LongRunningProcessResult,
+)
+from api_shared.tasks.general.failing_task import (
+    FAILING_PROCESS_TASK,
+    FailingProcessInput,
+)
+from api_shared.tasks.general.pydantic_parse_task import (
+    PYDANTIC_PARSE_CHECK_TASK,
+    NestedModel,
+    PydanticParseInput,
+    PydanticParseResult,
+)
+
+__all__ = [
+    "FAILING_PROCESS_TASK",
+    "LONG_RUNNING_PROCESS_TASK",
+    "PYDANTIC_PARSE_CHECK_TASK",
+    "FailingProcessInput",
+    "LongRunningProcessInput",
+    "LongRunningProcessResult",
+    "NestedModel",
+    "PydanticParseInput",
+    "PydanticParseResult",
+]

api_shared-0.0.2/src/api_shared/tasks/general/complex_task.py

@@ -0,0 +1,18 @@
+from pydantic import BaseModel, Field
+
+LONG_RUNNING_PROCESS_TASK = "long_running_process"
+
+
+class LongRunningProcessInput(BaseModel):
+    duration: int = Field(
+        default=10,
+        ge=1,
+        le=60,
+        description="Duration of the task in seconds.",
+    )
+
+
+class LongRunningProcessResult(BaseModel):
+    start_time: float
+    end_time: float
+    elapsed: float

api_shared-0.0.2/src/api_shared/tasks/general/failing_task.py

@@ -0,0 +1,10 @@
+from pydantic import BaseModel, Field
+
+FAILING_PROCESS_TASK = "failing_process"
+
+
+class FailingProcessInput(BaseModel):
+    error_message: str = Field(
+        default="This is a deliberate error",
+        description="Message to be raised in exception.",
+    )

api_shared-0.0.2/src/api_shared/tasks/general/pydantic_parse_task.py

@@ -0,0 +1,24 @@
+from pydantic import BaseModel, Field
+
+PYDANTIC_PARSE_CHECK_TASK = "pydantic_parse_check"
+
+
+class NestedModel(BaseModel):
+    name: str
+    value: int
+    tags: list[str]
+
+
+class PydanticParseInput(BaseModel):
+    text: str = Field(default="test", description="Text to send")
+    count: int = Field(default=5, ge=1, description="Count to send")
+    nested: NestedModel = Field(
+        default_factory=lambda: NestedModel(name="default", value=42, tags=["a", "b"])
+    )
+
+
+class PydanticParseResult(BaseModel):
+    received_text: str
+    received_count: int
+    received_nested: NestedModel
+    doubled_count: int

api_shared-0.0.2/src/api_shared/tasks/ml/__init__.py

@@ -0,0 +1,17 @@
+from api_shared.tasks.ml.ml_tasks import (
+    ML_INFERENCE_TASK,
+    TRAIN_MODEL_TASK,
+    MLInferenceInput,
+    MLInferenceResult,
+    MLTrainingInput,
+    MLTrainingResult,
+)
+
+__all__ = [
+    "ML_INFERENCE_TASK",
+    "TRAIN_MODEL_TASK",
+    "MLInferenceInput",
+    "MLInferenceResult",
+    "MLTrainingInput",
+    "MLTrainingResult",
+]

api_shared-0.0.2/src/api_shared/tasks/ml/ml_tasks.py

@@ -0,0 +1,39 @@
+from pydantic import BaseModel, Field
+
+ML_INFERENCE_TASK = "ml_inference"
+TRAIN_MODEL_TASK = "train_model"
+
+
+class MLInferenceInput(BaseModel):
+    model_id: str = Field(..., description="ID of the ML model to use for inference")
+    input_data: dict = Field(
+        ...,
+        description="Input data with 'features' and optional 'num_classes'",
+        examples=[{"features": [1.0, 2.0, 3.0], "num_classes": 3}],
+    )
+
+
+class MLInferenceResult(BaseModel):
+    model_id: str
+    predictions: list[float]
+    confidence: float
+
+
+class MLTrainingInput(BaseModel):
+    dataset_id: str = Field(..., description="ID of the dataset to use for training")
+    model_configuration: dict = Field(
+        ...,
+        description="Model config with 'input_size' and 'output_size'",
+        examples=[{"input_size": 10, "output_size": 1}],
+    )
+    hyperparameters: dict = Field(
+        ...,
+        description="Training hyperparameters: epochs, learning_rate, batch_size",
+        examples=[{"epochs": 5, "learning_rate": 0.01, "batch_size": 32}],
+    )
+
+
+class MLTrainingResult(BaseModel):
+    dataset_id: str
+    model_id: str
+    training_metrics: dict[str, float | int]

api_shared-0.0.2/src/api_shared/utils/test_tokens.py

@@ -0,0 +1,31 @@
+import base64
+import json
+from collections.abc import Mapping
+
+
+def _urlsafe_b64encode_json(payload: Mapping[str, object]) -> str:
+    encoded = base64.urlsafe_b64encode(
+        json.dumps(payload, separators=(",", ":")).encode("utf-8")
+    )
+    return encoded.decode("utf-8").rstrip("=")
+
+
+def generate_hatchet_test_token(
+    *,
+    sub: str = "test-tenant",
+    server_url: str = "https://example.test",
+    grpc_broadcast_address: str = "127.0.0.1:7070",
+    exp: int = 4_700_000_000,
+) -> str:
+    """Generate a JWT-shaped token with claims required by hatchet-sdk ClientConfig."""
+    header = {"alg": "HS256", "typ": "JWT"}
+    claims = {
+        "sub": sub,
+        "server_url": server_url,
+        "grpc_broadcast_address": grpc_broadcast_address,
+        "exp": exp,
+    }
+
+    return (
+        f"{_urlsafe_b64encode_json(header)}.{_urlsafe_b64encode_json(claims)}.signature"
+    )

api_shared-0.0.1/src/api_shared/broker.py

@@ -1,225 +0,0 @@
-from pathlib import Path
-from typing import Any
-
-import yaml
-from pydantic import BaseModel, Field, ValidationError
-from taskiq import (
-    AsyncBroker,
-    AsyncResultBackend,
-    InMemoryBroker,
-    SmartRetryMiddleware,
-)
-from taskiq.instrumentation import TaskiqInstrumentor
-from taskiq.schedule_sources import LabelScheduleSource
-from taskiq.scheduler.scheduler import TaskiqScheduler
-from taskiq_aio_pika import AioPikaBroker
-from taskiq_redis import RedisAsyncResultBackend
-
-from api_shared.core.settings import Environment, OLTPLogMethod, settings
-
-if settings.TASKIQ_DASHBOARD_URL:
-    from api_shared.middlewares.dashboard import DashboardMiddleware
-
-if settings.OLTP_LOG_METHOD != OLTPLogMethod.NONE:
-    TaskiqInstrumentor().instrument()
-
-
-class BrokerConfigSchema(BaseModel):
-    """Pydantic model for broker configuration validation.
-
-    Attributes:
-        queue: Queue name for this broker's tasks.
-        routing_key: Routing key pattern for message routing.
-        exchange: Exchange name for this broker.
-        description: Optional description of the broker's purpose.
-    """
-
-    queue: str = Field(..., description="Queue name for this broker's tasks")
-    routing_key: str = Field(
-        default="#", description="Routing key pattern for message routing"
-    )
-    exchange: str = Field(..., description="Exchange name for this broker")
-    description: str | None = Field(
-        default=None, description="Description of the broker's purpose"
-    )
-
-
-class BrokersConfigSchema(BaseModel):
-    """Pydantic model for the complete brokers YAML file.
-
-    Attributes:
-        brokers: Dictionary mapping broker names to their configurations.
-    """
-
-    brokers: dict[str, BrokerConfigSchema] = Field(
-        ..., description="Broker configurations"
-    )
-
-
-class BrokerManager:
-    """Manages taskiq broker instances and provides access to them."""
-
-    def __init__(self):
-        """Initialize the broker manager and create all configured brokers."""
-        self._brokers: dict[str, AsyncBroker] = {}
-        self._scheduler: TaskiqScheduler | None = None
-        self._broker_configs: dict[str, BrokerConfigSchema] = {}
-        self._load_broker_configs()
-        self._initialize_brokers()
-
-    def _load_broker_configs(self) -> None:
-        """Load and validate broker configurations from YAML file.
-
-        Raises:
-            FileNotFoundError: If the broker config file doesn't exist.
-            ValidationError: If the YAML structure is invalid.
-        """
-        if settings.TASKIQ_BROKERS_CONFIG_FILE:
-            config_path = Path(settings.TASKIQ_BROKERS_CONFIG_FILE)
-        else:
-            config_path = (
-                Path(__file__).parent.parent.parent / "configs" / "brokers.yml"
-            )
-
-        if not config_path.exists():
-            raise FileNotFoundError(
-                f"Broker configuration file not found: {config_path}. "
-                f"Create the file or set TASKIQ_BROKERS_CONFIG_FILE environment variable."
-            )
-
-        with config_path.open("r") as f:
-            raw_config = yaml.safe_load(f)
-
-        try:
-            validated_config = BrokersConfigSchema.model_validate(raw_config)
-        except ValidationError as e:
-            raise ValueError(
-                f"Invalid broker configuration in {config_path}:\n{e}"
-            ) from e
-
-        self._broker_configs = validated_config.brokers
-
-    def _create_broker(
-        self, broker_name: str, broker_config: BrokerConfigSchema
-    ) -> AsyncBroker:
-        """Create a configured taskiq broker instance.
-
-        Args:
-            broker_name: Name identifier for the broker.
-            broker_config: Broker configuration object.
-
-        Returns:
-            Configured AsyncBroker instance.
-        """
-        result_backend: AsyncResultBackend[Any] = RedisAsyncResultBackend(
-            redis_url=str(settings.REDIS_URL.with_path(f"/{settings.REDIS_TASK_DB}")),
-        )
-
-        middlewares = [
-            SmartRetryMiddleware(
-                default_retry_count=5,
-                default_delay=10,
-                use_jitter=True,
-                use_delay_exponent=True,
-                max_delay_exponent=120,
-            ),
-        ]
-
-        if settings.TASKIQ_DASHBOARD_URL:
-            middlewares.append(
-                DashboardMiddleware(
-                    url=settings.TASKIQ_DASHBOARD_URL,
-                    api_token=settings.TASKIQ_DASHBOARD_API_TOKEN,
-                    broker_name=broker_name,
-                )
-            )
-
-        return (
-            AioPikaBroker(
-                str(settings.RABBITMQ_URL),
-                queue_name=broker_config.queue,
-                routing_key=broker_config.routing_key,
-                exchange_name=broker_config.exchange,
-            )
-            .with_result_backend(result_backend)
-            .with_middlewares(*middlewares)
-        )
-
-    def _initialize_brokers(self) -> None:
-        """Initialize all configured brokers."""
-        # NOTE: For testing, create in-memory brokers for all configured brokers
-        if settings.ENVIRONMENT == Environment.TEST:
-            self._brokers = {
-                broker_name: InMemoryBroker() for broker_name in self._broker_configs
-            }
-        else:
-            for broker_name, broker_config in self._broker_configs.items():
-                self._brokers[broker_name] = self._create_broker(
-                    broker_name, broker_config
-                )
-
-        if settings.ENVIRONMENT != Environment.TEST:
-            workers_broker = self._brokers.get("general")
-            if workers_broker:
-                self._scheduler = TaskiqScheduler(
-                    broker=workers_broker,
-                    sources=[LabelScheduleSource(workers_broker)],
-                )
-
-    def get_broker(self, name: str) -> AsyncBroker:
-        """Get a broker by name.
-
-        Args:
-            name: Name of the broker to retrieve.
-
-        Returns:
-            AsyncBroker instance.
-
-        Raises:
-            RuntimeError: If the broker is not enabled.
-        """
-        broker = self._brokers.get(name)
-        if broker is None:
-            raise RuntimeError(
-                f"Broker '{name}' is not enabled. Enable it in the broker configuration file."
-            )
-        return broker
-
-    def get_all_brokers(self) -> dict[str, AsyncBroker]:
-        """Get all configured brokers.
-
-        Returns:
-            Dictionary mapping broker names to broker instances.
-        """
-        return self._brokers.copy()
-
-    async def startup_all(self) -> None:
-        """Start up all configured brokers.
-
-        Only starts brokers that are not in worker process mode.
-        """
-        for broker_instance in self._brokers.values():
-            if not broker_instance.is_worker_process:
-                await broker_instance.startup()
-
-    async def shutdown_all(self) -> None:
-        """Shut down all configured brokers.
-
-        Only shuts down brokers that are not in worker process mode.
-        """
-        for broker_instance in self._brokers.values():
-            if not broker_instance.is_worker_process:
-                await broker_instance.shutdown()
-
-    @property
-    def scheduler(self) -> TaskiqScheduler | None:
-        """Get the scheduler instance if available.
-
-        Returns:
-            TaskiqScheduler instance or None if not configured.
-        """
-        return self._scheduler
-
-
-# Create singleton instance
-broker_manager = BrokerManager()

api_shared-0.0.1/src/api_shared/core/settings.py

@@ -1,209 +0,0 @@
-import ipaddress
-from enum import StrEnum
-from typing import Annotated
-
-from pydantic import (
-    AfterValidator,
-    AnyHttpUrl,
-    Field,
-    PlainValidator,
-    TypeAdapter,
-)
-from pydantic_settings import BaseSettings, SettingsConfigDict
-from yarl import URL
-
-AnyHttpUrlAdapter = TypeAdapter(AnyHttpUrl)
-
-CustomHttpUrlStr = Annotated[
-    str,
-    PlainValidator(AnyHttpUrlAdapter.validate_strings),
-    AfterValidator(lambda x: str(x).rstrip("/")),
-]
-
-
-class Environment(StrEnum):
-    """Possible environments."""
-
-    DEV = "dev"
-    TEST = "test"
-    PROD = "prod"
-
-
-class OLTPLogMethod(StrEnum):
-    NONE = "none"
-    MANUAL = "manual"
-    LOGFIRE = "logfire"
-
-
-class RunMode(StrEnum):
-    NONE = "none"
-    API = "api"
-    WORKER = "worker"
-
-
-def _should_use_http_scheme(host: str) -> bool:
-    """Check if the host should use HTTP scheme instead of HTTPS.
-
-    Uses HTTP for:
-    - IP addresses (IPv4 or IPv6)
-    - Simple hostnames without dots (like docker hostnames: redis, postgres, etc.)
-
-    Uses HTTPS for:
-    - Domain names with dots (like redis.example.com)
-
-    Args:
-        host: The host string to check.
-
-    Returns:
-        True if should use HTTP scheme, False if should use HTTPS.
-    """
-    try:
-        ipaddress.ip_address(host)
-        return True
-    except ValueError:
-        pass
-
-    return "." not in host
-
-
-class SharedBaseSettings(BaseSettings):
-    """Base settings class with common configuration shared across all services."""
-
-    ENVIRONMENT: Environment = Field(
-        default=Environment.DEV,
-        description="Application environment (dev, test, prod).",
-    )
-    OLTP_LOG_METHOD: OLTPLogMethod = Field(
-        default=OLTPLogMethod.NONE,
-        description="OpenTelemetry logging method (none, manual, logfire).",
-    )
-    OTLP_ENDPOINT: CustomHttpUrlStr | None = Field(
-        default=None,
-        description="OpenTelemetry GRPC endpoint for OTLP exporter.",
-    )
-    OLTP_STD_LOGGING_ENABLED: bool = Field(
-        default=False,
-        description="Enable standard logging integration with OpenTelemetry.",
-    )
-    RABBITMQ_HOST: str = Field(
-        default="localhost",
-        description="RabbitMQ server hostname or IP address.",
-    )
-    RABBITMQ_PORT: int = Field(
-        default=5672,
-        description="RabbitMQ server port.",
-    )
-    RABBITMQ_USERNAME: str = Field(
-        description="RabbitMQ authentication username.",
-    )
-    RABBITMQ_PASSWORD: str = Field(
-        description="RabbitMQ authentication password.",
-    )
-    RABBITMQ_VHOST: str = Field(
-        default="/",
-        description="RabbitMQ virtual host.",
-    )
-    REDIS_PORT: int = Field(
-        default=6379,
-        description="Redis server port.",
-    )
-    REDIS_HOST: str = Field(
-        default="localhost",
-        description="Redis server hostname or IP address.",
-    )
-    REDIS_USER: str | None = Field(
-        default=None,
-        description="Redis authentication username.",
-    )
-    REDIS_PASS: str = Field(
-        description="Redis authentication password.",
-    )
-    REDIS_BASE: str | None = Field(
-        default=None,
-        description="Redis database base path.",
-    )
-    REDIS_TASK_DB: int = Field(
-        default=1,
-        ge=1,
-        le=16,
-        description="Redis database number for taskiq result backend. Must be between 1-16.",
-    )
-    RUN_MODE: RunMode = Field(
-        default=RunMode.NONE,
-        description="Application run mode api or worker).",
-    )
-    TASKIQ_DASHBOARD_HOST: str | None = Field(
-        default=None,
-        description="Taskiq dashboard server hostname or IP address.",
-    )
-    TASKIQ_DASHBOARD_PORT: int = Field(
-        default=8001,
-        description="Taskiq dashboard server port.",
-    )
-    TASKIQ_DASHBOARD_API_TOKEN: str = Field(
-        default="supersecret",
-        description="API token for Taskiq dashboard authentication.",
-    )
-    TASKIQ_BROKERS_CONFIG_FILE: str | None = Field(
-        default=None,
-        description="Path to YAML file containing broker configurations.",
-    )
-
-    @property
-    def TASKIQ_DASHBOARD_URL(self) -> str | None:
-        """Assemble Taskiq Dashboard URL from settings.
-
-        Returns:
-            Taskiq Dashboard URL.
-        """
-        if self.TASKIQ_DASHBOARD_HOST is None:
-            return None
-
-        return f"http://{self.TASKIQ_DASHBOARD_HOST}:{self.TASKIQ_DASHBOARD_PORT}"
-
-    @property
-    def REDIS_URL(self) -> URL:
-        """Assemble REDIS URL from settings.
-
-        Returns:
-            Redis URL.
-        """
-        path = f"/{self.REDIS_BASE}" if self.REDIS_BASE is not None else ""
-        scheme = "redis" if _should_use_http_scheme(self.REDIS_HOST) else "rediss"
-
-        return URL.build(
-            scheme=scheme,
-            host=self.REDIS_HOST,
-            port=self.REDIS_PORT,
-            user=self.REDIS_USER,
-            password=self.REDIS_PASS,
-            path=path,
-        )
-
-    @property
-    def RABBITMQ_URL(self) -> URL:
-        """Assemble RabbitMQ URL from settings.
-
-        Returns:
-            RabbitMQ URL.
-        """
-        scheme = "amqp" if _should_use_http_scheme(self.RABBITMQ_HOST) else "amqps"
-
-        return URL.build(
-            scheme=scheme,
-            host=self.RABBITMQ_HOST,
-            port=self.RABBITMQ_PORT,
-            user=self.RABBITMQ_USERNAME,
-            password=self.RABBITMQ_PASSWORD,
-            path=self.RABBITMQ_VHOST,
-        )
-
-    model_config = SettingsConfigDict(
-        env_file=".env",
-        # env_prefix="API_TEMPLATE_SHARED_",
-        env_file_encoding="utf-8",
-        extra="ignore",
-    )
-
-
-settings = SharedBaseSettings()  # type: ignore[call-arg]

api_shared-0.0.1/src/api_shared/middlewares/dashboard.py

@@ -1,169 +0,0 @@
-# NOTE: From https://github.com/danfimov/taskiq-dashboard/blob/main/taskiq_dashboard/interface/middleware.py
-import asyncio
-from datetime import datetime, timezone
-from logging import getLogger
-from typing import Any
-from urllib.parse import urljoin
-
-import httpx
-from taskiq.abc.middleware import TaskiqMiddleware
-from taskiq.compat import model_dump
-from taskiq.message import TaskiqMessage
-from taskiq.result import TaskiqResult
-
-logger = getLogger("taskiq_dashboard.admin_middleware")
-
-
-class DashboardMiddleware(TaskiqMiddleware):
-    """A Taskiq middleware that reports task lifecycle events to an external admin dashboard API.
-
-    This middleware sends HTTP POST requests to a configured endpoint when tasks
-    are queued, started, or completed. It can be used for task monitoring, auditing,
-    or visualization in external systems.
-
-    Attributes:
-        url (str): Base URL of the admin API.
-        api_token (str): Token used for authenticating with the API.
-        timeout (float): Timeout (in seconds) for API requests.
-        broker_name (str): Name of the broker instance to include in the payload. Defaults to 'default_broker'.
-        _pending (set[asyncio.Task]): Set of currently running background request tasks.
-        _client (httpx.AsyncClient | None): HTTP client session used for sending requests.
-    """
-
-    def __init__(
-        self,
-        url: str,
-        api_token: str,
-        timeout: float = 5.0,
-        broker_name: str = "default_broker",
-    ) -> None:
-        super().__init__()
-        self.url = url
-        self.timeout = timeout
-        self.api_token = api_token
-        self.broker_name = broker_name
-        self._pending: set[asyncio.Task[Any]] = set()
-        self._client: httpx.AsyncClient | None = None
-
-    @staticmethod
-    def _now_iso() -> str:
-        return datetime.now(timezone.utc).replace(tzinfo=None).isoformat()
-
-    def _get_client(self) -> httpx.AsyncClient:
-        """Create and cache session."""
-        if self._client is None:
-            self._client = httpx.AsyncClient(timeout=self.timeout)
-        return self._client
-
-    async def startup(self) -> None:
-        """Startup method to initialize httpx.AsyncClient."""
-        self._client = self._get_client()
-
-    async def shutdown(self) -> None:
-        """Shutdown method to run all pending requests and close the session."""
-        if self._pending:
-            await asyncio.gather(*self._pending, return_exceptions=True)
-        if self._client is not None:
-            await self._client.aclose()
-
-    async def _spawn_request(
-        self,
-        endpoint: str,
-        payload: dict[str, Any],
-    ) -> None:
-        """Fire and forget helper.
-
-        Start an async POST to the admin API, keep the resulting Task in _pending
-        so it can be awaited/cleaned during graceful shutdown.
-        """
-
-        async def _send() -> None:
-            client = self._get_client()
-            try:
-                resp = await client.post(
-                    urljoin(self.url, endpoint),
-                    headers={"access-token": self.api_token},
-                    json=payload,
-                )
-                resp.raise_for_status()
-                if not resp.is_success:
-                    logger.error("POST %s - %s", endpoint, resp.status_code)
-            except httpx.HTTPStatusError:
-                logger.exception("POST %s failed with HTTP error", endpoint)
-            except httpx.RequestError:
-                logger.exception("POST %s failed with request error", endpoint)
-
-        task = asyncio.create_task(_send())
-        self._pending.add(task)
-        task.add_done_callback(self._pending.discard)
-
-    async def post_send(self, message: TaskiqMessage) -> None:
-        """
-        This hook is executed right after the task is sent.
-
-        This is a client-side hook. It executes right
-        after the message is kicked in broker.
-
-        :param message: kicked message.
-        """
-        dict_message: dict[str, Any] = model_dump(message)
-        await self._spawn_request(
-            f"api/tasks/{message.task_id}/queued",
-            {
-                "args": dict_message["args"],
-                "kwargs": dict_message["kwargs"],
-                "labels": dict_message["labels"],
-                "queuedAt": self._now_iso(),
-                "taskName": message.task_name,
-                "worker": self.broker_name,
-            },
-        )
-
-    async def pre_execute(self, message: TaskiqMessage) -> TaskiqMessage:
-        """
-        This hook is called before executing task.
-
-        This is a worker-side hook, which means it
-        executes in the worker process.
-
-        :param message: incoming parsed taskiq message.
-        :return: modified message.
-        """
-        dict_message: dict[str, Any] = model_dump(message)
-        await self._spawn_request(
-            f"api/tasks/{message.task_id}/started",
-            {
-                "args": dict_message["args"],
-                "kwargs": dict_message["kwargs"],
-                "labels": dict_message["labels"],
-                "startedAt": self._now_iso(),
-                "taskName": message.task_name,
-                "worker": self.broker_name,
-            },
-        )
-        return message
-
-    async def post_execute(
-        self,
-        message: TaskiqMessage,
-        result: TaskiqResult[Any],
-    ) -> None:
-        """
-        This hook executes after task is complete.
-
-        This is a worker-side hook. It's called
-        in worker process.
-
-        :param message: incoming message.
-        :param result: result of execution for current task.
-        """
-        dict_result: dict[str, Any] = model_dump(result)
-        await self._spawn_request(
-            f"api/tasks/{message.task_id}/executed",
-            {
-                "finishedAt": self._now_iso(),
-                "executionTime": result.execution_time,
-                "error": None if result.error is None else repr(result.error),
-                "returnValue": {"return_value": dict_result["return_value"]},
-            },
-        )

api_shared-0.0.1/src/api_shared/tasks/general/__init__.py

@@ -1,31 +0,0 @@
-"""Worker tasks that use the 'general' broker."""
-
-from api_shared.broker import broker_manager
-
-# This will raise RuntimeError if general broker is not enabled
-workers_broker = broker_manager.get_broker("general")
-
-from api_shared.tasks.general.complex_task import (
-    LongRunningProcessResult,
-    long_running_process,
-)
-from api_shared.tasks.general.dummy import add_one, add_one_with_retry
-from api_shared.tasks.general.failing_task import failing_process
-from api_shared.tasks.general.pydantic_parse_task import (
-    NestedModel,
-    PydanticParseInput,
-    PydanticParseResult,
-    pydantic_parse_check,
-)
-
-__all__ = [
-    "LongRunningProcessResult",
-    "NestedModel",
-    "PydanticParseInput",
-    "PydanticParseResult",
-    "add_one",
-    "add_one_with_retry",
-    "failing_process",
-    "long_running_process",
-    "pydantic_parse_check",
-]

api_shared-0.0.1/src/api_shared/tasks/general/complex_task.py

@@ -1,20 +0,0 @@
-from pydantic import BaseModel
-
-from api_shared.broker import broker_manager
-
-broker = broker_manager.get_broker("general")
-
-
-class LongRunningProcessResult(BaseModel):
-    start_time: float
-    end_time: float
-    elapsed: float
-    status: str
-
-
-@broker.task(task_name="long_running_process")
-async def long_running_process(duration: int = 5) -> LongRunningProcessResult:
-    """
-    Simulates a long-running process by sleeping.
-    """
-    raise NotImplementedError("This task is implemented in the worker package")

api_shared-0.0.1/src/api_shared/tasks/general/dummy.py

@@ -1,46 +0,0 @@
-import random
-from datetime import datetime
-
-from loguru import logger
-
-from api_shared.broker import broker_manager
-
-broker = broker_manager.get_broker("general")
-
-
-@broker.task
-async def add_one(value: int) -> int:
-    return value + 1
-
-
-@broker.task(retry_on_error=True, max_retries=5, delay=15)
-async def add_one_with_retry(value: int) -> int:
-    # Randomly fail 50% of the time
-    if random.random() < 0.5:  # noqa: PLR2004
-        raise RuntimeError("Random failure in add_one_with_retry")
-
-    return value + 1
-
-
-@broker.task(
-    schedule=[
-        {
-            "cron": "*/2 * * * *",  # type: str, either cron or time should be specified. Runs every 2 minutes.
-            "cron_offset": None,  # type: str | timedelta | None, can be omitted.
-            "time": None,  # type: datetime | None, either cron or time should be specified.
-            "args": [1],  # type List[Any] | None, can be omitted.
-            "kwargs": {},  # type: Dict[str, Any] | None, can be omitted.
-            "labels": {},  # type: Dict[str, Any] | None, can be omitted.
-        }
-    ]
-)
-async def add_one_scheduled(value: int) -> int:
-    current_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-    logger.info(f"Current time: {current_time}")
-
-    return value + 1
-
-
-@broker.task
-async def parse_int(val: str) -> int:
-    return int(val)

api_shared-0.0.1/src/api_shared/tasks/general/failing_task.py

@@ -1,13 +0,0 @@
-from api_shared.broker import broker_manager
-
-broker = broker_manager.get_broker("general")
-
-
-@broker.task(task_name="failing_process")
-async def failing_process(
-    error_message: str = "This is a deliberate error",
-) -> None:
-    """
-    A task that intentionally fails to demonstrate error handling.
-    """
-    raise NotImplementedError("This task is implemented in the worker package")

api_shared-0.0.1/src/api_shared/tasks/general/pydantic_parse_task.py

@@ -1,33 +0,0 @@
-from pydantic import BaseModel
-
-from api_shared.broker import broker_manager
-
-broker = broker_manager.get_broker("general")
-
-
-class NestedModel(BaseModel):
-    name: str
-    value: int
-    tags: list[str]
-
-
-class PydanticParseInput(BaseModel):
-    text: str
-    count: int
-    nested: NestedModel
-
-
-class PydanticParseResult(BaseModel):
-    received_text: str
-    received_count: int
-    received_nested: NestedModel
-    doubled_count: int
-    status: str
-
-
-@broker.task(task_name="pydantic_parse_check")
-async def pydantic_parse_check(data: PydanticParseInput) -> PydanticParseResult:
-    """
-    Tests taskiq's ability to parse and serialize Pydantic BaseModels.
-    """
-    raise NotImplementedError("This task is implemented in the worker package")

api_shared-0.0.1/src/api_shared/tasks/general/redis.py

@@ -1,21 +0,0 @@
-# from typing import Annotated
-
-# from app.api.redis.deps import get_redis_pool
-# from loguru import logger
-# from redis.asyncio import ConnectionPool, Redis
-# from taskiq import TaskiqDepends
-
-# from api_shared.broker import broker_manager
-
-# broker = broker_manager.get_broker("general")
-
-
-# @broker.task
-# async def my_redis_task(
-#     key: str,
-#     val: str,
-#     pool: Annotated[ConnectionPool, TaskiqDepends(get_redis_pool)],
-# ):
-#     async with Redis(connection_pool=pool) as redis:
-#         await redis.set(name=key, value=val)
-#         logger.debug(f"Set key {key} with value {val} in Redis using connection pool")

api_shared-0.0.1/src/api_shared/tasks/ml/__init__.py

@@ -1,20 +0,0 @@
-"""ML tasks that use the 'ml' broker."""
-
-from api_shared.broker import broker_manager
-
-# This will raise RuntimeError if ML broker is not enabled
-ml_broker = broker_manager.get_broker("ml")
-
-from api_shared.tasks.ml.ml_tasks import (
-    MLInferenceResult,
-    MLTrainingResult,
-    ml_inference_task,
-    train_model_task,
-)
-
-__all__ = [
-    "MLInferenceResult",
-    "MLTrainingResult",
-    "ml_inference_task",
-    "train_model_task",
-]

api_shared-0.0.1/src/api_shared/tasks/ml/ml_tasks.py

@@ -1,60 +0,0 @@
-from pydantic import BaseModel
-
-from api_shared.broker import broker_manager
-
-ml_broker = broker_manager.get_broker("ml")
-
-
-class MLInferenceResult(BaseModel):
-    model_id: str
-    predictions: list[float]
-    confidence: float
-    status: str
-
-
-@ml_broker.task(task_name="ml_inference")
-async def ml_inference_task(model_id: str, input_data: dict) -> MLInferenceResult:
-    """
-    Perform ML inference on input data.
-
-    This task is implemented in the ML worker package.
-    It will be processed by ML workers listening to the 'taskiq_ml' queue.
-
-    Args:
-        model_id: Identifier for the ML model to use.
-        input_data: Input data for inference.
-
-    Returns:
-        Inference results with predictions and confidence scores.
-    """
-    raise NotImplementedError("This task is implemented in the ML worker package")
-
-
-class MLTrainingResult(BaseModel):
-    dataset_id: str
-    model_id: str
-    training_metrics: dict[str, float | int]
-    status: str
-
-
-@ml_broker.task(task_name="train_model")
-async def train_model_task(
-    dataset_id: str,
-    model_config: dict,
-    hyperparameters: dict,
-) -> MLTrainingResult:
-    """
-    Train an ML model with given configuration.
-
-    This task is implemented in the ML worker package.
-    It will be processed by ML workers listening to the 'taskiq_ml' queue.
-
-    Args:
-        dataset_id: Identifier for the training dataset.
-        model_config: Model architecture configuration.
-        hyperparameters: Training hyperparameters.
-
-    Returns:
-        Training results and model metadata.
-    """
-    raise NotImplementedError("This task is implemented in the ML worker package")