dppd 0.27__tar.gz → 0.30__tar.gz

{dppd-0.27 → dppd-0.30}/LICENSE.txt

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2018 Florian Finkernagel
+Copyright (c) 2025 Florian Finkernagel
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

{dppd-0.27/src/dppd.egg-info → dppd-0.30}/PKG-INFO

@@ -1,20 +1,28 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: dppd
-Version: 0.27
+Version: 0.30
 Summary: A pythonic dplyr clone
-Home-page: https://github.com/TyberiusPrime/dppd
-Author: Florian Finkernagel
-Author-email: finkernagel@imt.uni-marburg.de
-License: mit
-Platform: any
-Classifier: Development Status :: 4 - Beta
-Classifier: Programming Language :: Python
-Requires-Python: >=3.6
+Author-email: Florian Finkernagel <finkernagel@imt.uni-marburg.de>
+License-Expression: MIT
+Project-URL: Documentation, https://dppd.readthedocs.io/en/latest/
+Project-URL: Repository, https://github.com/TyberiusPrime/dppd
+Requires-Python: >=3.9
 Description-Content-Type: text/markdown
-Provides-Extra: testing
-Provides-Extra: doc
 License-File: LICENSE.txt
 License-File: AUTHORS.rst
+Requires-Dist: natsort
+Requires-Dist: numpy
+Requires-Dist: pandas>=2
+Requires-Dist: wrapt
+Provides-Extra: dev
+Requires-Dist: build; extra == "dev"
+Requires-Dist: numpydoc; extra == "dev"
+Requires-Dist: plotnine; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Requires-Dist: sphinx; extra == "dev"
+Requires-Dist: sphinx-bootstrap-theme; extra == "dev"
+Dynamic: license-file
 
 # dppd
 

dppd-0.30/pyproject.toml

@@ -0,0 +1,57 @@
+[project]
+name = "dppd"
+version = "0.30"
+description = "A pythonic dplyr clone"
+readme = "README.md"
+requires-python = ">=3.9"
+authors = [
+	{name = "Florian Finkernagel", email = "finkernagel@imt.uni-marburg.de"}
+]
+license="MIT"
+dependencies = [
+    "natsort",
+    "numpy",
+	"pandas>=2",
+    "wrapt",
+]
+
+[project.urls]
+Documentation = "https://dppd.readthedocs.io/en/latest/"
+Repository = "https://github.com/TyberiusPrime/dppd"
+
+[build-system]
+requires = ["setuptools >= 61.0"]
+build-backend = "setuptools.build_meta"
+
+[project.optional-dependencies]
+	dev = [
+	"build",
+    "numpydoc",
+	"plotnine",
+    "pytest",
+    "pytest-cov",
+    "sphinx",
+    "sphinx-bootstrap-theme",
+]
+
+[tool.pytest.ini_options]
+# Options for py.test:
+# Specify command line options as you would do when invoking py.test directly.
+# e.g. --cov-report html (or xml) for html/xml output or --junitxml junit.xml
+# in order to write a coverage file that can be read by Jenkins.
+addopts = """
+    --cov dppd --cov-report term-missing
+    --verbose
+"""
+norecursedirs = [
+    "dist",
+    "build",
+    ".tox",
+]
+testpaths = "tests"
+filterwarnings = [
+    "ignore:::statsmodels.base.wrapper:100",
+    "ignore:::patsy.constraint:13",
+    "ignore:::matplotlib.backends.backend_wx:",
+]
+

dppd-0.30/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

{dppd-0.27 → dppd-0.30}/src/dppd/__init__.py

@@ -4,6 +4,6 @@ from .base import dppd, register_verb, register_type_methods_as_verbs
 from . import single_verbs  # noqa:F401
 from . import non_df_verbs  # noqa:F401
 
-__version__ = "0.27"
+__version__ = "0.30"
 
 __all_ = [dppd, register_verb, register_type_methods_as_verbs, __version__]

{dppd-0.27 → dppd-0.30}/src/dppd/single_verbs.py

@@ -23,14 +23,20 @@ register_type_methods_as_verbs(SeriesGroupBy, [])
 
 
 def group_variables(grp):
