FlowerPower 0.9.13.1__py3-none-any.whl → 1.0.0b1__py3-none-any.whl

flowerpower/tui.py

@@ -1,79 +0,0 @@
-from textual.app import App
-from textual.layouts.grid import GridLayout
-from textual.reactive import Reactive
-from textual.scroll_view import ScrollView
-from textual.widgets import Footer, Header, Static
-
-from flowerpower.pipeline import PipelineManager
-
-
-class PipelineList(Static):
-    def __init__(self, pipelines):
-        super().__init__()
-        self.pipelines = pipelines
-
-    def render(self):
-        return "\n".join(f"- {pipeline.name}" for pipeline in self.pipelines)
-
-
-class FlowerPowerTUI(App):
-    pipelines = Reactive([])
-
-    async def on_load(self):
-        await self.bind("q", "quit")  # , "Beenden")
-        await self.bind("a", "add_pipeline")  # , "Pipeline hinzufügen")
-        await self.bind("d", "delete_pipeline")  # , "Pipeline löschen")
-
-    async def on_mount(self):
-        self.pipeline_manager = PipelineManager()
-        self.refresh_pipelines()
-
-        grid = await self.view.dock_grid(edge="top")
-
-        grid.add_column(fraction=1, name="left", min_size=30)
-        grid.add_column(fraction=3, name="right")
-
-        grid.add_row(fraction=1, name="row")
-
-        grid.add_areas(
-            area_left="left,row",
-            area_right="right,row",
-        )
-
-        header = Header()
-        footer = Footer()
-
-        self.pipeline_list = PipelineList(self.pipelines)
-        self.details_view = ScrollView()
-
-        await self.view.dock(header, edge="top")
-        await self.view.dock(footer, edge="bottom")
-        grid.place(area_left=self.pipeline_list, area_right=self.details_view)
-
-        await self.view.dock(grid)
-
-    def refresh_pipelines(self):
-        self.pipelines = self.pipeline_manager.find_pipelines()
-
-    async def action_add_pipeline(self):
-        # Logik zum Hinzufügen einer neuen Pipeline
-        pass
-
-    async def action_delete_pipeline(self):
-        # Logik zum Löschen einer Pipeline
-        pass
-
-    async def on_key(self, event):
-        if event.key == "up":
-            # Navigiere nach oben in der Pipeline-Liste
-            pass
-        elif event.key == "down":
-            # Navigiere nach unten in der Pipeline-Liste
-            pass
-        elif event.key == "enter":
-            # Zeige Details zur ausgewählten Pipeline an
-            pass
-
-
-if __name__ == "__main__":
-    FlowerPowerTUI().run()

flowerpower/utils/datastore.py

