sunpeek-common-utils 0.1.0.dev6__py3-none-any.whl

sunpeek_common_utils/errors.py

@@ -0,0 +1,83 @@
+class SunPeekError(Exception):
+    pass
+
+
+class ConfigurationError(SunPeekError):
+    pass
+
+
+class IncompatibleUnitError(SunPeekError):
+    """Supplied unit (of raw sensor) is not compatible with the expected unit, e.g. as defined in SensorType.
+    """
+    pass
+
+
+class VirtualSensorConfigurationError(SunPeekError):
+    """Error in calcluation of virtual sensor due to missing input or input being None.
+    """
+    pass
+
+
+class PCMethodError(SunPeekError):
+    """General error in definition / configuration / calculation of PC method.
+    """
+    pass
+
+
+class CalculationError(SunPeekError):
+    """General error in definition / handling of virtual senso.
+    """
+    pass
+
+
+class AlgorithmError(SunPeekError):
+    """Error in some core_method algorithm.
+    """
+    pass
+
+
+class DuplicateNameError(SunPeekError):
+    """Error due to creating a component with a duplicate name, where this is not allowed"""
+    pass
+
+
+class SensorNotFoundError(SunPeekError):
+    """Error due to not finding a sensor when one was expected to exist"""
+    pass
+
+
+class SensorDataNotFoundError(SunPeekError):
+    """Error due to not finding a data column for a sensor in the current data store"""
+    pass
+
+
+class NoDataError(SunPeekError):
+    """No data are available in the selected data range"""
+    pass
+
+
+class TimeIndexError(SunPeekError):
+    """Error handling or retrieving plant.time_index."""
+    pass
+
+
+class TimeZoneError(SunPeekError):
+    """Error related to time zone"""
+    pass
+
+
+class DataProcessingError(SunPeekError):
+    """Error related to data upload and processing"""
+    pass
+
+
+class DatabaseAlreadyExistsError(SunPeekError):
+    pass
+
+
+class CollectorDefinitionError(SunPeekError):
+    """Error in Collector definition.
+    E.g. if supplied information is contradictory or not sufficient for full Collector definition.
+    See #70 for valid Collector definitions.
+    """
+    pass

sunpeek_common_utils/helpers.py

