rangekeeper 0.7.4__tar.gz → 0.7.5__tar.gz

{rangekeeper-0.7.4 → rangekeeper-0.7.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: Rangekeeper
-Version: 0.7.4
+Version: 0.7.5
 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,6 +12,7 @@ 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: black (>=25.1.0,<26.0.0)
 Requires-Dist: matplotlib (>=3.10,<4.0)
 Requires-Dist: multiprocess (>=0.70,<0.71)
 Requires-Dist: networkx (>=3.3,<4.0)

{rangekeeper-0.7.4 → rangekeeper-0.7.5}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "Rangekeeper"
-version = "0.7.4"
+version = "0.7.5"
 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"
@@ -24,6 +24,7 @@ pyvis = "^0.3"
 plotly = "^6.0"
 aenum = "^3.1"
 numpy-financial = "^1.0"
+black = "^25.1.0"
 
 [tool.poetry.dev-dependencies]
 pytest = "^8.3"

{rangekeeper-0.7.4 → rangekeeper-0.7.5}/rangekeeper/flux.py

@@ -17,21 +17,20 @@ import pyxirr
 import rangekeeper as rk
 
 
-def _format_series(
-        series: pd.Series,
-        units: pint.Unit,
-        decimals: int = 2):
-    if units.dimensionality == '[currency]':
+def _format_series(series: pd.Series, units: pint.Unit, decimals: int = 2):
+    if units.dimensionality == "[currency]":
         formatted = pd.Series(
             data=[str(locale.currency(value, grouping=True)) for value in series],
-            index=pd.Series(series.index, name='date'),
-            name=series.name)
+            index=pd.Series(series.index, name="date"),
+            name=series.name,
+        )
     else:
         floatfmt = "{:." + str(decimals) + "f}"
         formatted = pd.Series(
             data=[str(floatfmt.format(value)) for value in series],
-            index=pd.Series(series.index, name='date'),
-            name=series.name)
+            index=pd.Series(series.index, name="date"),
+            name=series.name,
+        )
 
     return formatted
 
@@ -46,10 +45,8 @@ class Flow:
     """
 
     def __init__(
-            self,
-            movements: pd.Series,
-            units: Optional[pint.Unit] = None,
-            name: str = None):
+        self, movements: pd.Series, units: Optional[pint.Unit] = None, name: str = None
+    ):
         """
         Initializes a Flow. If units are not provided, a scalar (dimensionless) unit is assumed.
 
@@ -68,7 +65,11 @@ class Flow:
             try:
                 movements = movements.astype(float)
             except Exception as e:
-                raise Exception("Error: Flow's movements' dtype cannot be cast to float: {0}".format(str(e)))
+                raise Exception(
+                    "Error: Flow's movements' dtype cannot be cast to float: {0}".format(
+                        str(e)
+                    )
+                )
         self.movements = movements
         if name:
             self.name = name
@@ -81,60 +82,56 @@ class Flow:
         elif isinstance(units, pint.Unit):
             self.units = units
         else:
-            raise ValueError('Error: Units must be of type pint.Unit')
+            raise ValueError("Error: Units must be of type pint.Unit")
 
     def __str__(self):
-        return os.linesep + str(_format_series(
-            series=self.movements,
-            units=self.units)
-        )
+        return os.linesep + str(_format_series(series=self.movements, units=self.units))
 
     def _repr_html_(self):
-        return _format_series(
-            series=self.movements,
-            units=self.units).to_markdown(
-            stralign="right",
-            numalign="right",
-            tablefmt='html')
-
-    def duplicate(
-            self,
-            name: str = None) -> Flow:
+        return _format_series(series=self.movements, units=self.units).to_markdown(
+            stralign="right", numalign="right", tablefmt="html"
+        )
+
+    def duplicate(self, name: str = None) -> Flow:
         return self.__class__(
             movements=self.movements.copy(deep=True),
             units=self.units,
-            name=self.name if name is None else name)
+            name=self.name if name is None else name,
+        )
 
     # def _format(
     #         self,
     #         decimals: int = 2):
 
