FlowerPower 0.11.6.20__py3-none-any.whl → 0.20.0__py3-none-any.whl

flowerpower/job_queue/apscheduler/__init__.py

@@ -1,11 +0,0 @@
-from .manager import APSManager
-from .setup import APSBackend, APSDataStore, APSEventBroker
-from .trigger import APSTrigger
-
-__all__ = [
-    "APSManager",
-    "APSTrigger",
-    "APSBackend",
-    "APSDataStore",
-    "APSEventBroker",
-]

flowerpower/job_queue/apscheduler/_setup/datastore.py

@@ -1,110 +0,0 @@
-from apscheduler.datastores.base import BaseDataStore
-from sqlalchemy import text
-from sqlalchemy.ext.asyncio import AsyncEngine, create_async_engine
-
-from ...base import BackendType, BaseBackend
-
-
-class APSDataStoreType(BackendType):
-    POSTGRESQL = "postgresql"
-    SQLITE = "sqlite"
-    MYSQL = "mysql"
-    MONGODB = "mongodb"
-    MEMORY = "memory"
-
-
-class APSDataStore(BaseBackend):
-    """Data store for APScheduler."""
-
-    def __post_init__(self):
-        super().__post_init__(backend_type=APSDataStoreType)
-        self._validate_inputs()
-
-    @classmethod
-    def from_dict(cls, d: dict[str, any]) -> "APSDataStore":
-        return cls(**d)
-
-    def _validate_inputs(self) -> None:
-        if self.type.value not in [ds.value for ds in APSDataStoreType]:
-            raise ValueError(
-                f"Invalid data store type: {self.type}. Valid types: {[ds.value for ds in APSDataStoreType]}"
-            )
-
-    async def _setup_db(self) -> None:
-        sqla_engine = create_async_engine(self.uri)
-
-        try:
-            await self._create_schema(sqla_engine)
-        except Exception:
-            await self._create_database_and_schema(sqla_engine)
-
-    async def _create_schema(self, engine: AsyncEngine) -> None:
-        if not self.schema_or_queue:
-            return
-
-        async with engine.begin() as conn:
-            await conn.execute(
-                text(f"CREATE SCHEMA IF NOT EXISTS {self.schema_or_queue}")
-            )
-            await conn.commit()
-
-    async def _create_database_and_schema(self, engine: AsyncEngine) -> None:
-        database_name = self.uri.split("/")[-1].split("?")[0]
-        temp_uri = self.uri.replace(f"/{database_name}", "/template1")
-        temp_engine = create_async_engine(temp_uri)
-
-        async with temp_engine.begin() as conn:
-            await conn.execute(text("COMMIT"))
-            try:
-                await conn.execute(text(f"CREATE DATABASE {database_name}"))
-            finally:
-                await conn.execute(text("COMMIT"))
-
-        if self.schema_or_queue:
-            await self._create_schema(engine)
-
-    def setup_db(self) -> None:
-        from anyio.from_thread import start_blocking_portal
-
-        with start_blocking_portal() as portal:
-            portal.call(self._setup_db)
-
-    def _setup_sqlalchemy(self) -> None:
-        from apscheduler.datastores.sqlalchemy import SQLAlchemyDataStore
-
-        if not self.type.is_sqlite_type:
-            self.setup_db()
-        self._sqla_engine = create_async_engine(self.uri)
-        self._client = SQLAlchemyDataStore(
-            self._sqla_engine, schema=self.schema_or_queue
-        )
-
-    def _setup_mongodb(self) -> None:
-        from apscheduler.datastores.mongodb import MongoDBDataStore
-
-        self._client = MongoDBDataStore(self.uri, database=self.schema_or_queue)
-
-    def _setup_memory(self) -> None:
-        from apscheduler.datastores.memory import MemoryDataStore
-
-        self._client = MemoryDataStore()
-
-    def setup(self) -> None:
-        if self.type.is_sqla_type:
-            self._setup_sqlalchemy()
-        elif self.type.is_mongodb_type:
-            self._setup_mongodb()
-        else:
-            self._setup_memory()
-
-    @property
-    def client(self) -> BaseDataStore:
-        if self._client is None:
-            self.setup()
-        return self._client
-
-    @property
-    def sqla_engine(self) -> AsyncEngine | None:
-        if self._sqla_engine is None:
-            self.setup()
-        return self._sqla_engine

flowerpower/job_queue/apscheduler/_setup/eventbroker.py

@@ -1,93 +0,0 @@
-from apscheduler.eventbrokers.base import BaseEventBroker
-from sqlalchemy.ext.asyncio import AsyncEngine
-
-from ...base import BackendType, BaseBackend
-
-
-class APSEventBrokerType(BackendType):
-    POSTGRESQL = "postgresql"
-    MEMORY = "memory"
-    REDIS = "redis"
-    MQTT = "mqtt"
-
-
-class APSEventBroker(BaseBackend):
-    """Data store for APScheduler."""
-
-    def __post_init__(self):
-        super().__post_init__(backend_type=APSEventBrokerType)
-
-    @classmethod
-    def from_dict(cls, d: dict[str, any]) -> "APSEventBroker":
-        return cls(**d)
-
-    def _validate_inputs(self) -> None:
-        if self.type.value not in [ds.value for ds in APSEventBrokerType]:
-            raise ValueError(
-                f"Invalid data store type: {self.type}. Valid types: {[ds.value for ds in APSEventBrokerType]}"
-            )
-
-    def _setup_asyncpg_event_broker(self):
-        from apscheduler.eventbrokers.asyncpg import AsyncpgEventBroker
-
-        if self._sqla_engine is None:
-            self._event_broker = AsyncpgEventBroker.from_dsn(dsn=self.uri)
-        else:
-            self._event_broker = AsyncpgEventBroker.from_async_sqla_engine(
-                engine=self._sqla_engine
-            )
-
-    def _setup_mqtt_event_broker(self):
-        import urllib.parse
-
-        from apscheduler.eventbrokers.mqtt import MQTTEventBroker
-
-        # Parse the URI
-        parsed = urllib.parse.urlparse(self.uri)
-
-        hostname = parsed.hostname
-        port = parsed.port
-        username = parsed.username
-        password = parsed.password
-        use_ssl = parsed.scheme == "mqtts"
-
-        self._event_broker = MQTTEventBroker(
-            host=hostname, port=port, ssl=use_ssl, topic="flowerpower/scheduler"
-        )
-        if (self.username is not None) and (self.password is not None):
-            self._event_broker._client.username_pw_set(
-                username,
-                password,
-            )
-
-    def _setup_redis_event_broker(self):
-        from apscheduler.eventbrokers.redis import RedisEventBroker
-
-        self._event_broker = RedisEventBroker(self.uri)
-
-    def _setup_local_event_broker(self):
-        from apscheduler.eventbrokers.local import LocalEventBroker
-
-        self._event_broker = LocalEventBroker()
-
-    def setup(self):
-        if self.is_sqla_type:
-            self._setup_asyncpg_event_broker()
-        elif self.is_mqtt_type:
-            self._setup_mqtt_event_broker()
-        elif self.is_redis_type:
-            self._setup_redis_event_broker()
-        else:
-            self._setup_local_event_broker()
-
-    @property
-    def client(self) -> BaseEventBroker:
-        if self._event_broker is None:
-            self.setup()
-        return self._event_broker
-
-    @property
-    def sqla_engine(self) -> AsyncEngine | None:
-        if self._sqla_engine is None:
-            self.setup()
-        return self._sqla_engine