tsp 1.7.7__py3-none-any.whl → 1.8.0__py3-none-any.whl

tsp/gtnp.py

@@ -1,148 +1,148 @@
-from datetime import timezone, timedelta, tzinfo
-from typing import Optional
-from collections import OrderedDict
-
-import re
-import warnings
-
-from tsp.time import get_utc_offset
-
-
-class GtnpMetadata:
-    def __init__(self, filepath):
-        """A class to read GTN-P metadata files
-
-        Parameters
-        ----------
-        filepath : str
-            Path to GTN-P *.metadata.txt file.
-        """
-        self.filepath = filepath
-        self._dict = OrderedDict()
-        self._read()
-        self._parse()
-
-    def _read(self):
-        try:
-            with open(self.filepath, 'r') as f:
-                self._raw = f.readlines()
-
-        except UnicodeDecodeError:
-            warnings.warn("Couldn't read file with utf-8 encoding. Metadata might be corrupted.")
-            with open(self.filepath, 'r', errors='ignore') as f:
-                self._raw = f.readlines()
-
-    @property
-    def raw(self) -> 'list[str]':
-        return self._raw
-
-    @raw.setter
-    def raw(self, value):
-        raise ValueError("Cannot set")
-
-    @property
-    def parsed(self) -> dict:
-        return self._dict
-    
-    def _parse(self):
-        lines = [line for line in self._raw]  # Make a copy in case we need to use fallback plan
-        
-        try:
-            self._dict = OrderedDict()
-            recursively_build_metadata(lines, self._dict)
-
-        except Exception:
-            print("Couldn't build nested dictionary. Fallback to simple dictionary.")
-            self._dict = OrderedDict()
-            self._parse_dict()
- 
-
-    def _parse_dict(self) -> None:
-        pattern = re.compile(r"^([^:]+):\s*(.*)$")
-        
-        for line in self._raw:
-            result = pattern.match(line)
-            if result:
-                key, value = result.groups()
-                
-                if value.strip() != "":
-                    self._dict[key] = value.strip()
-
-    def get_timezone(self) -> Optional[tzinfo]:
-        try:
-            zone = self._dict['Timezone']
-        except KeyError:
-            return None
-        
-        if zone == 'UTC':
-            return timezone.utc
-        elif isinstance(zone, str):
-            seconds = get_utc_offset(zone.strip())
-            tz = timezone(timedelta(seconds=seconds))
-            return tz
-    
-    def get_latitude(self) -> Optional[float]:
-        try:
-            return float(self._dict['Latitude'])
-        except KeyError:
-            return None
-
-    def get_longitude(self) -> Optional[float]:
-        try:
-            return float(self._dict['Longitude'])
-        except KeyError:
-            return None
-
-
-def recursively_build_metadata(lines: list, odict: OrderedDict, depth:int=0) -> None:
-    """ A recursive function to build an OrderedDict from a list of lines.
-    
-    The function expects lines to be in the format:
-    Key: Value
-    Key: Value
-    Key: 
-        Subkey: Multi line Subvalue
-                Multi line Subvalue
-                Multi line Subvalue
-        Subkey: Subvalue
-        Subkey: 
-            Subsubkey: Subsubvalue
-
-    Parameters
-    ----------
-    lines : list
-        A list of lines from a metadata file.
-    odict : OrderedDict
-        An OrderedDict to build.
-    depth : int, optional
-        The depth of the OrderedDict, by default 0
-    
-    """
-    pattern = re.compile(r"^(\t*)([^:]+):\s*(.*)$")
-
-    while lines:
-        line = lines.pop(0)
-        result = pattern.match(line)
-        
-        if result:
-            tabs, key, value = result.groups()
-            
-            if len(tabs) < depth:  # Un-indent, return to previous level
-                lines.insert(0, line)
-                return
-
-            if value.strip() != "":  # Valid key:value pair
-                odict[key] = value.strip()
-            
-            else:  # Empty value, recurse
-                odict[key] = OrderedDict()
-                recursively_build_metadata(lines, odict[key], depth=depth+1)
-                
-        else:  # Multi-line value
-            try:
-                odict[next(reversed(odict))] = odict[next(reversed(odict))] + line
-            except StopIteration:  # If no key:value pair has been added yet
-                continue
-            except TypeError:  # If the value is not a string
-                continue
-            continue
+from datetime import timezone, timedelta, tzinfo
+from typing import Optional
+from collections import OrderedDict
+
+import re
+import warnings
+
+from tsp.time import get_utc_offset
+
+
+class GtnpMetadata:
+    def __init__(self, filepath):
+        """A class to read GTN-P metadata files
+
+        Parameters
+        ----------
+        filepath : str
+            Path to GTN-P *.metadata.txt file.
+        """
+        self.filepath = filepath
+        self._dict = OrderedDict()
+        self._read()
+        self._parse()
+
+    def _read(self):
+        try:
+            with open(self.filepath, 'r') as f:
+                self._raw = f.readlines()
+
+        except UnicodeDecodeError:
+            warnings.warn("Couldn't read file with utf-8 encoding. Metadata might be corrupted.")
+            with open(self.filepath, 'r', errors='ignore') as f:
+                self._raw = f.readlines()
+
+    @property
+    def raw(self) -> 'list[str]':
+        return self._raw
+
+    @raw.setter
+    def raw(self, value):
+        raise ValueError("Cannot set")
+
+    @property
+    def parsed(self) -> dict:
+        return self._dict
+    
+    def _parse(self):
+        lines = [line for line in self._raw]  # Make a copy in case we need to use fallback plan
+        
+        try:
+            self._dict = OrderedDict()
+            recursively_build_metadata(lines, self._dict)
+
+        except Exception:
+            print("Couldn't build nested dictionary. Fallback to simple dictionary.")
+            self._dict = OrderedDict()
+            self._parse_dict()
+ 
+
+    def _parse_dict(self) -> None:
+        pattern = re.compile(r"^([^:]+):\s*(.*)$")
+        
+        for line in self._raw:
+            result = pattern.match(line)
+            if result:
+                key, value = result.groups()
+                
+                if value.strip() != "":
+                    self._dict[key] = value.strip()
+
+    def get_timezone(self) -> Optional[tzinfo]:
+        try:
+            zone = self._dict['Timezone']
+        except KeyError:
+            return None
+        
+        if zone == 'UTC':
+            return timezone.utc
+        elif isinstance(zone, str):
+            seconds = get_utc_offset(zone.strip())
+            tz = timezone(timedelta(seconds=seconds))
+            return tz
+    
+    def get_latitude(self) -> Optional[float]:
+        try:
+            return float(self._dict['Latitude'])
+        except KeyError:
+            return None
+
+    def get_longitude(self) -> Optional[float]:
+        try:
+            return float(self._dict['Longitude'])
+        except KeyError:
+            return None
+
+
+def recursively_build_metadata(lines: list, odict: OrderedDict, depth:int=0) -> None:
+    """ A recursive function to build an OrderedDict from a list of lines.
+    
+    The function expects lines to be in the format:
+    Key: Value
+    Key: Value
+    Key: 
+        Subkey: Multi line Subvalue
+                Multi line Subvalue
+                Multi line Subvalue
+        Subkey: Subvalue
+        Subkey: 
+            Subsubkey: Subsubvalue
+
+    Parameters
+    ----------
+    lines : list
+        A list of lines from a metadata file.
+    odict : OrderedDict
+        An OrderedDict to build.
+    depth : int, optional
+        The depth of the OrderedDict, by default 0
+    
+    """
+    pattern = re.compile(r"^(\t*)([^:]+):\s*(.*)$")
+
+    while lines:
+        line = lines.pop(0)
+        result = pattern.match(line)
+        
+        if result:
+            tabs, key, value = result.groups()
+            
+            if len(tabs) < depth:  # Un-indent, return to previous level
+                lines.insert(0, line)
+                return
+
+            if value.strip() != "":  # Valid key:value pair
+                odict[key] = value.strip()
+            
+            else:  # Empty value, recurse
+                odict[key] = OrderedDict()
+                recursively_build_metadata(lines, odict[key], depth=depth+1)
+                
+        else:  # Multi-line value
+            try:
+                odict[next(reversed(odict))] = odict[next(reversed(odict))] + line
+            except StopIteration:  # If no key:value pair has been added yet
+                continue
+            except TypeError:  # If the value is not a string
+                continue
+            continue