-    def display(
-            self,
-            tablefmt: str = 'github',
-            decimals: int = 2):
-        name = 'Name: ' + self.name
-        units = 'Units: ' + str(self.units)
-        movements = 'Movements: ' + os.linesep + _format_series(
-            series=self.movements,
-            units=self.units,
-            decimals=decimals).to_markdown(
-            stralign="right",
-            numalign="right",
-            tablefmt=tablefmt,
-            floatfmt='.' + str(decimals) + 'f')
+    def display(self, tablefmt: str = "github", decimals: int = 2):
+        name = "Name: " + self.name
+        units = "Units: " + str(self.units)
+        movements = (
+            "Movements: "
+            + os.linesep
+            + _format_series(
+                series=self.movements, units=self.units, decimals=decimals
+            ).to_markdown(
+                stralign="right",
+                numalign="right",
+                tablefmt=tablefmt,
+                floatfmt="." + str(decimals) + "f",
+            )
+        )
 
         print(os.linesep + os.linesep.join([name, units, movements]))
         # print(self._format(decimals=decimals) + os.linesep)
 
     def plot(
-            self,
-            bounds: Optional[Tuple[float, float]] = None,
-            normalize: bool = False,
-            *args, **kwargs):
+        self,
+        bounds: Optional[Tuple[float, float]] = None,
+        normalize: bool = False,
+        *args,
+        **kwargs,
+    ):
         self.movements.plot(*args, **kwargs)
-        plt.legend(loc='best')
-        plt.xlabel('Date')
+        plt.legend(loc="best")
+        plt.xlabel("Date")
         plt.ylabel(self.units.__doc__)
         if bounds is not None:
             plt.ylim(bottom=bounds[0], top=bounds[1])
@@ -144,34 +141,30 @@ class Flow:
 
     @classmethod
     def from_sequence(
-            cls,
-            sequence: pd.PeriodIndex,
-            data: [float],
-            units: Optional[pint.Unit] = None,
-            name: str = None) -> Flow:
+        cls,
+        sequence: pd.PeriodIndex,
+        data: [float],
+        units: Optional[pint.Unit] = None,
+        name: str = None,
+    ) -> Flow:
         """
         Returns a Flow where movement dates are defined by the end-dates of the specified sequence of periods (a pd.PeriodIndex)
         """
 
         if sequence.size != len(data):
             raise ValueError("Error: count of periods and data must match")
-        dates = [pd.Timestamp(period.to_timestamp(how='end').date()) for period in sequence]
+        dates = [
+            pd.Timestamp(period.to_timestamp(how="end").date()) for period in sequence
+        ]
         series = pd.Series(
-            data=data,
-            index=pd.Series(data=dates, name='date'),
-            name=name,
-            dtype=float)
-        return cls(
-            movements=series,
-            units=units,
-            name=name)
+            data=data, index=pd.Series(data=dates, name="date"), name=name, dtype=float
+        )
+        return cls(movements=series, units=units, name=name)
 
     @classmethod
     def from_dict(
-            cls,
-            movements: Dict[pd.Timestamp, float],
-            units: pint.Unit,
-            name: str = None) -> Flow:
+        cls, movements: Dict[pd.Timestamp, float], units: pint.Unit, name: str = None
+    ) -> Flow:
         """
         Returns a Flow where movements are defined by key-value pairs of pd.Timestamps and amounts.
         """
@@ -179,21 +172,20 @@ class Flow:
         dates = movements.keys()
         series = pd.Series(
             data=list(movements.values()),
-            index=pd.Series(dates, name='date'),
+            index=pd.Series(dates, name="date"),
             name=name,
-            dtype=float)
-        return cls(
-            movements=series,
-            units=units,
-            name=name)
+            dtype=float,
+        )
+        return cls(movements=series, units=units, name=name)
 
     @classmethod
     def from_projection(
-            cls,
-            value: Union[float, pint.Quantity, rk.distribution.Form],
-            proj: rk.projection,
-            units: pint.Unit = None,
-            name: str = None) -> Flow:
+        cls,
+        value: Union[float, pint.Quantity, rk.distribution.Form],
+        proj: rk.projection,
+        units: pint.Unit = None,
+        name: str = None,
+    ) -> Flow:
         """
         Generate a Flow from a projection of a value, with an optional timing
         offset in the application of the projection to the value. (i.e., the
@@ -211,7 +203,10 @@ class Flow:
             value = value.sample()[0]
 
         if isinstance(proj, rk.projection.Extrapolation):
-            if proj.form.type == rk.extrapolation.Type.STRAIGHT_LINE or proj.form.type == rk.extrapolation.Type.RECURRING:
+            if (
+                proj.form.type == rk.extrapolation.Type.STRAIGHT_LINE
+                or proj.form.type == rk.extrapolation.Type.RECURRING
+            ):
                 movements = value + proj.terms()
             elif proj.form.type == rk.extrapolation.Type.COMPOUNDING:
                 movements = value * proj.terms()
@@ -226,10 +221,7 @@ class Flow:
         # movements = movements[proj.bounds[0].to_timestamp(how='start'):proj.bounds[1].to_timestamp(how='end')]  # Fix for >yearly periodicities
         # TODO: Fix for issues with >yearly periodicities inducing movements at the end of multi-year periods beyond the end of the projection
 
-        return cls(
-            movements=movements,
-            units=units,
-            name=name)
+        return cls(movements=movements, units=units, name=name)
 
     def invert(self) -> Flow:
         """
