rangekeeper 0.1.0__py3-none-any.whl

rangekeeper/graph.py

@@ -0,0 +1,144 @@
+from __future__ import annotations
+
+import json
+import uuid
+import enum
+from typing import List, Dict
+
+import networkx as nx
+from pint import Quantity
+from py_linq import Enumerable
+
+from . import measure
+
+
+#
+# class Type(enum.Enum):
+#     name: str
+#     parent: Type
+#     children: [Type]
+#
+#     def __init__(
+#             self,
+#             name: str,
+#             parent: Type = None,
+#             children: List[Type] = None):
+#         super().__init__()
+#         self.name
+#         if parent is not None:
+#             self.set_parent(parent)
+#         if children is not None:
+#             self.set_children(children)
+#         else:
+#             self.children = []
+#
+#     def __str__(self):
+#         result = self.name
+#         try:
+#             result = self.parent.__str__() + '.' + result
+#         except AttributeError:
+#             pass
+#         return result
+#
+#     def set_parent(
+#             self,
+#             parent: Type):
+#         try:
+#             self.parent.children.remove(self)
+#         except AttributeError:
+#             pass
+#         self.parent = parent
+#         parent.children.append(self)
+#
+#     def set_children(
+#             self,
+#             children: List[Type]):
+#         for child in children:
+#             child.set_parent(self)
+#
+
+class Event:
+    name: str
+    type: str
+
+
+class Element:
+    id: str
+    name: str
+    type: str
+    attributes: dict
+    events: List[Event]
+    measurements: Dict[measure.Measure, Quantity]
+
+    def __str__(self):
+        return 'Element: ' + self.name + '. Type: ' + self.type
+
+    def __init__(
+            self,
+            name: str,
+            type: str,
+            id: str = None,
+            attributes: dict = None,
+            events: List[Event] = None,
+            measurements: Dict[measure.Measure, Quantity] = None):
+        self.name = name
+        self.type = type
+        self.id = str(uuid.uuid4()) if id is None else id
+        self.attributes = {} if attributes is None else attributes
+        self.events = [] if events is None else events
+        self.measurements = {} if measurements is None else measurements
+
+    def get_relatives(
+            self,
+            assembly: Assembly,
+            relationship_type: str,
+            outgoing: bool = True) -> List[Element]:
+
+        if outgoing:
+            edges = Enumerable(
+                assembly.edges(
+                    nbunch=[self],
+                    data='type')
+                ).where(
+                lambda edge: edge[2] == relationship_type)
+            return [edge[1] for edge in edges]
+
+        else:
+            edges = Enumerable(
+                assembly.in_edges(
+                    nbunch=[self],
+                    data='type')
+                ).where(
+                lambda edge: edge[2] == relationship_type)
+            return [edge[0] for edge in edges]
+
+
+class Assembly(nx.MultiDiGraph, Element):
+    elements: Enumerable
+    relationships: Enumerable
+
+    def __init__(
+            self,
+            name: str,
+            type: str,
+            elements: List[Element],
+            relationships: List[tuple[Element, Element, str]],  # A list of tuples of the form [From, To, Type]
+            id: str = None,
+            attributes: dict = None,
+            events: List[Event] = None,
+            measurements: Dict[measure.Measure, Quantity] = None):
+        super().__init__(
+            name=name)
+        self.name = name
+        self.type = type
+        self.id = str(uuid.uuid4()) if id is None else id
+        self.attributes = {} if attributes is None else attributes
+        self.events = [] if events is None else events
+        self.measurements = {} if measurements is None else measurements
+
+        self.add_nodes_from(elements)
+        for relationship in relationships:
+            self.add_edge(relationship[0], relationship[1], type=relationship[2])
+
+        self.elements = Enumerable(self.nodes)
+        self.relationships = Enumerable(self.edges)

rangekeeper/measure.py

