sovereign 1.0.0a4__py3-none-any.whl → 1.0.0b148__py3-none-any.whl

sovereign/__init__.py

@@ -1,11 +1,11 @@
 from contextvars import ContextVar
 from importlib.metadata import version
 
-from sovereign.configuration import EncryptionConfig, config
+from sovereign.utils.crypto.suites import EncryptionType
 from sovereign.logging.bootstrapper import LoggerBootstrapper
+from sovereign.configuration import config, EncryptionConfig
 from sovereign.statistics import configure_statsd
 from sovereign.utils.crypto.crypto import CipherContainer
-from sovereign.utils.crypto.suites import EncryptionType
 
 _request_id_ctx_var: ContextVar[str] = ContextVar("request_id", default="")
 

sovereign/app.py

@@ -7,12 +7,12 @@ from fastapi.responses import FileResponse, JSONResponse, RedirectResponse, Resp
 from starlette_context.middleware import RawContextMiddleware
 
 from sovereign import __version__, logs
-from sovereign.configuration import ConfiguredResourceTypes, config
+from sovereign.configuration import config, ConfiguredResourceTypes
+from sovereign.response_class import json_response_class
 from sovereign.error_info import ErrorInfo
 from sovereign.middlewares import LoggingMiddleware, RequestContextLogMiddleware
-from sovereign.response_class import json_response_class
 from sovereign.utils.resources import get_package_file
-from sovereign.views import api, crypto, discovery, healthchecks, interface
+from sovereign.views import crypto, discovery, healthchecks, interface, api
 
 Router = namedtuple("Router", "module tags prefix")
 
@@ -68,10 +68,7 @@ def init_app() -> FastAPI:
 
     if dsn := config.sentry_dsn.get_secret_value():
         try:
-            # noinspection PyUnusedImports
             import sentry_sdk
-
-            # noinspection PyUnusedImports
             from sentry_sdk.integrations.asgi import SentryAsgiMiddleware
 
             sentry_sdk.init(dsn)

sovereign/cache/__init__.py