@@ -0,0 +1,151 @@
+import numpy as np
+import sqlalchemy
+from sqlalchemy import Column, Float, JSON, String
+import sunpeek_common_utils.unit_uncertainty as uu
+from sunpeek_common_utils.errors import ConfigurationError
+from sunpeek_common_utils.unit_uncertainty import Q
+
+
+
+class ComponentParam:
+    """Used to define parameters which are represented by Quantities, with optional limit checking.
+
+    Attributes
+    ----------
+    unit: compatible unit
+    minimum: value of the parameters should not be below this
+    maximum: value of the parameters should not be above this
+    array_type: either "scalar" or "array", defaults to used to create the correct database column types and apply checks correctly.
+    """
+
+    def __init__(self, unit: str = None, minimum: float = -np.inf, maximum: float = np.inf, param_type: str = 'scalar'):
+        self.unit = unit
+        self.minimum = minimum
+        self.maximum = maximum
+        self.array_type = param_type
+
+class AttrSetterMixin:
+    name = None
+    defer_post_config_changed_actions = False
+
+    @classmethod
+    def define_component_attrs(cls):
+        for sub_cls in cls.all_subclasses():
+            # Get all ComponentParam from all component / subclass attributes
+            params = {attr: obj for attr, obj in sub_cls.__dict__.items() if isinstance(obj, ComponentParam)}
+            for attr, obj in params.items():
+                sub_cls.add_component_attr(attr, obj.unit, obj.minimum, obj.maximum, obj.array_type)
+
+    @classmethod
+    def add_component_attr(cls, name, unit=None, minimum=-np.inf, maximum=np.inf, array_type='scalar'):
+        if array_type == 'scalar':
+            setattr(cls, f'_{name}_mag', Column(Float))
+        elif 'array':
+            setattr(cls, f'_{name}_mag', Column(JSON))
+        setattr(cls, f'_{name}_unit', Column(String))
+        prop = property(fset=lambda cls, value: cls.set_component_attribute(name, value, array_type),
+                        fget=lambda cls: cls.get_component_attribute(name))
+        setattr(cls, name, prop)
+        if not hasattr(cls, '_attr_props'):
+            cls._attr_props = {}
+        cls._attr_props[name] = {'unit': unit, 'minimum': minimum, 'maximum': maximum}
+        # print (self.attr_props[name])
+
+    @classmethod
+    def all_subclasses(cls, c=None):
+        if c is None: c = cls
+        return set(c.__subclasses__()).union(
+            [s for c in cls.__subclasses__() for s in c.all_subclasses(c)])
+
+    @classmethod
+    def register_callback(cls, callback_type, func):
+        print(cls)
+        try:
+            getattr(cls, callback_type).append(func)
+        except AttributeError:
+            cls.post_config_changed_callbacks = [func]
+
+    def _check_value(self, name, value, param_type):
+        unit = self._attr_props[name]['unit']
+
+        uu.assert_compatible(value.units, unit)
+
+        val = value.to(unit).magnitude
+        min = self._attr_props[name]['minimum']
+        max = self._attr_props[name]['maximum']
+
+        if param_type == 'scalar' or param_type is None:
+            if isinstance(value.magnitude, np.ndarray):
+                raise ConfigurationError("Attempting to assign an array quantity to a scalar type parameter")
+            if val < min:
+                raise ConfigurationError(
+                    f"attempting to set a value for attribute {name} that is less than the minimum of {min}{unit}")
+            if val > max:
+                raise ConfigurationError(
+                    f"attempting to set a value for attribute {name} that is greater than the maximum of {max}{unit}")
+
+        if param_type == 'array':
+            if not isinstance(value.magnitude, np.ndarray):
+                raise ConfigurationError("Attempting to assign an array quantity to a scalar type parameter")
+            if (val < min).any():
+                raise ConfigurationError(
+                    f"attempting to set a value for attribute {name} that is less than the minimum of {min}{unit}")
+            if (val > max).any():
+                raise ConfigurationError(
+                    f"attempting to set a value for attribute {name} that is greater than the maximum of {max}{unit}")
+
+    def set_component_attribute(self, name, value, array_type):
+        if value is not None:
+            value = uu.parse_quantity(value)
+            if not self._attr_props[name]['unit'] == 'no_check':
+                self._check_value(name, value, array_type)
+
+            if array_type == 'scalar' or array_type is None:
+                mag = value.magnitude
+            elif array_type == 'array':
+                mag = value.magnitude.tolist()
+            else:
+                raise ValueError("type must be either 'scalar' or 'array'")
+
+            setattr(self, f'_{name}_mag', mag)
+            setattr(self, f'_{name}_unit', str(value.units))
+        else:
+            # setattr(self, name, None)
+            setattr(self, f'_{name}_mag', None)
+            setattr(self, f'_{name}_unit', None)
+
+        if getattr(self, 'plant', None) is not None and (self.__class__.__name__ != 'Sensor'):
+            # Update whether virtual sensor can be calculated with new plant information
+            if not self.defer_post_config_changed_actions:
+                [func(self.plant) for func in self.plant.post_config_changed_callbacks]
+
+    def get_component_attribute(self, name):
+        if self.__getattribute__(f'_{name}_mag') is None:
+            return None
+        return Q(self.__getattribute__(f'_{name}_mag'), self.__getattribute__(f'_{name}_unit'))
+
+
+
+    @classmethod
+    def get_default_unit(cls, name: str) -> str:
+        """Return default unit of a class attribute defined as ComponentParam.
+        """
+        return cls._attr_props[name]['unit']
+
+    def __str__(self):
+        try:
+            if self.name is not None:
+                return f'HarvestIT {self.__class__.__name__} component called {self.name}'
+            else:
+                return f'HarvestIT {self.__class__.__name__} object'
+        except sqlalchemy.exc.InvalidRequestError:
+            return "unknown SunPeek component"
+
+    def __repr__(self):
+        return self.__str__()
+
+    def __dir__(self):
+        try:
+            return list(self.sensor_slots.keys()) + list(super().__dir__())
+        except AttributeError:
+            return super().__dir__()

sunpeek_common_utils/pydantic_models.py

@@ -0,0 +1,66 @@
+from pydantic import BaseModel as PydanticBaseModel
+from pydantic import validator, Field, AliasChoices
+import pint
+from typing import List, Dict
+import numpy as np
+import datetime as dt
+
+
+class BaseModel(PydanticBaseModel):
+    class Config:
+        from_attributes = True
+        arbitrary_types_allowed = True
+        fields = {
+            'class_': 'class'
+        }
+
+    @validator('*', pre=True)
+    def make_strings(cls, v):
+        if isinstance(v, pint.Unit):
+            v = str(v)
+            return v
+#        if isinstance(v, str):
+#            v = v.lower()
+#            return v
+        # elif isinstance(v, pint.Quantity):
+        #     return str(v.units)
+        # elif isinstance(v, cmp.Collector):
+        #     return v.name
+        return v
+
+    @validator('units', 'native_unit', pre=True, check_fields=False)
+    def validate_units(cls, v):
+        if isinstance(v, pint.Quantity):
+            return str(v.units)
+        return v
+
+
+def np_to_list(val):
+    if isinstance(val, np.ndarray) and val.ndim == 1:
+        return list(val)
+    elif isinstance(val, np.ndarray) and val.ndim > 1:
+        out = []
+        for array in list(val):
+            out.append(np_to_list(array))
+        return out
+    return val
+
+class Quantity(BaseModel):
+    magnitude: float | List[float] | List[List[float]] = Field(validation_alias=AliasChoices('magnitude', 'Value'))
+    units: str = Field(validation_alias=AliasChoices('units', 'Unit'))
+
+    @validator('magnitude', pre=True)
+    def convert_numpy(cls, val):
+        return np_to_list(val)
+
+    @validator('units', pre=True)
+    def pretty_unit(cls, val):
+        if isinstance(val, pint.Unit):
+            return f"{val:~P}"
+        return val
+
+    @validator('units', pre=True)
+    def alternate_none(cls, val):
+        if val == '-':
+            return 'dimensionless'
+        return val