@@ -0,0 +1,138 @@
+from __future__ import annotations
+
+import locale
+
+import pint
+#from pint.definitions import UnitDefinition
+#from pint.converters import ScaleConverter
+import moneyed
+
+
+class Index:
+    # Define Fractions:
+    registry = pint.UnitRegistry()
+    #     preprocessors=[lambda s: s.replace('%', ' percent ')]
+    #     )
+    # # registry.define('percent = 0.01 * dimensionless = %')
+    # registry.define(UnitDefinition('percent', '%', (), ScaleConverter(1 / 100.0)))
+
+    # Add Additional Terms:
+    registry.define('squaremeter = 1 m**2 = m2 = sqm')
+    registry.define('squarefoot = 1 foot**2 = ft2 = sqft')
+
+    # Define Domain Units:
+    registry.define('zone = [space]')
+    registry.define('parking_stall = 1 * zone')
+
+    # self.registry = registry
+
+    # # Define Scalar:
+    # scalar = Measure(
+    #     name='Scalar Quantity',
+    #     definition='Dimensionless or Unitless Quantity',
+    #     units=pint.UnitRegistry().dimensionless)
+
+    # @staticmethod
+
+
+def remove_dimension(
+        quantity: pint.Quantity,
+        dimension: str,
+        registry: pint.UnitRegistry = None) -> pint.Quantity:
+    """
+    Remove a dimension from the units of a quantity. Specify the dimension as a string wrapped in square brackets (['']).
+    """
+    if dimension in quantity.dimensionality:
+        for unit_str in quantity.units._units:
+            units = registry.Unit(unit_str) if registry is not None else pint.Unit(unit_str)
+            if units.dimensionality == dimension:
+                if quantity.dimensionality[dimension] == -1:
+                    return quantity * units
+                elif quantity.dimensionality[dimension] == 1:
+                    return quantity / units
+                else:
+                    raise NotImplementedError(
+                        'Error: Dimension reduction currently only works for single-order (^1 or ^-1) dimensions.')
+    else:
+        return quantity
+
+
+def multiply_units(
+        units: [pint.Unit],
+        registry: pint.UnitRegistry = None) -> pint.Unit:
+    """
+    Multiply units together.
+    """
+    registry = registry if registry is not None else pint.UnitRegistry()
+    quantities = [registry.Quantity(1, unit) for unit in units]
+    result = 1 * registry.dimensionless
+    for quantity in quantities:
+        result *= quantity
+    return result.units
+
+
+def register_currency(
+        registry: pint.UnitRegistry):
+    # if unit_registry is None:
+    #     unit_registry = pint.UnitRegistry()
+
+    currency = moneyed.Currency(code=locale.localeconv()['int_curr_symbol'].strip())
+
+    if '[currency]' not in registry._dimensions:
+        registry.define('money = [currency]')
+        registry.define(
+            '{0} = nan money = {0} = {1}'.format(
+                ''.join(currency.code.split()),
+                ''.join(currency.name.split())))
+    else:
+        registry.define(
+            '{0} = nan money = {0} = {1}'.format(
+                ''.join(currency.code.split()),
+                ''.join(currency.name.split())))
+
+    return Measure(
+        name=currency.name,
+        definition='Currency of {0}'.format(currency.countries),
+        units=registry[currency.code].units)
+
+
+#
+# class Quantity(pint.Quantity):
+#     def __init__(
+#             self,
+#             value,
+#             units: pint.Unit
+#             ):
+#         """
+#         value : str, pint.Quantity or any numeric type. Value of the physical quantity to be created.
+#         units :
+#         """
+#         super.__init__()
+
+
+class Measure:
+    name: str
+    definition: str
+    units: pint.Unit
+
+    def __init__(
+            self,
+            name: str,
+            units: pint.Unit,
+            definition: str = None):
+        self.name = name
+        self.units = units
+        self.definition = definition
+
+    def __str__(self):
+        return 'Rangekeeper Measure: "{0}". {1}. Units: {2}'.format(
+            self.name,
+            self.definition,
+            self.units)
+
+    def __hash__(self):
+        return hash((self.name, self.units.__hash__()))
+
+    def __eq__(self, other):
+        return (self.name == other.name and
+                self.units == other.units)

rangekeeper/models/__init__.py

@@ -0,0 +1,5 @@
+from . import deterministic as deterministic
+from . import flexible as flexible
+from . import linear as linear
+from . import linear_graph as linear_graph
+from . import probabilistic as probabilistic