@@ -6,23 +6,20 @@ to configure their own remote cache backends through entry points.
 """
 
 import asyncio
-import os
-import threading
-import time
+from typing import Any
+from typing_extensions import final
 
 import requests
-from typing_extensions import final
 
-from sovereign import WORKER_URL, stats
-from sovereign import application_logger as log
+from sovereign import WORKER_URL, stats, application_logger as log
+from sovereign.types import DiscoveryRequest, RegisterClientRequest
+from sovereign.configuration import config
+from sovereign.cache.types import Entry, CacheResult
 from sovereign.cache.backends import CacheBackend, get_backend
 from sovereign.cache.filesystem import FilesystemCache
-from sovereign.cache.types import CacheResult, Entry
-from sovereign.configuration import config
-from sovereign.types import DiscoveryRequest, RegisterClientRequest
+
 
 CACHE_READ_TIMEOUT = config.cache.read_timeout
-REMOTE_TTL = 300  # 5 minutes - TTL for entries read from remote cache
 
 
 class CacheManagerBase:
@@ -81,27 +78,12 @@ class CacheReader(CacheManagerBase):
         return None
 
     def get(self, req: DiscoveryRequest) -> Entry | None:
-        """Read from cache, writing back from remote with short TTL if needed.
-
-        Flow:
-          1. Entry read from remote → cached with 300s TTL
-          2. Background registration triggers worker to generate fresh config
-          3. Remote entry expires after 300s
-          4. Next request gets worker-generated config (cached infinitely)
-        """
         id = client_id(req)
         if result := self.try_read(id):
             if result.from_remote:
-                # Write immediately with short TTL to prevent empty cache window
-                self.local.set(id, result.value, timeout=REMOTE_TTL)
-                log.info(
-                    f"Cache writeback from remote: client_id={id} version={result.value.version} "
-                    f"ttl={REMOTE_TTL} type=remote pid={os.getpid()}"
-                )
-                stats.increment("cache.fs.writeback", tags=["type:remote"])
-
-                # Background thread triggers worker to generate fresh config
-                self.register_async(req)
+                self.register(req)
+                # Write back to filesystem
+                self.local.set(id, result.value)
             return result.value
         return None
 
@@ -158,49 +140,6 @@ class CacheReader(CacheManagerBase):
             log.exception(f"Error while registering client: {e}")
         return False
 
-    def register_async(self, req: DiscoveryRequest):
-        """Register client async to trigger worker to generate fresh config.
-
-        Registration tells the worker about this client so it generates fresh config.
-        """
-
-        def job():
-            start_time = time.time()
-            attempts = 5
-            backoff = 1.0
-            attempt_num = 0
-
-            while attempts:
-                attempt_num += 1
-                if self.register_over_http(req):
-                    duration_ms = (time.time() - start_time) * 1000
-                    stats.increment(
-                        "client.registration.async",
-                        tags=["status:success", f"attempts:{attempt_num}"],
-                    )
-                    stats.timing("client.registration.async.duration_ms", duration_ms)
-                    log.debug(f"Async registration succeeded: attempts={attempt_num}")
-                    return
-                attempts -= 1
-                if attempts:
-                    log.debug(
-                        f"Async registration failed: retrying_in={backoff}s remaining={attempts}"
-                    )
-                    time.sleep(backoff)
-                    backoff *= 2
-
-            # Registration failed - entry stays at REMOTE_TTL, will expire and retry
-            duration_ms = (time.time() - start_time) * 1000
-            stats.increment("client.registration.async", tags=["status:exhausted"])
-            stats.timing("client.registration.async.duration_ms", duration_ms)
-            log.warning(
-                f"Async registration exhausted for {req}: remote entry will expire "
-                f"in {REMOTE_TTL}s and retry"
-            )
-
-        t = threading.Thread(target=job)
-        t.start()
-
 
 @final
 class CacheWriter(CacheManagerBase):
@@ -211,31 +150,19 @@ class CacheWriter(CacheManagerBase):
         cached = False
         try:
             self.local.set(key, value, timeout)
-            log.info(
-                f"Cache write to filesystem: client_id={key} version={value.version} "
-                f"ttl={timeout} pid={os.getpid()} thread_id={threading.get_ident()}"
-            )
             stats.increment("cache.fs.write.success")
             cached = True
         except Exception as e:
-            log.warning(
-                f"Failed to write to filesystem cache: client_id={key} error={e}"
-            )
+            log.warning(f"Failed to write to filesystem cache: {e}")
             msg.append(("warning", f"Failed to write to filesystem cache: {e}"))
             stats.increment("cache.fs.write.error")
         if self.remote:
             try:
                 self.remote.set(key, value, timeout)
-                log.info(
-                    f"Cache write to remote: client_id={key} version={value.version} "
-                    f"ttl={timeout} pid={os.getpid()} thread_id={threading.get_ident()}"
-                )
                 stats.increment("cache.remote.write.success")
                 cached = True
             except Exception as e:
-                log.warning(
-                    f"Failed to write to remote cache: client_id={key} error={e}"
-                )
+                log.warning(f"Failed to write to remote cache: {e}")
                 msg.append(("warning", f"Failed to write to remote cache: {e}"))
                 stats.increment("cache.remote.write.error")
         return cached, msg

sovereign/cache/backends/__init__.py

@@ -7,7 +7,7 @@ the loading mechanism for extensible cache backends via entry points.
 
 from collections.abc import Sequence
 from importlib.metadata import EntryPoints
-from typing import Any, Protocol, runtime_checkable
+from typing import Protocol, Any, runtime_checkable
 
 from sovereign import application_logger as log
 from sovereign.utils.entry_point_loader import EntryPointLoader

sovereign/cache/backends/s3.py

@@ -1,20 +1,15 @@
 import pickle
-import time
-from datetime import datetime, timedelta, timezone
-from importlib.util import find_spec
+from datetime import datetime, timezone, timedelta
 from typing import Any
-from urllib.parse import quote
-
 from typing_extensions import override
+from urllib.parse import quote
+from importlib.util import find_spec
 
 from sovereign import application_logger as log
 from sovereign.cache.backends import CacheBackend
 
 try:
-    # noinspection PyUnusedImports
     import boto3
-
-    # noinspection PyUnusedImports
     from botocore.exceptions import ClientError
 except ImportError:
     pass
@@ -71,10 +66,9 @@ class S3Client:
 class S3Backend(CacheBackend):
     """S3 cache backend implementation"""
 
-    # noinspection PyMissingConstructor,PyProtocol
     @override
-    def __init__(self, config: dict[str, Any], attempts: int = 0) -> None:  # pyright: ignore[reportMissingSuperCall]
-        """Initialise S3 backend
+    def __init__(self, config: dict[str, Any]) -> None:  # pyright: ignore[reportMissingSuperCall]
+        """Initialize S3 backend
 
         Args:
             config: Configuration dictionary containing S3 connection parameters
@@ -91,7 +85,6 @@ class S3Backend(CacheBackend):
         self.prefix = config.get("prefix", "sovereign-cache")
         self.registration_prefix = config.get("registration_prefix", "registrations-")
         self.role = config.get("assume_role")
-        self.remote_cache_key_suffix = config.get("remote_cache_key_suffix")
 
         client_args: dict[str, Any] = {}
         if endpoint_url := config.get("endpoint_url"):
@@ -104,24 +97,13 @@ class S3Backend(CacheBackend):
             self.s3.head_bucket(Bucket=self.bucket_name)
             log.info(f"S3 cache backend connected to bucket '{self.bucket_name}'")
         except Exception as e:
-            if attempts == 0:
-                # wait 5 seconds and then try to access the bucket again
-                time.sleep(5)
-                self.__init__(config, attempts + 1)
-                return
-
             log.error(
                 f"Failed to access S3 bucket '{self.bucket_name}' with current credentials: {e}"
             )
             raise
 
     def _make_key(self, key: str) -> str:
-        # noop
-        if self.remote_cache_key_suffix:
-            encoded_key = quote(f"{key}-{self.remote_cache_key_suffix}", safe="")
-            log.info(f"Using remote cache key: {encoded_key}")
-        else:
-            encoded_key = quote(key, safe="")
+        encoded_key = quote(key, safe="")
         return f"{self.prefix}/{encoded_key}"
 
     def get(self, key: str) -> Any | None:

sovereign/cache/filesystem.py

@@ -1,13 +1,13 @@
 import json
 import sqlite3
-from hashlib import sha256
 from pathlib import Path
-
-from cachelib import FileSystemCache
+from hashlib import sha256
 from typing_extensions import final
+from cachelib import FileSystemCache
 
-from sovereign.configuration import config
 from sovereign.types import DiscoveryRequest
+from sovereign.configuration import config
+
 
 INIT = """
 CREATE TABLE IF NOT EXISTS registered_clients (
@@ -24,8 +24,7 @@ SEARCH = "SELECT 1 FROM registered_clients WHERE client_id = ?"
 class FilesystemCache:
     def __init__(self, cache_path: str | None = None, default_timeout: int = 0):
         self.cache_path = cache_path or config.cache.local_fs_path
-        self.default_timeout = default_timeout  # 0 = infinite TTL
-
+        self.default_timeout = default_timeout
         self._cache = FileSystemCache(
             cache_dir=self.cache_path,
             default_timeout=self.default_timeout,

sovereign/cache/types.py

@@ -1,7 +1,5 @@
 from typing import Any
-
 from pydantic import BaseModel
-
 from sovereign.types import Node
 
 

sovereign/configuration.py

@@ -1,20 +1,20 @@
-import importlib
-import multiprocessing
+from collections import defaultdict
 import os
 import warnings
-from collections import defaultdict
-from dataclasses import dataclass
+import importlib
+import multiprocessing
+from pathlib import Path
 from enum import Enum
 from os import getenv
-from pathlib import Path
+from dataclasses import dataclass
 from typing import (
     Any,
-    Callable,
     Dict,
     Mapping,
     Optional,
     Self,
     Union,
+    Callable,
 )
 
 from croniter import CroniterBadCronError, croniter
@@ -22,15 +22,15 @@ from pydantic import (
     BaseModel,
     Field,
     SecretStr,
-    field_validator,
     model_validator,
+    field_validator,
 )
 from pydantic_settings import BaseSettings, SettingsConfigDict
 
 from sovereign.dynamic_config import Loadable
 from sovereign.types import XdsTemplate
-from sovereign.utils import dictupdate
 from sovereign.utils.crypto.suites import EncryptionType
+from sovereign.utils import dictupdate
 
 
 class CacheStrategy(str, Enum):
@@ -48,7 +48,6 @@ class ConfiguredSource(BaseModel):
     scope: str = "default"  # backward compatibility
 
 
-# noinspection DuplicatedCode
 class StatsdConfig(BaseModel):
     host: str = "127.0.0.1"
     port: Union[int, str] = 8125
@@ -217,7 +216,6 @@ class AccessLogConfiguration(BaseSettings):
     )
 
 
-# noinspection PyArgumentList
 class LoggingConfiguration(BaseSettings):
     application_logs: ApplicationLogConfiguration = ApplicationLogConfiguration()
     access_logs: AccessLogConfiguration = AccessLogConfiguration()
@@ -303,7 +301,6 @@ class SourcesConfiguration(BaseSettings):
     )
 
 
