datazip 0.2.0__py3-none-any.whl

datazip/__init__.py

@@ -0,0 +1,17 @@
+"""Datazip."""
+
+import logging
+
+# Create a root logger for use anywhere within the package.
+logger = logging.getLogger("datazip")
+
+try:
+    from datazip._version import version as __version__
+except ImportError:
+    logger.warning("Version unknown because package is not installed.")
+    __version__ = "unknown"
+
+from datazip.core import DataZip  # noqa: E402
+from datazip.mixin import IOMixin  # noqa: E402
+
+__all__ = ["DataZip", "IOMixin", "__version__"]

datazip/_optional.py

@@ -0,0 +1,142 @@
+"""Dummy modules and classes when optional packages are not installed.
+
+Could do something more like this:
+https://github.com/pola-rs/polars/blob/master/py-polars/polars/dependencies.py
+"""
+
+try:
+    import sqlalchemy
+except (ModuleNotFoundError, ImportError):
+
+    class sqlalchemy:  # noqa: N801
+        """Dummy for :mod:`sqlalchemy` when not installed."""
+
+        class engine:  # noqa: N801
+            """Dummy for :mod:`sqlalchemy.engine` when not installed."""
+
+            class Engine:
+                """Dummy for :mod:`sqlalchemy.engine.Engine` when not installed."""
+
+                pass
+
+        @staticmethod
+        def create_engine(*args, **kwargs):
+            """Dummy for :func:`sqlalchemy.create_engine` when not installed."""
+            pass
+
+
+try:
+    import plotly
+except (ModuleNotFoundError, ImportError):
+
+    class plotly:  # noqa: N801
+        """Dummy for :mod:`plotly` when not installed."""
+
+        class graph_objects:  # noqa: N801
+            """Dummy for :mod:`plotly.graph_objects` when not installed."""
+
+            class Figure:
+                """Dummy for :mod:`plotly.graph_objects.Figure` when not installed."""
+
+                pass
+
+
+try:
+    import numpy
+
+except (ModuleNotFoundError, ImportError):
+
+    class numpy:  # noqa: N801
+        """Dummy for :mod:`numpy` when not installed."""
+
+        class ndarray:  # noqa: N801
+            """Dummy for :mod:`numpy.ndarray` when not installed."""
+
+            pass
+
+        class int64:  # noqa: N801
+            """Dummy for :mod:`numpy.int64` when not installed."""
+
+            pass
+
+        class float64:  # noqa: N801
+            """Dummy for :mod:`numpy.float64` when not installed."""
+
+            pass
+
+        def load(*args, **kwargs):
+            """Dummy for :func:`numpy.load` when not installed."""
+            pass
+
+        def save(*args, **kwargs):
+            """Dummy for :func:`numpy.save` when not installed."""
+            pass
+
+
+try:
+    import pandas
+
+    if pandas.__version__ < "2.0.0":
+        raise ImportError("pandas < 2.0.0")
+
+except (ModuleNotFoundError, ImportError):
+
+    class pandas:  # noqa: N801
+        """Dummy for when pandas is not installed."""
+
+        class DataFrame:
+            """Dummy for when pandas is not installed."""
+
+            def to_parquet(*args, **kwargs):
+                """Dummy for when pandas is not installed."""
+                pass
+
+        class Series:
+            """Dummy for when pandas is not installed."""
+
+            def to_frame(*args, **kwargs):
+                """Dummy for when pandas is not installed."""
+                pass
+
+        class Timestamp:
+            """Dummy for when pandas is not installed."""
+
+            pass
+
+        def read_parquet(*args, **kwargs):
+            """Dummy for when pandas is not installed."""
+            pass
+
+
+try:
+    import polars
+
+except (ModuleNotFoundError, ImportError):
+
+    class polars:  # noqa: N801
+        """Dummy for when polars is not installed."""
+
+        class DataFrame:
+            """Dummy for when polars is not installed."""
+
+            def write_parquet(*args, **kwargs):
+                """Dummy for when polars is not installed."""
+                pass
+
+        class LazyFrame:
+            """Dummy for when polars is not installed."""
+
+            def collect(*args, **kwargs):
+                """Dummy for when polars is not installed."""
+                pass
+
+        class Series:
+            """Dummy for when polars is not installed."""
+
+            def to_frame(*args, **kwargs):
+                """Dummy for when polars is not installed."""
+                pass
+
+        def read_parquet(*args, **kwargs):
+            """Dummy for when polars is not installed."""
+            pass