@@ -238,7 +230,8 @@ class Flow:
         return self.__class__(
             movements=self.movements.copy(deep=True).multiply(-1),
             units=self.units,
-            name=self.name)
+            name=self.name,
+        )
 
     def collapse(self) -> Flow:
         """
@@ -248,7 +241,8 @@ class Flow:
         return self.__class__.from_dict(
             name=self.name,
             movements={self.movements.index[-1]: self.movements.sum()},
-            units=self.units)
+            units=self.units,
+        )
 
     def total(self) -> np.float64:
         """
@@ -256,85 +250,77 @@ class Flow:
         """
         return self.collapse().movements[0]
 
-    def pv(
-            self,
-            frequency: rk.duration.Type,
-            rate: float,
-            name: str = None) -> Flow:
+    def pv(self, frequency: rk.duration.Type, rate: float, name: str = None) -> Flow:
         """
         Returns a Flow with values discounted to the present (i.e. before its first period) by a specified rate
         """
         resampled = self.resample(frequency)
         frame = resampled.movements.to_frame()
-        frame.insert(0, 'index', range(resampled.movements.index.size))
-        frame['Discounted Flow'] = frame.apply(
-            lambda movement: movement[self.name] / np.power((1 + rate), movement['index'] + 1), axis=1)
+        frame.insert(0, "index", range(resampled.movements.index.size))
+        frame["Discounted Flow"] = frame.apply(
+            lambda movement: movement[self.name]
+            / np.power((1 + rate), movement["index"] + 1),
+            axis=1,
+        )
         if name is None:
-            name = 'Discounted ' + self.name
+            name = "Discounted " + self.name
         return self.__class__(
-            movements=frame['Discounted Flow'],
-            units=self.units,
-            name=name)
+            movements=frame["Discounted Flow"], units=self.units, name=name
+        )
 
     def xirr(self) -> float:
         return pyxirr.xirr(
             dates=[datetime.date() for datetime in list(self.movements.index.array)],
-            amounts=self.movements.to_list())
+            amounts=self.movements.to_list(),
+        )
 
-    def xnpv(
-            self,
-            rate: float) -> float:
+    def xnpv(self, rate: float) -> float:
         return pyxirr.xnpv(
             rate=rate,
             dates=[datetime.date() for datetime in list(self.movements.index.array)],
-            amounts=self.movements.to_list())
+            amounts=self.movements.to_list(),
+        )
 
-    def resample(
-            self,
-            frequency: rk.duration.Type) -> Flow:
+    def resample(self, frequency: rk.duration.Type) -> Flow:
         """
         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(),
+            movements=self.movements.copy(deep=True)
+            .resample(rule=rk.duration.Type.period(frequency))
+            .sum(),
             units=self.units,
-            name=self.name)
+            name=self.name,
+        )
 
-    def to_periods(
-            self,
-            frequency: rk.duration.Type) -> pd.Series:
+    def to_periods(self, frequency: rk.duration.Type) -> pd.Series:
         """
         Returns a pd.Series (of index pd.PeriodIndex) with movements summed to specified frequency
         """
-        return (self
-                .resample(frequency=frequency)
-                .movements.to_period(freq=rk.duration.Type.period(frequency), copy=True)
-                .rename_axis('period')
-                .groupby(level='period')
-                .sum()
-                )
+        return (
+            self.resample(frequency=frequency)
+            .movements.to_period(freq=rk.duration.Type.period(frequency), copy=True)
+            .rename_axis("period")
+            .groupby(level="period")
+            .sum()
+        )
 
     def get_frequency(self) -> str:
         return self.movements.index.freq
 