-# noinspection DuplicatedCode
 class TracingConfig(BaseSettings):
     enabled: bool = Field(False)
     collector: str = Field("notset")
@@ -463,10 +460,6 @@ class CacheConfiguration(BaseModel):
         default_factory=default_hash_rules,
         description="The set of JMES expressions against incoming Discovery Requests used to form a cache key.",
     )
-    poll_interval_secs: float = Field(
-        0.5,
-        description="How many seconds to wait between each read attempt from the cache",
-    )
     read_timeout: float = Field(
         5.0,
         description="How long to block when trying to read from the cache before giving up",
@@ -480,7 +473,6 @@ class CacheConfiguration(BaseModel):
     )
 
 
-# noinspection PyArgumentList
 class SovereignConfigv2(BaseSettings):
     # Config generation
     templates: TemplateConfiguration
@@ -496,32 +488,6 @@ class SovereignConfigv2(BaseSettings):
     worker_host: Optional[str] = Field("localhost", alias="SOVEREIGN_WORKER_HOST")
     worker_port: Optional[int] = Field(9080, alias="SOVEREIGN_WORKER_PORT")
 
-    # Worker v2
-
-    # only used for sqlite file path
-    worker_v2_data_store_path: Optional[str] = Field(
-        "/tmp/sovereign_v2_data_store.db",
-        alias="SOVEREIGN_WORKER_V2_DATA_STORE_PATH",
-    )
-    worker_v2_data_store_provider: Optional[str] = Field(
-        "sqlite",
-        alias="SOVEREIGN_WORKER_V2_DATA_STORE_PROVIDER",
-    )
-    worker_v2_queue_path: Optional[str] = Field(
-        "/tmp/sovereign_v2_queue.db",
-        alias="SOVEREIGN_WORKER_V2_QUEUE_PATH",
-    )
-    worker_v2_queue_provider: Optional[str] = Field(
-        "sqlite",
-        alias="SOVEREIGN_WORKER_V2_QUEUE_PROVIDER",
-    )
-    worker_v2_enabled: Optional[bool] = Field(
-        False, alias="SOVEREIGN_WORKER_V2_ENABLED"
-    )
-    worker_v2_queue_invsibility_time: Optional[int] = Field(
-        None, alias="SOVEREIGN_WORKER_V2_QUEUE_INVISIBILITY_TIME"
-    )
-
     # Supervisord settings
     supervisord: SupervisordConfig = SupervisordConfig()
 