datazip/_test_classes.py

@@ -0,0 +1,186 @@
+"""Mocks and other objects for testing [`DataZip`][datazip.core.DataZip]."""
+
+from __future__ import annotations
+
+from typing import NamedTuple
+
+import pandas as pd
+
+
+class ObjMeta(NamedTuple):
+    """NamedTuple for testing."""
+
+    module: str
+    qualname: str
+    constructor: str | None = None
+
+
+def _eq_func(self, other):
+    if not isinstance(other, self.__class__):
+        return False
+
+    def _comp(v0, v1):
+        if isinstance(v0, dict):
+            for v01, v11 in zip(v0.values(), v1.values()):  # noqa: B905
+                return _comp(v01, v11)
+        if isinstance(v0, list | tuple):
+            for v01, v11 in zip(v0, v1):  # noqa: B905
+                return _comp(v01, v11)
+        if isinstance(v0, pd.DataFrame | pd.Series):
+            return v0.compare(v1).empty
+        return bool(v0 == v1)
+
+    r = []
+
+    if hasattr(self, "__dict__"):
+        for v0, v1 in zip(  # noqa: B905
+            self.__dict__.values(), other.__dict__.values()
+        ):
+            r.append(_comp(v0, v1))
+
+    if hasattr(self, "__slots__"):
+        for k in self.__slots__:
+            if hasattr(self, k) and hasattr(other, k):
+                v0, v1 = getattr(self, k), getattr(other, k)
+                r.append(_comp(v0, v1))
+            if hasattr(self, k) and not hasattr(other, k):
+                r.append(False)
+
+    return all(r)
+
+
+class _TestKlassSlotsCore:
+    """Test class with slots w/o get/set."""
+
+    __slots__ = ("_dfs", "foo", "lis", "tup")
+
+    def __init__(self, **kwargs):
+        """Init."""
+        for k, v in kwargs.items():
+            setattr(self, k, v)
+
+    def __repr__(self):
+        attrs = ", ".join(
+            f"{k}={getattr(self, k)}" for k in self.__slots__ if hasattr(self, k)
+        )
+        return self.__class__.__qualname__ + f"({attrs})"
+
+    def __eq__(self, other):
+        return _eq_func(self, other)
+
+
+class _KlassSlots(_TestKlassSlotsCore):
+    """Generic class with slots and get/set."""
+
+    __slots__ = ("_dfs", "exclude", "foo", "lis", "tup")
+
+    def __init__(self, **kwargs):
+        """Init."""
+        super().__init__(**kwargs)
+        if "exclude" not in kwargs:
+            self.exclude = ()
+
+    def __setstate__(self, state):
+        _, state = state
+        for k, v in state.items():
+            if k in self.__slots__:
+                setattr(self, k, v)
+
+    def __getstate__(self):
+        return None, {k: getattr(self, k) for k in self.__slots__}
+
+
+class _KlassSlotsDzstate(_KlassSlots):
+    """Generic class with slots and get/set."""
+
+    __slots__ = ("_dfs", "exclude", "foo", "lis", "tup")
+
+    def _dzsetstate_(self, state):
+        _, state = state
+        for k in state["exclude"]:
+            state[k] = 5
+        for k, v in state.items():
+            if k in self.__slots__:
+                setattr(self, k, v)
+
+    def _dzgetstate_(self):
+        return None, {
+            k: getattr(self, k) for k in self.__slots__ if k not in self.exclude
+        }
+
+
+class _TestKlassSlotsDict:
+    """Test class with slots and __dict__ w/o get/set."""
+
+    __slots__ = (
+        "__dict__",
+        "foo",
+    )
+
+    def __init__(self, **kwargs):
+        """Init."""
+        for k, v in kwargs.items():
+            setattr(self, k, v)
+
+    def add_to_dict(self, k, v):
+        setattr(self, k, v)
+        return self
+
+    def __eq__(self, other):
+        return _eq_func(self, other)
+
+    def __repr__(self):
+        attrs = ", ".join(
+            f"{k}={getattr(self, k)}" for k in self.__slots__ if hasattr(self, k)
+        )
+        return self.__class__.__qualname__ + f"({attrs})"
+
+
+class _TestKlassCore:
+    """Generic class w/o slots w/o get/set."""
+
+    def __init__(self, **kwargs):
+        """Init."""
+        for k, v in kwargs.items():
+            setattr(self, k, v)
+
+    def __repr__(self):
+        return (
+            self.__class__.__qualname__
+            + f"({', '.join(f'{k}={v}' for k, v in self.__dict__.items())})"
+        )
+
+    def __eq__(self, other):
+        return _eq_func(self, other)
+
+
+class _TestKlass(_TestKlassCore):
+    """Generic class w/o slots with get/set."""
+
+    def __init__(self, **kwargs):
+        """Init."""
+        super().__init__(**kwargs)
+
+    def __setstate__(self, state):
+        self.__dict__ = state
+
+    def __getstate__(self):
+        return self.__dict__
+
+
+class _TestKlassDzstate(_TestKlass):
+    """Generic class w/o slots with get/set."""
+
+    def __init__(self, **kwargs):
+        """Init."""
+        super().__init__(**kwargs)
+        if "exclude" not in kwargs:
+            self.exclude = ()
+
+    def _dzsetstate_(self, state):
+        for k in state["exclude"]:
+            state[k] = 5
+        self.__dict__ = state
+
+    def _dzgetstate_(self):
+        return {k: v for k, v in self.__dict__.items() if k not in self.exclude}