-    def trim_to_span(
-            self,
-            span: rk.span.Span,
-            name: str = None) -> Flow:
+    def trim_to_span(self, span: rk.span.Span, name: str = None) -> Flow:
         """
         Returns a Flow with movements trimmed to the specified span
         """
         return self.__class__(
             movements=self.movements.copy(deep=True).truncate(
-                before=span.start_date,
-                after=span.end_date),
+                before=span.start_date, after=span.end_date
+            ),
             units=self.units,
-            name=self.name if name is None else name)
+            name=self.name if name is None else name,
+        )
 
-    def to_stream(
-            self,
-            frequency: rk.duration.Type,
-            name: str = None) -> Stream:
+    def to_stream(self, frequency: rk.duration.Type, name: str = None) -> Stream:
         """
         Returns a Stream with the flow as flow
         resampled at the specified frequency
@@ -342,7 +328,8 @@ class Flow:
         return Stream(
             name=name if name is not None else self.name,
             flows=[self],
-            frequency=frequency)
+            frequency=frequency,
+        )
 
 
 class Stream:
@@ -358,13 +345,14 @@ class Stream:
     """
 
     def __init__(
-            self,
-            flows: [Flow],
-            frequency: rk.duration.Type,
-            name: str = None):
+        self,
+        flows: [Flow],
+        frequency: rk.duration.Type,
+        name: str = None,
+    ):
 
         # Name:
-        self.name = name if name is not None else 'Unnamed'
+        self.name = name if name is not None else "Unnamed"
 
         # Units:
         # if all(flow.units == flows[0].units for flow in flows):
