datedict 0.1.1__tar.gz → 0.1.3__tar.gz

{datedict-0.1.1 → datedict-0.1.3}/.gitlab-ci.yml

@@ -13,6 +13,18 @@ build:
     paths: [dist/]
     expire_in: 1 hour
 
+test_pkg:
+  stage: test-release
+  image: python:3.11-bookworm
+  needs: 
+    - job: build
+      artifacts: true
+  script:
+    - python -m pip install -U pip
+    - pip install pytest
+    - pip install dist/*.whl || pip install dist/*.tar.gz
+    - pytest -q
+
 # Publish to TestPyPI on any tag vX.Y.Z
 publish_testpypi:
   stage: test-release
@@ -20,6 +32,7 @@ publish_testpypi:
   needs: 
     - job: build
       artifacts: true
+    - job: test_pkg
   rules:
     - if: '$CI_COMMIT_TAG =~ /^v\d+\.\d+\.\d+$/'
   id_tokens:
@@ -39,6 +52,7 @@ publish_pypi:
     - job: build
       artifacts: true
     - job: publish_testpypi
+    - job: test_pkg
   rules:
     - if: '$CI_COMMIT_TAG =~ /^v\d+\.\d+\.\d+$/'
   id_tokens:

{datedict-0.1.1 → datedict-0.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: datedict
-Version: 0.1.1
+Version: 0.1.3
 Summary: DateDict and YearDict: date-aware dictionary structures
 Project-URL: Homepage, https://github.com/you/datedict
 Project-URL: Issues, https://github.com/you/datedict/issues

{datedict-0.1.1 → datedict-0.1.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "datedict"
-version = "0.1.1"
+version = "0.1.3"
 description = "DateDict and YearDict: date-aware dictionary structures"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -27,3 +27,12 @@ packages = ["src/datedict"]
 
 [tool.hatch.build]
 exclude = ["tests", ".github", ".gitignore"]
+
+[tool.pytest.ini_options]
+addopts = "-q --strict-markers --maxfail=1"
+testpaths = ["tests"]
+pythonpath = ["src"]
+
+[tool.coverage.run]
+source = ["datedict"]
+branch = true

datedict-0.1.3/pytest.ini

@@ -0,0 +1,4 @@
+[pytest]
+addopts = -q --strict-markers --maxfail=1
+testpaths = tests
+pythonpath = src

datedict-0.1.3/src/datedict/DateDict.py

@@ -0,0 +1,214 @@
+from datetime import date, timedelta
+from decimal import Decimal
+from typing import Mapping
+
+from .common import NAN, ONE, Decimable, to_decimal, ZERO
+
+
+class DateDict:
+    def __init__(self, data: Mapping[str, Decimable], strict: bool = True):
+        if not data:
+            raise ValueError("Data cannot be empty.")
+        dates = sorted(data.keys())
+        if strict:
+            # enforce contiguous coverage
+            if dates != [
+                (date.fromisoformat(dates[0]) + timedelta(days=i)).strftime("%Y-%m-%d")
+                for i in range(
+                    (date.fromisoformat(dates[-1]) - date.fromisoformat(dates[0])).days
+                    + 1
+                )
+            ]:
+                raise ValueError(
+                    "Data must cover all dates in the contiguous range. "
+                    "To disable this check, set strict=False."
+                )
+        self.start_date, self.end_date = dates[0], dates[-1]
+        self.data: dict[str, Decimal] = {k: to_decimal(v) for k, v in data.items()}
+
+    def fill(self, start_date, end_date, value: Decimable) -> "DateDict":
+        """
+        Create a new graph with a specified range and value.
+        The range is defined by start_date and end_date.
+        """
+        v = to_decimal(value)
+        return DateDict(
+            {
+                (date.fromisoformat(start_date) + timedelta(days=i)).strftime(
+                    "%Y-%m-%d"
+                ): v
+                for i in range(
+                    (date.fromisoformat(end_date) - date.fromisoformat(start_date)).days
+                    + 1
+                )
+            }
+        )
+
+    def get(self, key: str, default: Decimal = NAN) -> Decimal:
+        """
+        Get the value for a specific date. If the date does not exist, return the default value.
+        The date should be in the format yyyy-mm-dd.
+        If the value is None, return the default value.
+        """
+        temp = self.data.get(key, NAN)
+        if temp.is_nan():
+            return default
+        return temp
+
+    def __getitem__(self, key) -> Decimal:
+        return self.data[key]
+
+    def __setitem__(self, key: str, value) -> None:
+        self.data[key] = to_decimal(value)
+
+    def crop(
+        self,
+        start: str | None = None,
+        end: str | None = None,
+        initial_value: Decimable = NAN,
+    ) -> "DateDict":
+        """
+        Crop the graph data to a specific range defined by start and end.
+        If any of the parameters is None, it will not filter by that parameter.
+        """
+        if start is None and end is None:
+            return self
+        return DateDict(
+            {
+                k: (self.get(k, to_decimal(initial_value)))
+                for k in map(
+                    lambda x: x.strftime("%Y-%m-%d"),
+                    [
+                        (
+                            date.fromisoformat(self.start_date)
+                            if start is None
+                            else date.fromisoformat(start)
+                        )
+                        + timedelta(days=i)
+                        for i in range(
+                            (
+                                (
+                                    date.fromisoformat(self.end_date)
+                                    if end is None
+                                    else date.fromisoformat(end)
+                                )
+                                - (
+                                    date.fromisoformat(self.start_date)
+                                    if start is None
+                                    else date.fromisoformat(start)
+                                )
+                            ).days
+                            + 1
+                        )
+                    ],
+                )
+            }
+        )
+
+    def non_negative(self) -> "DateDict":
+        """
+        Return a new DateDict with all negative values set to zero.
+        """
+        return DateDict({k: (v if (not v.is_nan() and v >= ZERO) else ZERO) for k, v in self.data.items()})
+
+    def sum(
+        self: "DateDict", start: str | None = None, end: str | None = None
+    ) -> Decimal:
+        """
+        Return the sum of values in the specified range.
+        If a value is NaN, it is treated as zero.
+        """
+        s = self.start_date if start is None else start
+        e = self.end_date if end is None else end
+        return sum(
+            [
+                (self.get(k, ZERO))
+                for k in map(
+                    lambda x: x.strftime("%Y-%m-%d"),
+                    [
+                        date.fromisoformat(s) + timedelta(days=i)
+                        for i in range(
+                            (date.fromisoformat(e) - date.fromisoformat(s)).days + 1
+                        )
+                    ],
+                )
+            ],
+            ZERO,
+        )
+
+    def __mul__(self, other: "Decimable | DateDict") -> "DateDict":
+        if isinstance(other, Decimable):
+            return DateDict({k: v * to_decimal(other) for k, v in self.data.items()})
+        elif isinstance(other, DateDict):
+            return DateDict({k: v * other.get(k, ONE) for k, v in self.data.items()})
+
+    def __rmul__(self, other: "Decimable | DateDict") -> "DateDict":
+        return self.__mul__(other)
+
+    def __neg__(self) -> "DateDict":
+        return self * Decimal("-1")
+
+    def __add__(self, other: "Decimable | DateDict") -> "DateDict":
+        if isinstance(other, Decimable):
+            return DateDict({k: (v + to_decimal(other)) for k, v in self.data.items()})
+        else:
+            return DateDict({k: v + other.get(k, ZERO) for k, v in self.data.items()})
+
+    def __radd__(self, other: "Decimable | DateDict") -> "DateDict":
+        return self.__add__(other)
+
+    def __sub__(self, other: "Decimable | DateDict") -> "DateDict":
+        if isinstance(other, Decimable):
+            return self.__add__(-to_decimal(other))
+        else:
+            return self.__add__(-other)
+
+    def __rsub__(self, other: "Decimable | DateDict") -> "DateDict":
+        return (-self).__add__(other)
+
+    def __truediv__(self, other: "Decimable | DateDict") -> "DateDict":
+        if isinstance(other, Decimable):
+            return DateDict({k: v / to_decimal(other) for k, v in self.data.items()})
+        else:
+            return DateDict({k: v / other.get(k, ONE) for k, v in self.data.items()})
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, DateDict):
+            return False
+        for k in set(self.data.keys()).union(other.data.keys()):
+            s = self.get(k)
+            o = other.get(k)
+            if s.is_nan() and o.is_nan():
+                continue
+            if s != o:
+                return False
+        return True
+
+    def __str__(self) -> str:
+        return "\n".join(f"{k}: {v}" for k, v in sorted(self.data.items()))
+
+    def __repr__(self) -> str:
+        return f"{self.data!r}"
+
+    def to_array(self) -> list[Decimal]:
+        """
+        Convert the DateDict values to a list of Decimals, ordered by date.
+        """
+        return [self.data[k] for k in sorted(self.data.keys())]
+
+    def to_dict(self) -> dict[str, Decimal]:
+        """
+        Convert the DateDict to a standard dictionary.
+        """
+        return dict(self.data)
+
+
+    def average(self) -> Decimal:
+        """
+        Calculate the average of all values in the DateDict.
+        If there are no valid values, return ZERO.
+        """
+        valid_values = [v for v in self.data.values() if not v.is_nan()]
+        if not valid_values:
+            return ZERO
+        return Decimal(sum(valid_values)) / len(valid_values)

datedict-0.1.3/src/datedict/YearDict.py

@@ -0,0 +1,148 @@
+from decimal import Decimal
+from typing import Mapping
+
+from .common import NAN, ONE, Decimable, to_decimal, ZERO
+
+
+class YearDict:
+    def __init__(self, data: Mapping[int, Decimable], strict: bool = True):
+        if not data:
+            raise ValueError("Data cannot be empty.")
+        years = sorted(data.keys())
+        if strict:
+            # enforce contiguous coverage
+            if years != list(range(years[0], years[-1] + 1)):
+                raise ValueError(
+                    "Data must cover all years in the contiguous range. "
+                    "To disable this check, set strict=False."
+                )
+        self.start_year, self.end_year = years[0], years[-1]
+        self.data = {k: to_decimal(v) for k, v in data.items()}
+
+    def fill(self, start_year: int, end_year: int, value: Decimable) -> "YearDict":
+        """
+        Create a new graph with a specified range and value.
+        The range is defined by start_year and end_year.
+        """
+        v = to_decimal(value)
+        return YearDict({y: v for y in range(int(start_year), int(end_year) + 1)})
+
+    def get(self, year: int, default: Decimal = NAN) -> Decimal:
+        """
+        Get the value for a specific year. If the year does not exist, return the default value.
+        If the value is None, return the default value.
+        """
+        temp = self.data.get(year, NAN)
+        if temp.is_nan():
+            return default
+        return temp
+
+    def __getitem__(self, year: int) -> Decimal:
+        return self.data[year]
+
+    def __setitem__(self, year: int, value) -> None:
+        self.data[int(year)] = to_decimal(value)
+
+    def crop(
+        self,
+        start: int | None = None,
+        end: int | None = None,
+        initial_value: Decimable = NAN,
+    ) -> "YearDict":
+        if start is None and end is None:
+            return self
+        return YearDict(
+            {
+                k: (self.get(k, to_decimal(initial_value)))
+                for k in range(
+                    self.start_year if start is None else int(start),
+                    self.end_year if end is None else int(end)
+                    +1,
+                )
+            }
+        )
+
+    def non_negative(self) -> "YearDict":
+        """
+        Return a new YearDict with all negative values set to zero.
+        """
+        return YearDict({y: (v if (not v.is_nan() and v >= ZERO) else ZERO) for y, v in self.data.items()})
+
+    def sum(self, start: int | None = None, end: int | None = None) -> Decimal:
+        """
+        Return the sum of values in the specified range.
+        If a value is NaN, it is treated as zero.
+        """
+        s = self.start_year if start is None else start
+        e = self.end_year if end is None else end
+        return sum((self.get(y, ZERO) for y in range(s, e + 1) if y in self.data), ZERO)
+
+    def __mul__(self, other: "Decimable | YearDict") -> "YearDict":
+        if isinstance(other, Decimable):
+            return YearDict({k: v * to_decimal(other) for k, v in self.data.items()})
+        elif isinstance(other, YearDict):
+            return YearDict({k: v * other.get(k, ONE) for k, v in self.data.items()})
+
+    def __rmul__(self, other):
+        return self.__mul__(other)
+
+    def __neg__(self) -> "YearDict":
+        return self * Decimal("-1")
+
+    def __add__(self, other: "Decimable | YearDict") -> "YearDict":
+        if isinstance(other, Decimable):
+            return YearDict({k: v + to_decimal(other) for k, v in self.data.items()})
+        elif isinstance(other, YearDict):
+            return YearDict({k: v + other.get(k, ZERO) for k, v in self.data.items()})
+
+    def __radd__(self, other: "Decimable | YearDict") -> "YearDict":
+        return self.__add__(other)
+
+    def __sub__(self, other: "Decimable | YearDict") -> "YearDict":
+        if isinstance(other, Decimable):
+            return self.__add__(-to_decimal(other))
+        elif isinstance(other, YearDict):
+            return self.__add__(-other)
+
+    def __rsub__(self, other: "Decimable | YearDict") -> "YearDict":
+        return (-self).__add__(other)
+
+    def __truediv__(self, other: "Decimable | YearDict") -> "YearDict":
+        if isinstance(other, Decimable):
+            return YearDict({k: v / to_decimal(other) for k, v in self.data.items()})
+        elif isinstance(other, YearDict):
+            return YearDict({k: v / other.get(k, ONE) for k, v in self.data.items()})
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, YearDict):
+            return False
+        for k in set(self.data.keys()).union(other.data.keys()):
+            s = self.get(k)
+            o = other.get(k)
+            if s.is_nan() and o.is_nan():
+                continue
+            if s != o:
+                return False
+        return True
+
+    def __str__(self):
+        return "\n".join(f"{y}: {v}" for y, v in sorted(self.data.items()))
+
+    def __repr__(self):
+        return f"{self.data!r}"
+
+    def to_array(self):
+        return [self.data[k] for k in self.data.keys()]
+
+    def to_dict(self):
+        return dict(self.data)
+
+    def average(self) -> Decimal:
+        """
+        Return the average of the values in the YearDict.
+        If there are no years, return Zero
+        """
+        valid_values = [v for v in self.data.values() if not v.is_nan()]
+        if not valid_values:
+            return ZERO
+        return sum(valid_values, ZERO) / Decimal(len(valid_values))

datedict-0.1.3/src/datedict/__init__.py

@@ -0,0 +1,6 @@
+from .DateDict import DateDict
+from .YearDict import YearDict
+from .common import ZERO, ONE, NAN, Decimable
+
+__all__ = ["DateDict", "YearDict", "ZERO", "ONE", "NAN", "Decimable"]
+__version__ = "0.1.2"

datedict-0.1.3/src/datedict/common.py

@@ -0,0 +1,19 @@
+from decimal import Decimal
+from typing import Union
+
+Decimable = Union[Decimal, str, int, float, None]
+
+ZERO = Decimal("0")
+ONE = Decimal("1")
+NAN = Decimal("NaN")
+
+
+def to_decimal(x: Decimable) -> Decimal:
+    if x is None:
+        return Decimal("NaN")
+    if isinstance(x, Decimal):
+        return x
+    if isinstance(x, (int, str)):
+        return Decimal(x)
+    if isinstance(x, float):
+        return Decimal(str(x))

datedict-0.1.1/src/datedict/DateDict.py

@@ -1,137 +0,0 @@
-from datetime import date
-from decimal import Decimal
-
-from datetime import timedelta
-
-from .common import _to_decimal, _Z
-
-
-class DateDict:
-    def __init__(self, data=dict()):
-        self.data: dict[str, Decimal | None] = data
-
-    def create(self, start_date, end_date, value: Decimal) -> "DateDict":
-        """
-        Create a new graph with a specified range and value.
-        The range is defined by start_date and end_date.
-        If the value is None, it will not be included in the graph.
-        """
-        start = (
-            date.fromisoformat(start_date)
-            if isinstance(start_date, str)
-            else start_date
-        )
-        end = date.fromisoformat(end_date) if isinstance(end_date, str) else end_date
-        self.data = {
-            date.strftime("%Y-%m-%d"): (value if value is not None else None)
-            for date in (
-                start + timedelta(days=i) for i in range((end - start).days + 1)
-            )
-        }
-        return self
-
-    def get(self, key: str, default: Decimal) -> Decimal:
-        """
-        Get the value for a specific date. If the date does not exist, return the default value.
-        The date should be in the format yyyy-mm-dd.
-        If the value is None, return the default value.
-        """
-        return self.data.get(key) or default
-
-    def __getitem__(self, key) -> Decimal | None:
-        return self.data.get(key, None)
-
-    def __setitem__(self, key: str, value) -> None:
-        self.data[key] = value
-
-    def crop(self, start: str | None = None, end: str | None = None) -> "DateDict":
-        """
-        Crop the graph data to a specific range defined by start and end.
-        If any of the parameters is None, it will not filter by that parameter.
-        """
-        if start is None and end is None:
-            return self
-        return DateDict(
-            {
-                k: v
-                for k, v in self.data.items()
-                if (start is None or k >= start) and (end is None or k <= end)
-            }
-        )
-
-    def sum(self: "DateDict") -> Decimal:
-        """
-        Calculate the sum of all values in the graph.
-        If a value is None, it is treated as zero.
-        """
-        return Decimal(
-            sum(value if value is not None else _Z for value in self.data.values())
-        )
-
-    def __add__(self, other: "Decimal | DateDict") -> "DateDict":
-        if isinstance(other, Decimal):
-            return DateDict(
-                {
-                    k: (v + other if v is not None else None)
-                    for k, v in self.data.items()
-                }
-            )
-        else:
-            return DateDict(
-                {
-                    k: ((v + (other.data.get(k) or _Z) if v is not None else None))
-                    for k, v in self.data.items()
-                }
-            )
-
-    def __mul__(self, other: "Decimal | DateDict") -> "DateDict":
-        if isinstance(other, Decimal):
-            return DateDict(
-                {
-                    k: (v * other if v is not None else None)
-                    for k, v in self.data.items()
-                }
-            )
-        elif isinstance(other, DateDict):
-            return DateDict(
-                {
-                    k: ((v * (other.data.get(k) or _Z) if v is not None else None))
-                    for k, v in self.data.items()
-                }
-            )
-
-    def __sub__(self, other: "Decimal | DateDict") -> "DateDict":
-        return self + (other * Decimal(-1))
-
-    def __truediv__(self, other: "Decimal | DateDict") -> "DateDict":
-        if isinstance(other, Decimal):
-            return DateDict(
-                {
-                    k: (v / other if v is not None else None)
-                    for k, v in self.data.items()
-                }
-            )
-        elif isinstance(other, DateDict):
-            return DateDict(
-                {
-                    k: ((v / (other.data.get(k) or _Z) if v is not None else None))
-                    for k, v in self.data.items()
-                }
-            )
-
-    def to_dict(self) -> dict[str, Decimal | None]:
-        """
-        Convert the graph data to a dictionary.
-        This is useful for serialization or returning as a response.
-        """
-        return self.data.copy()
-
-    def average(self) -> Decimal:
-        """
-        Calculate the average of all values in the graph.
-        If there are no valid values, return Decimal(0).
-        """
-        valid_values = [v for v in self.data.values() if v is not None]
-        if not valid_values:
-            return _Z
-        return Decimal(sum(valid_values)) / len(valid_values)

datedict-0.1.1/src/datedict/YearDict.py

@@ -1,103 +0,0 @@
-from decimal import Decimal
-
-from .common import _to_decimal, _Z
-
-
-class YearDict:
-    def __init__(self, start_year=2025, end_year=2025, initial_value: Decimal | int | float = _Z):
-        self.start_year: int = start_year
-        self.end_year: int = end_year
-        iv: Decimal = _to_decimal(initial_value)
-        self.data: dict[int, Decimal] = {y: iv for y in range(self.start_year, self.end_year + 1)}
-
-    def __getitem__(self, year: int) -> Decimal:
-        return self.data[year]
-
-    def __setitem__(self, year: int, value):
-        self.data[int(year)] = _to_decimal(value)
-
-    def override(self, data: dict[int, Decimal | float | int | str]) -> "YearDict":
-        if not data:
-            raise ValueError("Data cannot be empty.")
-        ys = sorted(data.keys())
-        # enforce contiguous coverage
-        if ys != list(range(ys[0], ys[-1] + 1)):
-            raise ValueError("Data must cover all years in the contiguous range.")
-        self.start_year, self.end_year = ys[0], ys[-1]  # inclusive
-        self.data = {
-            y: _to_decimal(data[y]) for y in range(self.start_year, self.end_year + 1)
-        }
-        return self
-
-    def fit(self, start_year: int, end_year: int, initial_value: Decimal = _Z):
-        self.start_year, self.end_year = int(start_year), int(end_year)
-        iv = _to_decimal(initial_value)
-        self.data = {
-            y: _to_decimal(self.data[y]) if y in self.data else iv
-            for y in range(self.start_year, self.end_year + 1)
-        }
-        return self
-
-    def non_negative(self) -> "YearDict":
-        out = YearDict(self.start_year, self.end_year)
-        out.data = {y: (v if v >= _Z else _Z) for y, v in self.data.items()}
-        return out
-
-    def sum(
-        self, start_year: int | None = None, end_year: int | None = None
-    ) -> Decimal:
-        sy = self.start_year if start_year is None else int(start_year)
-        ey = self.end_year if end_year is None else int(end_year)
-        return sum((self.data[y] for y in range(sy, ey + 1) if y in self.data), _Z)
-
-    def __mul__(self, other):
-        result = YearDict(self.start_year, self.end_year)
-        if isinstance(other, (int, float, Decimal)):
-            result.data = {
-                year: Decimal(value) * Decimal(str(other))
-                for year, value in self.data.items()
-            }
-        elif isinstance(other, YearDict):
-            result.data = {
-                year: Decimal(self.data[year]) * Decimal(other.data[year])
-                for year in self.data.keys() & other.data.keys()
-            }
-        else:
-            return NotImplemented
-        return result
-
-    def __rmul__(self, other):
-        return self.__mul__(other)
-
-    def __add__(self, other):
-        result = YearDict(self.start_year, self.end_year)
-        if isinstance(other, (int, float, Decimal)):
-            result.data = {
-                year: value + Decimal(str(other)) for year, value in self.data.items()
-            }
-        elif isinstance(other, YearDict):
-            result.data = {
-                year: Decimal(self.data[year]) + Decimal(other.data[year])
-                for year in self.data.keys() & other.data.keys()
-            }
-        else:
-            return NotImplemented
-        return result
-
-    def __radd__(self, other):
-        return self.__add__(other)
-
-    def __sub__(self, other):
-        return self.__add__(-1 * other)
-
-    def __str__(self):
-        return "\n".join(f"{y}: {v}" for y, v in sorted(self.data.items()))
-
-    def __repr__(self):
-        return f"{self.data!r}"
-
-    def to_array(self):
-        return [self.data[y] for y in range(self.start_year, self.end_year + 1)]
-
-    def to_dict(self):
-        return dict(self.data)

datedict-0.1.1/src/datedict/__init__.py

@@ -1,5 +0,0 @@
-from .DateDict import DateDict
-from .YearDict import YearDict
-
-__all__ = ["DateDict", "YearDict"]
-__version__ = "0.1.1"

datedict-0.1.1/src/datedict/common.py

@@ -1,14 +0,0 @@
-from decimal import Decimal
-
-
-_Z = Decimal("0")
-
-
-def _to_decimal(x) -> Decimal:
-    if isinstance(x, Decimal):
-        return x
-    if isinstance(x, (int, str)):
-        return Decimal(x)
-    if isinstance(x, float):
-        return Decimal(str(x))
-    raise TypeError(f"Unsupported type for Decimal: {type(x)}")