boti-data 1.0.2__tar.gz → 1.0.6__tar.gz

{boti_data-1.0.2 → boti_data-1.0.6}/PKG-INFO

@@ -1,8 +1,9 @@
 Metadata-Version: 2.4
 Name: boti-data
-Version: 1.0.2
+Version: 1.0.6
 Summary: Data infrastructure for the Boti ecosystem
-Author-email: Luis Valverde <lvalverdeb@gmail.com>
+Author: Luis Valverde
+Maintainer-email: Luis Valverde <lvalverdeb@gmail.com>
 License-Expression: MIT
 Project-URL: Homepage, https://github.com/lvalverdeb/boti-data
 Project-URL: Repository, https://github.com/lvalverdeb/boti-data
@@ -11,12 +12,10 @@ Project-URL: Issues, https://github.com/lvalverdeb/boti-data/issues
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Requires-Python: >=3.10
+Requires-Python: >=3.13
 Description-Content-Type: text/markdown
 Requires-Dist: asyncmy<0.3.0,>=0.2.11
 Requires-Dist: boti<2.0.0,>=1.0.2

{boti_data-1.0.2 → boti_data-1.0.6}/pyproject.toml

@@ -1,21 +1,22 @@
 [project]
 name = "boti-data"
-version = "1.0.2"
+version = "1.0.6"
 description = "Data infrastructure for the Boti ecosystem"
 readme = "README.md"