@@ -383,15 +371,19 @@ class Stream:
 
         # Stream:
         flows_dates = list(
-            itertools.chain.from_iterable(list(flow.movements.index.array) for flow in self.flows))
+            itertools.chain.from_iterable(
+                list(flow.movements.index.array) for flow in self.flows
+            )
+        )
         self.start_date = min(flows_dates)
         self.end_date = max(flows_dates)
 
         index = rk.duration.Sequence.from_bounds(
-            include_start=self.start_date,
-            frequency=self.frequency,
-            bound=self.end_date)
-        self._resampled_flows = [flow.to_periods(frequency=self.frequency) for flow in self.flows]
+            include_start=self.start_date, frequency=self.frequency, bound=self.end_date
+        )
+        self._resampled_flows = [
+            flow.to_periods(frequency=self.frequency) for flow in self.flows
+        ]
         self.frame = pd.concat(self._resampled_flows, axis=1).fillna(0).sort_index()
         """
         A pd.DataFrame of the Stream's flow Flows accumulated into the Stream's frequency
@@ -402,40 +394,36 @@ class Stream:
 
     def _repr_html_(self):
         return self._format_flows().to_markdown(
-            stralign="right",
-            numalign="right",
-            tablefmt='html',
-            floatfmt=".2f")
+            stralign="right", numalign="right", tablefmt="html", floatfmt=".2f"
+        )
 
-    def _format_flows(
-            self,
-            decimals: int = 2) -> pd.DataFrame:
+    def _format_flows(self, decimals: int = 2) -> pd.DataFrame:
 
         formatted_flows = []
         for flow in self.flows:
             series = flow.to_periods(frequency=self.frequency)
-            formatted_flows.append(_format_series(
-                series=series,
-                units=flow.units,
-                decimals=decimals))
+            formatted_flows.append(
+                _format_series(series=series, units=flow.units, decimals=decimals)
+            )
         # formatted_flows = [flow._format_movements(decimals=decimals) for flow in self._resampled_flows]
         frame = pd.concat(formatted_flows, axis=1).fillna(0).sort_index()
         return frame
 
-    def display(
-            self,
-            tablefmt: str = 'github',
-            decimals: int = 2):
+    def display(self, tablefmt: str = "github", decimals: int = 2):
 
         floatfmt = "." + str(decimals) + "f"
 
-        name = 'Name: ' + self.name if self.name is not None else ''
-        units = 'Units: ' + json.dumps({flow.name: flow.units.__str__() for flow in self.flows}, indent=4)
-        flows = 'Flows: ' + os.linesep + self._format_flows(decimals=decimals).to_markdown(
-            tablefmt=tablefmt,
-            stralign="right",
-            numalign="right",
-            floatfmt=floatfmt)
+        name = "Name: " + self.name if self.name is not None else ""
+        units = "Units: " + json.dumps(
+            {flow.name: flow.units.__str__() for flow in self.flows}, indent=4
+        )
+        flows = (
+            "Flows: "
+            + os.linesep
+            + self._format_flows(decimals=decimals).to_markdown(
+                tablefmt=tablefmt, stralign="right", numalign="right", floatfmt=floatfmt
+            )
+        )
 
         print(os.linesep + os.linesep.join([name, units, flows]))
 
@@ -453,11 +441,7 @@ class Stream:
             flows.extend(other.flows)
         else:
             raise Exception("Cannot add type " + type(other).__name__ + " to Stream.")
-        return self.__class__(
-            name=self.name,
-            flows=flows,
-            frequency=self.frequency)
-
+        return self.__class__(name=self.name, flows=flows, frequency=self.frequency)
 
     def is_homogeneous(self) -> bool:
         return len(list(set(list(self.units.values())))) == 1
@@ -466,39 +450,37 @@ class Stream:
         return self.__class__(
             name=self.name,
             flows=[flow.duplicate() for flow in self.flows],
-            frequency=self.frequency)
+            frequency=self.frequency,
+        )
 
     @classmethod
-    def from_DataFrame(
-            cls,
-            name: str,
-            data: pd.DataFrame,
-            units: pint.Unit) -> Stream:
+    def from_DataFrame(cls, name: str, data: pd.DataFrame, units: pint.Unit) -> Stream:
         flows = []
         for column in data.columns:
             series = data[column]
-            flows.append(
-                Flow(
-                    movements=series,
-                    units=units,
-                    name=series.name))
+            flows.append(Flow(movements=series, units=units, name=series.name))
         return cls(
             name=name,
             flows=flows,
-            frequency=rk.duration.Type.from_value(data.index.freqstr))
+            frequency=rk.duration.Type.from_value(data.index.freqstr),
+        )
 
     def plot(
-            self,
-            flows: Dict[str, tuple] = None,
-            normalize: bool = False,
-            ):
+        self,
+        flows: Dict[str, tuple] = None,
+        normalize: bool = False,
+    ):
         """
         Plots the specified flows against each respective value range (min-max)
 
         :param flows: A dictionary of flows to plot, by name and value range (as a tuple)
         """
 
-        flows = flows if flows is not None else {flow.name: (flow.min(), flow.max()) for flow in self._resampled_flows}
+        flows = (
+            flows
+            if flows is not None
+            else {flow.name: (flow.min(), flow.max()) for flow in self._resampled_flows}
+        )
         dates = list(self.frame.index.astype(str))
 
         fig, host = plt.subplots(nrows=1, ncols=1)
@@ -507,33 +489,27 @@ class Stream:
         datums = []
         axes = []
 
-        host.set_xlabel('Date')
+        host.set_xlabel("Date")
         # host.set_xticklabels(host.get_xticks(), rotation=90)
-        host.set_facecolor('white')
-        host.grid(axis='x',
-                  color='gainsboro',
-                  which='major',
-                  linewidth=1)
-        host.grid(axis='y',
-                  color='gainsboro',
-                  which='major',
-                  linewidth=1)
-        host.grid(axis='y',
-                  color='whitesmoke',
-                  which='minor',
-                  linestyle='-.',
-                  linewidth=0.5)
+        host.set_facecolor("white")
+        host.grid(axis="x", color="gainsboro", which="major", linewidth=1)
+        host.grid(axis="y", color="gainsboro", which="major", linewidth=1)
+        host.grid(
+            axis="y", color="whitesmoke", which="minor", linestyle="-.", linewidth=0.5
+        )
 
         primary_flow_name = list(flows.keys())[0]
-        primary, = host.plot(dates,
-                             self.frame[primary_flow_name],
-                             color=plt.cm.viridis(0),
-                             label=primary_flow_name)
+        (primary,) = host.plot(
+            dates,
+            self.frame[primary_flow_name],
+            color=plt.cm.viridis(0),
+            label=primary_flow_name,
+        )
         host.spines.left.set_linewidth(1)
         host.set_ylabel(primary_flow_name)
         host.yaxis.label.set_color(primary.get_color())
         host.spines.left.set_color(primary.get_color())
-        host.tick_params(axis='y', colors=primary.get_color(), **tkw)
+        host.tick_params(axis="y", colors=primary.get_color(), **tkw)
 
         datums.append(primary)
         axes.append(host)
@@ -542,11 +518,12 @@ class Stream:
         if normalize:
             for i in range(1, len(flows)):
                 additional_flow_name = list(flows.keys())[i]
-                additional, = host.plot(
+                (additional,) = host.plot(
                     dates,
                     self.frame[additional_flow_name],
                     color=plt.cm.viridis(1 / (len(flows) + 1)),
-                    label=additional_flow_name)
+                    label=additional_flow_name,
+                )
                 datums.append(additional)
 
         else:
@@ -555,19 +532,24 @@ class Stream:
             if len(flows) > 1:
                 secondary_flow_name = list(flows.keys())[1]
                 right = host.twinx()
-                secondary, = right.plot(dates,
-                                        self.frame[secondary_flow_name],
-                                        color=plt.cm.viridis(1 / (len(flows) + 1)),
-                                        label=secondary_flow_name)
+                (secondary,) = right.plot(
+                    dates,
+                    self.frame[secondary_flow_name],
+                    color=plt.cm.viridis(1 / (len(flows) + 1)),
+                    label=secondary_flow_name,
+                )
                 right.spines.right.set_visible(True)
                 right.spines.right.set_linewidth(1)
                 right.set_ylabel(secondary_flow_name)
                 right.grid(False)
                 right.yaxis.label.set_color(secondary.get_color())
                 right.spines.right.set_color(secondary.get_color())
-                right.tick_params(axis='y', colors=secondary.get_color(), **tkw)
+                right.tick_params(axis="y", colors=secondary.get_color(), **tkw)
                 # if flows[secondary_flow] is not None:
-                right.set_ylim(bottom=flows[secondary_flow_name][0], top=flows[secondary_flow_name][1])
+                right.set_ylim(
+                    bottom=flows[secondary_flow_name][0],
+                    top=flows[secondary_flow_name][1],
+                )
 
                 datums.append(secondary)
                 axes.append(right)
@@ -576,21 +558,31 @@ class Stream:
                     for i in range(2, len(flows)):
                         additional_flow_name = list(flows.keys())[i]
                         supplementary = host.twinx()
-                        additional, = supplementary.plot(dates,
-                                                         self.frame[additional_flow_name],
-                                                         color=plt.cm.viridis(i / (len(flows) + 1)),
-                                                         label=additional_flow_name)
-                        supplementary.spines.right.set_position(('axes', 1 + (i - 1) / 7.5))
+                        (additional,) = supplementary.plot(
+                            dates,
+                            self.frame[additional_flow_name],
+                            color=plt.cm.viridis(i / (len(flows) + 1)),
+                            label=additional_flow_name,
+                        )
+                        supplementary.spines.right.set_position(
+                            ("axes", 1 + (i - 1) / 7.5)
+                        )
                         supplementary.spines.right.set_visible(True)
                         supplementary.spines.right.set_linewidth(1)
                         supplementary.set_ylabel(additional_flow_name)
                         supplementary.grid(False)
                         supplementary.yaxis.label.set_color(additional.get_color())
                         supplementary.spines.right.set_color(additional.get_color())
-                        supplementary.tick_params(axis='y', colors=additional.get_color(), **tkw)
+                        supplementary.tick_params(
+                            axis="y", colors=additional.get_color(), **tkw
+                        )
                         if flows[additional_flow_name] is not None:
                             supplementary.set_ylim(
-                                [flows[additional_flow_name][0], flows[additional_flow_name][1]])
+                                [
+                                    flows[additional_flow_name][0],
+                                    flows[additional_flow_name][1],
+                                ]
+                            )
 
                         datums.append(additional)
                         axes.append(supplementary)
@@ -599,23 +591,22 @@ class Stream:
         legend = axes[-1].legend(
             datums,
             labels,
-            loc='best',
+            loc="best",
             title=self.name,
             title_fontsize=8,
             fontsize=7,
             facecolor="white",
             frameon=True,
             framealpha=1,
-            borderpad=.75,
-            edgecolor='grey')
+            borderpad=0.75,
+            edgecolor="grey",
+        )
         fig.autofmt_xdate(rotation=90)
         plt.minorticks_on()
         # plt.tight_layout()
         plt.show(block=True)
 
-    def extract(
-            self,
-            flow_name: str) -> Flow:
+    def extract(self, flow_name: str) -> Flow:
         """
         Extract an Stream's resampled flow as a Flow
         :param flow_name:
