pyPRMS 0.9.7__py3-none-any.whl

pyPRMS/control/ControlVariable.py

@@ -0,0 +1,208 @@
+#!/usr/bin/env python3
+
+import datetime
+import numpy as np
+import re
+from typing import Callable, Dict, List, Optional, Sequence, Union
+
+from ..constants import NEW_PTYPE_TO_DTYPE
+from pyPRMS.prms_helpers import cond_check, set_date
+from ..Exceptions_custom import ControlError
+
+class ControlVariable(object):
+    """
+    Class object for a single control variable.
+    """
+
+    # Author: Parker Norton (pnorton@usgs.gov)
+    # Create date: 2019-04-18
+
+    def __init__(self, name: str,
+                 value = None,
+                 meta: Optional[Dict] = None,
+                 strict: Optional[bool] = True):
+        """Initialize a control variable object.
+
+        :param name: Name of control variable
+        :param meta: Metadata of the control variable
+        """
+
+        self.__name = name
+        self.__values: Union[np.ndarray, None] = None
+
+        if meta is None:
+            if strict:
+                raise ValueError(f'Strict is true but no metadata was supplied')
+            else:
+                self.meta = {}
+        else:
+            if strict:
+                if name in meta:
+                    self.meta = meta[name]
+                else:
+                    raise ValueError(f'`{self.name}` does not exist in metadata')
+            else:
+                # The meta must be supplied as an adhoc dictionary
+                self.meta = meta
+
+        self.values = value
+
+    def __str__(self) -> str:
+        outstr = f'----- ControlVariable -----\n'
+        outstr += f'name: {self.name}\n'
+
+        for kk, vv in self.meta.items():
+            outstr += f'{kk}: {vv}\n'
+
+        return outstr
+
+    @property
+    def dyn_param_meaning(self):
+        """Returns a list of meanings for the value of a parameter flag"""
+        meaning = self.meta.get('valid_values', {}).get(str(self.values), None)
+
+        if meaning is None:
+            return list()
+        else:
+            return meaning.split(',')
+
+    @property
+    def name(self) -> str:
+        """Returns the name of the control variable.
+
+        :returns: Name of control variable
+        """
+
+        return self.__name
+
+    @property
+    def size(self) -> int:
+        """Return number of values"""
+        if self.__values is None:
+            return 0
+        elif isinstance(self.__values, np.ndarray):
+            return self.__values.size
+        else:
+            # int, float, str scalars
+            return 1
+
+    @property
+    def values(self) -> Union[np.ndarray, int, float, str, None]:
+        """Get the values for the control variable.
+
+        If force_default is True then the default value is returned regardless
+        of what the value is set to; otherwise, current value is returned.
+
+        :returns: Value(s) of control variable
+        """
+
+        force_default = self.meta.get('force_default', False)
+
+        if force_default or self.__values is None:
+            if isinstance(self.meta.get('default', None), np.str_ | np.int32 | np.float32):
+                return self.meta.get('default', None).item()
+            else:
+                return self.meta.get('default', None)
+        else:
+            if isinstance(self.__values, np.str_ | np.int32 | np.float32):
+                return self.__values.item()
+            else:
+                return self.__values
+
+    @values.setter
+    def values(self, data: Union[Sequence[str], str, int, float, datetime.datetime]):
+        """Set the value(s) for the control variable.
+
+        :param data: list or string of value(s)
+        """
+
+        # if self.meta is not None:
+        if data is None:
+            self.__values = self.meta.get('default', None)
+        else:
+            cdtype = NEW_PTYPE_TO_DTYPE[self.meta['datatype']]
+
+            if self.meta['context'] == 'scalar':
+                if isinstance(data, list):
+                    # Only first value is used for scalars
+                    self.__values = np.array(data, dtype=cdtype)[0]
+                elif isinstance(data, np.ndarray):
+                    if self.meta['datatype'] == 'datetime':
+                        self.__values = cdtype(set_date(data))
+                    elif data.dtype == cdtype:
+                        self.__values = data[0]
+                    else:
+                        raise TypeError(f'{self.name}: {cdtype} expected but got {data[0].dtype}')
+                        # print(f'WARNING: {self.name} - datatype inconsistency; no values added')
+                elif ((cdtype == np.str_ and not isinstance(data, str | cdtype)) or
+                      (cdtype == np.int32 and not isinstance(data, int | cdtype)) or
+                      (cdtype == np.float32 and not isinstance(data, float | cdtype))):
+                    raise TypeError(f'{self.name}: {cdtype} expected but got {type(data)}')
+                else:
+                    self.__values = cdtype(data)
+            else:
+                if isinstance(data, list):
+                    self.__values = np.array(data, dtype=cdtype)
+                elif isinstance(data, np.ndarray):
+                    if data.dtype == cdtype:
+                        # TODO: 20230707 PAN - currently never hit with string arrays
+                        self.__values = data   # pragma: no cover
+                    else:
+                        # Attempt to convert to correct datatype
+                        self.__values = np.array(data, dtype=cdtype)
+                else:
+                    # TODO: 20230707 PAN - currently never hit
+                    self.__values = np.array([data], dtype=cdtype)   # pragma: no cover
+
+    @property
+    def value_meaning(self) -> Union[str, None]:
+        """Returns the meaning for a given value if it exists.
+
+        :returns: Control variable value meaning
+        """
+
+        # This will fail for keys that are conditionals (e.g. ">0")
+        meaning = self.meta.get('valid_values', None)
+
+        if meaning is None:
+            # valid_values key does not exist
+            return meaning
+
+        return self._value_meaning_test(self.values, meaning)
+        # return meaning.get(self.values, meaning.get(str(self.values), None))
+
+    def _value_meaning_test(self, key, src_dict):
+        try:
+            return src_dict[key]
+        except KeyError:
+            # Maybe the key is a string
+            try:
+                return src_dict[str(key)]
+            except KeyError:
+                # Maybe one of the keys is a conditional?
+                patterns = ['[><]']
+                regex = [re.compile('^' + pat).match for pat in patterns]
+
+                tt = {kk: vv for kk, vv in src_dict.items()
+                      if any (reg(kk) for reg in regex)}
+
+                if len(tt) > 0:
+                    # So there is a conditional
+                    for mm in tt:
+                        # print(mm.split())
+                        if cond_check[mm[0]](key, int(mm[1:])):
+                            return src_dict[mm]
+                            # print(f'{mm}: {src_dict[mm]}')
+        raise ValueError('Invalid control value')
+
+
+        #     try:
+        #         if 'valid_values' in self.meta:
+        #             # We want a KeyError here if the key is missing
+        #             return self.meta['valid_values'][self.values]
+        #
+        #         return None
+        #     except KeyError:
+        #         # Try again but return None if the key is still missing
+        #         return self.meta['valid_values'].get(str(self.values), None)
+        # return None

