datedict 0.1.2__py3-none-any.whl → 0.1.4__py3-none-any.whl

datedict/DateDict.py

@@ -1,50 +1,72 @@
-from datetime import date
+from datetime import date, timedelta
 from decimal import Decimal
+from typing import Mapping
 
-from datetime import timedelta
-
-from .common import ZERO
+from .common import NAN, ONE, Decimable, to_decimal, ZERO
 
 
 class DateDict:
-    def __init__(self, data=dict()):
-        self.data: dict[str, Decimal | None] = data
-
-    def create(self, start_date, end_date, value: Decimal) -> "DateDict":
+    def __init__(self, data: Mapping[str, Decimable] = dict(), 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.
-        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
+        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
+                )
+            }
         )
-        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:
+    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.
         """
-        return self.data.get(key) or default
+        temp = self.data.get(key, NAN)
+        if temp.is_nan():
+            return default
+        return temp
 
-    def __getitem__(self, key) -> Decimal | None:
-        return self.data.get(key, None)
+    def __getitem__(self, key) -> Decimal:
+        return self.data[key]
 
     def __setitem__(self, key: str, value) -> None:
-        self.data[key] = value
-
-    def crop(self, start: str | None = None, end: str | None = None) -> "DateDict":
+        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.
@@ -53,85 +75,144 @@ class DateDict:
             return self
         return DateDict(
             {
-                k: v
+                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()
-                if (start is None or k >= start) and (end is None or k <= end)
             }
         )
 
-    def sum(self: "DateDict") -> Decimal:
+    def sum(
+        self: "DateDict", start: str | None = None, end: str | None = None
+    ) -> Decimal:
         """
-        Calculate the sum of all values in the graph.
-        If a value is None, it is treated as zero.
+        Return the sum of values in the specified range.
+        If a value is NaN, it is treated as zero.
         """
-        return Decimal(
-            sum(value if value is not None else ZERO for value in self.data.values())
+        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 __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 ZERO) 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()
-                }
-            )
+    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.data.get(k) or ZERO) 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 ZERO) if v is not None else None))
-                    for k, v in self.data.items()
-                }
-            )
+            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 | None]:
+    def to_dict(self) -> dict[str, Decimal]:
         """
-        Convert the graph data to a dictionary.
-        This is useful for serialization or returning as a response.
+        Convert the DateDict to a standard dictionary.
         """
-        return self.data.copy()
+        return dict(self.data)
 
     def average(self) -> Decimal:
         """
-        Calculate the average of all values in the graph.
-        If there are no valid values, return Decimal(0).
+        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 v is not None]
+        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/YearDict.py

@@ -1,101 +1,133 @@
 from decimal import Decimal
+from typing import Mapping
 
-from .common import to_decimal, ZERO
+from .common import NAN, ONE, Decimable, to_decimal, ZERO
 
 
 class YearDict:
-    def __init__(
-        self,
-        start_year=2025,
-        end_year=2025,
-        initial_value: Decimal | int | float = ZERO,
-    ):
-        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 __init__(self, data: Mapping[int, Decimable] = dict(), 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):
+    def __setitem__(self, year: int, value) -> None:
         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 = ZERO):
-        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 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":
-        out = YearDict(self.start_year, self.end_year)
-        out.data = {y: (v if v >= ZERO else ZERO) 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), ZERO)
-
-    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()
+        """
+        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):
-            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
+            return YearDict({k: v * other.get(k, ONE) for k, v in self.data.items()})
 
     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()
-            }
+    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):
-            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
+            return YearDict({k: v + other.get(k, ZERO) for k, v in self.data.items()})
 
-    def __radd__(self, other):
+    def __radd__(self, other: "Decimable | YearDict") -> "YearDict":
         return self.__add__(other)
 
-    def __sub__(self, other):
-        return self.__add__(-1 * 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()))
@@ -104,7 +136,17 @@ class YearDict:
         return f"{self.data!r}"
 
     def to_array(self):
-        return [self.data[y] for y in range(self.start_year, self.end_year + 1)]
+        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/__init__.py

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

datedict/common.py

@@ -1,14 +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) -> Decimal:
+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))
-    raise TypeError(f"Unsupported type for Decimal: {type(x)}")

{datedict-0.1.2.dist-info → datedict-0.1.4.dist-info}/METADATA

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: datedict
-Version: 0.1.2
+Version: 0.1.4
 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
+Project-URL: Homepage, https://gitlab.com/grisus/datedict
+Project-URL: Issues, https://gitlab.com/grisus/datedict/-/issues
 Author-email: Lorenzo Guideri <lorenzo.guideri@dec-energy.ch>
 License: MIT License
         
-        Copyright (c) 2025 Lorenzo Guideri
+        Copyright (c) 2025 DEC Energy SA
         
         Permission is hereby granted, free of charge, to any person obtaining a copy
         of this software and associated documentation files (the "Software"), to deal

datedict-0.1.4.dist-info/RECORD

@@ -0,0 +1,8 @@
+datedict/DateDict.py,sha256=2UdkSp-dVFqmbFMWnlK7Ol1Gixv2koiwjWw7tw79Zhs,7776
+datedict/YearDict.py,sha256=EcVg4y8Tzfgr33KjCIdoKP4GUN1GDVOrxGpHDH0ZLGQ,5494
+datedict/__init__.py,sha256=4QSCqCW_owSqD3k3Oz1WAsB4p_vvzUlINroAxxFCEWQ,201
+datedict/common.py,sha256=aUCsMV6roKGQIQXSFIJIN0cxAXIlK_YyRDWS1EIBu8E,424
+datedict-0.1.4.dist-info/METADATA,sha256=-SL17egrcvdh_MkOPa84wvJyFUeRNQ88tlw2tvYuYwE,1991
+datedict-0.1.4.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+datedict-0.1.4.dist-info/licenses/LICENSE,sha256=GMmiaNfJSsljmGtIp9lCY6V-Dkc9NDZn0jSZuAbFe7Y,1070
+datedict-0.1.4.dist-info/RECORD,,

{datedict-0.1.2.dist-info → datedict-0.1.4.dist-info}/licenses/LICENSE

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

datedict-0.1.2.dist-info/RECORD

@@ -1,8 +0,0 @@
-datedict/DateDict.py,sha256=JrqKAJIcZL4Q7JMvzKPZQCzXGQ3wZAEkpWABAfHXLr0,4658
-datedict/YearDict.py,sha256=P8t43vUyOtxxABtIKf1epAU7Ohqx2-V9e9t-PyqFEh0,3798
-datedict/__init__.py,sha256=pZv27luenqTNoEm9jdodgCu3B5vnYdDgMYllFwCA2Sc,153
-datedict/common.py,sha256=yW3ohkISis4FP6baN8QJFPYHCkpVyecip7AlFg49_Kw,314
-datedict-0.1.2.dist-info/METADATA,sha256=p8BOciltez0gbtRl-UPsG0ihMtI4cSn5w8PBm1sNlwM,1985
-datedict-0.1.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-datedict-0.1.2.dist-info/licenses/LICENSE,sha256=ULDgLM2c4o9DLMR-VEkeyuB-DRWBFX7VunJmlWShWxQ,1072
-datedict-0.1.2.dist-info/RECORD,,