@@ -625,32 +616,38 @@ class Stream:
             name=flow_name,
             data=list(self.frame[flow_name]),
             sequence=self.frame.index,
-            units=self.units[flow_name])
+            units=self.units[flow_name],
+        )
 
-    def sum(
-            self,
-            name: str = None) -> Flow:
+    def sum(self, name: str = None) -> Flow:
         """
         Returns a Flow whose movements are the sum of the Stream's flows by period
         :return: Flow
         """
         # Check if all units are the same:
         if not len(list(set(list(self.units.values())))) == 1:
-            raise ValueError("Error: summation requires all flows' units to be the same. Units: {0}".format(
-                json.dumps(
-                    {flow.name: flow.units.__str__() for flow in self.flows}, indent=4)))
+            raise ValueError(
+                "Error: summation requires all flows' units to be the same. Units: {0}".format(
+                    json.dumps(
+                        {flow.name: flow.units.__str__() for flow in self.flows},
+                        indent=4,
+                    )
+                )
+            )
 
         return Flow.from_sequence(
-            name=name if name is not None else self.name + ' (sum)',
+            name=name if name is not None else self.name + " (sum)",
             sequence=self.frame.index,
             data=self.frame.sum(axis=1).to_list(),
-            units=next(iter(self.units.values())))
+            units=next(iter(self.units.values())),
+        )
 
     def product(
-            self,
-            name: str = None,
-            registry: pint.UnitRegistry = None,
-            scope: Optional[dict] = None) -> Flow:
+        self,
+        name: str = None,
+        registry: pint.UnitRegistry = None,
+        scope: Optional[dict] = None,
+    ) -> Flow:
         """
         Returns a Flow whose movements are the product of the Stream's flows by period
         :return: Flow
@@ -661,72 +658,116 @@ class Stream:
         # singleton = eval(' * '.join(singleton), scope)
         registry = registry if registry is not None else rk.measure.Index.registry
         units = rk.measure.multiply_units(
-            units=list(self.units.values()),
-            registry=registry)
+            units=list(self.units.values()), registry=registry
+        )
         reduced_units = rk.measure.remove_dimension(
-            quantity=registry.Quantity(1, units),
-            dimension='[time]',
-            registry=registry).units
+            quantity=registry.Quantity(1, units), dimension="[time]", registry=registry
+        ).units
 
         return Flow.from_sequence(
-            name=name if name is not None else self.name + ' (product)',
+            name=name if name is not None else self.name + " (product)",
             sequence=self.frame.index,  # .to_period(),
             data=self.frame.prod(axis=1).to_list(),
-            units=reduced_units)
+            units=reduced_units,
+        )
 
-    def min(
-            self,
-            name):
+    def min(self, name):
         """
         Returns a Flow whose movements are the minimum of the Stream's flows by period
         """
         if not self.is_homogeneous():
-            raise ValueError("Error: minimum requires all flows' units to be the same. Units: {0}".format(
-                json.dumps(
-                    {flow.name: flow.units.__str__() for flow in self.flows}, indent=4)))
+            raise ValueError(
+                "Error: minimum requires all flows' units to be the same. Units: {0}".format(
+                    json.dumps(
+                        {flow.name: flow.units.__str__() for flow in self.flows},
+                        indent=4,
+                    )
+                )
+            )
         else:
-            name=name if name is not None else self.name + ' (min)'
+            name = name if name is not None else self.name + " (min)"
             return Flow.from_sequence(
                 sequence=self.frame.index,
                 data=self.frame.min(axis=1).to_list(),
                 units=next(iter(self.units.values())),
-                name=name)
+                name=name,
+            )
 
-    def max(
-            self,
-            name):
+    def max(self, name):
         """
         Returns a Flow whose movements are the maximum of the Stream's flows by period
         """
         if not self.is_homogeneous():
-            raise ValueError("Error: maximum requires all flows' units to be the same. Units: {0}".format(
-                json.dumps(
-                    {flow.name: flow.units.__str__() for flow in self.flows}, indent=4)))
+            raise ValueError(
+                "Error: maximum requires all flows' units to be the same. Units: {0}".format(
+                    json.dumps(
+                        {flow.name: flow.units.__str__() for flow in self.flows},
+                        indent=4,
+                    )
+                )
+            )
         else:
-            name=name if name is not None else self.name + ' (max)'
+            name = name if name is not None else self.name + " (max)"
             return Flow.from_sequence(
                 sequence=self.frame.index,
                 data=self.frame.max(axis=1).to_list(),
                 units=next(iter(self.units.values())),
-                name=name)
+                name=name,
+            )
 
     def collapse(self) -> Stream:
         """
         Returns an Stream with Flows' movements collapsed (summed) to the Stream's final period
         :return: Stream
         """
-        flows = [self.extract(flow_name=flow_name) for flow_name in list(self.frame.columns)]
+        flows = [
+            self.extract(flow_name=flow_name) for flow_name in list(self.frame.columns)
+        ]
         return self.__class__(
             name=self.name,
             flows=[flow.collapse() for flow in flows],
-            frequency=self.frequency)
+            frequency=self.frequency,
+        )
 
     def total(self) -> np.float64:
         return self.sum().collapse().movements.iloc[0]
 
+    # def append(
+    #         self,
+    #         flows: [Flow]) -> None:
+    #     """
+    #     Appends a list of Flows to the Stream
+    #     :param flows:
+    #     :type flows:
+    #     :return:
+    #     :rtype:
+    #     """
+    #     # if any(flow.units != self.units for flow in flows):
+    #     #     raise Exception("Input Flows have dissimilar units. Cannot aggregate into Stream.")
+    #
+    #     # Append Flows:
+    #     self.flows.extend(flows)
+    #
+    #     # Append Units:
+    #     self.units.update({flow.name: flow.units for flow in flows})
+    #
+    #     # Stream:
+    #     flows_dates = list(
+    #         itertools.chain.from_iterable(list(flow.movements.index.array) for flow in self.flows))
+    #     self.start_date = min(flows_dates)
+    #     self.end_date = max(flows_dates)
+    #
+    #     # sequence = rk.duration.Sequence.from_bounds(
+    #     #     include_start=self.start_date,
+    #     #     frequency=self.frequency,
+    #     #     bound=self.end_date)
+    #     _resampled_flows = [flow.to_periods(frequency=self.frequency) for flow in self.flows]
+    #     self.frame = pd.concat(_resampled_flows, axis=1).fillna(0)
+
     def append(
-            self,
-            flows: [Flow]) -> None:
+        self,
+        flows: [Flow],
+    ):
         """
         Appends a list of Flows to the Stream
         :param flows:
@@ -734,39 +775,17 @@ class Stream:
         :return:
         :rtype:
         """