pyPRMS/control/__init__.py

@@ -0,0 +1,3 @@
+from .Control import Control
+from .ControlVariable import ControlVariable
+from .ControlFile import ControlFile

pyPRMS/dimensions/Dimension.py

@@ -0,0 +1,154 @@
+from typing import Dict, Optional, Union
+
+
+class Dimension(object):
+    """Defines a single dimension."""
+
+    __name: str = ''
+    __size: int = 0
+
+    def __init__(self, name: str,
+                 meta: Optional[Dict] = None,
+                 size: Optional[int] = None,
+                 strict: Optional[bool] = True):
+        """Create a new dimension object.
+
+        A dimension has a name and a size associated with it.
+
+        :param name: The name of the dimension
+        :param size: The size of the dimension
+        :param strict: Enforce use of valid dimensions metadata
+        """
+
+        self.__name = name
+
+        if meta is None:
+            if strict:
+                raise ValueError(f'Strict is true but no metadata was supplied')
+            else:
+                self.meta = {}
+        else:
+            if strict:
+                if name in meta:
+                    self.meta = meta[name]
+                else:
+                    raise ValueError(f'`{self.name}` does not exist in metadata')
+            else:
+                if isinstance(meta, dict):
+                    # Assume we have a dictionary of metadata for this dimension
+                    self.meta = meta
+
+        if size is None:
+            self.size = self.meta.get('default', 0)
+        else:
+            self.size = size
+
+    def __iadd__(self, other: int):
+        """Add a number to dimension size.
+
+        :param other: Integer value
+
+        :returns: Dimension size
+
+        :raises ValueError: if type of parameter is not an integer
+        """
+
+        # Augment in-place addition so the instance plus a number results
+        # in a change to self.__size
+        if not isinstance(other, int):
+            raise ValueError('Dimension size type must be an integer')
+        self.size += other
+        return self
+
+    def __isub__(self, other: int):
+        """Subtracts integer from dimension size.
+
+        :param other: Integer value
+
+        :returns: Dimension size
+
+        :raises ValueError: if type of parameter is not an integer
+        :raises ValeuError: if parameter is not a positive integer
+        """
+
+        # Augment in-place addition so the instance minus a number results
+        # in a change to self.__size
+        if not isinstance(other, int):
+            raise ValueError('Dimension size type must be an integer')
+        self.size -= other
+        return self
+
+    def __repr__(self) -> str:
+        """String respresentation of dimension.
+
+        :returns: string with name and size of dimension
+        """
+        return f"Dimension(name='{self.name}', meta={self.meta}, size={self.size}, strict=False)"
+
+    def __str__(self) -> str:
+        """Return friendly string representation of dimension
+        """
+        outstr = f'----- Dimension -----\n'
+        outstr += f'name: {self.name}\n'
+
+        for kk, vv in self.meta.items():
+            if kk != 'size':
+                outstr += f'{kk}: {vv}\n'
+
+        outstr += f'size: {self.size}\n'
+
+        return outstr
+
+    @property
+    def is_fixed(self):
+        return self.meta.get('is_fixed', False)
+
+    @property
+    def name(self) -> str:
+        """Name of the dimension.
+
+        :returns: Name of the dimension
+        """
+
+        return self.__name
+
+    @property
+    def size(self) -> int:
+        """Size of the dimension.
+
+        :returns: Size of the dimension
+        """
+
+        return self.__size
+
+    @size.setter
+    def size(self, value: Union[int, str]):
+        """Set the size of the dimension.
+
+        :param value: Size of the dimension
+        :raises ValueError: if dimension size is not a positive integer
+        """
+
+        if isinstance(value, float):
+            raise ValueError(f'{self.name} size cannot be a float value')
+
+        value = int(value)
+        def_value = self.meta.get('default', 0)
+
+        if value < 0:
+            raise ValueError('Dimension size must be a positive integer')
+
+        if self.is_fixed:
+            if 0 < value != def_value:
+                raise ValueError(f'{self.name} is a fixed dimension and cannot be changed')
+
+            self.__size = def_value
+        else:
+            # The size of a dimension should never be less than the default
+            if value < def_value:
+                raise ValueError(f'{self.name} size cannot be less than default value ({def_value})')
+
+            self.__size = max(value, def_value)
+
+            # TODO: 2023-06-07 PAN - should the metadata size also get changed?
+            self.meta['size'] = self.__size