-    return grp.grouper.names
+    if hasattr(grp, "_grouper"):
+        return grp._grouper.names
+    else:
+        return grp.grouper.names
 
 
 def group_extract_params(grp):
-    if grp.axis != 0:
+    if hasattr(grp, "axis") and grp.axis != 0:
         raise ValueError(f"Verbs assume that groupby is on axis=0, was {grp.axis}")
     res = {"by": group_variables(grp)}
-    for k in ["squeeze", "axis", "level", "as_index", "sort", "group_keys", "observed"]:
+    attrs = ["squeeze", "level", "as_index", "sort", "group_keys", "observed"]
+    if pd.__version__ < "2.1.":
+        attrs.append("axis")
+    for k in attrs:
         if hasattr(grp, k):
             res[k] = getattr(grp, k)
         else:  # pragma: no cover
@@ -56,7 +62,10 @@ def _print(obj):
 @register_verb(name="debug", types=None)
 def _debug(obj, k=5):
     d = obj.iloc[np.r_[0:k, -k:0]]
-    print(d)
+    try:
+        display(d)  # noqa: F821 - Jupyter only, needs to import.
+    except NameError:
+        print(d)
     return obj
 
 
@@ -354,9 +363,12 @@ def mutate_DataFrameGroupBy(grp, **kwargs):
                 try:
                     r = v[group_key]
                 except KeyError:
-                    raise KeyError(
-                        f"Grouped mutate results did not contain data for {group_key}"
-                    )
+                    try:
+                        r = v[group_key,]
+                    except KeyError:
+                        raise KeyError(
+                            f"Grouped mutate results did not contain data for {group_key}. Keys where {v.keys()}"
+                        )
                 r = pd.Series(r, index=sub_index)
                 parts.append(r)
             parts = pd.concat(parts)
@@ -451,7 +463,10 @@ def filter_by(obj, filter_arg):
         for idx, sub_df in df.groupby(groups):
             # if not idx in filter_arg and not isinstance(tuple(idx)):
             # idx = (idx,)
-            keep = filter_arg[idx]
+            try:
+                keep = filter_arg[idx]
+            except KeyError:
+                keep = filter_arg[idx[0]]
             parts.append(sub_df[keep])
         result = pd.concat(parts, axis=0)
     elif isinstance(filter_arg, str):
@@ -543,7 +558,7 @@ def summarize(obj, *args):
         result = result[groups + [x for x in result.columns if x not in groups]]
         # restore category to categories
         for g in groups:
