PyPI - labfreed - Versions diffs - 0.0.8__py2.py3-none-any.whl → 0.0.9__py2.py3-none-any.whl - Mend

labfreed 0.0.8py2.py3-none-any.whl → 0.0.9py2.py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (20) hide show

labfreed/DisplayNameExtension/DisplayNameExtension.py +1 -1
labfreed/PAC_ID/data_model.py +60 -28
labfreed/PAC_ID/parse.py +6 -4
labfreed/TREX/UneceUnits.json +33730 -0
labfreed/TREX/data_model.py +869 -0
labfreed/TREX/parse.py +128 -0
labfreed/TREX/serialize.py +3 -0
labfreed/TREX/unece_units.py +90 -0
labfreed/__init__.py +1 -1
labfreed/{TREXExtension → conversion_tools}/unit_utilities.py +8 -42
labfreed/validation.py +115 -39
{labfreed-0.0.8.dist-info → labfreed-0.0.9.dist-info}/METADATA +1 -1
labfreed-0.0.9.dist-info/RECORD +22 -0
labfreed/TREXExtension/data_model.py +0 -239
labfreed/TREXExtension/parse.py +0 -53
labfreed-0.0.8.dist-info/RECORD +0 -19
/labfreed/{TREXExtension → conversion_tools}/uncertainty.py +0 -0
/labfreed/{DisplayNameExtension → utilities}/base36.py +0 -0
{labfreed-0.0.8.dist-info → labfreed-0.0.9.dist-info}/WHEEL +0 -0
{labfreed-0.0.8.dist-info → labfreed-0.0.9.dist-info}/licenses/LICENSE +0 -0

labfreed/TREX/parse.py ADDED Viewed

