rangekeeper 0.1.0__py3-none-any.whl

rangekeeper/__init__.py

@@ -0,0 +1,40 @@
+from . import api as api
+from . import distribution as distribution
+from . import extrapolation as extrapolation
+from . import flux as flux
+from . import graph as graph
+from . import measure as measure
+from . import periodicity as periodicity
+from . import policy as policy
+from . import projection as projection
+from . import span as span
+from . import segmentation as segmentation
+from . import space as space
+
+from . import dynamics as dynamics
+
+from . import models as models
+
+# Helper Methods:
+import functools
+
+
+def update_class(
+        main_class=None, exclude=("__module__", "__name__", "__dict__", "__weakref__")
+        ):
+    """Class decorator. Adds all methods and members from the wrapped class to main_class
+
+    Args:
+    - main_class: class to which to append members. Defaults to the class with the same name as the wrapped class
+    - exclude: black-list of members which should not be copied
+    """
+
+    def decorates(main_class, exclude, appended_class):
+        if main_class is None:
+            main_class = locals()[appended_class.__name__]
+        for k, v in appended_class.__dict__.items():
+            if k not in exclude:
+                setattr(main_class, k, v)
+        return main_class
+
+    return functools.partial(decorates, main_class, exclude)

rangekeeper/api.py

@@ -0,0 +1,88 @@
+import specklepy
+import specklepy.api.credentials
+import specklepy.api.client
+from specklepy.transports.server import ServerTransport
+from specklepy.api import operations
+from specklepy import objects
+from specklepy.api.wrapper import StreamWrapper
+
+
+class Speckle:
+    def __init__(
+            self,
+            host="speckle.xyz",
+            token=None):
+
+        print("Connecting to {} with {}".format(host, token))
+        self.client = specklepy.api.client.SpeckleClient(host=host)
+        account = specklepy.api.credentials.get_account_from_token(token, host)
+        self.client.authenticate_with_account(account)
+        print(self.client)
+
+    def get_item(
+            self,
+            stream_id: str,
+            commit_id: str):
+        stream = self.client.stream.get(id=stream_id)
+        transport = ServerTransport(client=self.client, stream_id=stream_id)
+        # latest_commit = stream.branches.items[0].commits.items[0]
+
+        commit = self.client.commit.get(stream_id, commit_id)
+        received_base = operations.receive(obj_id=commit.referencedObject, remote_transport=transport)
+        data = received_base
+        return data
+
+
+    # @staticmethod
+    # def query(
+    #         stream_id: str,
+    #         commit_id: str,
+    #         host: str = 'https://speckle.xyz/',
+    #         account: specklepy.api.credentials.Account = None):
+    #     foo = 1
+    #     account = get_default_account() if account is None else account
+    #     client = SpeckleClient(host=host)
+    #     client.authenticate_with_account(account)
+    #
+    #     commit = client.commit.get(stream_id, commit_id)
+    #     transport = ServerTransport(client=client, stream_id=stream_id)
+    #
+    #     obj = operations.receive(commit.referencedObject, transport)
+    #
+    #     data = obj['data']
+    #
+    #     return data
+    #
+    # @staticmethod
+    # def query2(resource: str):
+    #     wrapper = StreamWrapper(resource)
+    #     client = wrapper.get_client()
+    #     transport = wrapper.get_transport()
+    #
+    #     commit_id = wrapper.commit_id
+    #
+    #     commit = client.commit.get(wrapper.stream_id, commit_id)
+    #
+    #     obj = client.object.get(wrapper.stream_id, wrapper.object_id)
+    #
+    #     return client.object.get(wrapper.stream_id, obj.get_id())#[obj.get_dynamic_member_names()[0]].id
+    #     # obj = operations.receive(commit.referencedObject, transport)
+    #
+    #
+    #
+    #
+    #
+    #
+    #
+    #
+    #
+    #     # or whatever your host is
+
+#
+# class Conversion:
+#     @staticmethod
+#     def from_speckle(
+#             element: specklepy.objects.Base
+#             ):
+#         foo = specklepy.objects.base.Base()
+#         foo.totalChildrenCount

rangekeeper/distribution.py

