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

labfreed/validation.py

@@ -1,71 +1,149 @@
 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=None):
+        if not str_to_highlight_in:
+            str_to_highlight_in = str(self)
+        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.10.dist-info}/METADATA

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

labfreed-0.0.10.dist-info/RECORD

@@ -0,0 +1,22 @@
+labfreed/__init__.py,sha256=OWHCq64GWIUC0FwQzQWmRekkMBw8RG2IMyQYi-AKqaY,88
+labfreed/parse_pac.py,sha256=HA3-jAnw2crsXMW_D7Tw-z99qnUWL5MBQVXEzdYP2m4,6287
+labfreed/validation.py,sha256=QwkZWJhAjWbPUZtJJwjVYsw9TxeFhdbZaKjrPPIpuAA,5937
+labfreed/DisplayNameExtension/DisplayNameExtension.py,sha256=l9JZY2eRS0V-H5h3-WXIHiiBJuljns-_e_t9Bp84_CU,1155
+labfreed/PAC_CAT/__init__.py,sha256=frcCV1k9oG9oKj3dpUqdJg1PxRT2RSN_XKdLCPjaYaY,2
+labfreed/PAC_CAT/data_model copy.py,sha256=JWMVkwkX9vWZayOLOzdTHk3VZVYBuyupumNqL-cWCxU,9611
+labfreed/PAC_CAT/data_model.py,sha256=pcib1lEQuqejWP7dfmPUtLakz-y-zeDb9CIe94Jmz0A,13677
+labfreed/PAC_ID/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+labfreed/PAC_ID/data_model.py,sha256=g09qgC-TV6fjJw9VyDF6mTJ6co2i2RKZc0Z-BmiiUIQ,7483
+labfreed/PAC_ID/extensions.py,sha256=bvuZnlNKUdwsDLrPm8fyifqPn_PR4wCVkkScFnvRiuM,1158
+labfreed/TREX/UneceUnits.json,sha256=kwfQSp_nTuWbADfBBgqTWrvPl6XtM5SedEVLbMJrM7M,898953
+labfreed/TREX/data_model.py,sha256=_xhnYGMcMPa0uf_020epq88zqHT1wdsUPC2ELJcSRWE,29684
+labfreed/TREX/parse.py,sha256=86962VEJpkrTcT436iFIB5dNed5WHABzpjxRjkA3PXo,2043
+labfreed/TREX/unece_units.py,sha256=scPKdsPzY1neAdFOhA08_tRZaR-yplM8mBhIzzDqZBk,3006
+labfreed/utilities/base36.py,sha256=_yX8aQ1OwrK5tnJU1NUEzQSFGr9xAVnNvPObpNzCPYs,2895
+labfreed/utilities/extension_intertpreters.py,sha256=B3IFJLfVMJQuPfBBtX6ywlDUZEi7_x6tY4g8V7SpWSs,124
+labfreed/utilities/utility_types.py,sha256=Zhk8Mu4hHjkn1gs8oh7vOxxaT7L7wLMVG40ZOWCKGK4,2865
+labfreed/utilities/well_known_keys.py,sha256=nqk66kHdSwJTJfMKlP-xQbBglS8F_NoWsGkfOVITFN0,331
+labfreed-0.0.10.dist-info/licenses/LICENSE,sha256=gHFOv9FRKHxO8cInP3YXyPoJnuNeqrvcHjaE_wPSsQ8,1100
+labfreed-0.0.10.dist-info/WHEEL,sha256=BXjIu84EnBiZ4HkNUBN93Hamt5EPQMQ6VkF7-VZ_Pu0,100
+labfreed-0.0.10.dist-info/METADATA,sha256=ukautezUMEqYcU-eqihpy3uyTiBIRqg8PCVc_NSAJ1c,207
+labfreed-0.0.10.dist-info/RECORD,,

labfreed/PAC_ID/parse.py