@@ -1,186 +0,0 @@
-ALL_DATA_STORES = [
-    "sqlalchemy",
-    "asyncpg",
-    "psycopg2",
-    "postgresql",
-    "sqlite",
-    "sqlite3",
-    "mysql",
-    "mongodb",
-    "local",
-    "memory",
-]
-
-
-class DataStore:
-    def __init__(
-        self,
-        type: str | None = None,
-        engine_or_uri: str | None = None,
-        schema: str | None = "flowerpower",
-        username: str | None = None,
-        password: str | None = None,
-        ssl: bool = False,
-        **kwargs,
-    ):
-        self.type = type or "memory"
-        self.engine_or_uri = engine_or_uri
-        self.sqla_engine = None
-        self.schema = schema
-        self.username = username
-        self.password = password
-        self.ssl = ssl
-        self._kwargs = kwargs
-
-        if self.type not in ALL_DATA_STORES:
-            raise ValueError(
-                f"Invalid data store type: {type}. Valid data store types are: {ALL_DATA_STORES}"
-            )
-        if (
-            type
-            in [
-                "sqlalchemy",
-                "postgresql",
-                "asyncpg",
-                "psycopg2",
-                "sqlite",
-                "sqlite3",
-                "mysql",
-                "mongodb",
-            ]
-            and not engine_or_uri
-        ):
-            raise ValueError(f"Data store type {type} requires an engine or uri")
-
-    def _gen_uri(self):
-        import urllib.parse
-
-        if self.password and "@" not in self.engine_or_uri:
-            if not self.username:
-                raise ValueError(
-                    "Data store type `sqlalchemy` requires a username when a password is provided"
-                )
-            password = urllib.parse.quote(self.password)
-            self.engine_or_uri = self.engine_or_uri.replace(
-                "://", f"://{self.username}:{password}@"
-            )
-        if self.ssl and "?ssl" not in self.engine_or_uri:
-            self.engine_or_uri = self.engine_or_uri + "?ssl=allow"
-
-        # asyncio.run(self.setup_db())
-        # self.setup_db()
-
-    def _setup_sqlalchemy(self):
-        from apscheduler.datastores.sqlalchemy import SQLAlchemyDataStore
-        from sqlalchemy.ext.asyncio import create_async_engine
-
-        self._gen_uri()
-        self.setup_db()
-        self.sqla_engine = create_async_engine(self.engine_or_uri)
-        self._data_store = SQLAlchemyDataStore(self.sqla_engine, schema=self.schema)
-
-    def _setup_mongodb(self, uri: str):
-        from apscheduler.datastores.mongodb import MongoDBDataStore
-
-        self._data_store = MongoDBDataStore(self.engine_or_uri, database=self.schema)
-
-    def _setup_memory(self):
-        from apscheduler.datastores.memory import MemoryDataStore
-
-        self._data_store = MemoryDataStore()
-
-    def setup(
-        self,
-    ):
-        if self.type in [
-            "sqlalchemy",
-            "sqlite",
-            "postgresql",
-            "asyncpg",
-            "psychopg2",
-            "sqlite3",
-            "mysql",
-        ]:
-            self._setup_sqlalchemy()
-        elif self.type == "mongodb":
-            self._setup_mongodb()
-        else:
-            self._setup_memory()
-
-    def get(self) -> tuple:
-        return self._data_store, self.sqla_engine
-
-    async def _setup_db(self):
-        from sqlalchemy import text
-        from sqlalchemy.ext.asyncio import create_async_engine
-
-        self._gen_uri()
-        sqla_engine = create_async_engine(self.engine_or_uri)
-        try:
-            async with sqla_engine.begin() as conn:
-                if self.schema:
-                    await conn.execute(
-                        text(f"CREATE SCHEMA IF NOT EXISTS {self.schema}")
-                    )
-                    await conn.commit()
-        except Exception as e:
-            _ = e
-            database_name = self.engine_or_uri.split("/")[-1].split("?")[0]
-            temp_engine = create_async_engine(
-                self.engine_or_uri.replace(f"/{database_name}", "/template1")
-            )
-            async with temp_engine.begin() as conn:
-                await conn.execute(text("COMMIT"))
-                try:
-                    await conn.execute(text(f"CREATE DATABASE {database_name}"))
-                # await conn.commit()
-                except Exception as e:
-                    _ = e
-                    pass
-                finally:
-                    await conn.execute(text("COMMIT"))
-            if self.schema:
-                async with sqla_engine.begin() as conn:
-                    await conn.execute(
-                        text(f"CREATE SCHEMA IF NOT EXISTS {self.schema}")
-                    )
-                    await conn.commit()
-
-    def setup_db(self):
-        from anyio.from_thread import start_blocking_portal
-
-        with start_blocking_portal() as portal:
-            portal.call(self._setup_db)
-
-
-def setup_data_store(
-    type: str,
-    engine_or_uri: str,
-    schema: str | None = "flowerpower",
-    username: str | None = None,
-    password: str | None = None,
-    ssl: bool = False,
-    **kwargs,
-) -> tuple:
-
-    # ds = DataStore(
-    #    type=type,
-    #    engine_or_uri=engine_or_uri,
-    #    schema=schema,
-    #    username=username,
-    #    password=password,
-    #    ssl=ssl,
-    #    **kwargs,
-    # )
-    # ds.setup_db()
-    ds2 = DataStore(
-        type=type,
-        engine_or_uri=engine_or_uri,
-        schema=schema,
-        username=username,
-        password=password,
-        ssl=ssl,
-        **kwargs,
-    )
-    ds2.setup()
-    return ds2.get()

flowerpower/utils/eventbroker.py