@@ -0,0 +1,128 @@
+import logging
+import re
+from .data_model import *
+from labfreed.validation import LabFREEDValidationError
+class TREX_Parser():
+    def __init__(self, suppress_errors=False):
+        self._suppress_errors = suppress_errors
+    def parse_trex_str(self, trex_str, name=None) -> TREX:
+        trex = _from_trex_string(trex_str, name=name)
+        trex.print_validation_messages(trex_str)
+        if not trex.is_valid() and not self._suppress_errors:
+            raise LabFREEDValidationError(validation_msgs = trex.get_nested_validation_messages())
+        return trex
+def _from_trex_string(trex_str, name=None, enforce_type=True) -> TREX:
+    if not trex_str:
+        raise ValueError(f'T-REX must be a string of non zero length')
+    # remove extension indicator. Precaution in case it is not done yet
+    if trex_str[0]=="*":
+        trex_str=trex_str[1:-1]
+    # remove line breaks. for editing T-REXes it's more convenient to have them in, so one never knows
+    trex_str = trex_str.replace('\n','')
+    d = re.match('((?P<name>.+)\$(?P<type>.+)/)?(?P<data>.+)', trex_str).groupdict()
+    if not d:
+        raise ValueError('TREX is invalid.')
+    type = d.get('type')
+    if not type:
+        logging.warning('No type given. Assume its trex')
+    elif type != 'TREX' and enforce_type:
+        logging.error(f'Extension type {type} is not TREX. Aborting')
+        raise ValueError(f'Extension type {type} is not TREX.')
+    else:
+        logging.warning('Extension type {type} is not TREX. Try anyways')
+    s_name = d.get('name')
+    if name and s_name:
+        logging.warning(f'conflicting names given. The string contained {s_name}, method parameter was {name}. Method parameter wins.')
+    elif not name and not s_name:
+        raise ValueError('No extension name was given')
+    elif s_name:
+        name = s_name
+    data = d.get('data')
+    segment_strings = data.split('+')
+    out_segments = list()
+    for s in segment_strings:
+        # there are only two valid options. The segment is a scalar or a table.
+        # Constructors do the parsing anyways and raise exceptions if invalid data
+        # try both options and then let it fail
+        segment = _deserialize_table_segment_from_trex_segment_str(s)
+        if not segment:
+            segment = _deserialize_value_segment_from_trex_segment_str(s)
+        if not segment:
+            raise ValueError('TREX contains neither valid value segment nor table')
+        out_segments.append(segment)
+    trex = TREX(name_= name, segments=out_segments)
+    trex._trex_str = trex_str
+    return trex
+def _deserialize_value_segment_from_trex_segment_str(trex_segment_str) -> ValueSegment:
+    #re_scalar_pattern = re.compile(f"(?P<name>[\w\.-]*?)\$(?P<unit>[\w\.]*?):(?P<value>.*)")
+    re_scalar_pattern = re.compile(f"(?P<name>.+?)\$(?P<unit>.+?):(?P<value>.+)")
+    matches = re_scalar_pattern.match(trex_segment_str)
+    if not matches:
+        return None
+    name, type_, value = matches.groups()
+    out = ValueSegment.get_subclass(type=type_, value=value, key=name)
+    return out
+def _deserialize_table_segment_from_trex_segment_str(trex_segment_str) -> TREX_Table:
+    # re_table_pattern = re.compile(f"(?P<tablename>[\w\.-]*?)\$\$(?P<header>[\w\.,\$:]*?)::(?P<body>.*)")
+    # re_col_head_pattern = re.compile(f"(?P<name>[\w\.-]*?)\$(?P<unit>[\w\.]*)")
+    re_table_pattern = re.compile(r"(?P<tablename>.+?)\$\$(?P<header>.+?)::(?P<body>.+)")
+    matches = re_table_pattern.match(trex_segment_str)
+    if not matches:
+        return None
+    name, header, body = matches.groups()
+    column_headers_str = header.split(':')
+    headers = []
+    for colum_header in column_headers_str:
+         ch = colum_header.split('$')
+         col_key = ch[0]
+         col_type = ch[1] if len(ch) > 1 else ''
+         headers.append(ColumnHeader(key=col_key, type=col_type))
+    data = [row.split(':') for row in body.split('::') ]
+    col_types = [h.type for h in headers]
+    # convert to correct value types
+    data_with_types = [[str_to_value_type(c,t) for c, t in zip(r, col_types)] for r in data]
+    data = [ TableRow(r) for r in data_with_types]
+    out = TREX_Table(column_headers=headers, data=data_with_types, key=name)
+    return out
+def str_to_value_type(s:str, t:str):
+    match t:
+        case 'T.D': v = DateValue(value=s)
+        case 'T.B': v = BoolValue(value=s)
+        case 'T.A': v = AlphanumericValue(value=s)
+        case 'T.T': v = TextValue(value=s)
+        case 'T.X': v = BinaryValue(value=s)
+        case 'E'  : v = ErrorValue(value=s)
+        case _    : v = NumericValue(value=s)
+    return v

labfreed/TREX/serialize.py ADDED Viewed

@@ -0,0 +1,3 @@
+from .data_model import TREX
+def serialize_as_trex_str(trex:TREX):
+    return trex.data

labfreed/TREX/unece_units.py ADDED Viewed