@@ -1,142 +0,0 @@
-
-
-import re
-from types import MappingProxyType
-from .data_model import *
-
-from ..validation import extract_warnings, ValidationWarning
-
-
-category_conventions = MappingProxyType(
-                            {
-                                '-MD': ['240', '21'],
-                                '-MS': ['240', '10', '20', '21', '250'],
-                                '-MC': ['240', '10', '20', '21', '250'],
-                                '-MM': ['240', '10', '20', '21', '250']
-                            }
-                        )
-
-
-extension_convention = MappingProxyType(
-                                {
-                                    0: { 'name': 'N', 'type': 'N'},
-                                    1: { 'name': 'SUM', 'type': 'TREX'}
-                                }
-                            )
-
-
-
-class PAC_Parser():
-    
-    def __init__(self, extension_interpreters:dict[str, Extension]=None):
-        self.extension_interpreters = extension_interpreters or {}
-        
-    def parse_pac_url(self, pac_url:str) -> tuple[PACID_With_Extensions, list[ValidationWarning] ]:
-        if '*' in pac_url:
-            id_str, ext_str = pac_url.split('*', 1)
-        else:
-            id_str = pac_url
-            ext_str = ""
-            
-        pac_id = self.parse_pac_id(id_str)
-        extensions = self.parse_extensions(ext_str)
-        
-        pac_with_extension = PACID_With_Extensions(pac_id=pac_id, extensions=extensions)
-        warnings = extract_warnings(pac_with_extension)
-        
-        return pac_with_extension, warnings
-            
-            
-    def parse_id_segments(self, identifier:str):
-        if not identifier:
-            return []    
-        
-        id_segments = list()  
-        if len(identifier) > 0 and identifier[0] == '/':
-            identifier = identifier[1:]
-        for s in identifier.split('/'):
-            tmp = s.split(':')
-            
-            if len(tmp) == 1:
-                segment = IDSegment(value=tmp[0])
-            elif len(tmp) == 2:
-                segment = IDSegment(key=tmp[0], value=tmp[1])
-            else:
-                raise ValueError(f'invalid segment: {s}')
-                
-            id_segments.append(segment)
-        return id_segments
-    
-    
-    def _apply_category_defaults(self, segments_in: list[IDSegment]):
-        
-        segments = segments_in.copy()
-        default_keys = None
-        for s in segments:
-            if not s.key and default_keys:
-                s.key = default_keys.pop(0)
-            else:
-                default_keys = None
-                
-            # category starts: start with new defaults. 
-            if s.value in category_conventions.keys():
-                default_keys = category_conventions.get(s.value).copy() #copy, so the entries can be popped when used
-        return segments
-                
-            
-        
-    def parse_pac_id(self,id_str:str) -> PACID:
-        m = re.match(f'(HTTPS://)?(PAC.)?(?P<issuer>.+?\..+?)/(?P<identifier>.*)', id_str)
-        d = m.groupdict()
-        
-        id_segments = list()
-        default_keys = None
-        id_segments = self.parse_id_segments(d.get('identifier'))
-        id_segments = self._apply_category_defaults(id_segments)
-        
-        pac = PACID(issuer= d.get('issuer'),
-                     identifier=Identifier(segments=id_segments)
-        )
-        return pac
-
-
-    def parse_extensions(self, extensions_str:str|None) -> list[Extension]:    
-        extensions = list()
-        
-        if not extensions_str:
-            return extensions
-        
-        defaults = extension_convention
-        for i, e in enumerate(extensions_str.split('*')):
-            if e == '': #this will happen if first extension starts with *
-                continue
-            d = re.match('((?P<name>.+)\$(?P<type>.+)/)?(?P<data>.+)', e).groupdict()
-            
-            name = d.get('name')
-            type = d.get('type') 
-            data = d.get('data')
-    
-            if name:
-                defaults = None # once a name was specified no longer assign defaults
-            else:
-                if defaults:
-                    name = defaults.get(i).get('name')
-                    type = defaults.get(i).get('type')
-                else:
-                    raise ValueError('extension number {i}, must have name and type')
-            
-            #convert to subtype if they were given
-            subtype = self.extension_interpreters.get(type) or UnknownExtension
-            e = subtype.from_spec_fields(name=name, type=type, data=data)
-            extensions.append(e)
-
-        return extensions
-        
- 
-
-     
-
-if __name__ == "__main__":
-    pacid_str = 'HTTPS://PAC.METTORIUS.COM/-DR/AB378/-MD/B-500/1235/-MS/AB/X:88/WWW/-MS/240:11/BB*ABCFD*A$HUR:25+B$CEL:99*BLUBB$TREX/A$HUR:25+B$CEL:99'
-    
-    pac = PAC_Parser().parse_pac(pacid_str)

labfreed/PAC_ID/serialize.py