-            if pd.api.types.is_categorical_dtype(df[g]):
+            if isinstance(df.dtypes[g], pd.CategoricalDtype):
                 result = result.assign(
                     **{
                         g: pd.Categorical(
@@ -603,7 +618,7 @@ def do(obj, func, *args, **kwargs):
         result = result[groups + [x for x in result.columns if x not in groups]]
         # restore category to categories
         for g in groups:
-            if pd.api.types.is_categorical_dtype(df[g]):
+            if isinstance(df.dtypes[g], pd.CategoricalDtype):
                 result = result.assign(
                     **{
                         g: pd.Categorical(
@@ -767,7 +782,10 @@ def seperate(df, column, new_names, sep=".", remove=False):
 
 @register_verb("print", types=DataFrameGroupBy)
 def print_DataFrameGroupBy(grps):
-    print("groups: %s" % (grps.grouper.names))
+    if hasattr(grps, "_grouper"):
+        print("groups: %s" % (grps._grouper.names))
+    else:
+        print("groups: %s" % (grps.grouper.names))
     print(grps._selected_obj)
     return grps
 
@@ -809,7 +827,7 @@ def arrange_DataFrameGroupBy(grp, column_spec, kind="quicksort", na_position="la
     columns = grp_params["by"].copy()
     ascending = [True] * len(columns)
     columns += [x[0] for x in cols_plus_inversed]
-    ascending += [~x[1] for x in cols_plus_inversed]
+    ascending += [not x[1] for x in cols_plus_inversed]
     df_out = df.sort_values(
         columns, ascending=ascending, kind=kind, na_position=na_position
     )
@@ -951,7 +969,9 @@ def norm_0_to_1(df, axis=1, keep_nan=False):
         a1 = 0
         a2 = 1
     df_normed = df.sub(df.min(axis=a1), axis=a2)
-    df_normed = df.div(df_normed.max(axis=a1), axis=a2)
+    assert df_normed.min().min() == 0.0
+    df_normed = df_normed.div(df_normed.max(axis=a1), axis=a2)
+    assert df_normed.max().max() == 1.0
     if not keep_nan:
         df_normed = df_normed[~pd.isnull(df_normed).any(axis=1)]
     return df_normed
@@ -1004,7 +1024,7 @@ def pca_dataframe(df, whiten=False, random_state=None, n_components=2):
     df_fit = pd.DataFrame(p.fit_transform(df))
     cols = ["1st", "2nd"]
     if n_components > 2:
-        cols.append('3rd')
+        cols.append("3rd")
     for ii in range(3, n_components):
         cols.append(f"{ii+1}th")
     df_fit.columns = cols

{dppd-0.27 → dppd-0.30/src/dppd.egg-info}/PKG-INFO

@@ -1,20 +1,28 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: dppd
-Version: 0.27
+Version: 0.30
 Summary: A pythonic dplyr clone
-Home-page: https://github.com/TyberiusPrime/dppd
-Author: Florian Finkernagel
-Author-email: finkernagel@imt.uni-marburg.de
-License: mit
-Platform: any
-Classifier: Development Status :: 4 - Beta
-Classifier: Programming Language :: Python
-Requires-Python: >=3.6
+Author-email: Florian Finkernagel <finkernagel@imt.uni-marburg.de>
+License-Expression: MIT
+Project-URL: Documentation, https://dppd.readthedocs.io/en/latest/
+Project-URL: Repository, https://github.com/TyberiusPrime/dppd
+Requires-Python: >=3.9
 Description-Content-Type: text/markdown
-Provides-Extra: testing
-Provides-Extra: doc
 License-File: LICENSE.txt
 License-File: AUTHORS.rst
+Requires-Dist: natsort
+Requires-Dist: numpy
+Requires-Dist: pandas>=2
+Requires-Dist: wrapt
+Provides-Extra: dev
+Requires-Dist: build; extra == "dev"
+Requires-Dist: numpydoc; extra == "dev"
+Requires-Dist: plotnine; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Requires-Dist: sphinx; extra == "dev"
+Requires-Dist: sphinx-bootstrap-theme; extra == "dev"
+Dynamic: license-file
 
 # dppd
 

{dppd-0.27 → dppd-0.30}/src/dppd.egg-info/SOURCES.txt

@@ -1,8 +1,7 @@
 AUTHORS.rst
 LICENSE.txt
 README.md
-setup.cfg
-setup.py
+pyproject.toml
 src/dppd/__init__.py
 src/dppd/base.py
 src/dppd/column_spec.py
@@ -11,6 +10,10 @@ src/dppd/single_verbs.py
 src/dppd.egg-info/PKG-INFO
 src/dppd.egg-info/SOURCES.txt
 src/dppd.egg-info/dependency_links.txt
-src/dppd.egg-info/not-zip-safe
 src/dppd.egg-info/requires.txt
-src/dppd.egg-info/top_level.txt
+src/dppd.egg-info/top_level.txt
+tests/test_base.py
+tests/test_pandas_forwards.py
+tests/test_reshaping.py
+tests/test_select.py
+tests/test_single_verbs.py

{dppd-0.27 → dppd-0.30}/src/dppd.egg-info/requires.txt

@@ -1,17 +1,13 @@
-pandas>=0.22
-numpy
 natsort
+numpy
+pandas>=2
 wrapt
 
-[doc]
-sphinx
-sphinx-bootstrap-theme
+[dev]
+build
 numpydoc
-pandas
-
-[testing]
+plotnine
 pytest
 pytest-cov
-plotnine
-pandas<2.0
-flake8
+sphinx
+sphinx-bootstrap-theme

dppd-0.30/tests/test_base.py

@@ -0,0 +1,352 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+import pytest
+from dppd import dppd, register_verb
+from dppd.base import register_property
+import pandas as pd
+import numpy as np
+import pandas.testing
+import wrapt
+from plotnine.data import mtcars, diamonds
+
+
+__author__ = "Florian Finkernagel"
+__copyright__ = "Florian Finkernagel"
+__license__ = "mit"
+
+assert_series_equal = pandas.testing.assert_series_equal
+assert_frame_equal = pandas.testing.assert_frame_equal
+
+dp, X = dppd()
+
+
+def test_noop():
+    df = pd.DataFrame({"a": list(range(10))})
+    actual = dp(df)
+    actual = actual.pd
+    assert isinstance(actual, pd.DataFrame)
+    should = df
+    assert_frame_equal(should, actual)
+
+
+def test_non_df_result():
+    import dppd.base
+
+    df = pd.DataFrame({"a": list(range(10))})
+    shape = dp(df).head(5).shape
+    assert not isinstance(shape, dppd.base.DPPDAwareProxy)
+    assert shape == (5, 1)
+    real_pd = shape.pd
+    assert isinstance(real_pd, tuple)
+
+
+def test_nested_dp_pd_calls():
+    df = pd.DataFrame({"a": list(range(10))})
+    actual = dp(df).head(5).concat(dp(df).tail(4).pd).pd
+    should = pd.concat([df.head(5), df.tail(4)], axis=0)
+    assert_frame_equal(should, actual)
+
+
+def test_dp_pd_calls_nested_in_function_calls():
+    df = pd.DataFrame(
+        {"a": list(range(10)), "bb": list(range(10)), "ccc": list(range(10))}
+    ).set_index("a")
+
+    def shu():
+        return dp(df).head(1).pd
+
+    def sha():
+        return dp(df).tail(1).pd
+
+    should = pd.concat([df.head(1), df.tail(1), df.head(1)])
+    actual = dp(shu()).concat(sha()).concat(shu()).pd
+    assert_frame_equal(should, actual)
+
+
+def test_redefining_verb_vars():
+    def noop(df):
+        return df
+
+    register_verb("test_redefining_verb_vars_noop")(noop)
+    with pytest.warns(UserWarning):
+        register_verb("test_redefining_verb_vars_noop")(noop)
+
+
+def test_property_shadowed():
+    with pytest.warns(UserWarning):
+        register_property("select", pd.DataFrame)
+
+
+def test_property_list_of_types():
+    import dppd.base
+
+    class A:
+        pass
+
+    class B:
+        pass
+
+    register_property("test_property_list_of_types", [A, B])
+    assert "test_property_list_of_types" in dppd.base.property_registry[A]
+
+
+def test_verb_shadows_property():
+    def noop(df):
+        return df
+
+    register_property("test_verb_shadows_property_noop")
+
+    with pytest.warns(UserWarning):
+        register_verb("test_verb_shadows_property_noop")(noop)
+
+
+def test_register_verb_raises_on_non_identifier():
+    with pytest.raises(TypeError):
+        register_verb(name="Hello world")(lambda x: x)
+
+
+def test_register_verb_aliases():
+    import dppd.base
+
+    def shu():
+        pass
+
+    register_verb(["test_register_verb_aliases", "test_register_verb_aliases2"])(shu)
+    assert ("test_register_verb_aliases", None) in dppd.base.verb_registry
+    assert ("test_register_verb_aliases2", None) in dppd.base.verb_registry
+    assert (
+        dppd.base.verb_registry[("test_register_verb_aliases", None)]
+        is dppd.base.verb_registry[("test_register_verb_aliases2", None)]
+    )
+
+
+def test_verb_returning_non_df():
+    df = pd.DataFrame({"a": [str(x) for x in (range(10))]})
+    register_verb("da_length")(lambda df: len(df))
+    assert 10 == dp(df).da_length()
+
+
+def test_no_context_manager_non_df_returning_verbs():
+    df = pd.DataFrame({"a": [str(x) for x in (range(10))]})
+    dp(df)
+    dp().head(1)
+    assert len(X) == 1
+    assert X.shape == (1, 1)
+    actual = dp().pd
+    assert actual.shape == (1, 1)
+    assert actual.__len__() == 1
+
+
+def test_no_attribute_no_verb_raises_attribute_error():
+    df = pd.DataFrame({"a": [str(x) for x in (range(10))]})
+    with pytest.raises(AttributeError):
+        dp(df).shu()
+
+
+def test_no_attribute_no_verb_raises_attribute_error_context_manager():
+    df = pd.DataFrame({"a": [str(x) for x in (range(10))]})
+    with pytest.raises(AttributeError):
+        with dppd(df) as (dp, X):
+            dp.shu()
+
+
+def test_dp_on_empty_stack_raises():
+    dp, X = dppd()
+    with pytest.raises(ValueError):
+        dp()
+
+
+def test_dp_continuation():
+    df = pd.DataFrame(
+        {"a": [str(x) for x in (range(10))], "bb": 10, "ccc": list(range(20, 30))}
+    ).set_index("a")
+    dp(df).head(5)
+    dp().tail(1)
+    actual = dp().pd
+    should = df.iloc[4:5]
+    assert_frame_equal(should, actual)
+
+
+def test_context_manager():
+    df = pd.DataFrame(
+        {"a": [str(x) for x in (range(10))], "bb": 10, "ccc": list(range(20, 30))}
+    ).set_index("a")
+    with dppd(df) as (d, X):
+        d.head(5)
+        d.tail(1)
+    should = df.iloc[4:5]
+    assert_frame_equal(X, should)
+
+
+def test_context_manager_with_non_df_args():
+    df = pd.DataFrame(
+        {"a": [str(x) for x in (range(10))], "bb": 10, "ccc": list(range(20, 30))}
+    ).set_index("a")
+    with dppd(df) as (d, X):
+        d.head(5)
+        assert d.shape == (5, 2)
+        d.tail(1)
+    should = df.iloc[4:5]
+    assert_frame_equal(X, should)
+
+
+def test_context_manager_totally_to_pandas():
+    df = pd.DataFrame(
+        {"a": [str(x) for x in (range(10))], "bb": 10, "ccc": list(range(20, 30))}
+    ).set_index("a")
+    with dppd(df) as (d, X):
+        d.head(5)
+        assert d.shape == (5, 2)
+        d.tail(1)
+    should = df.iloc[4:5]
+    assert_frame_equal(X, should)
+    assert isinstance(X, wrapt.ObjectProxy)
+    X = X.pd
+    assert not isinstance(X, wrapt.ObjectProxy)
+    assert_frame_equal(X, should)
+
+
+def test_interleaved_context_managers():
+    with dppd(mtcars) as (dpX, X):
+        with dppd(diamonds) as (dpY, Y):
+            dpX.groupby("cyl")
+            dpY.filter_by(Y.cut == "Ideal")
+            dpX.summarize(("hp", np.mean, "mean_hp"))
+            dpY.summarize(("price", np.max, "max_price"))
+    should_X = (
+        mtcars.groupby("cyl")[["hp"]].agg("mean").rename(columns={"hp": "mean_hp"})
+    ).reset_index()
+    should_Y = (
+        pd.DataFrame(diamonds[diamonds.cut == "Ideal"].max()[["price"]])
+        .transpose()
+        .rename(columns={"price": "max_price"})
+    )
+    should_Y["max_price"] = should_Y["max_price"].astype(int)
+    assert_frame_equal(X, should_X)
+    assert_frame_equal(Y, should_Y)
+
+
+def test_context_manager_chain():
+    with dppd(mtcars) as (dp, X):
+        dp.mutate(kw=X.hp * 0.7457)
+    with dppd(X) as (dp, X):
+        dp.mutate(watt=X.kw * 1000)
+    assert "watt" in X.columns
+
+
+def test_mixing_context_manager_and_dp():
+    with dppd(mtcars) as (dpY, Y):
+        dpY.sort_values("hp")
+        dp(diamonds).filter_by(X.cut == "ideal")
+        dpY.filter_by(Y.cyl.isin([4, 6]))
+        actual_diamonds = dp().sort_values("price").head().pd
+        actual_mtcars_full = dpY.pd
+        dpY.head()
+    actual_mtcars = dpY.pd
+    should_diamonds = diamonds[diamonds.cut == "ideal"].sort_values("price").head()
+    should_mtcars = mtcars.sort_values("hp")
+    should_mtcars_full = should_mtcars[should_mtcars["cyl"].isin([4, 6])]
+    should_mtcars = should_mtcars_full.head()
+    assert_frame_equal(should_diamonds, actual_diamonds)
+    assert_frame_equal(should_mtcars, actual_mtcars)
+    assert_frame_equal(should_mtcars_full, actual_mtcars_full)
+
+
+def test_dppd_raises_on_non_dataframe():
+    with pytest.raises(ValueError):
+        dp(5)
+
+
+def test_straight_dp_raises():
+    dp, X = dppd()
+    with pytest.raises(ValueError):
+        dp.select(["hp", "cyl"])
+
+    with pytest.raises(ValueError):
+        dp.loc[5]
+
+
+def test_stacking():
+    dp, X = dppd()
+    dp(mtcars).select(["name", "hp", "cyl"])
+    b = dp(mtcars).select("hp").pd
+    assert_frame_equal(b, mtcars[["hp"]])
+    assert_frame_equal(X, mtcars[["name", "hp", "cyl"]])
+    c = dp.pd
+    assert_frame_equal(c, mtcars[["name", "hp", "cyl"]])
+    assert X == None  # noqa:E711 since it's the proxy, is will fail
+
+
+def test_forking():
+    dp, X = dppd()
+    a = dp(mtcars).select(["name", "hp", "cyl"])
+    b = dp.unselect("hp").select(X.name).head().pd
+    with pytest.raises(AttributeError):
+        c = a.select(X.hp).head().pd
+    c = dp(a).select(X.hp).head().pd
+    assert_series_equal(c["hp"], mtcars["hp"].head())
+    assert_series_equal(b["name"], mtcars["name"].head())
+    assert X == None  # noqa:E711 since it's the proxy, is will fail
+
+
+def test_forking_context_manager():
+    with dppd(mtcars) as (dp, X):
+        a = dp.select(["name", "hp", "cyl"])
+        b = dp.select("name").head().pd
+        c = a.select("hp").head().pd
+        dp.head()
+    assert_series_equal(c["hp"], mtcars["hp"].head())
+    assert_series_equal(b["name"], mtcars["name"].head())
+    assert_frame_equal(X, mtcars[["hp"]].head())
+
+
+def test_dp_on_dp():
+    import wrapt
+
+    a = dp(mtcars)
+    b = dp(a)
+    assert not isinstance(a.df, wrapt.ObjectProxy)
+    assert not isinstance(b.df, wrapt.ObjectProxy)
+
+
+def test_descend_on_None_raises():
+    with pytest.raises(ValueError):
+        dp(mtcars)._descend(None)
+
+
+def test_series_methods():
+    actual = dp(mtcars).sum().to_frame().pd
+    should = mtcars.sum().to_frame()
+    assert_frame_equal(should, actual)
+
+
+def test_group_on_series_raises():
+    with pytest.raises(KeyError):
+        dp(mtcars).sum().groupby("no_such_columns")
+
+
+def test_dir():
+    from dppd import base
+
+    dp, X = dppd()
+    actual = set(dir(dp(mtcars)))
+    should_min = set(base.property_registry[pd.DataFrame])
+    delta = should_min.difference(actual)
+    print(sorted(actual))
+    print(sorted(delta))
+    assert not len(delta)
+    assert len(actual) > len(should_min)
+
+
+def test_version_is_correct():
+    from pathlib import Path
+    try:
+        import tomllib
+        import dppd as org_dppd
+
+        c = tomllib.load(open(Path(__file__).parent.parent / "pyproject.toml", "rb"))
+        version = c["project"]["version"]
+        assert version == org_dppd.__version__
+    except ImportError:
+        pass # python < 3.11