@@ -1,127 +0,0 @@
-from sqlalchemy.engine import Engine
-
-ALL_EVENT_BROKERS = [
-    "sqlalchemy",
-    "asyncpg",
-    "psycopg2",
-    "postgresql",
-    "mqtt",
-    "redis",
-    "local",
-    "memory",
-]
-
-
-class EventBroker:
-    def __init__(
-        self,
-        type: str | None = None,
-        uri: str | None = None,
-        sqla_engine: Engine | None = None,
-        host: str | None = None,
-        port: int = 0,
-        username: str | None = None,
-        password: str | None = None,
-    ):
-        self.type = type or "memory"
-        self.uri = uri
-        self.host = host
-        self.port = port
-        self.username = username
-        self.password = password
-        self._sqla_engine = sqla_engine
-
-        if self.type not in ALL_EVENT_BROKERS:
-            raise ValueError(
-                f"Invalid event broker type: {type}. Valid event broker types are: {ALL_EVENT_BROKERS}"
-            )
-        if type in ["sqlalchemy", "asyncpg", "psycopg3", "postgresql"] and not (
-            sqla_engine or uri
-        ):
-            raise ValueError(
-                f"Event broker type `{type} requires an `sqla_engine` or `uri`"
-            )
-        if type == "mqtt" and not ((host and port) or uri):
-            raise ValueError(
-                "Event broker type `mqtt` requires a `host` and `port` or `uri`"
-            )
-        if type == "redis" and not (uri or (host and port)):
-            raise ValueError(
-                "Event broker type `redis` requires a `uri` or `host` and `port`"
-            )
-
-    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):
-        from apscheduler.eventbrokers.mqtt import MQTTEventBroker
-
-        if self.uri is not None:
-            if ":" in self.uri:
-                self.host, self.port = self.uri.split(":")
-                self.port = int(self.port)
-            else:
-                self.host = self.uri
-
-        self._event_broker = MQTTEventBroker(
-            self.host, self.port, topic="flowerpower/scheduler"
-        )
-        if (self.username is not None) and (self.password is not None):
-            self._event_broker._client.username_pw_set(
-                self.username,
-                self.password,
-            )
-
-    def _setup_redis_event_broker(self):
-        from apscheduler.eventbrokers.redis import RedisEventBroker
-
-        if self.uri is None:
-            self.uri = f"redis://{self.host}:{self.port}"
-        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.type in ["sqlalchemy", "asyncpg", "psycopg3", "postgresql"]:
-            self._setup_asyncpg_event_broker()
-        elif self.type == "mqtt":
-            self._setup_mqtt_event_broker()
-        elif self.type == "redis":
-            self._setup_redis_event_broker()
-        else:
-            self._setup_local_event_broker()
-
-    def get(self):
-        return self._event_broker
-
-
-def setup_event_broker(
-    type: str,
-    uri: str | None = None,
-    sqla_engine: Engine | None = None,
-    host: str | None = None,
-    port: int = 0,
-    username: str | None = None,
-    password: str | None = None,
-):
-    eb = EventBroker(
-        type=type,
-        uri=uri,
-        sqla_engine=sqla_engine,
-        host=host,
-        port=port,
-        username=username,
-        password=password,
-    )
-    eb.setup()
-    return eb.get()

flowerpower/utils/executor.py

@@ -1,58 +0,0 @@
-import importlib
-import importlib.util
-
-from hamilton.execution import executors
-from loguru import logger
-
-if importlib.util.find_spec("distributed"):
-    from dask import distributed
-else:
-    distributed = None
-
-
-if importlib.util.find_spec("ray"):
-    import ray
-else:
-    ray = None
-
-
-def get_executor(mode: str, max_tasks: int = 10, num_cpus: int = 4):
-    shutdown = None
-
-    if mode == "processpool" or mode == "process" or mode == "multiprocessing":
-        remote_executor = executors.MultiProcessingExecutor(max_tasks=max_tasks)
-    elif mode == "threadpool" or mode == "future_adapter" or mode == "threading":
-        remote_executor = executors.MultiThreadingExecutor(max_tasks=max_tasks)
-    elif mode == "dask":
-        if distributed:
-            from hamilton.plugins import h_dask
-
-            cluster = distributed.LocalCluster()
-            client = distributed.Client(cluster)
-            remote_executor = h_dask.DaskExecutor(client=client)
-            shutdown = cluster.close
-        else:
-            logger.info(
-                "Dask is not installed. If you want to use Dask for distributed execution, install it using via:"
-                "`pip install dask`"
-                "'conda install dask'"
-                "`pip install flowerpower[dask]`"
-            )
-            remote_executor = None  # executors.SynchronousLocalTaskExecutor()
-    elif mode == "ray":
-        if ray:
-            from hamilton.plugins import h_ray
-
-            remote_executor = h_ray.RayTaskExecutor(num_cpus=num_cpus)
-            shutdown = ray.shutdown
-        else:
-            logger.info(
-                "Ray is not installed. If you want to use Ray for distributed execution, install it using via:"
-                "`pip install ray`"
-                "'conda install ray'"
-                "`pip install flowerpower[ray]`"
-            )
-            remote_executor = None  # executors.SynchronousLocalTaskExecutor()
-    else:
-        remote_executor = None  # executors.SynchronousLocalTaskExecutor()
-    return remote_executor, shutdown