@@ -0,0 +1,269 @@
+from typing import Optional
+
+import enum
+import numpy as np
+import scipy.stats as ss
+from abc import abstractmethod
+
+
+class Type(enum.Enum):
+    UNIFORM = 'Uniform'  # Continuous uniform distribution or rectangular distribution
+    TRIANGULAR = 'Triangular'  # Continuous linear distribution with lower limit a, upper limit b and mode c, where a < b and a ≤ c ≤ b.
+    NORMAL = 'Normal'  # Continuous probability distribution defined as the limiting case of a discrete binomial distribution.
+    PERT = 'PERT'  # Transformation of the four-parameter Beta distribution defined by the minimum, most likely, and maximum values.
+
+
+class Form:
+    type: Type
+
+    def __init__(
+            self,
+            generator: Optional[np.random.Generator] = None):
+        self.generator = generator
+        self.dist = ss.rv_continuous()
+
+    def sample(
+            self,
+            size: int = 1):
+
+        if hasattr(self.dist, 'b'):
+            if self.dist.b == 0.:
+                return self.dist.a  # If the distribution is a point mass, return the value of the point mass
+
+        if self.generator is None:
+            generator = np.random.default_rng()
+        else:
+            generator = self.generator
+        return self.dist.rvs(size=size, random_state=generator)
+
+        # if size == 1:
+        #     return variates[0]
+        # else:
+        #     return variates
+
+    @abstractmethod
+    def interval_density(
+            self,
+            parameters: [float]):
+        """
+        Returns the cumulative density (integral of the interpolated curve)
+        between n parameter pairs as intervals (i.e. returns n-1 results)
+
+        :param parameters: Any set of floats between 0 and 1
+        :return: List of floats representing the cumulative density of that interval.
+        If the input parameters span 0 to 1, the sum of the interval densities will reach 1.
+        """
+
+        if (all(parameters) >= 0) & (all(parameters) <= 1):
+            return [(self.dist.cdf(parameters[i + 1]) - self.dist.cdf(parameters[i]))
+                    for i in (range(0, len(parameters) - 1))]
+        else:
+            raise ValueError("Error: Parameter must be between 0 and 1 inclusive")
+
+    @abstractmethod
+    def cumulative_density(
+            self,
+            parameters: [float]):
+        """
+        Returns the cumulative distribution at parameters between 0 and 1.
+        """
+        if (all(parameters) >= 0) & (all(parameters) <= 1):
+            return [self.dist.cdf(parameter) for parameter in parameters]
+        else:
+            raise ValueError("Error: Parameter must be between 0 and 1 inclusive")
+
+
+class Symmetric(Form):
+    def __init__(
+            self,
+            type: Type,
+            residual: float,
+            mean: float = 0,
+            generator: Optional[np.random.Generator] = None):
+        """
+        Parameters that define the mean and residual (maximum deviation)
+        of a symmetric distribution
+
+        :param type: Type of symmetric distribution
+        :param residual: Maximum deviation from the mean
+        :param mean: Mean of the distribution. Defaults to 0.
+        """
+        super().__init__(generator=generator)
+        if type is Type.UNIFORM or type is Type.PERT or type is Type.TRIANGULAR:
+            self.type = type
+        else:
+            raise ValueError("Distribution type must be able to be symmetrical about its mean")
+        self.mean = mean
+        self.residual = residual
+        self.generator = generator
+        self.dist = self._distribution().dist
+
+    def _distribution(self):
+        if self.type == Type.UNIFORM:
+            return Uniform(
+                lower=self.mean - self.residual,
+                range=self.residual * 2,
+                generator=self.generator)
+        elif self.type == Type.PERT:
+            return PERT.symmetric(
+                peak=self.mean,
+                residual=self.residual)
+        elif self.type == Type.TRIANGULAR:
+            return Triangular.symmetric(
+                mode=self.mean,
+                residual=self.residual)
+
+    def interval_density(
+            self,
+            parameters: [float]) -> [float]:
+        return self._distribution().interval_density(parameters)
+
+    def cumulative_density(
+            self,
+            parameters: [float]) -> [float]:
+        return self._distribution().cumulative_density(parameters)
+
+
+class Uniform(Form):
+    """
+    For default arguments, this is a continuous, uniform distribution between 0 and 1,
+    such the cumulative distribution reaches 1. (For uniform distribution, this means the density is continuously 1).
+
+    For specified arguments, this distribution is constant between lower, and lower + range.
+    """
+
+    def __init__(
+            self,
+            lower: float = 0.,
+            range: float = 1.,
+            generator: Optional[np.random.Generator] = None):
+        super().__init__(generator=generator)
+        self.dist = ss.uniform(loc=lower, scale=range)
+        self.type = Type.UNIFORM
+
+    @classmethod
+    def symmetric(
+            cls,
+            mean: float,
+            residual: float,
+            generator: Optional[np.random.Generator] = None):
+        return cls(
+            lower=mean - residual,
+            range=residual * 2,
+            generator=generator)
+
+    def interval_density(
+            self,
+            parameters: [float]) -> [float]:
+        return super().interval_density(parameters)
+
+    def cumulative_density(
+            self,
+            parameters: [float]) -> [float]:
+        return super().cumulative_density(parameters)
+
+
+class Triangular(Form):
+    """
+    A continuous probability distribution with lower limit a, upper limit b and mode c, where a < b and a ≤ c ≤ b.
+    """
+
+    def __init__(
+            self,
+            lower: float = 0.,
+            upper: float = 1.,
+            mode: float = 0.5,
+            generator: Optional[np.random.Generator] = None):
+        super().__init__(generator=generator)
+        loc = lower
+        scale = upper - lower
+        if scale == 0:
+            c = lower
+        else:
+            c = (mode - lower) / (upper - lower)
+        self.dist = ss.triang(loc=loc, scale=scale, c=c)
+        self.type = Type.TRIANGULAR
+
+    @classmethod
+    def symmetric(
+            cls,
+            mode: float,
+            residual: float):
+        return cls(
+            lower=mode - residual,
+            upper=mode + residual,
+            mode=mode)
+
+    def interval_density(
+            self,
+            parameters: [float]) -> [float]:
+        return super().interval_density(parameters)
+
+    def cumulative_density(
+            self,
+            parameters: [float]) -> [float]:
+        return super().cumulative_density(parameters)
+
+
+class PERT(Form):
+    """
+    A continuous distribution that is controlled by the placement and weighting of the mode (peak) value.
+    It produces similar distributions to the Normal (Gaussian) distribution within a specified domain.
+    Its cumulative distribution function (CDF) curve is a classic 's-curve'.
+
+    Peak must be between 0 and 1. Weighting must be >= 0. Standard weighting is 4.
+
+    Specifically, it is a Beta Distribution extended to specified domain,
+    with the mean (μ) constrained so that μ = (a + Ɣ*b + c) /  (Ɣ + 2),
+    where a and c are the limits (0 and 1 in this formulation), b is the mode (peak value),
+    and Ɣ is a weighting factor for the mode.
+
+    This function is built from the formulation in Tensorflow:
+    https://github.com/tensorflow/probability/blob/master/tensorflow_probability/python/distributions/pert.py
+    """
+
+    def __init__(
+            self,
+            peak: float = 0.5,
+            weighting: float = 4.0,
+            minimum: float = 0.0,
+            maximum: float = 1.0,
+            generator: Optional[np.random.Generator] = None):
+        super().__init__(generator=generator)
+        self.type = Type.PERT
+        self.peak = peak
+        self.weighting = weighting
+        self.minimum = minimum
+        self.maximum = maximum
+        self.scale = maximum - minimum
+        if (self.weighting >= 0) & (self.peak >= minimum) & (self.peak <= maximum):
+            a = (1. + self.weighting * (self.peak - minimum) / (maximum - minimum))
+            b = (1. + self.weighting * (maximum - self.peak) / (maximum - minimum))
+            self.dist = ss.beta(
+                loc=minimum,
+                scale=self.scale,
+                a=a,
+                b=b)
+        else:
+            raise ValueError("Error: Weighting must be greater than 0 and Peak must be between 0 and 1 inclusive")
+
+    @classmethod
+    def symmetric(
+            cls,
+            peak: float,
+            residual: float):
+        return cls(
+            peak=peak,
+            weighting=4.,
+            minimum=peak - residual,
+            maximum=peak + residual)
+
+    def interval_density(
+            self,
+            parameters: [float]) -> [float]:
+        return super().interval_density(parameters)
+
+    def cumulative_density(
+            self,
+            parameters: [float]) -> [float]:
+        return super().cumulative_density(parameters)