@@ -0,0 +1,90 @@
+from functools import cache
+import json
+from pathlib import Path
+@cache
+def unece_units() -> list[dict]:
+    p = Path(__file__).parent / 'UneceUnits.json'
+    with open(p) as f:
+        l = json.load(f)
+    return l
+@cache
+def unece_unit_codes():
+    codes= [u.get('commonCode') for u in unece_units() if u.get('state') == 'ACTIVE']
+    return codes
+# def quantity_from_UN_CEFACT(value:str, unit_UN_CEFACT) -> UnitQuantity:
+#     """
+#     Maps units from https://unece.org/trade/documents/revision-17-annexes-i-iii
+#     to an object of the quantities library https://python-quantities.readthedocs.io/en/latest/index.html
+#     """
+#     # cast to numeric type. try int first, which will fail if string has no decimals.
+#     # nothing to worry yet: try floast next. if that fails the input was not a str representation of a number
+#     try:
+#         value_out = int(value)
+#     except ValueError:
+#         try:
+#             value_out = float(value)
+#         except ValueError as e:
+#             raise Exception(f'Input {value} is not a str representation of a number') from e
+#     d = {um[0]: um[1] for um in unit_map}
+#     unit = d.get(unit_UN_CEFACT)
+#     if not unit:
+#         raise NotImplementedError(f"lookup for unit {unit} not implemented")
+#     out = UnitQuantity(data=value_out, unit_name=unit.name, unit_symbol=unit.symbol)
+#     return out
+# def quantity_to_UN_CEFACT(value:UnitQuantity ) -> Tuple[int|float, str]:
+#     d = {um[1].symbol: um[0] for um in unit_map}
+#     unit_un_cefact = d.get(value.unit_symbol)
+#     if not unit_un_cefact:
+#         raise NotImplementedError(f"lookup for unit {value.unit_symbol} not implemented")
+#     return value.data, unit_un_cefact
+def check_compatibility_unece_quantities():
+    unece = get_unece_units()
+    print(f'Number of units in file: {len(unece)}')
+    failed = list()
+    sucess = list()
+    for u in unece:
+        if u.get('state') ==  'ACTIVE':
+            try:
+                if not u.get('symbol'):
+                    assert False
+                u.get('name')
+                validate_unit(u.get('symbol'))
+                sucess.append(u)
+            except AssertionError as e:
+                failed.append(u)
+        else:
+            pass
+    print('[blue] FAILED [/blue]')
+    for u in failed:
+        print(f'{u.get('commonCode')}: {u.get('name')}')
+    print('[yellow] SUCCESSFUL [/yellow]')
+    for u in sucess:
+        print(u)
+    print(f'{len(failed)} / {len(unece)} failed to convert')

labfreed/__init__.py CHANGED Viewed