sovereign/context.py

@@ -1,23 +1,24 @@
-import asyncio
-import datetime
-import heapq
-import inspect
 import time
+import heapq
 import zlib
+import datetime
+import asyncio
+import inspect
 from enum import Enum
 from typing import Any, Callable, Optional, Union
+from typing_extensions import final, override
 
 import pydantic
 from croniter import croniter
-from typing_extensions import final, override
 
 from sovereign import application_logger as log
+from sovereign.types import DiscoveryRequest
 from sovereign.configuration import config
-from sovereign.dynamic_config import Loadable
-from sovereign.events import Event, Topic, bus
 from sovereign.statistics import configure_statsd
-from sovereign.types import DiscoveryRequest
 from sovereign.utils.timer import wait_until
+from sovereign.dynamic_config import Loadable
+from sovereign.events import bus, Event, Topic
+
 
 stats = configure_statsd()
 DEFAULT_RETRY_INTERVAL = config.template_context.refresh_retry_interval_secs

sovereign/dynamic_config/__init__.py

@@ -1,11 +1,12 @@
 import inspect
 from typing import Any
 
-from pydantic import BaseModel, ConfigDict, Field
+from pydantic import BaseModel, Field, ConfigDict
 
-from sovereign.dynamic_config.deser import ConfigDeserializer
-from sovereign.dynamic_config.loaders import CustomLoader
 from sovereign.utils.entry_point_loader import EntryPointLoader