rangekeeper/models/deterministic.py

@@ -0,0 +1,143 @@
+import pandas as pd
+
+import rangekeeper as rk
+
+# except:
+#     import modules.rangekeeper.distribution
+#     from modules.rangekeeper.flux import Flow, Stream
+#     from modules.rangekeeper.periodicity import Periodicity
+#     from modules.rangekeeper.span import Span
+
+
+# Base Model:
+class Model:
+    def __init__(
+            self,
+            params: dict):
+
+        # Phasing:
+        self.acquisition_span = rk.span.Span.from_num_periods(
+            name='Acquisition',
+            date=params['start_date'],
+            period_type=rk.periodicity.Type.YEAR,
+            num_periods=1)
+
+        self.operation_span = rk.span.Span.from_num_periods(
+            name='Operation',
+            date=rk.periodicity.offset_date(
+                date=self.acquisition_span.end_date,
+                period_type=rk.periodicity.Type.DAY,
+                num_periods=1),
+            period_type=rk.periodicity.Type.YEAR,
+            num_periods=params['num_periods'])
+
+        self.projection_span = rk.span.Span.from_num_periods(
+            name='Projection',
+            date=rk.periodicity.offset_date(
+                date=self.operation_span.end_date,
+                period_type=rk.periodicity.Type.DAY,
+                num_periods=1),
+            period_type=rk.periodicity.Type.YEAR,
+            num_periods=1)
+
+        self.noi_calc_span = rk.span.Span.merge(
+            name='NOI Calculation Span',
+            spans=[self.operation_span, self.projection_span])
+
+        # Cashflows:
+        self.escalation = rk.extrapolation.Compounding(rate=params['growth_rate'])
+
+        # Potential Gross Income
+        self.pgi = rk.flux.Flow.from_projection(
+            name='Potential Gross Income',
+            value=params['initial_pgi'],
+            proj=rk.projection.Extrapolation(
+                form=self.escalation,
+                sequence=self.noi_calc_span.to_index(period_type=params['period_type'])),
+            units=params['units'])
+
+        self.addl_pgi = rk.flux.Flow(
+            movements=pd.Series(
+                data=range(self.pgi.movements.size),
+                index=self.pgi.movements.index,
+                dtype=float),
+            units=params['units'],
+            name='Additional PGI')
+
+        self.addl_pgi.movements = self.addl_pgi.movements * params['addl_pgi_per_period']
+        self.pgi = rk.flux.Flow(
+            movements=self.pgi.movements + self.addl_pgi.movements,
+            units=params['units'],
+            name=self.pgi.name)
+
+        # Vacancy Allowance
+        self.vacancy = rk.flux.Flow.from_periods(
+            name='Vacancy Allowance',
+            index=self.noi_calc_span.to_index(period_type=params['period_type']),
+            data=self.pgi.movements * params['vacancy_rate'],
+            units=params['units']).invert()
+
+        # Effective Gross Income:
+        self.egi = rk.flux.Stream(
+            name='Effective Gross Income',
+            flows=[self.pgi, self.vacancy],
+            period_type=params['period_type'])
+
+        # Operating Expenses:
+        self.opex = rk.flux.Flow.from_periods(
+            name='Operating Expenses',
+            index=self.noi_calc_span.to_index(period_type=params['period_type']),
+            data=self.pgi.movements * params['opex_pgi_ratio'],
+            units=params['units']).invert()
+
+        # Net Operating Income:
+        self.noi = rk.flux.Stream(
+            name='Net Operating Income',
+            flows=[self.egi.sum('Effective Gross Income'), self.opex],
+            period_type=params['period_type'])
+
+        # Capital Expenses:
+        self.capex = rk.flux.Flow.from_periods(
+            name='Capital Expenditures',
+            index=self.noi_calc_span.to_index(period_type=params['period_type']),
+            data=self.pgi.movements * params['capex_pgi_ratio'],
+            units=params['units']).invert()
+
+        # Net Cashflows:
+        self.ncf = rk.flux.Stream(
+            name='Net Cashflows',
+            flows=[self.noi.sum(), self.capex],
+            period_type=params['period_type'])
+
+        # Disposition
+        # We require each next period's NCF as the numerator:
+        sale_values = list(self.ncf.sum().movements.iloc[1:] / params['cap_rate'])
+        self.disposition = rk.flux.Flow.from_periods(
+            name='Disposition',
+            # We no longer need the noi_calc_span:
+            index=self.operation_span.to_index(period_type=params['period_type']),
+            data=sale_values,
+            units=params['units'])
+
+        # Calculate the Present Value of the NCFs:
+        self.pv_ncf = self.ncf.sum().pv(
+            period_type=params['period_type'],
+            discount_rate=params['discount_rate'])
+
+        # Calculate the Present Value of Reversion CFs:
+        self.pv_disposition = self.disposition.pv(
+            period_type=params['period_type'],
+            discount_rate=params['discount_rate'])
+
+        # Add Cumulative Sum of Discounted Net Cashflows to each period's Discounted Disposition
+        pv_ncf_cumsum = rk.flux.Flow(
+            movements=self.pv_ncf.movements.cumsum(),
+            name='Discounted Net Cashflow Cumulative Sums',
+            units=params['units'])
+        self.pv_ncf_agg = rk.flux.Stream(
+            name='Discounted Net Cashflow Sums',
+            flows=[pv_ncf_cumsum, self.pv_disposition],
+            period_type=params['period_type'])
+
+        self.pv_sums = self.pv_ncf_agg.sum()
+        self.pv_sums.movements = self.pv_sums.movements[:-1]