flowerpower/utils/trigger.py

@@ -1,140 +0,0 @@
-import datetime as dt
-
-# from tzlocal import get_localzone
-
-ALL_TRIGGER_TYPES = [
-    "cron",
-    "interval",
-    "calendarinterval",
-    "date",
-]
-ALL_TRIGGER_KWARGS = {
-    "cron": [
-        "crontab",
-        "year",
-        "month",
-        "week",
-        "day",
-        "day_of_week",
-        "hour",
-        "minute",
-        "second",
-        "start_time",
-        "end_time",
-        "timezone",
-    ],
-    "interval": [
-        "weeks",
-        "days",
-        "hours",
-        "minutes",
-        "seconds",
-        "microseconds",
-        "start_time",
-        "end_time",
-    ],
-    "calendarinterval": [
-        "years",
-        "months",
-        "weeks",
-        "days",
-        "hour",
-        "minute",
-        "second",
-        "start_date",
-        "end_date",
-        "timezone",
-    ],
-    "date": [
-        "run_time",
-    ],
-}
-
-
-class Trigger:
-    def __init__(
-        self,
-        type_: str,
-    ):
-        if type_ not in ALL_TRIGGER_TYPES:
-            raise ValueError(
-                f"Invalid trigger type: {type_}. Valid trigger types are: {ALL_TRIGGER_TYPES}"
-            )
-        self.trigger_type = type_
-
-    def _check_kwargs(self, **kwargs):
-        for k, v in kwargs.items():
-            if k not in ALL_TRIGGER_KWARGS[self.trigger_type]:
-                raise ValueError(
-                    f"Invalid argument: {k}. Valid arguments are: {ALL_TRIGGER_KWARGS[self.trigger_type]}"
-                )
-
-    def _filter_kwargs(self, **kwargs):
-        return {
-            k: v
-            for k, v in kwargs.items()
-            if k in ALL_TRIGGER_KWARGS[self.trigger_type] and v is not None
-        }
-
-    def get(self, **kwargs):
-        #
-        kwargs = self._filter_kwargs(**kwargs)
-        self._check_kwargs(**kwargs)
-
-        if self.trigger_type == "cron":
-            return self._get_cron_trigger(**kwargs)
-        elif self.trigger_type == "interval":
-            return self._get_interval_trigger(**kwargs)
-        elif self.trigger_type == "calendarinterval":
-            return self._get_calendar_trigger(**kwargs)
-        elif self.trigger_type == "date":
-            return self._get_date_trigger(**kwargs)
-
-    def _get_cron_trigger(
-        self,
-        **kwargs,
-    ):
-        from apscheduler.triggers.cron import CronTrigger
-
-        crontab = kwargs.pop("crontab", None)
-        print(crontab)
-
-        if crontab is not None:
-            return CronTrigger.from_crontab(crontab)  # , kwargs)
-        else:
-            return CronTrigger(
-                **kwargs,
-            )
-
-    def _get_interval_trigger(
-        self,
-        **kwargs,
-    ):
-        from apscheduler.triggers.interval import IntervalTrigger
-
-        return IntervalTrigger(
-            **kwargs,
-        )
-
-    def _get_calendar_trigger(
-        self,
-        **kwargs,
-    ):
-        from apscheduler.triggers.calendarinterval import \
-            CalendarIntervalTrigger
-
-        return CalendarIntervalTrigger(
-            **kwargs,
-        )
-
-    def _get_date_trigger(self, **kwargs):
-        from apscheduler.triggers.date import DateTrigger
-
-        if "run_time" not in kwargs:
-            kwargs["run_time"] = dt.datetime.now()
-        return DateTrigger(**kwargs)
-
-
-def get_trigger(type_: str, **kwargs):
-    trigger = Trigger(type_)
-    return trigger.get(**kwargs)