@@ -1,60 +0,0 @@
-
-from .data_model import *
-
-    
-    
-class PAC_Serializer():    
-    def to_url(self, pac:PACID|PACID_With_Extensions, extensions:list[Extension]=None, use_short_notation_for_extensions=False, uppercase_only=False) -> str:
-        if isinstance(pac, PACID_With_Extensions):
-            if extensions:
-                raise ValueError('Extensions were given twice, as part of PACID_With_Extension and as method parameter.')
-            extensions = pac.extensions
-            pac = pac.pac_id
-        issuer = pac.issuer
-        extensions_str = self._serialize_extensions(extensions, use_short_notation_for_extensions)
-        id_segments = self._serialize_id_segments(pac.identifier.segments)
-        out = f"HTTPS://PAC.{issuer}{id_segments}{extensions_str}"
-        if uppercase_only:
-            out = out.upper()
-        return out
-    
-    
-    def _serialize_id_segments(self, segments):
-        out = ''
-        for s in segments:
-            if s.key:
-                out += f'/{s.key}:{s.value}'
-            else:
-                out += f'/{s.value}'
-        return out
-    
-    
-    def _serialize_extensions(self, extensions:list[Extension], use_short_notation_for_extensions):
-        out = ''
-        short_notation = use_short_notation_for_extensions
-        for i, e in enumerate(extensions):
-            
-            if short_notation and i==0:
-                if e.name=='N':
-                    out += f'*{e.data}'
-                    continue
-                else: 
-                    short_notation = False
-            if short_notation and i==1:
-                if e.name=='SUM':
-                    out += f'*{e.data}'
-                    continue
-                else: 
-                    short_notation = False
-                
-            out += f'*{e.name}${e.type}/{e.data}'
-        return out
-        
-
-   
-def main():
-    pass
-     
-
-if __name__ == "__main__":
-    main()

labfreed/TREXExtension/data_model.py