-        # if any(flow.units != self.units for flow in flows):
-        #     raise Exception("Input Flows have dissimilar units. Cannot aggregate into Stream.")
-
-        # Append Flows:
-        self.flows.extend(flows)
-
-        # Append Units:
-        self.units.update({flow.name: flow.units for flow in flows})
-
-        # Stream:
-        flows_dates = list(
-            itertools.chain.from_iterable(list(flow.movements.index.array) for flow in self.flows))
-        self.start_date = min(flows_dates)
-        self.end_date = max(flows_dates)
-
-        # sequence = rk.duration.Sequence.from_bounds(
-        #     include_start=self.start_date,
-        #     frequency=self.frequency,
-        #     bound=self.end_date)
-        _resampled_flows = [flow.to_periods(frequency=self.frequency) for flow in self.flows]
-        self.frame = pd.concat(_resampled_flows, axis=1).fillna(0)
 
-    def resample(
-            self,
-            frequency: rk.duration.Type) -> Stream:
-        return Stream(
+        return self.__class__(
             name=self.name,
-            flows=self.flows,
-            frequency=frequency)
+            flows=self.flows + flows,
+            frequency=self.frequency,
+        )
+
+    def resample(self, frequency: rk.duration.Type) -> Stream:
+        return Stream(name=self.name, flows=self.flows, frequency=frequency)
 
-    def trim_to_span(
-            self,
-            span: rk.span.Span) -> Stream:
+    def trim_to_span(self, span: rk.span.Span) -> Stream:
         """
         Returns an Stream with all flows trimmed to the specified Span
         :param span:
@@ -775,22 +794,18 @@ class Stream:
         return self.__class__(
             name=self.name,
             flows=[flow.duplicate().trim_to_span(span) for flow in self.flows],
-            frequency=self.frequency)
+            frequency=self.frequency,
+        )
 
     @classmethod
-    def merge(
-            cls,
-            streams,
-            name: str,
-            frequency: rk.duration.Type) -> Stream:
+    def merge(cls, streams, name: str, frequency: rk.duration.Type) -> Stream:
         # Check Units:
         if any(stream.units != streams[0].units for stream in streams):
-            raise Exception("Input Streams have dissimilar units. Cannot merge into Stream.")
+            raise Exception(
+                "Input Streams have dissimilar units. Cannot merge into Stream."
+            )
 
         # Aggregands:
         flows = [flow for stream in streams for flow in stream.flows]
 
-        return cls(
-            name=name,
-            flows=flows,
-            frequency=frequency)
+        return cls(name=name, flows=flows, frequency=frequency)