rangekeeper/models/flexible.py

@@ -0,0 +1,177 @@
+import pandas as pd
+
+import rangekeeper as rk
+
+
+# Base Model:
+class Model:
+    def __init__(
+            self,
+            params: dict):
+
+        # Phasing:
+        self.acquisition_span = rk.span.Span.from_num_periods(
+            name='Acquisition',
+            date=params['start_date'],
+            period_type=rk.periodicity.Type.YEAR,
+            num_periods=1)
+
+        self.operation_span = rk.span.Span.from_num_periods(
+            name='Operation',
+            date=rk.periodicity.offset_date(
+                date=self.acquisition_span.end_date,
+                period_type=rk.periodicity.Type.DAY,
+                num_periods=1),
+            period_type=rk.periodicity.Type.YEAR,
+            num_periods=params['num_periods'])
+
+        self.disposition_span = rk.span.Span.from_num_periods(
+            name='Disposition',
+            date=rk.periodicity.offset_date(
+                date=self.acquisition_span.start_date,
+                period_type=rk.periodicity.Type.YEAR,
+                num_periods=params['num_periods']),
+            period_type=rk.periodicity.Type.YEAR,
+            num_periods=1)
+
+        self.projection_span = rk.span.Span.from_num_periods(
+            name='Projection',
+            date=rk.periodicity.offset_date(
+                date=self.operation_span.end_date,
+                period_type=rk.periodicity.Type.DAY,
+                num_periods=1),
+            period_type=rk.periodicity.Type.YEAR,
+            num_periods=1)
+
+        self.noi_calc_span = rk.span.Span.merge(
+            name='NOI Calculation Span',
+            spans=[self.operation_span, self.projection_span])
+
+        # Cashflows:
+        self.escalation = rk.extrapolation.Compounding(rate=params['growth_rate'])
+
+        # Potential Gross Income
+        self.pgi = rk.flux.Flow.from_projection(
+            name='Potential Gross Income',
+            value=params['initial_pgi'],
+            proj=rk.projection.Extrapolation(
+                form=self.escalation,
+                sequence=self.noi_calc_span.to_index(period_type=params['period_type'])),
+            units=params['units'])
+
+        factors = params['space_market_dist'].sample(size=self.pgi.movements.size)
+        self.pgi_factor = rk.flux.Flow(
+            movements=pd.Series(
+                data=factors,
+                index=self.pgi.movements.index,
+                dtype=float),
+            units=params['units'],
+            name='Space Market Pricing Factors')
+
+        self.pgi = rk.flux.Flow(
+            movements=self.pgi.movements * self.pgi_factor.movements,
+            units=params['units'],
+            name=self.pgi.name)
+
+        # Vacancy Allowance
+        self.vacancy = rk.flux.Flow.from_periods(
+            name='Vacancy Allowance',
+            index=self.noi_calc_span.to_index(period_type=params['period_type']),
+            data=self.pgi.movements * params['vacancy_rate'],
+            units=params['units']).invert()
+
+        # Effective Gross Income:
+        self.egi = rk.flux.Stream(
+            name='Effective Gross Income',
+            flows=[self.pgi, self.vacancy],
+            period_type=params['period_type'])
+
+        # Operating Expenses:
+        self.opex = rk.flux.Flow.from_periods(
+            name='Operating Expenses',
+            index=self.noi_calc_span.to_index(period_type=params['period_type']),
+            data=self.pgi.movements * params['opex_pgi_ratio'],
+            units=params['units']).invert()
+
+        # Net Operating Income:
+        self.noi = rk.flux.Stream(
+            name='Net Operating Income',
+            flows=[self.egi.sum('Effective Gross Income'), self.opex],
+            period_type=params['period_type'])
+
+        # Capital Expenses:
+        self.capex = rk.flux.Flow.from_periods(
+            name='Capital Expenditures',
+            index=self.noi_calc_span.to_index(period_type=params['period_type']),
+            data=self.pgi.movements * params['capex_pgi_ratio'],
+            units=params['units']).invert()
+
+        # Net Cashflows:
+        self.ncf = rk.flux.Stream(
+            name='Net Cashflows',
+            flows=[self.noi.sum(), self.capex],
+            period_type=params['period_type'])
+
+        # Reversion:
+        # We no longer need the noi_calc_span:
+        operation_periods = self.operation_span.to_index(period_type=params['period_type'])
+        self.cap_rates = params['asset_market_dist'].sample(size=operation_periods.size)
+        self.sale_values = rk.flux.Flow.from_periods(
+            name='Sale Values',
+            # We no longer need the noi_calc_span:
+            index=operation_periods,
+            data=list(self.ncf.sum().movements[
+                      :self.operation_span.end_date] / self.cap_rates),
+            units=params['units'])
+
+        # Flexibility Rules:
+        disposition_flags = []
+        for i in range(self.sale_values.movements.size):
+            flag = False
+            if i > 1:
+                if not any(disposition_flags):
+                    if self.pgi_factor.movements[i] > 1.2:
+                        self.disposition_date = self.sale_values.movements.index[i]
+                        flag = True
+            disposition_flags.append(flag)
+
+        self.disposition = rk.flux.Flow(
+            name="Disposition",
+            movements=pd.Series(
+                data=self.sale_values.movements * disposition_flags,
+                index=self.sale_values.movements.index),
+            units=params['units'])
+
+        # Calculate the Present Value of the NCFs:
+        self.pv_ncf = self.ncf.sum().pv(
+            period_type=params['period_type'],
+            discount_rate=params['discount_rate'])
+
+        # Calculate the Present Value of Disposition CFs:
+        self.pv_disposition = self.disposition.pv(
+            period_type=params['period_type'],
+            discount_rate=params['discount_rate'])
+
+        self.pv_ncf_agg = rk.flux.Stream(
+            name='Discounted Net Cashflow Sums',
+            flows=[self.pv_ncf, self.pv_disposition],
+            period_type=params['period_type'])
+
+        self.pv_sums = self.pv_ncf_agg.sum()
+
+        self.pv_sums.movements = self.pv_sums.movements[:self.disposition_date]
+
+        self.acquisition = rk.flux.Flow.from_periods(
+            index=self.acquisition_span.to_index(rk.periodicity.Type.YEAR),
+            data=[-abs(params['acquisition_price'])],
+            units=params['units'],
+            name='Acquisition Price')
+
+        self.investment_cashflows = rk.flux.Stream(
+            name='Investment Cashflows',
+            flows=[self.ncf.sum(), self.disposition, self.acquisition],
+            period_type=params['period_type'])
+
+        self.investment_cashflows.frame = self.investment_cashflows.frame[:self.disposition_date]
+        self.irr = self.investment_cashflows.sum().xirr()
+        self.npv = self.investment_cashflows.sum().xnpv(params['discount_rate'])