@@ -1,239 +0,0 @@
-from datetime import datetime
-from enum import Enum
-import logging
-import re
-
-from pydantic import BaseModel, ValidationError, field_validator
-from abc import ABC
-
-from .unit_utilities import *
-from ..PAC_ID.data_model import Extension
-
-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_scalar_pattern = re.compile(f"(?P<name>[\w\.-]*?)\$(?P<unit>[\w\.]*?):(?P<value>.*)")
-        
-TREX_DATEFORMAT = '%Y%m%dT%H%M%S'
-TREX_TIMEFORMAT = '%Y%m%d'
-        
-class TREX_types(Enum):
-    BOOL = 'T.B'
-    DATE = 'T.D'
-    TEXT = 'T.A'
-    ERROR = 'E'
-    
-
-   
-class T_REX_Segment_ParseError(BaseException):
-    pass
-
-
-class TREX_Segment(BaseModel, ABC):
-    segment_name: str = None
-    
-    def as_trex_segment_str(self, segment_name):
-        pass
- 
-      
-class TREX_SimpleSegment(TREX_Segment):
-    type: str 
-    value: str
-    
-    @field_validator('type', mode='before')
-    def validate_type(t):
-        if isinstance(t, TREX_types):
-            t = t.value
-        return t
-          
-    @staticmethod
-    def from_trex_segmentstring(segment_str):
-       
-        matches = re_scalar_pattern.match(segment_str)
-        if not matches:
-            raise T_REX_Segment_ParseError("Segment is not a valid TREX Scalar")
-        
-        name, type_, value = matches.groups()
-        
-        out = TREX_SimpleSegment(type=type_, value=value, segment_name=name)
-        return out
-        
-    @property
-    def value_as_builtin_or_quantity_type(self) -> datetime|bool|str|PydanticUncertainQuantity:
-        return _value_as_builtin_or_quantity(self.value, self.type)
-    
-    def as_trex_segment_str(self, segment_name) -> str:
-        return f'{segment_name}${self.type}:{self.value}'
-  
-  
-class TREX_Table(TREX_Segment):
-    col_names: list[str]
-    col_types: list[str]
-    data: list[list[str]]
-        
-    @staticmethod
-    def from_trex_segmentstring( segment_str:str):
-        matches = re_table_pattern.match(segment_str) 
-        if not matches:
-            raise T_REX_Segment_ParseError(f"Segment is not a valid TREX table: {segment_str}")
-        name, header, body = matches.groups()
-                
-        column_heads = [re_col_head_pattern.match(colhead).groups() for colhead in header.split(':')]
-        col_names = [ch[0] for ch in column_heads]
-        col_types = [ch[1] for ch in column_heads]
-        
-        data = [row.split(':') for row in body.split('::') ]
-        
-        out = TREX_Table(col_names=col_names, col_types=col_types, data=data, segment_name=name)
-        return out
-     
-    def n_rows(self) -> int:
-        return len(self.data)
-    
-    def n_cols(self) -> int:
-        return len(self.col_names)
-      
-    def row_data(self, row:int) -> list:
-        out = [_value_as_builtin_or_quantity(element, self.col_types[i]) for i, element in enumerate(self.data)]
-        return out
-                
-    def col_data(self, col:str|int) -> list:
-        col_index = self._get_col_index(col)
-        type = self.col_types[col_index]
-        out =  [_value_as_builtin_or_quantity(row[col_index],type) for row in self.data]
-        return out
-     
-    def cell_data(self, row:int, col:str|int):
-        try:
-            col_index = self._get_col_index(col)
-            value = self.data[row][col_index]
-            type = self.col_types[col_index]   
-        except ValueError:
-            logging.warning(f"row {row}, column {col} not found")
-            return None
-        
-        return _value_as_builtin_or_quantity(value, type)
-            
-    def _get_col_index(self, col:str|int):
-        if isinstance(col, str):
-            col_index = self.col_names.index(col)
-        elif isinstance(col, int):
-            col_index = col
-        else:
-            raise TypeError(f"Column must be specified as string or int: {col.__name__}")
-        return col_index
-    
-    def as_trex_segment_str(self, name):
-        header = ':'.join([f'{el[0]}${el[1]}' for el in zip(self.col_names, self.col_types)])
-        date_rows = list()
-        for r in self.data:
-            row = ':'.join([str(cell) for cell in r])
-            date_rows.append(row)
-        data = '::'.join(date_rows)
-        s = f'{name}$${header}::{data}'
-        return s
-        
-
-
-class TREX(Extension, BaseModel):
-    name_:str
-    segments: dict[str,TREX_Segment]
-       
-    @property
-    def name(self)->str:
-        return self.name_
-    
-    @property
-    def type(self)->str:
-        return 'TREX'
-    
-    @property
-    def data(self)->str:
-        seg_strings = list()
-        for s_name, s in self.segments.items():
-            seg_strings.append(s.as_trex_segment_str(s_name))
-        s_out = '+'.join(seg_strings)
-        return s_out
-    
-    @staticmethod
-    def from_spec_fields(name, type, data):
-        if type != 'TREX':
-            logging.warning(f'Type {name} was given, but this extension should only be used with type "TREX". Will try to parse data as TREX')
-        
-        if not data:
-            raise ValueError(f'T-REX must be a string of non zero length')
-        
-        trex_str = data
-
-        # 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 = re.sub(r"\s+", "", trex_str)
-                
-        segment_strings = trex_str.split('+')
-        out_segments = dict()
-        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
-            try:
-                segment = TREX_SimpleSegment.from_trex_segmentstring(s)
-            except T_REX_Segment_ParseError:
-                segment = TREX_Table.from_trex_segmentstring(s)
-            out_segments[segment.segment_name] = segment
-        
-        return TREX(name_=name, segments=out_segments)
-    
-    def get_segment(self, segment_id:str) -> TREX_Segment:
-        return self.segments.get(segment_id)
-    
-    
-    
-    
-class TREX_Struct(TREX_Segment):
-    """Struct is a special interpretation of a T-REX Table with one row"""
-    wrapped_table:TREX_Table
-    
-    @property
-    def segment_name_(self):
-        return self.wrapped_table.segment_name
-    
-    @field_validator('wrapped_table')
-    def validate_table(table):
-        if len(table.data) != 1:
-            raise ValidationError("Too many input rows. Struct can only have one row")
-        return table
-                
-    def get(self, key):
-        return self.wrapped_table.cell_data(0, key)
-    
-    def keys(self):
-        return self.wrapped_table.col_names
-    
-    
-    
- 
-def _to_datetime(trex_datetime):  
-    try:
-        # return datetime.fromisoformat(trex_datetime) # should work with python 3.11
-        return datetime.strptime(trex_datetime, TREX_DATEFORMAT)
-    except (ValueError , TypeError) as e:
-        try:
-            return datetime.strptime(trex_datetime, TREX_TIMEFORMAT)
-        except (ValueError, TypeError):
-            return None
-        
-def _value_as_builtin_or_quantity(v:str|list[str], type:str) -> datetime|bool|str|PydanticUncertainQuantity:
-    match type:
-        case 'T.D':
-            return _to_datetime(v)
-        case 'T.B':
-            return v == 'T' or bool(v)
-        case 'T.A':
-            return v
-        case 'T.X':
-            raise NotImplementedError("Base36 encoded T-REX segment not implemented")
-        case 'E':
-            return v
-        case _:
-            return quantity_from_UN_CEFACT(v, type)