-requires-python = ">=3.10"
+requires-python = ">=3.13"
 license = "MIT"
 authors = [
+    {name = "Luis Valverde"}
+]
+maintainers = [
     {name = "Luis Valverde", email = "lvalverdeb@gmail.com"}
 ]
 classifiers = [
     "Development Status :: 3 - Alpha",
     "Intended Audience :: Developers",
     "Programming Language :: Python :: 3",
-    "Programming Language :: Python :: 3.10",
-    "Programming Language :: Python :: 3.11",
-    "Programming Language :: Python :: 3.12",
     "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3 :: Only",
     "Topic :: Software Development :: Libraries :: Python Modules",
 ]
 dependencies = [
@@ -51,7 +52,7 @@ dev = [
 
 [tool.ruff]
 line-length = 100
-target-version = "py310"
+target-version = "py313"
 
 [tool.ruff.lint]
 select = ["E", "F", "W", "I", "UP"]
@@ -75,10 +76,6 @@ filterwarnings = [
     'ignore:Closing managed Dask session with 1 live persisted collection\(s\).*Missing dependency\.:RuntimeWarning',
 ]
 
-[tool.uv.sources]
-boti = { workspace = true }
-boti-dask = { workspace = true }
-
 [tool.setuptools]
 include-package-data = true
 

{boti_data-1.0.2 → boti_data-1.0.6}/src/boti_data/datacube/artifact.py

@@ -84,13 +84,17 @@ class BaseArtifact(PicklableLifecycleCoreMixin, LifecycleCore):
 
         merged = {**self.config, **kwargs}
         self._helper: DataHelper = DataHelper(merged)
-        self.logger = Logger.default_logger(logger_name=self.__class__.__name__)
+        self.logger = kwargs.get("logger") or Logger.default_logger(
+            logger_name=self.__class__.__name__
+        )
 
         self.parquet_start_date: str | None = _validate_and_format_date(
-            "parquet_start_date", merged.get("parquet_start_date"),
+            "parquet_start_date",
+            merged.get("parquet_start_date"),
         )
         self.parquet_end_date: str | None = _validate_and_format_date(
-            "parquet_end_date", merged.get("parquet_end_date"),
+            "parquet_end_date",
+            merged.get("parquet_end_date"),
         )
         self.data_wrapper_class: type[Any] | None = merged.get("data_wrapper_class")
         self.class_params: dict[str, Any] = merged.get("class_params") or {
@@ -106,14 +110,16 @@ class BaseArtifact(PicklableLifecycleCoreMixin, LifecycleCore):
         instance.df = None
         instance._helper = helper
         instance.config = {**cls.config, **overrides}
-        instance.logger = Logger.default_logger(logger_name=cls.__name__)
+        instance.logger = overrides.get("logger") or Logger.default_logger(logger_name=cls.__name__)
 
         merged = {**cls.config, **overrides}
         instance.parquet_start_date = _validate_and_format_date(
-            "parquet_start_date", merged.get("parquet_start_date"),
+            "parquet_start_date",
+            merged.get("parquet_start_date"),
         )
         instance.parquet_end_date = _validate_and_format_date(
-            "parquet_end_date", merged.get("parquet_end_date"),
+            "parquet_end_date",
+            merged.get("parquet_end_date"),
         )
         instance.data_wrapper_class = merged.get("data_wrapper_class")
         instance.class_params = merged.get("class_params") or {

{boti_data-1.0.2 → boti_data-1.0.6}/src/boti_data/datacube/base.py

@@ -60,7 +60,9 @@ class BaseDataCube(PicklableLifecycleCoreMixin, LifecycleCore):
 
         merged = {**self.config, **kwargs}
         self._helper: DataHelper = DataHelper(merged)
-        self.logger = Logger.default_logger(logger_name=self.__class__.__name__)
+        self.logger = kwargs.get("logger") or Logger.default_logger(
+            logger_name=self.__class__.__name__
+        )
         super().__init__()
 
     @classmethod
@@ -70,7 +72,7 @@ class BaseDataCube(PicklableLifecycleCoreMixin, LifecycleCore):
         instance.df = None
         instance._helper = helper
         instance.config = {**cls.config, **overrides}
-        instance.logger = Logger.default_logger(logger_name=cls.__name__)
+        instance.logger = overrides.get("logger") or Logger.default_logger(logger_name=cls.__name__)
         # __new__() bypasses __init__(), so LifecycleCore's state (_state_lock,
         # _is_closed, the GC finalizer, etc.) must be wired up explicitly here.
         LifecycleCore.__init__(instance)
@@ -111,9 +113,7 @@ class BaseDataCube(PicklableLifecycleCoreMixin, LifecycleCore):
         return self.__class__.fix_data is not BaseDataCube.fix_data
 
     def _log_no_data(self) -> None:
-        self.logger.debug(
-            "No data was found by %s loader", self.__class__.__name__
-        )
+        self.logger.debug("No data was found by %s loader", self.__class__.__name__)
 
     # ── public API ──────────────────────────────────────────────────────
 

{boti_data-1.0.2 → boti_data-1.0.6}/src/boti_data/db/sql_engine.py

@@ -34,12 +34,24 @@ def _parse_connection_url(
     normalized_url = _normalize_connection_url(connection_url)
     parsed = sqlalchemy_url.make_url(normalized_url)
     try:
-        parsed.get_dialect()
+        dialect_cls = parsed.get_dialect()
     except NoSuchModuleError as exc:
         raise SQLAlchemyError(
             f"{consumer_name} received unsupported SQLAlchemy dialect '{parsed.drivername}'. "
             "Check the driver name in the connection URL."
         ) from exc
+    # get_dialect() only resolves the SQLAlchemy dialect class; the DBAPI driver
+    # package itself (e.g. psycopg2, pymysql) is imported lazily and would
+    # otherwise only fail deep inside create_engine()/first connect().
+    try:
+        dialect_cls.import_dbapi()
+    except (ModuleNotFoundError, ImportError) as exc:
+        raise SQLAlchemyError(
+            f"{consumer_name} connection_url uses dialect '{parsed.drivername}' but its DBAPI "
+            f"driver package is not installed ({exc}). Install the driver package for this "
+            "dialect (e.g. 'psycopg2-binary' for 'postgresql+psycopg2', 'pymysql' for "
+            "'mysql+pymysql') before constructing this resource."
+        ) from exc
     return parsed
 
 

{boti_data-1.0.2 → boti_data-1.0.6}/src/boti_data/gateway/_backend_strategies.py

@@ -116,8 +116,7 @@ _FALLBACK_DTYPE_BYTES: int = 16
 def _estimate_bytes_per_row(meta_dtypes: dict[str, str]) -> int:
     """Estimate the in-memory footprint of one result row from its column dtypes."""
     total = sum(
-        _DTYPE_BYTE_WEIGHTS.get(dtype, _FALLBACK_DTYPE_BYTES)
-        for dtype in meta_dtypes.values()
+        _DTYPE_BYTE_WEIGHTS.get(dtype, _FALLBACK_DTYPE_BYTES) for dtype in meta_dtypes.values()
     )
     return max(1, total)
 
@@ -388,7 +387,12 @@ class SqlAlchemyStrategy(BackendStrategy):
         cfg = dict(cfg)
         raw_url = cfg.pop("connection_url", None)
         if raw_url is None:
-            raise ValueError("from_config requires 'connection_url'.")
+            raise ValueError(
+                "from_config requires 'connection_url' for the 'sqlalchemy' backend "
+                "(the default used when no 'backend' key is present in config). "
+                "If you intended a different backend, pass an explicit 'backend' key "
+                "(e.g. 'parquet', 'datacube')."
+            )
         connection_url = SecretStr(raw_url) if isinstance(raw_url, str) else raw_url
         return SqlDatabaseConfig(connection_url=connection_url, **cfg)
 
@@ -620,7 +624,8 @@ class SqlAlchemyStrategy(BackendStrategy):
                 t_coerce = perf_counter()
                 if len(df) <= single_fetch_ceiling:
                     df = SqlPartitionExecutor.align_and_coerce_partition(
-                        df, meta_dtypes,
+                        df,
+                        meta_dtypes,
                     )
                     t_dask = perf_counter()
                     result = dd.from_pandas(df, npartitions=1)
@@ -808,10 +813,7 @@ class SqlAlchemyStrategy(BackendStrategy):
         )
         t1 = perf_counter()
         if diagnostics:
-            resource.logger.info(
-                "Configured async select "
-                f"reflect_select={t1 - t0:.3f}s"
-            )
+            resource.logger.info(f"Configured async select reflect_select={t1 - t0:.3f}s")
         if ctx.execution_mode == "lazy":
             t2 = perf_counter()
             partitioned_options = build_partitioned_load_options(
@@ -826,10 +828,7 @@ class SqlAlchemyStrategy(BackendStrategy):
             request = build_sql_partitioned_request(options_dict)
             t3 = perf_counter()
             if diagnostics:
-                resource.logger.info(
-                    "Build partitioned request "
-                    f"elapsed={t3 - t2:.3f}s"
-                )
+                resource.logger.info(f"Build partitioned request elapsed={t3 - t2:.3f}s")
             return await self._run_async_partitioned_request(ctx, resource, request)
 
         df = await read_sql_async(

{boti_data-1.0.2 → boti_data-1.0.6}/src/boti_data/gateway/core.py

@@ -139,7 +139,9 @@ class DataGateway(PicklableLifecycleCoreMixin, LifecycleCore):
         self._return_type: ReturnType = self._df_params.return_type
         self._execution_mode: ExecutionMode = self._df_params.execution_mode
         self._configured_select_cache: OrderedDict[tuple[str, ...], tuple[Any, Any]] = OrderedDict()
-        self._configured_async_select_cache: OrderedDict[tuple[str, ...], tuple[Any, Any]] = OrderedDict()
+        self._configured_async_select_cache: OrderedDict[tuple[str, ...], tuple[Any, Any]] = (
+            OrderedDict()
+        )
         self._raw_sql_policy = raw_sql_policy
         self._policies = policies or GatewayPolicies()
         self._strict_filter_validation = strict_filter_validation
@@ -225,7 +227,6 @@ class DataGateway(PicklableLifecycleCoreMixin, LifecycleCore):
         """
         return self._logger
 
-
     def _load_planner(self) -> LoadPlanner:
         return LoadPlanner(
             configured=self._configured,
@@ -354,7 +355,12 @@ class DataGateway(PicklableLifecycleCoreMixin, LifecycleCore):
         provided.
         """
         cfg = dict(config)
-        cfg.update(overrides)
+        # Wrapper classes (e.g. ParquetReader -> DataHelper) always forward
+        # fs=None/fs_factory=None when the caller didn't explicitly pass them,
+        # rather than omitting the keys. A blind cfg.update(overrides) would let
+        # that incidental None clobber a real fs embedded directly in the config
+        # mapping, so only non-None overrides are allowed to win.
+        cfg.update({key: value for key, value in overrides.items() if value is not None})
 
         backend, common = _factory.extract_config_common_options(cfg)
         strategy = get_strategy(backend)
@@ -389,7 +395,9 @@ class DataGateway(PicklableLifecycleCoreMixin, LifecycleCore):
     # Load API — structured mode
     # ------------------------------------------------------------------
 
-    def preview(self, statement: Any, model: Any, n: int = 5, npartitions: int = 1, **options: Any) -> pd.DataFrame:
+    def preview(
+        self, statement: Any, model: Any, n: int = 5, npartitions: int = 1, **options: Any
+    ) -> pd.DataFrame:
         """Load a preview (first *n* rows) as a pandas DataFrame.
 
         Leverages lazy loading + ``safe_head`` so a distributed client is used
@@ -404,7 +412,9 @@ class DataGateway(PicklableLifecycleCoreMixin, LifecycleCore):
         )
         return safe_head(frame, n=n, npartitions=npartitions)
 
-    async def apreview(self, statement: Any, model: Any, n: int = 5, npartitions: int = 1, **options: Any) -> pd.DataFrame:
+    async def apreview(
+        self, statement: Any, model: Any, n: int = 5, npartitions: int = 1, **options: Any
+    ) -> pd.DataFrame:
         """Async version of :meth:`preview`."""
         frame = await self.aload(
             statement=statement,
@@ -436,7 +446,6 @@ class DataGateway(PicklableLifecycleCoreMixin, LifecycleCore):
                         f"Allowed fields: {sorted(self._allowed_filter_fields)}"
                     )
 
-
     @staticmethod
     def _perform_load_kwargs(*, request: GatewayLoadRequest | None, plan: Any) -> dict[str, Any]:
         """Shared kwargs for _perform_load_sync/_perform_load_async, derived
@@ -648,9 +657,7 @@ class DataGateway(PicklableLifecycleCoreMixin, LifecycleCore):
 
         # Resolve any Series values before chunked dispatch so the chunker
         # sees plain lists (which it already knows how to split).
-        loader_options = await _series_filters.resolve_series_filters_async(
-            loader_options
-        )
+        loader_options = await _series_filters.resolve_series_filters_async(loader_options)
         in_chunk_size, in_chunk_concurrency = self._resolve_in_chunk_controls_for_plan(
             loader_options, plan
         )
@@ -874,7 +881,3 @@ class DataGateway(PicklableLifecycleCoreMixin, LifecycleCore):
             )
         kwargs[f"{on}__in"] = join_series
         return await self.aload(**kwargs)
-
-
-
-

{boti_data-1.0.2 → boti_data-1.0.6}/src/boti_data/gateway/loaders.py

@@ -27,7 +27,9 @@ from .requests import (
 )
 
 
-def _prepare_sql_statement(request: SqlLoadRequest, *, logger: Any, debug: bool) -> tuple[Any, dict[str, Any] | None]:
+def _prepare_sql_statement(
+    request: SqlLoadRequest, *, logger: Any, debug: bool
+) -> tuple[Any, dict[str, Any] | None]:
     if request.statement is not None:
         statement = request.statement
         if request.columns:
@@ -61,9 +63,7 @@ def _arrow_table_from_sql_result(
     if statement is None:
         if not rows:
             return pa.table({name: [] for name in columns})
-        return pa.Table.from_pylist(
-            [dict(zip(columns, row)) for row in rows]
-        )
+        return pa.Table.from_pylist([dict(zip(columns, row)) for row in rows])
 
     sql_types = [getattr(selected, "type", None) for selected in statement.selected_columns]
     schema = build_arrow_schema_from_sqlalchemy_types(columns, sql_types)
@@ -106,9 +106,7 @@ def build_sql_partitioned_request(options: dict[str, Any]) -> SqlPartitionedLoad
     # Discard any extra fields that SqlPartitionedLoadRequest does not accept
     # (e.g. dry_run, resilient — control keys passed through from the gateway).
     partitioned_options = {
-        k: v
-        for k, v in partitioned_options.items()
-        if k in SqlPartitionedLoadRequest.model_fields
+        k: v for k, v in partitioned_options.items() if k in SqlPartitionedLoadRequest.model_fields
     }
     partitioned_options.setdefault("as_pandas", False)
     partitioned_options.setdefault("partitioned", True)
@@ -164,8 +162,11 @@ def load_sql_partitioned(
     resource: SqlDatabaseResource,
     request: SqlPartitionedLoadRequest,
 ):
-    loader = SqlPartitionedLoader(config, resource=resource, use_arrow=request.use_arrow)
-    return loader.load_request(request)
+    # resource is caller-owned (SqlPartitionedLoader._owns_resource is False here),
+    # so closing the loader only releases its own planner/executor state and does
+    # not touch resource — safe to close deterministically instead of relying on GC.
+    with SqlPartitionedLoader(config, resource=resource, use_arrow=request.use_arrow) as loader:
+        return loader.load_request(request)
 
 
 async def read_sql_async(

{boti_data-1.0.2 → boti_data-1.0.6}/src/boti_data/parquet/resource.py

@@ -495,9 +495,9 @@ class ParquetDataResource(SecureResource):
         if modified_at is None:
             return False
 
-        now = dt.datetime.now(dt.timezone.utc)
+        now = dt.datetime.now(dt.UTC)
         if modified_at.tzinfo is None:
-            modified_at = modified_at.replace(tzinfo=dt.timezone.utc)
+            modified_at = modified_at.replace(tzinfo=dt.UTC)
         return (now - modified_at) <= dt.timedelta(minutes=self.config.parquet_max_age_minutes)
 
     def scan_summary(self, *, max_files: int) -> tuple[int | None, int | None]:
@@ -562,7 +562,7 @@ class ParquetDataResource(SecureResource):
         if isinstance(modified, dt.datetime):
             return modified
         if isinstance(modified, (int, float)):
-            return dt.datetime.fromtimestamp(modified, tz=dt.timezone.utc)
+            return dt.datetime.fromtimestamp(modified, tz=dt.UTC)
         if isinstance(modified, str):
             try:
                 return dt.datetime.fromisoformat(modified)

{boti_data-1.0.2 → boti_data-1.0.6}/src/boti_data/pipelines/base.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import inspect
 from collections.abc import Mapping, Sequence
 from dataclasses import dataclass
-from typing import Any, Protocol, TypeAlias, Union, cast
+from typing import Any, Protocol, Union, cast
 
 from boti.core.lifecycle import LifecycleCore
 from boti.core.lifecycle_pickle import PicklableLifecycleCoreMixin
@@ -24,8 +24,8 @@ from boti_data.watermark import (
     advance_watermark,
 )
 
-PipelineSource: TypeAlias = Union[DataHelper, HybridDataset]
-PipelineDestination: TypeAlias = ParquetDestination
+type PipelineSource = Union[DataHelper, HybridDataset]
+type PipelineDestination = ParquetDestination
 
 
 class FrameEnricher(Protocol):

{boti_data-1.0.2 → boti_data-1.0.6}/src/boti_data/pipelines/sinks.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import asyncio
 from collections.abc import Callable, Mapping, Sequence
 from dataclasses import dataclass
-from typing import Any, Protocol, TypeAlias, Union, cast
+from typing import Any, Protocol, Union, cast
 from urllib.parse import urlparse
 
 import dask.dataframe as dd
@@ -19,8 +19,8 @@ from pydantic import Field, field_validator
 
 from boti_data.parquet import ParquetDataConfig, ParquetReader
 
-FrameResult: TypeAlias = Union[pd.DataFrame, dd.DataFrame, pa.Table, pl.DataFrame]
-ParquetDestination: TypeAlias = Union[ParquetReader, ParquetDataConfig, Mapping[str, Any]]
+type FrameResult = Union[pd.DataFrame, dd.DataFrame, pa.Table, pl.DataFrame]
+type ParquetDestination = Union[ParquetReader, ParquetDataConfig, Mapping[str, Any]]
 
 
 def to_dask_frame(frame: FrameResult) -> dd.DataFrame:
@@ -57,9 +57,21 @@ def prepare_partitioned_frame(
                 f"{sink_name} expected date_field={date_field!r} in loaded frame columns "
                 f"but only found {list(frame.columns)!r}."
             )
+        pre_assign_dtypes = frame.dtypes
         frame = frame.assign(
             partition_date=dd.to_datetime(frame[date_field], errors="coerce").dt.date.astype(str)
         )
+        # dask-expr's query optimizer can re-derive _meta for the whole frame when
+        # .assign() adds a column, silently dropping explicit per-column dtype hints
+        # (e.g. bool cast via map_partitions upstream) in favor of generic `object`.
+        # Restore any dtype that changed as an unintended side effect of the assign.
+        changed_dtypes = {
+            column: dtype
+            for column, dtype in pre_assign_dtypes.items()
+            if column in frame.columns and frame.dtypes[column] != dtype
+        }
+        if changed_dtypes:
+            frame = frame.astype(changed_dtypes)
         missing = [name for name in partition_columns if name not in frame.columns]
 
     if missing:
@@ -217,6 +229,13 @@ class CsvSink(SecureResource):
         overwrite: bool = True,
         persist: bool = False,
     ) -> SinkWriteResult:
+        """Write *frame* to the configured CSV destination.
+
+        ``overwrite=True`` replaces the *entire* target directory (all
+        partitions/dates), not just the partition(s) present in *frame* — see
+        :func:`_write_with_staging`. For incremental per-date writes, do not
+        rely on ``overwrite=True`` to mean "overwrite this date only".
+        """
         ddf = to_dask_frame(frame)
         ddf = prepare_partitioned_frame(
             ddf,
@@ -381,6 +400,13 @@ class JsonlSink(SecureResource):
         overwrite: bool = True,
         persist: bool = False,
     ) -> SinkWriteResult:
+        """Write *frame* to the configured JSONL destination.
+
+        ``overwrite=True`` replaces the *entire* target directory (all
+        partitions/dates), not just the partition(s) present in *frame* — see
+        :func:`_write_with_staging`. For incremental per-date writes, do not
+        rely on ``overwrite=True`` to mean "overwrite this date only".
+        """
         ddf = to_dask_frame(frame)
         ddf = prepare_partitioned_frame(
             ddf,
@@ -558,6 +584,13 @@ class ParquetSink(PicklableLifecycleCoreMixin, LifecycleCore):
         overwrite: bool = True,
         persist: bool = False,
     ) -> SinkWriteResult:
+        """Write *frame* to the configured parquet destination.
+
+        ``overwrite=True`` replaces the *entire* target directory (all
+        partitions/dates), not just the partition(s) present in *frame* — see
+        :func:`_write_with_staging`. For incremental per-date writes, do not
+        rely on ``overwrite=True`` to mean "overwrite this date only".
+        """
         ddf = to_dask_frame(frame)
         ddf = prepare_partitioned_frame(
             ddf,

{boti_data-1.0.2 → boti_data-1.0.6}/src/boti_data.egg-info/PKG-INFO

@@ -1,8 +1,9 @@
 Metadata-Version: 2.4
 Name: boti-data
-Version: 1.0.2
+Version: 1.0.6
 Summary: Data infrastructure for the Boti ecosystem
-Author-email: Luis Valverde <lvalverdeb@gmail.com>
+Author: Luis Valverde
+Maintainer-email: Luis Valverde <lvalverdeb@gmail.com>
 License-Expression: MIT
 Project-URL: Homepage, https://github.com/lvalverdeb/boti-data
 Project-URL: Repository, https://github.com/lvalverdeb/boti-data
@@ -11,12 +12,10 @@ Project-URL: Issues, https://github.com/lvalverdeb/boti-data/issues
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Requires-Python: >=3.10
+Requires-Python: >=3.13
 Description-Content-Type: text/markdown
 Requires-Dist: asyncmy<0.3.0,>=0.2.11
 Requires-Dist: boti<2.0.0,>=1.0.2