+from sovereign.dynamic_config.loaders import CustomLoader
+from sovereign.dynamic_config.deser import ConfigDeserializer
+
 
 LOADERS: dict[str, CustomLoader] = {}
 DESERIALIZERS: dict[str, ConfigDeserializer] = {}

sovereign/dynamic_config/deser.py

@@ -1,8 +1,8 @@
 import json
 from typing import Any, Protocol
 
-import jinja2
 import yaml
+import jinja2
 
 try:
     import ujson

sovereign/dynamic_config/loaders.py

@@ -1,8 +1,8 @@
-import importlib
 import os
-from importlib.machinery import SourceFileLoader
-from pathlib import Path
+import importlib
 from typing import Any, Protocol
+from pathlib import Path
+from importlib.machinery import SourceFileLoader
 
 import requests
 

sovereign/error_info.py

@@ -1,7 +1,8 @@
 import json
-from dataclasses import asdict, dataclass, field
+
+from typing import Union, Optional, Any
+from dataclasses import dataclass, field, asdict
 from functools import singledispatchmethod
-from typing import Any, Optional, Union
 
 from sovereign import get_request_id
 

sovereign/events.py

@@ -1,9 +1,9 @@
+import pydantic
+from enum import IntEnum
 from asyncio import Queue, gather
 from collections import defaultdict
-from enum import IntEnum
-from typing import Sequence, final
+from typing import final, Sequence
 
-import pydantic
 
 Primitives = str | int | float | bool | Sequence[str]
 

sovereign/logging/access_logger.py

@@ -6,9 +6,9 @@ import structlog
 from starlette_context import context
 from structlog.stdlib import BoundLogger
 
-from sovereign.configuration import SovereignConfigv2
 from sovereign.logging.base_logger import BaseLogger
 from sovereign.logging.types import EventDict, LoggingType, ProcessedMessage
+from sovereign.configuration import SovereignConfigv2
 
 
 class AccessLogger(BaseLogger):

sovereign/logging/application_logger.py

@@ -4,9 +4,9 @@ from typing import Any, Dict
 import structlog
 from structlog.stdlib import BoundLogger
 
-from sovereign.configuration import SovereignConfigv2
 from sovereign.logging.base_logger import BaseLogger
 from sovereign.logging.types import EventDict, LoggingType, ProcessedMessage
+from sovereign.configuration import SovereignConfigv2
 
 
 class ApplicationLogger(BaseLogger):

sovereign/logging/bootstrapper.py

@@ -2,10 +2,10 @@ import structlog
 from structlog.exceptions import DropEvent
 from structlog.stdlib import BoundLogger
 
-from sovereign.configuration import SovereignConfigv2
 from sovereign.logging.access_logger import AccessLogger
 from sovereign.logging.application_logger import ApplicationLogger
 from sovereign.logging.types import EventDict, ProcessedMessage
+from sovereign.configuration import SovereignConfigv2
 
 
 class LoggerBootstrapper:

sovereign/modifiers/lib.py

@@ -8,7 +8,7 @@ used via configuration.
 """
 
 import abc
-from typing import Any, Dict, List
+from typing import List, Any, Dict
 
 
 class Modifier(metaclass=abc.ABCMeta):