datazip/_utils.py

@@ -0,0 +1,87 @@
+from __future__ import annotations
+
+import getpass
+import logging
+from contextlib import suppress
+from importlib import import_module
+from typing import Any
+
+LOGGER = logging.getLogger("datazip")
+
+
+def _quote_strip(string: str) -> str:
+    return string.replace("'", "").replace('"', "")
+
+
+def _get_version(obj: Any) -> str:
+    mod = import_module(obj.__class__.__module__.partition(".")[0])
+    for v_attr in ("__version__", "version", "release"):
+        if hasattr(mod, v_attr):
+            return getattr(mod, v_attr)
+    return "unknown"
+
+
+def _get_username():
+    try:
+        return getpass.getuser()
+    except (ModuleNotFoundError, OSError) as exc0:
+        import os
+
+        try:
+            return os.getlogin()
+        except Exception as exc1:
+            LOGGER.error("No username %r from %r", exc1, exc0)
+            return "unknown"
+
+
+def _objinfo(obj: Any) -> str:
+    return obj.__class__.__module__ + "|" + obj.__class__.__qualname__
+
+
+def _get_klass(mod_klass: str | list | tuple):
+
+    if isinstance(mod_klass, str):
+        mod_klass = mod_klass.split("|")
+    try:
+        mod, qname, *_ = mod_klass
+        klass: type = getattr(import_module(mod), qname)
+    except (AttributeError, ModuleNotFoundError) as exc:
+        raise ImportError(f"Unable to import {qname} from {mod}.") from exc
+    else:
+        return klass
+
+
+def default_setstate(obj, state):
+    """Called if no `__setstate__` implementation."""
+    if state is None:
+        pass
+    elif isinstance(state, dict):
+        obj.__dict__ = state
+    elif isinstance(state, tuple):
+        d_state, s_state = state
+        if d_state is not None:
+            obj.__dict__ = d_state
+        for k, v in s_state.items():
+            setattr(obj, k, v)
+
+
+def default_getstate(obj):
+    """Called if no `__getstate__` implementation."""
+
+    def slots_dict(_slots):
+        sout = {}
+        for k in _slots:
+            if k != "__dict__":
+                with suppress(AttributeError):
+                    sout.update({k: getattr(obj, k)})
+        return sout
+
+    match obj:
+        case object(__dict__=d_state, __slots__=slots):
+            return d_state.copy(), slots_dict(slots)
+        case object(__dict__=d_state):
+            return d_state.copy()
+        case object(__slots__=slots):
+            return None, slots_dict(slots)
+        case _:
+            return None

datazip/_version.py

@@ -0,0 +1,24 @@
+# file generated by vcs-versioning
+# don't change, don't track in version control
+from __future__ import annotations
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+version: str
+__version__: str
+__version_tuple__: tuple[int | str, ...]
+version_tuple: tuple[int | str, ...]
+commit_id: str | None
+__commit_id__: str | None
+
+__version__ = version = '0.2.0'
+__version_tuple__ = version_tuple = (0, 2, 0)
+
+__commit_id__ = commit_id = None