rangekeeper 0.7.2.post4__tar.gz → 0.7.4__tar.gz

{rangekeeper-0.7.2.post4 → rangekeeper-0.7.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: Rangekeeper
-Version: 0.7.2.post4
+Version: 0.7.4
 Summary: A Python library assisting financial modelling in real estate asset & development planning, decision-making, cashflow forecasting, and scenario analysis.
 License: MPL-2.0
 Author: Daniel Fink
@@ -12,23 +12,20 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Requires-Dist: aenum (>=3.1,<4.0)
-Requires-Dist: matplotlib (>=3.9,<4.0)
-Requires-Dist: mpld3 (>=0.5,<0.6)
+Requires-Dist: matplotlib (>=3.10,<4.0)
 Requires-Dist: multiprocess (>=0.70,<0.71)
 Requires-Dist: networkx (>=3.3,<4.0)
-Requires-Dist: numba (>=0.60,<0.61)
+Requires-Dist: numba (>=0.61,<0.62)
 Requires-Dist: numpy-financial (>=1.0,<2.0)
-Requires-Dist: pandas (>=2,<3)
+Requires-Dist: pandas (>=2.2,<3.0)
 Requires-Dist: pint (>=0.24,<0.25)
-Requires-Dist: plotly (>=5.22,<6.0)
+Requires-Dist: plotly (>=6.0,<7.0)
 Requires-Dist: py-moneyed (>=3.0,<4.0)
-Requires-Dist: pyarrow (>=18.1,<19.0)
 Requires-Dist: pyvis (>=0.3,<0.4)
 Requires-Dist: pyxirr (>=0.10,<0.11)
-Requires-Dist: pyyaml (>=6.0,<7.0)
-Requires-Dist: scipy (>=1.13,<2.0)
+Requires-Dist: scipy (>=1.14,<2.0)
 Requires-Dist: seaborn (>=0.13,<0.14)
-Requires-Dist: specklepy (>=2.19,<3.0)
+Requires-Dist: specklepy (>=2.21,<3.0)
 Requires-Dist: tabulate (>=0.9,<0.10)
 Description-Content-Type: text/markdown
 

{rangekeeper-0.7.2.post4 → rangekeeper-0.7.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "Rangekeeper"
-version = "0.7.2-4"
+version = "0.7.4"
 description = "A Python library assisting financial modelling in real estate asset & development planning, decision-making, cashflow forecasting, and scenario analysis."
 authors = ["Daniel Fink <danfink@mit.edu>"]
 license = "MPL-2.0"
@@ -8,28 +8,25 @@ readme = "README.md"
 
 [tool.poetry.dependencies]
 python = ">=3.10, <3.13"
-matplotlib = "^3.9"
-pandas = "^2"
+matplotlib = "^3.10"
+pandas = "^2.2"
 pint = "^0.24"
 pyxirr = "^0.10"
-scipy = "^1.13"
+scipy = "^1.14"
 networkx = "^3.3"
 py-moneyed = "^3.0"
 tabulate = "^0.9"
-pyyaml = "^6.0"
-specklepy = "^2.19"
-numba = "^0.60"
+specklepy = "^2.21"
+numba = "^0.61"
 multiprocess = "^0.70"
 seaborn = "^0.13"
 pyvis = "^0.3"
-plotly = "^5.22"
-mpld3 = "^0.5"
-pyarrow = "^18.1"
+plotly = "^6.0"
 aenum = "^3.1"
 numpy-financial = "^1.0"
 
 [tool.poetry.dev-dependencies]
-pytest = "^8.2"
+pytest = "^8.3"
 
 [build-system]
 requires = ["setuptools", "poetry-core>=1.0.0"]

{rangekeeper-0.7.2.post4 → rangekeeper-0.7.4}/rangekeeper/flux.py

@@ -293,7 +293,7 @@ class Flow:
             self,
             frequency: rk.duration.Type) -> Flow:
         """
-        Returns a Flow with movements summed to specified frequency of dates
+        Returns a Flow with movements summed to specified frequency of periods
         """
         return rk.flux.Flow(
             movements=self.movements.copy(deep=True).resample(rule=rk.duration.Type.period(frequency)).sum(),

rangekeeper-0.7.4/rangekeeper/formula/__init__.py

@@ -0,0 +1 @@
+from . import financial as financial

rangekeeper-0.7.2.post4/rangekeeper/formula.py → rangekeeper-0.7.4/rangekeeper/formula/financial.py

@@ -1,29 +1,104 @@
-from typing import Callable, Optional
 import enum
+import dataclasses
 import numpy as np
-from numba import jit
 import numba
 import pandas as pd
-import scipy.optimize as opt
 
 import rangekeeper as rk
 
 
-class Financial:
+class Balance:
+    startings: rk.flux.Flow
+    endings: rk.flux.Flow
 
-    class Instrument(enum.Enum):
+    def __init__(
+            self,
+            starting: float,
+            transactions: rk.flux.Flow,
+            frequency: rk.duration.Type,
+    ):
+        """
+        Calculate the balance of a financial account given a starting balance and a series of transactions.
+        """
+
+        transactions = transactions.resample(frequency=frequency)
+
+        result = self._calculate_balance(
+            startings=numba.typed.List([np.float64(starting)]),
+            transactions=numba.typed.List(transactions.movements.to_list()))
+
+        self.startings=rk.flux.Flow(
+            movements=pd.Series(result[0], index=transactions.movements.index),
+            units=transactions.units,
+            name='Start Balance')
+
+        self.endings=rk.flux.Flow(
+            movements=pd.Series(result[1], index=transactions.movements.index),
+            units=transactions.units,
+            name='End Balance')
+
+    @classmethod
+    def from_flows(
+            cls,
+            startings: rk.flux.Flow,
+            endings: rk.flux.Flow,
+    ):
+        balance = super().__new__(cls)
+        balance.startings = startings
+        balance.endings = endings
+
+        return balance
+
+    def overdraft(
+            self,
+            name: str = None,
+    ) -> rk.flux.Flow:
+        """
+        Identifies the portion of transactions occurring while the balance is negative.
+        """
+
+        starts = self.startings.movements.where(self.startings.movements < 0).fillna(0)
+        ends = self.endings.movements.where(self.endings.movements < 0).fillna(0)
+
+        overdrafts = ends - starts
+        overdrafts = overdrafts.where(overdrafts < 0).dropna()
+
+        return rk.flux.Flow(
+            movements=overdrafts,
+            units=self.startings.units,
+            name='Overdraft' if name is None else name)
+
+
+    @staticmethod
+    @numba.jit
+    def _calculate_balance(
+            startings: numba.typed.List,
+            transactions: numba.typed.List) -> (numba.typed.List, numba.typed.List):
+
+        endings = numba.typed.List.empty_list(numba.float64)
+        for i in range(len(transactions)):
+            endings.append(float(startings[-1] + transactions[i]))
+            startings.append(endings[-1])
+
+        return (startings[:-1], endings)
+
+
+class Interest:
+    amounts: rk.flux.Flow
+    balance: Balance
+
+    class Type(enum.Enum):
         INTEREST_ONLY = 'interest_only'
         COMPOUND = 'compound'
         CAPITALIZED = 'capitalized'
 
-
-    @staticmethod
-    def interest(
+    def __init__(
+            self,
             rate: float | rk.flux.Flow,
             transactions: rk.flux.Flow,
             frequency: rk.duration.Type,
-            # capitalized: bool = False)\
-            instrument: Instrument = Instrument.COMPOUND) -> (rk.flux.Stream, rk.flux.Flow):
+            type: Type = Type.COMPOUND,
+    ):
         """
         Calculate interest expense on a loan or other interest-bearing liability,
         described by a series of transactions.
@@ -43,47 +118,45 @@ class Financial:
                     sequence=rk.duration.Sequence.from_datestamps(
                         datestamps=transactions.movements.index,
                         frequency=frequency)))
+        else:
+            raise NotImplementedError('Only float rates are supported currently.')
 
         if len(transactions.movements) != len(rate.movements):
             raise ValueError('The number of transactions must match the number of rates.')
 
-        startings, endings, interests = rk.formula.Financial._calc_interest(
+        startings, endings, interests = self._calc_interest(
             transactions=numba.typed.List(transactions.movements.to_list()),
             rates=numba.typed.List(rate.movements.to_list()),
-            instrument=instrument.value)
-
-        balance = rk.flux.Stream(
-            name='Balance',
-            flows=[
-                rk.flux.Flow(
-                    movements=pd.Series(startings, index=transactions.movements.index),
-                    units=transactions.units,
-                    name='Start Balance'),
-                rk.flux.Flow(
-                    movements=pd.Series(endings, index=transactions.movements.index),
-                    units=transactions.units,
-                    name='End Balance')
-            ],
-            frequency=frequency)
-
-        interest = rk.flux.Flow(
+            type=type.value)
+
+        self.balance = rk.formula.financial.Balance.from_flows(
+            startings=rk.flux.Flow(
+                movements=pd.Series(startings, index=transactions.movements.index),
+                units=transactions.units,
+                name='Start Balance'),
+            endings=rk.flux.Flow(
+                movements=pd.Series(endings, index=transactions.movements.index),
+                units=transactions.units,
+                name='End Balance')
+        )
+
+        self.amounts = rk.flux.Flow(
             movements=pd.Series(interests, index=transactions.movements.index),
             units=transactions.units,
             name='Interest')
 
-        return (balance, interest)
-
 
     @staticmethod
     @numba.jit
     def _calc_interest(
             transactions: numba.typed.List,
             rates: numba.typed.List,
-            instrument: str) -> (numba.typed.List, numba.typed.List, numba.typed.List):
+            type: str,
+    ) -> (numba.typed.List, numba.typed.List, numba.typed.List):
 
         startings = numba.typed.List.empty_list(numba.float64)
         endings = numba.typed.List.empty_list(numba.float64)
-        interests = numba.typed.List.empty_list(numba.float64)
+        amounts = numba.typed.List.empty_list(numba.float64)
 
         for i in range(len(transactions)):
             if i == 0:
@@ -92,87 +165,25 @@ class Financial:
                 startings.append(endings[-1])
 
             principal = startings[i] + transactions[i]
-            if instrument == 'interest_only':
+            if type == 'interest_only':
                 interest = principal * rates[i] if principal > 0 else 0
                 endings.append(principal)
 
-            elif instrument == 'compound':
+            elif type == 'compound':
                 interest = principal * rates[i] if principal > 0 else 0
                 endings.append(principal + interest)
 
-            elif instrument == 'capitalized':
+            elif type == 'capitalized':
                 interest = (principal * rates[i]) / (1 - rates[i]) if principal > 0 else 0 # Since we are capitalizing
-                # interest, the interest amount (draw) must include interest to pay on the principal. Derived from i = r * (P + i)
+                # interest, the amount (draw) must include interest to pay on the principal. Derived from i = r * (P + i)
                 endings.append(principal + interest)
 
             else:
-                raise ValueError(f'Invalid instrument: {instrument}')
+                raise ValueError(f'Invalid instrument: {type}')
 
-            interests.append(interest)
+            amounts.append(interest)
 
-        return (startings, endings, interests)
+        return (startings, endings, amounts)
 
 
-    @staticmethod
-    def balance(
-            starting: float,
-            transactions: rk.flux.Flow,
-            frequency: rk.duration.Type,
-            name: str = None) -> rk.flux.Stream:
-        """
-        Calculate the balance of a financial account given a starting balance and a series of transactions.
-        """
-
-        starting = numba.typed.List([np.float64(starting)])
-        transaction_amounts = numba.typed.List(transactions.movements.to_list())
-
-        balance = rk.formula.Financial._calculate_balance(
-            starting=starting,
-            transactions=transaction_amounts)
-
-        flows = [
-            rk.flux.Flow(
-                movements=pd.Series(record, index=transactions.movements.index),
-                units=transactions.units,
-                name=name)
-            for record, name in zip(balance, ('Start Balance', 'End Balance'))
-        ]
 
-        statement = rk.flux.Stream(
-            name=name,
-            flows=flows,
-            frequency=frequency)
-
-        return statement
-
-    @staticmethod
-    @numba.jit
-    def _calculate_balance(
-            starting: numba.typed.List,
-            transactions: numba.typed.List) -> (numba.typed.List, numba.typed.List):
-
-        ending = numba.typed.List.empty_list(numba.float64)
-        for i in range(len(transactions)):
-            ending.append(float(starting[-1] + transactions[i]))
-            starting.append(ending[-1])
-        return (starting[:-1], ending)
-
-    @staticmethod
-    def overdraft(
-            balance: rk.flux.Stream,
-            name: str = None) -> rk.flux.Flow:
-        """
-        Identifies the portion of transactions occurring while the balance is negative.
-        """
-        if len(balance.flows) != 2:
-            raise ValueError('Balance must be Stream with two flows; Start and End.')
-        if balance.flows[0].units != balance.flows[1].units:
-            raise ValueError('Units of the Start and End Flows must be the same.')
-
-        starts = balance.flows[0].movements.where(balance.flows[0].movements < 0).fillna(0)
-        ends = balance.flows[1].movements.where(balance.flows[1].movements < 0).fillna(0)
-
-        return rk.flux.Flow(
-            movements=ends - starts,
-            units=balance.flows[0].units,
-            name='Overdraft' if name is None else name)

{rangekeeper-0.7.2.post4 → rangekeeper-0.7.4}/rangekeeper/span.py

@@ -41,9 +41,9 @@ class Span:
         self.end_date = self._interval.right
 
     def __str__(self):
-        return 'Span: {}\n' \
-               'Start Date: {}\n' \
-               'End Date: {}'.format(self.name, self.start_date.date(), self.end_date.date())
+        return f'Span: {self.name}\n' \
+               f'Start Date: {self.start_date.date()}\n' \
+               f'End Date: {self.end_date.date()}\n'
 
     def __repr__(self):
         return self.__str__()