rangekeeper/dynamics/__init__.py

@@ -0,0 +1,6 @@
+from . import cyclicality as cyclicality
+from . import market as market
+from . import trend as trend
+from . import volatility as volatility
+from . import noise as noise
+from . import black_swan as black_swan

rangekeeper/dynamics/black_swan.py

@@ -0,0 +1,77 @@
+from __future__ import annotations
+
+import numpy as np
+import pandas as pd
+from numba import jit
+
+import rangekeeper as rk
+
+
+class BlackSwan:
+    def __init__(
+            self,
+            sequence: pd.PeriodIndex,
+            likelihood: float,
+            dissipation_rate: float,
+            probability: rk.distribution.Form,
+            impact: float):
+        """
+        This random variable will determine whether a "black swan" event
+        occurs in any given year. We ensure that no more than one black
+        swan will occur in the 24-yr history, as black swans are by definition
+        rare events.
+
+        This column causes the effect of the Black Swan event to dissipate
+        over time, geometrically, at the same mean reversion rate as is
+        applied in general to the rents (entered in co.F).
+
+        This is another source or type of uncertainty in real estate pricing.
+        This will apply the given "black swan" result, but then reduces
+        the subsequent impact of the event gradually as mean-reversion
+        takes effect.
+        """
+        self.sequence = sequence
+        self.likelihood = likelihood
+        self.dissipation_rate = dissipation_rate
+        self.probability = probability
+        self.impact = impact
+
+    def generate(self) -> rk.flux.Flow:
+        return rk.flux.Flow(
+            name='Black Swan Effect',
+            movements=pd.Series(
+                data=self.calculate_black_swan_effects(
+                    likelihood=self.likelihood,
+                    dissipation_rate=self.dissipation_rate,
+                    events=self.probability.sample(self.sequence.size)),
+                index=rk.periodicity.to_datestamps(period_index=self.sequence)))
+
+    @staticmethod
+    @jit(nopython=True)
+    def calculate_black_swan_effects(
+            likelihood: float,
+            dissipation_rate: float,
+            events: [float]):
+        """
+
+        :param likelihood:
+        :type likelihood:
+        :param dissipation_rate:
+        :type dissipation_rate:
+        :param events:
+        :type events:
+        :return:
+        :rtype:
+        """
+        idx = -1
+        impacts = []
+        for i in range(len(events)):
+            if idx == -1:
+                if events[i] < likelihood:
+                    idx = i
+                    impacts.append(1)
+                else:
+                    impacts.append(0)
+            else:
+                impacts.append(np.power((1 - dissipation_rate), (i - idx)))
+        return impacts