@@ -2,4 +2,4 @@
 Python implementation of LabFREED building blocks
 '''
-__version__ = "0.0.8"
+__version__ = "0.0.9"

labfreed/{TREXExtension → conversion_tools}/unit_utilities.py RENAMED Viewed

@@ -1,12 +1,17 @@
+from functools import cache
+import json
+from pathlib import Path
+from rich import print
 from typing import Tuple
 from typing_extensions import Annotated
 from pydantic import BaseModel, AfterValidator
 import quantities as pq
-from quantities import Quantity, UnitQuantity, units, dimensionless
+from quantities import  units
 from  .uncertainty import to_significant_digits_str
 def validate_unit(unit_name:str) -> str :
     """
     Pydantic validator function for the unit.
@@ -92,51 +97,12 @@ unit_map = [
 ]
-def quantity_from_UN_CEFACT(value:str, unit_UN_CEFACT) -> PydanticUncertainQuantity:
-    """
-    Maps units from https://unece.org/trade/documents/revision-17-annexes-i-iii
-    to an object of the quantities library https://python-quantities.readthedocs.io/en/latest/index.html
-    """
-    # cast to numeric type. try int first, which will fail if string has no decimals.
-    # nothing to worry yet: try floast next. if that fails the input was not a str representation of a number
-    try:
-        value_out = int(value)
-    except ValueError:
-        try:
-            value_out = float(value)
-        except ValueError as e:
-            raise Exception(f'Input {value} is not a str representation of a number') from e
-    d = {um[0]: um[1] for um in unit_map}
-    unit = d.get(unit_UN_CEFACT)
-    if not unit:
-        raise NotImplementedError(f"lookup for unit {unit} not implemented")
-    out = PydanticUncertainQuantity(data=value_out, unit_name=unit.name, unit_symbol=unit.symbol)
-    return out
-def quantity_to_UN_CEFACT(value:PydanticUncertainQuantity ) -> Tuple[int|float, str]:
-    d = {um[1].symbol: um[0] for um in unit_map}
-    unit_un_cefact = d.get(value.unit_symbol)
-    if not unit_un_cefact:
-        raise NotImplementedError(f"lookup for unit {value.unit_symbol} not implemented")
-    return value.data, unit_un_cefact
 if __name__ == "__main__":
-    pass
+    pass

labfreed/validation.py CHANGED Viewed

@@ -1,71 +1,147 @@
 from pydantic import BaseModel, Field, PrivateAttr
 from typing import List, Set, Tuple
+from rich import print
+from rich.text import Text
 domain_name_pattern = r"(?!-)([A-Za-z0-9-]{1,63}(?<!-)\.)+[A-Za-z]{2,63}"
 hsegment_pattern = r"[A-Za-z0-9_\-\.~!$&'()+,:;=@]|%[0-9A-Fa-f]{2}"
-class ValidationWarning(BaseModel):
+class ValidationMessage(BaseModel):
     source:str
     type: str
     problem_msg:str
     recommendation_msg: str = ""
     highlight:str = "" #this can be used to highlight problematic parts
     highlight_sub:list[str] = Field(default_factory=list())
+    @property
+    def emphazised_highlight(self):
+        fmt = lambda s: f'[emph]{s}[/emph]'
+        if not self.highlight_sub:
+            return fmt(self.highlight)
+        result = []
+        for c in self.highlight:
+            if c in self.highlight_sub:
+                result.append(fmt(c))
+            else:
+                result.append(c)
+        return ''.join(result)
+class LabFREEDValidationError(ValueError):
+    def __init__(self, message=None, validation_msgs=None):
+        super().__init__(message)
+        self._validation_msgs = validation_msgs
+    @property
+    def validation_msgs(self):
+        return self._validation_msgs
-class BaseModelWithWarnings(BaseModel):
+class BaseModelWithValidationMessages(BaseModel):
     """ Extension of Pydantic BaseModel, so that validator can issue warnings.
     The purpose of that is to allow only minimal validation but on top check for stricter recommendations"""
-    _warnings: list[ValidationWarning] = PrivateAttr(default_factory=list)
+    _validation_messages: list[ValidationMessage] = PrivateAttr(default_factory=list)
-    def add_warning(self, *, msg: str, type:str, recommendation:str="", source:str="", highlight_pattern="", highlight_sub=None):
+    def add_validation_message(self, *, msg: str, type:str, recommendation:str="", source:str="", highlight_pattern="", highlight_sub=None):
         if not highlight_sub:
             highlight_sub = []
-        w = ValidationWarning(problem_msg=msg, recommendation_msg=recommendation, source=source, type=type, highlight=highlight_pattern, highlight_sub=highlight_sub)
-        if not w in self._warnings:
-            self._warnings.append(w)
+        w = ValidationMessage(problem_msg=msg, recommendation_msg=recommendation, source=source, type=type, highlight=highlight_pattern, highlight_sub=highlight_sub)
-    def get_warnings(self) -> list[ValidationWarning]:
-        return self._warnings
+        if not w in self._validation_messages:
+            self._validation_messages.append(w)
-    def clear_warnings(self):
-        self._warnings.clear()
+    def get_validation_messages(self) -> list[ValidationMessage]:
+        return self._validation_messages
+    def get_errors(self) -> list[ValidationMessage]:
+        return filter_errors(self._validation_messages)
-# Function to extract warnings from a model and its nested models
-def extract_warnings(model: BaseModelWithWarnings, parent_name: str = "", visited: Set[int] = None) -> List[ValidationWarning]:
-    """
-    Recursively extract warnings from a Pydantic model and its nested fields.
+    def get_warnings(self) -> list[ValidationMessage]:
+        return filter_warnings(self._validation_messages)
-    :param model: The Pydantic model instance to inspect.
-    :param parent_name: The name of the parent model to track the path.
-    :return: List of tuples containing (model name, warning message).
-    """
-    if visited is None:
-        visited = set()
-    model_id = id(model)
-    if model_id in visited:
-        return []
-    visited.add(model_id)
-    warnings_list = [(parent_name or model.__class__.__name__, model_id,  warning) for warning in model.get_warnings()]
+    def is_valid(self) -> bool:
+        return len(filter_errors(self.get_nested_validation_messages())) == 0
+    # Function to extract warnings from a model and its nested models
+    def get_nested_validation_messages(self, parent_name: str = "", visited: Set[int] = None) -> List[ValidationMessage]:
+        """
+        Recursively extract warnings from a Pydantic model and its nested fields.
+        :param model: The Pydantic model instance to inspect.
+        :param parent_name: The name of the parent model to track the path.
+        :return: List of tuples containing (model name, warning message).
+        """
+        if visited is None:
+            visited = set()
+        model_id = id(self)
+        if model_id in visited:
+            return []
+        visited.add(model_id)
+        warnings_list = [warning for warning in self.get_validation_messages()]
+        # warnings_list = [(parent_name or self.__class__.__name__, model_id,  warning) for warning in self.get_validation_messages()]
-    for field_name, field in model.__fields__.items():
-        full_path = f"{parent_name}.{field_name}" if parent_name else field_name
-        value = getattr(model, field_name)
+        for field_name, field in self.__fields__.items():
+            full_path = f"{parent_name}.{field_name}" if parent_name else field_name
+            value = getattr(self, field_name)
-        if isinstance(value, BaseModelWithWarnings):
-            warnings_list.extend(extract_warnings(value, full_path, visited))
-        elif isinstance(value, list):
-            for index, item in enumerate(value):
-                if isinstance(item, BaseModelWithWarnings):
-                    list_path = f"{full_path}[{index}]"
-                    warnings_list.extend(extract_warnings(item, list_path, visited))
+            if isinstance(value, BaseModelWithValidationMessages):
+                warnings_list.extend(value.get_nested_validation_messages(full_path, visited))
+            elif isinstance(value, list):
+                for index, item in enumerate(value):
+                    if isinstance(item, BaseModelWithValidationMessages):
+                        list_path = f"{full_path}[{index}]"
+                        warnings_list.extend(item.get_nested_validation_messages(list_path, visited))
+        return warnings_list
+    def get_nested_errors(self) -> list[ValidationMessage]:
+        return filter_errors(self.get_nested_validation_messages())
+    def get_nested_warnings(self) -> list[ValidationMessage]:
+        return filter_warnings(self.get_nested_validation_messages())
+    def print_validation_messages(self, str_to_highlight_in):
+        msgs = self.get_nested_validation_messages()
+        print('\n'.join(['\n',
+                         '=======================================',
+                         'Validation Results',
+                         '---------------------------------------'
+                        ]
+                        )
+        )
+        for m in msgs:
+            if m.type.casefold() == "error":
+                color = 'red'
+            else:
+                color = 'yellow'
+            text = Text.from_markup(f'\n [bold {color}]{m.type} [/bold {color}] in \t {m.source}' )
+            print(text)
+            formatted_highlight = m.emphazised_highlight.replace('emph', f'bold {color}')
+            fmtd = str_to_highlight_in.replace(m.highlight, formatted_highlight)
+            fmtd = Text.from_markup(fmtd)
+            print(fmtd)
+            print(Text.from_markup(f'{m.problem_msg}'))
+def filter_errors(val_msg:list[ValidationMessage]) -> list[ValidationMessage]:
+    return [ m for m in val_msg if m.type.casefold() == "error" ]
-    return warnings_list
+def filter_warnings(val_msg:list[ValidationMessage]) -> list[ValidationMessage]:
+    return [ m for m in val_msg if m.type.casefold() != "error" ]

{labfreed-0.0.8.dist-info → labfreed-0.0.9.dist-info}/METADATA RENAMED Viewed

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: labfreed
-Version: 0.0.8
+Version: 0.0.9
 Summary: Python implementation of LabFREED building blocks
 Author-email: Reto Thürer <thuerer.r@buchi.com>
 License-Expression: MIT

labfreed-0.0.9.dist-info/RECORD ADDED Viewed

@@ -0,0 +1,22 @@
+labfreed/__init__.py,sha256=NqKE8cu-i6wAIxbyZat0L_dbFSjpJgHYzJYqGEGXBBk,87
+labfreed/validation.py,sha256=3w69iAX_fH6QdceMj_sgR9pQhJsSy5mXhxLxz_YNHfU,5850
+labfreed/DisplayNameExtension/DisplayNameExtension.py,sha256=MKc9YzI5KKEfnH8glXEteB29ZMfZxbmvFzJTLKbOX_g,1051
+labfreed/PAC_CAT/__init__.py,sha256=frcCV1k9oG9oKj3dpUqdJg1PxRT2RSN_XKdLCPjaYaY,2
+labfreed/PAC_CAT/data_model.py,sha256=hob-WNs2-633LmxQ7Ot3RBpcvStYFzdj20QDQZOQyqY,4306
+labfreed/PAC_ID/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+labfreed/PAC_ID/data_model.py,sha256=c2exBF2AXwXxudPS9Cd74xex0VB5Q-EeJHQi43LRmwQ,9300
+labfreed/PAC_ID/parse.py,sha256=g0AXzJ9El8TZ2c05GOMN6yfa3FUAFDFVndx5mefe_ZM,5175
+labfreed/PAC_ID/serialize.py,sha256=0BhF7aXGlLpr312lkBvl1O5fXDFZeLLPgSBddO9Y86Q,1963
+labfreed/PAC_ID/well_known_segment_keys.py,sha256=zrzMvvS42urPpiwinI-IhHPgT3r86zEBl4TlEMOfzbU,338
+labfreed/TREX/UneceUnits.json,sha256=kwfQSp_nTuWbADfBBgqTWrvPl6XtM5SedEVLbMJrM7M,898953
+labfreed/TREX/data_model.py,sha256=727da6PPvl-5gwPbljTDNprU38de80Cs1Q1bxKJ6DWI,29804
+labfreed/TREX/parse.py,sha256=rV7EDCaY9cmBJNqsrSZQLNzcivyOCzLsKXW2sAOitaA,4867
+labfreed/TREX/serialize.py,sha256=5M0c8l4xTtiX4PIKVRI3Gt-jNFYNcKOeuO3C-m1HE5g,89
+labfreed/TREX/unece_units.py,sha256=7PL4eR8SGklnuR5gC4ooAvgFFYg9dCF9HmwIU25OZYw,2682
+labfreed/conversion_tools/uncertainty.py,sha256=l3WxrLnWTQYfX28gFisXwDcVPvT8bCAd4q6Xl02dRdE,1117
+labfreed/conversion_tools/unit_utilities.py,sha256=5NXDt-XRkajcg2lLdg0vDBWbmfhUCqeY4hu_k6PkbCY,2445
+labfreed/utilities/base36.py,sha256=2lwmEMWm8qrFJkcrP-nMPwS0eCm2THhCJ3Vk-TdGQg0,2455
+labfreed-0.0.9.dist-info/licenses/LICENSE,sha256=gHFOv9FRKHxO8cInP3YXyPoJnuNeqrvcHjaE_wPSsQ8,1100
+labfreed-0.0.9.dist-info/WHEEL,sha256=BXjIu84EnBiZ4HkNUBN93Hamt5EPQMQ6VkF7-VZ_Pu0,100
+labfreed-0.0.9.dist-info/METADATA,sha256=whgM7VD1R3S7JlP96c9mVBYWoDGwJzjdxdmE2nZRMFU,206
+labfreed-0.0.9.dist-info/RECORD,,

labfreed 0.0.8__py2.py3-none-any.whl → 0.0.9__py2.py3-none-any.whl

labfreed 0.0.8py2.py3-none-any.whl → 0.0.9py2.py3-none-any.whl