pyPRMS/dimensions/Dimensions.py

@@ -0,0 +1,256 @@
+
+from typing import Any, Dict, Optional, Union   # , OrderedDict as OrderedDictType, Union
+
+import xml.etree.ElementTree as xmlET
+
+from .Dimension import Dimension
+from ..constants import MetaDataType
+
+
+class Dimensions(object):
+    """Container of Dimension objects."""
+    __dimensions: Dict[str, Dimension]
+
+    def __init__(self, metadata: Optional[MetaDataType] = None,
+                 verbose: Optional[bool] = False,
+                 strict: Optional[bool] = True):
+        """Create dictionary containing Dimension objects.
+
+        :param verbose: Output additional debug information
+        """
+        self.__dimensions: Dict[str, Dimension] = {}
+        self.__verbose = verbose
+        self.__strict = strict
+        self.metadata: Union[Dict, None] = None
+
+        if strict:
+            if metadata is None:
+                raise ValueError(f'Metadata is required but was not supplied')
+            self.metadata = metadata['dimensions']
+        else:
+            if metadata is None:
+                self.metadata = {}
+            else:
+                # TODO: 20230707 PAN - is adhoc metadata a useful idea?
+                self.metadata = metadata
+
+        # if metadata is not None:
+        #     self.metadata = metadata['dimensions']
+
+        # if self.metadata is not None:
+        #     for cdim, cvals in self.metadata.items():
+        #         self.add(name=cdim, meta=self.metadata)
+        #
+
+    def __getattr__(self, name: str) -> Any:
+        """Get named dimension.
+
+        :param name: name of dimensions
+        :returns: dimension object
+        """
+
+        # print('ATTR: {}'.format(name))
+        # https://nedbatchelder.com/blog/201010/surprising_getattr_recursion.html
+        if name == "__setstate__":
+            raise AttributeError(name)
+        return getattr(self.__dimensions, name)
+
+    def __getitem__(self, item: str) -> Dimension:
+        """Get named dimension.
+
+        :param item: name of dimension
+        :returns: Dimension object
+        """
+        return self.__dimensions[item]
+
+    def __str__(self) -> str:
+        """Pretty-print dimensions.
+
+        :returns: Pretty-print string of dimensions
+        """
+
+        outstr = ''
+        if len(self.__dimensions) == 0:
+            outstr = '<empty>'
+        else:
+            for kk, vv in self.__dimensions.items():
+                outstr += f'{vv}\n'
+        return outstr
+
+    @property
+    def dimensions(self) -> Dict[str, Dimension]:
+        """Get ordered dictionary of Dimension objects.
+
+        :returns: OrderedDict of Dimension objects
+        """
+        return self.__dimensions
+
+    @property
+    def ndim(self) -> int:
+        """Get number of dimensions.
+
+        :returns: Number of dimensions
+        """
+
+        return len(self.__dimensions)
+
+    @property
+    def xml(self) -> xmlET.Element:
+        """Get xml element for the dimensions.
+
+        :returns: XML element for the dimensions
+        """
+
+        dims_xml = xmlET.Element('dimensions')
+
+        for kk, vv in self.dimensions.items():
+            dim_sub = xmlET.SubElement(dims_xml, 'dimension')
+            dim_sub.set('name', kk)
+            xmlET.SubElement(dim_sub, 'size').text = str(vv.size)
+            # dim_sub.set('size', str(vv.size))
+        return dims_xml
+
+    def add(self, name: str, size: Optional[int] = None):
+        """Add a new Dimension object.
+
+        :param name: Name of the dimension
+        :param size: Size of the dimension
+        """
+
+        # This method adds a dimension if it doesn't exist
+        # Duplicate dimension names are silently ignored
+        if name not in self.__dimensions:
+            self.__dimensions[name] = Dimension(name=name, meta=self.metadata,
+                                                size=size,
+                                                strict=self.__strict)
+        # else:
+        #     # TODO: Should this raise an error?
+        #     print('Dimension {} already exists...skipping add name'.format(name))
+
+    def exists(self, name: str) -> bool:
+        """Check if dimension exists.
+
+        :param name: Name of the dimension
+        :returns: True if dimension exists, otherwise False
+        """
+
+        return name in self.dimensions.keys()
+
+    def get(self, name: str) -> Dimension:
+        """Get dimension.
+
+        :param name: Name of the dimension
+
+        :returns: Dimension object
+
+        :raises ValueError: if dimension does not exist
+        """
+
+        if self.exists(name):
+            return self.__dimensions[name]
+        else:
+            raise ValueError(f'Dimension, {name}, does not exist.')
+
+    def remove(self, name: str):
+        """Remove Dimension object.
+
+        :param name: name of dimension to remove
+        """
+
+        if self.exists(name):
+            del self.__dimensions[name]
+
+    def tostructure(self) -> Dict[str, Dict[str, int]]:
+        """Get data structure of Dimensions data for serialization.
+
+        :returns: dictionary of dimension names and sizes
+        """
+
+        dims = {}
+        for kk, vv in self.dimensions.items():
+            dims[kk] = {'size': vv.size}
+        return dims
+
+
+class ParamDimensions(Dimensions):
+    """Container for parameter dimensions.
+
+    This object adds tracking of dimension position and restricts the total number
+    of individual dimensions to 2.
+    """
+
+    def __init__(self, metadata: Optional[MetaDataType] = None,
+                 verbose: Optional[bool] = False,
+                 strict: Optional[bool] = True):
+
+        super(ParamDimensions, self).__init__(metadata=metadata, verbose=verbose, strict=strict)
+
+    @property
+    def xml(self) -> xmlET.Element:
+        """Get xml for the dimensions.
+
+        :returns: XML element of the dimensions
+        """
+
+        # <dimensions>
+        #     <dimension name = "nsegment" position = "1" size = "1434" />
+        # </ dimensions>
+        dims_xml = xmlET.Element('dimensions')
+
+        for kk, vv in self.dimensions.items():
+            dim_sub = xmlET.SubElement(dims_xml, 'dimension')
+            dim_sub.set('name', kk)
+            xmlET.SubElement(dim_sub, 'position').text = str(self.get_position(kk)+1)
+            xmlET.SubElement(dim_sub, 'size').text = str(vv.size)
+
+            # dim_sub.set('position', str(self.get_position(kk)+1))
+            # dim_sub.set('size', str(vv.size))
+        return dims_xml
+
+    def add(self, name: str, size: Optional[int] = None):
+        """Add a new Dimension object.
+
+        :param name: Name of the dimension
+        :param size: Size of the dimension
+        """
+
+        if self.ndim == 2:
+            raise ValueError('A parameter cannot have more than two dimensions.')
+
+        # Restrict number of dimensions for parameters
+        super().add(name, size)
+
+    def get_dimsize_by_index(self, index: int) -> int:
+        """Return size of dimension at the given index.
+
+        :param index: The 0-based position of the dimension
+        :returns: Size of the dimension
+
+        :raises ValueError: if index is greater than number dimensions for the parameter
+        """
+
+        if index < len(self.dimensions.items()):
+            return list(self.dimensions.items())[index][1].size
+        raise IndexError(f'Parameter has no dimension at index {index}')
+
+    def get_position(self, name: str) -> int:
+        """Get 0-based index position of a dimension.
+
+        :param name: name of the dimension
+
+        :returns: Zero-based Index position of dimension
+        """
+
+        # TODO: method name should be index() ??
+        return list(self.dimensions.keys()).index(name)
+
+    def tostructure(self) -> Dict[str, Dict[str, int]]:
+        """Get dictionary structure of the dimensions.
+
+        :returns: dictionary of Dimensions names, sizes, and positions
+        """
+
+        ldims = super(ParamDimensions, self).tostructure()
+        for kk, vv in ldims.items():
+            vv['position'] = self.get_position(kk)
+        return ldims

pyPRMS/dimensions/__init__.py

@@ -0,0 +1,2 @@
+from .Dimension import Dimension
+from .Dimensions import Dimensions, ParamDimensions