tsp/labels.py

@@ -1,4 +1,4 @@
-HOURLY = 60 * 60
-DAILY = HOURLY * 24
-MONTHLY = DAILY * 31
+HOURLY = 60 * 60
+DAILY = HOURLY * 24
+MONTHLY = DAILY * 31
 YEARLY = DAILY * 365

tsp/misc.py

@@ -1,90 +1,90 @@
-import numpy as np
-import pandas as pd
-import re
-
-import tsp.labels as lbl
-
-
-def _is_depth_column(col_name, pattern) -> bool:
-    return bool(re.search(pattern, col_name))
-
-
-def completeness(df: pd.DataFrame, f1, f2) -> pd.DataFrame:
-    """ Calculate completeness of an aggregated dataframe 
-    Parameters
-    ----------
-    df : pd.DataFrame
-        Dataframe with temporal index and values equal to the number of observations
-        in aggregation period
-    f1 : str
-        Aggregation period of data from which df is aggregated
-    f2 : str
-        Aggregation period of df
-
-    Returns
-    -------
-    pd.DataFrame : Dataframe with completeness values as a decimal fraction [0,1]
-    """
-    # df must have temporal index
-    C = None
-    if f1 == lbl.HOURLY:
-        if f2 == lbl.DAILY:
-            C = df / 24
-    
-    elif f1 == lbl.DAILY:
-        if f2 == lbl.MONTHLY:
-            C = df / E_day_in_month(df)
-        elif f2 == lbl.YEARLY:
-            C = df / E_day_in_year(df)
-    
-    elif f1 == lbl.MONTHLY:
-        if f2 == lbl.YEARLY:
-            cnt = 12
-    
-    elif isinstance(f1, float) and isinstance(f1, float):
-        R = f2 / f1
-        C = df / R
-    
-    if C is None:
-        raise ValueError(f"Unknown aggregation period {f1} or {f2}")
-    
-    return C
-
-
-def df_has_period(f, *args, **kwargs):
-    df = args[0] if args[0] else kwargs.get('df')
-    if not isinstance(df.index, pd.PeriodIndex):
-        raise ValueError("Index must be a PeriodIndex")
-    return f(*args, **kwargs)
-
-
-#@df_has_period
-def E_day_in_year(df: "pd.DataFrame") -> "pd.DataFrame":
-    """ Expected number of daily observations per year """
-    leap = df.index.to_period().is_leap_year
-    days = np.atleast_2d(np.where(leap, 366, 365)).transpose()
-    result = pd.DataFrame(index=df.index,
-                          columns=df.columns,
-                          data=np.repeat(np.atleast_2d(days), df.shape[1], axis=1))
-    return result
-
-
-#@df_has_period
-def E_month_in_year(df: "pd.DataFrame") -> "pd.DataFrame":
-    """ Expected number of monthly observations per year """
-    result = pd.DataFrame(index=df.index, 
-                          columns=df.columns, 
-                          data=12)
-    return result
-
-
-#@df_has_period
-def E_day_in_month(df: "pd.DataFrame") -> "pd.DataFrame":
-    """ Expected number of daily observations per month """
-    nday = df.index.to_period().days_in_month
-    result = pd.DataFrame(index=df.index, 
-                          columns=df.columns, 
-                          data=np.repeat(np.atleast_2d(nday).transpose(), df.shape[1], axis=1))
-    return result
-
-
+import numpy as np
+import pandas as pd
+import re
+
+import tsp.labels as lbl
+
+
+def _is_depth_column(col_name, pattern) -> bool:
+    return bool(re.search(pattern, col_name))
+
+
+def completeness(df: pd.DataFrame, f1, f2) -> pd.DataFrame:
+    """ Calculate completeness of an aggregated dataframe 
+    Parameters
+    ----------
+    df : pd.DataFrame
+        Dataframe with temporal index and values equal to the number of observations
+        in aggregation period
+    f1 : str
+        Aggregation period of data from which df is aggregated
+    f2 : str
+        Aggregation period of df
+
+    Returns
+    -------
+    pd.DataFrame : Dataframe with completeness values as a decimal fraction [0,1]
+    """
+    # df must have temporal index
+    C = None
+    if f1 == lbl.HOURLY:
+        if f2 == lbl.DAILY:
+            C = df / 24
+    
+    elif f1 == lbl.DAILY:
+        if f2 == lbl.MONTHLY:
+            C = df / E_day_in_month(df)
+        elif f2 == lbl.YEARLY:
+            C = df / E_day_in_year(df)
+    
+    elif f1 == lbl.MONTHLY:
+        if f2 == lbl.YEARLY:
+            cnt = 12
+    
+    elif isinstance(f1, float) and isinstance(f1, float):
+        R = f2 / f1
+        C = df / R
+    
+    if C is None:
+        raise ValueError(f"Unknown aggregation period {f1} or {f2}")
+    
+    return C
+
+
+def df_has_period(f, *args, **kwargs):
+    df = args[0] if args[0] else kwargs.get('df')
+    if not isinstance(df.index, pd.PeriodIndex):
+        raise ValueError("Index must be a PeriodIndex")
+    return f(*args, **kwargs)
+
+
+#@df_has_period
+def E_day_in_year(df: "pd.DataFrame") -> "pd.DataFrame":
+    """ Expected number of daily observations per year """
+    leap = df.index.to_period().is_leap_year
+    days = np.atleast_2d(np.where(leap, 366, 365)).transpose()
+    result = pd.DataFrame(index=df.index,
+                          columns=df.columns,
+                          data=np.repeat(np.atleast_2d(days), df.shape[1], axis=1))
+    return result
+
+
+#@df_has_period
+def E_month_in_year(df: "pd.DataFrame") -> "pd.DataFrame":
+    """ Expected number of monthly observations per year """
+    result = pd.DataFrame(index=df.index, 
+                          columns=df.columns, 
+                          data=12)
+    return result
+
+
+#@df_has_period
+def E_day_in_month(df: "pd.DataFrame") -> "pd.DataFrame":
+    """ Expected number of daily observations per month """
+    nday = df.index.to_period().days_in_month
+    result = pd.DataFrame(index=df.index, 
+                          columns=df.columns, 
+                          data=np.repeat(np.atleast_2d(nday).transpose(), df.shape[1], axis=1))
+    return result
+
+