labfreed 0.0.3__py3-none-any.whl

labfreed/DisplayNameExtension/DisplayNameExtension.py

@@ -0,0 +1,34 @@
+import logging
+from pydantic import BaseModel
+from ..PAC_ID.data_model import Extension
+from .base36 import from_base36, to_base36
+
+
+class DisplayNames(Extension, BaseModel):
+    display_names: list[str]
+       
+    @property
+    def name(self)->str:
+        return 'N'
+    
+    @property
+    def type(self)->str:
+        return 'N'
+    
+    @property
+    def data(self)->str:
+        return '/'.join([to_base36(dn) for dn in self.display_names])
+    
+    @staticmethod
+    def from_spec_fields(name, type, data):
+        if name != 'N':
+            logging.warning(f'Name {name} was given, but this extension should only be used with name "N". Will ignore input')
+            
+        if type != 'N':
+            logging.warning(f'Type {name} was given, but this extension should only be used with type "N". Will try to parse data as display names')
+        
+        display_names = [from_base36(b36) for b36 in data.split('/')]
+         
+        return DisplayNames(display_names=display_names)
+
+

labfreed/DisplayNameExtension/base36.py

@@ -0,0 +1,66 @@
+import string
+
+def alphabet(base):
+    """ returns an alphabet, which corresponds to what pythons int(s:str, base:int=10) function used.
+    """
+    if base < 2 or base > 36:
+        ValueError('base can only be between 2 and 36')    
+    alphabet = (string.digits + string.ascii_uppercase)[0:base]
+    return alphabet
+
+def to_base36(s:str):
+    """Takes a string, encodes it in UTF-8 and then as base36 string."""
+    utf8_encoded = s.encode('utf-8')
+    num = int.from_bytes(utf8_encoded, byteorder='big', signed=False)
+    
+    # note: this cannot be arbitrarily chosen. The choice here corresponds to what pythons int(s:str, base:int=10) function used.
+    base36_chars = alphabet(base=36)
+    if num == 0:
+        return base36_chars[0]
+    base36 = []
+    _num = num
+    while _num:
+        _num, i = divmod(_num, 36)
+        base36.append(base36_chars[i])
+    return ''.join(reversed(base36))
+
+
+def from_base36(s36:str):
+    """inverse of to_base36"""
+    # this built in function interprets each character as number in a base represented by the standartd alphabet [0-9 (A-Z|a-z)][0:base] it is case INsensitive.
+    num = int(s36, 36)
+    num_bytes = (num.bit_length() + 7) // 8
+    _bytes = num.to_bytes(num_bytes, byteorder='big')
+    s = _bytes.decode('utf-8')
+    return s
+
+if __name__ == "__main__":
+    ss = ["A",
+      "B-500 B",
+      "B-500 Ba",
+      "B-500 Bal",
+      "B-500 Bala",
+      "B-500 Balanc",
+      "B-500 Balance",
+      "B-500 D",
+      "Mini Spray Dryer S-300", 
+      "w3ApashAt!!£NAGDSAF*ç%&/()",
+      "HELLOWORLD", 
+      "Helloworld",
+      "$£äö!'?^{]<@#¦&¬|¢)&§°😀你好🌍🏯😇🎵🔥你👻🐉😀你好🌍🏯😇🎵🔥你👻🐉😀你好🌍🏯😇🎵🔥你👻🐉😀你好🌍🏯😇🎵🔥你👻🐉😀你好🌍🏯😇🎵🔥你👻🐉😀你好🌍🏯😇🎵🔥你👻🐉😀你好🌍🏯😇🎵🔥你👻🐉",
+      "往跟住！師立甲錯什正再圓身升因月室",
+      "Balance BAL500 @☣️Lab",
+      "BAL500 @☣️Lab",
+      "BAL-CLEAN",
+      "Smørrebrød µ-Nutrients",
+      "Demo Result from R-300",
+      "Rotavapor R-300",
+      "Rotavapor R-250",
+      "Rotavapor R-220",
+      "SyncorePlus"
+      ]
+    for s in ss:
+        s36 = to_base36(s)
+        s_back = from_base36(s36)
+        identical = (s == s_back)
+        print(f'{s} >> {s36} >> {s_back}: match:{identical}')

labfreed/PAC_CAT/__init__.py

@@ -0,0 +1 @@
+

labfreed/PAC_CAT/data_model.py

@@ -0,0 +1,109 @@
+from abc import ABC
+from pydantic import Field
+from pydantic import BaseModel
+
+from ..PAC_ID.data_model import IDSegment, Category
+
+class CATBase(BaseModel, ABC):
+    category_key:str
+    additional_segments: list[IDSegment] = Field(default_factory=list)
+    
+    class Config:
+        populate_by_name = True # this will allow field names, as well as aliases in validation
+    
+    def to_identifier_category(self, use_short_notation=False):
+        '''Creates a Category with the correct segments. 
+           Segments are in order of the Pydantic model fields. 
+           Segment keys are omitted as long as the recommendation is followed.
+           Additional segments are added at the end'''
+        segments = []
+        can_omit_keys = use_short_notation # keeps track of whether keys can still be omitted. That is the case when the segment recommendation is followed
+        for field_name, field_info in self.model_fields.items():
+            if field_name in ['category_key', 'additional_segments']:
+                continue
+            if value := getattr(self, field_name):
+                if can_omit_keys:
+                    key = None
+                else:
+                    key = field_info.alias
+                segments.append(IDSegment(key= key, value= value)  )
+            else:
+                can_omit_keys = False
+        if self.additional_segments:     
+            segments.extend(self.additional_segments)
+        return Category(key=self.category_key,
+                        segments=segments)
+                
+            
+
+
+class Material_Device(CATBase):
+    category_key: str =         Field(default='-MD', frozen=True)
+    model_number: str =         Field(              alias='240', min_length=1)
+    serial_number: str =        Field(              alias='21', min_length=1)
+    
+class Material_Substance(CATBase):
+    category_key: str =         Field(default='-MS', frozen=True)
+    product_number:str =        Field(              alias='240', min_length=1)
+    batch_number:str|None =     Field(default=None, alias='10')
+    container_size:str|None =   Field(default=None, alias='20')
+    container_number:str|None = Field(default=None, alias='21')
+    aliquot:str|None =          Field(default=None, alias='250')
+    
+class Material_Consumable(CATBase):
+    category_key: str = Field(default='-MC', frozen=True)
+    product_number:str =        Field(              alias='240', min_length=1)
+    batch_number:str|None =     Field(default=None, alias='10')
+    packing_size:str|None =     Field(default=None, alias='20')
+    serial_number:str|None =    Field(default=None, alias='21')
+    aliquot:str|None =          Field(default=None, alias='250')
+    
+class Material_Misc(Material_Consumable):
+    category_key: str = Field(default='-MM', frozen=True)
+
+
+
+class Data_Result(CATBase):
+    category_key: str = Field(default='-DR', frozen=True)
+    id:str =                    Field(              alias='240', min_length=1)
+    
+class Data_Method(CATBase):
+    category_key: str = Field(default='-DM', frozen=True)
+    id:str =                    Field(              alias='240', min_length=1)
+    
+class Data_Calibration(CATBase):
+    category_key: str = Field(default='-DC', frozen=True)
+    id:str =                    Field(              alias='240', min_length=1)
+    
+class Data_Progress(CATBase):
+    category_key: str = Field(default='-DP', frozen=True)
+    id:str =                    Field(              alias='240', min_length=1)
+    
+class Data_Static(CATBase):
+    category_key: str = Field(default='-DS', frozen=True)
+    id:str =                    Field(              alias='240', min_length=1)
+    
+    
+    
+    
+mapping  = {
+        '-MD': Material_Device,
+        '-MS': Material_Substance,
+        '-MC': Material_Consumable,
+        '-MM': Material_Misc,
+        '-DM': Data_Method,
+        '-DR': Data_Result,
+        '-DC': Data_Calibration,
+        '-DP': Data_Progress,
+        '-DS': Data_Static 
+    }
+    
+def CAT_from_category(category:Category) -> CATBase|None:
+    raise NotImplementedError()
+
+def CAT_from_category_key(category_key) -> CATBase|None:
+    return mapping.get(category_key)
+    
+
+if __name__ == "__main__":
+    pass

labfreed/PAC_ID/data_model.py

@@ -0,0 +1,114 @@
+from typing import Optional
+from typing_extensions import Self
+from pydantic import BaseModel, Field, computed_field, conlist, model_validator
+from abc import ABC, abstractproperty, abstractstaticmethod
+
+class IDSegment(BaseModel):
+    key:Optional[str] = Field(None, pattern=r'^[A-Z0-9-+]+$', min_length=1)
+    value:str = Field(..., pattern=r'^[A-Z0-9-+]+$', min_length=1)
+
+
+class Category(BaseModel):
+    key:str|None = None
+    segments: list[IDSegment]
+
+
+class Identifier(BaseModel):
+    segments: conlist(IDSegment, min_length=1) = Field(..., exclude=True) # exclude=True prevents this from being serialized by Pydantic
+        
+    @computed_field
+    @property
+    def categories(self) -> list[Category]:
+        categories = list()
+        c = Category(segments=[])
+        categories.append(c)
+        for s in self.segments:
+            # new category starts with "-"
+            if s.value[0] == '-':
+                cat_key = s.value
+                c = Category(key=cat_key, segments=[])
+                categories.append(c)
+            else:
+                c.segments.append(s)
+            
+        # the first category might have no segments. remove categories without segments
+        if not categories[0].segments:
+            categories = categories[1:]
+                
+        return categories
+    
+    @model_validator(mode='after')
+    def check_keys_are_unique_in_each_category(self) -> Self:
+        for c in self.categories:
+            keys = [s.key for s in c.segments if s.key]
+            duplicate_keys = [k for k in set(keys) if keys.count(k) > 1]
+            if duplicate_keys:
+                raise ValueError(f'Duplicate keys {",".join(duplicate_keys)} in category {c.key}')
+            return self
+       
+    @staticmethod 
+    def from_categories(categories:list[Category]) :
+        segments = list()
+        for c in categories:
+            if c.key:
+                segments.append(IDSegment(value=c.key))
+            segments.extend(c.segments)
+        return Identifier(segments=segments)
+        
+    
+
+class Extension(ABC, BaseModel): 
+    
+    @abstractproperty
+    def name(self)->str:
+        pass
+    
+    @abstractproperty
+    def type(self)->str:
+        pass
+    
+    @abstractproperty
+    def data(self)->str:
+        pass
+    
+    @abstractstaticmethod
+    def from_spec_fields(name, type, data):
+        pass
+    
+    
+class UnknownExtension(Extension):
+    name_:str
+    type_:str
+    data_:str
+    
+    @property
+    def name(self)->str:
+        return self.name_
+    
+    @property
+    def type(self)->str:
+        return self.type_
+    
+    @property
+    def data(self)->str:
+        return self.data_
+       
+    @staticmethod
+    def from_spec_fields(name, type, data):
+        return UnknownExtension(name_=name, type_=type, data_=data)
+    
+
+
+class PACID(BaseModel):
+    issuer:str
+    identifier: Identifier
+    
+    
+class PACID_With_Extensions(BaseModel):
+    pac_id: PACID
+    extensions: list[Extension] = Field(default_factory=list)
+
+
+
+
+

labfreed/PAC_ID/parse.py

@@ -0,0 +1,133 @@
+
+
+import re
+from types import MappingProxyType
+from .data_model import *
+
+
+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) -> PACID_With_Extensions:
+        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)    
+        return PACID_With_Extensions(pac_id=pac_id, extensions=extensions)
+            
+            
+    def parse_id_segments(self, identifier:str):
+        if not identifier:
+            return []    
+        
+        id_segments = list()  
+        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)
+            
+        return PACID(issuer= d.get('issuer'),
+                     identifier=Identifier(segments=id_segments)
+        )
+
+
+    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

@@ -0,0 +1,57 @@
+
+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) -> 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)
+        return f"HTTPS://PAC.{issuer}{id_segments}{extensions_str}".upper()
+    
+    
+    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

@@ -0,0 +1,239 @@
+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)

labfreed/TREXExtension/parse.py

@@ -0,0 +1,46 @@
+import logging
+import re
+
+from .data_model import TREX, T_REX_Segment_ParseError, TREX_SimpleSegment, TREX_Table
+
+
+def from_trex_string(trex_str, 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')
+    name = d.get('name')
+    data = d.get('data')
+    
+    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')
+    
+            
+    segment_strings = data.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
+    trex = TREX(name_= name, segments=out_segments)
+    trex._trex_str = trex_str
+    return trex

labfreed/TREXExtension/uncertainty.py

@@ -0,0 +1,32 @@
+from math import floor, log10, pow
+
+def to_significant_digits_str(x:int|float, uncertainty:float|int) -> str:
+    if uncertainty == None:
+        if isinstance(x, float):
+            Warning(f'Uncertainty was given as none. Returning unrounded number')
+            return str(x)
+        else:
+            uncertainty = 1
+
+    
+    log_least_significant_digit = floor(log10(uncertainty))
+    digits = -log_least_significant_digit
+    
+    x_significant = round(x, digits)
+    
+    if digits <= 0:
+        return str(int(x_significant))
+    else:
+        return str(x_significant)
+        
+
+
+if __name__ == "__main__":
+    print(to_significant_digits_str(111111.1111111, 1000))
+    print(to_significant_digits_str(111111.1111111, 100))
+    print(to_significant_digits_str(111111.1111111, 10))
+    print(to_significant_digits_str(111111.1111111, 1))
+    print(to_significant_digits_str(111111.1111111, 0.1))
+    print(to_significant_digits_str(111111.1111111, 0.01))
+    print(to_significant_digits_str(111111.1111111, 0.001))
+    print(to_significant_digits_str(111111.1111111, 0.0001))

labfreed/TREXExtension/unit_utilities.py

@@ -0,0 +1,134 @@
+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  .uncertainty import to_significant_digits_str
+            
+                
+
+def validate_unit(unit_name:str) -> str :
+    """
+    Pydantic validator function for the unit.
+    Checks if the unit is a valid unit.
+    
+
+    Args:
+        unit (str): unit symbol, e.g. 'kg'
+
+    Returns:
+        str: the input unit. 
+        
+    Errors:
+        raises an AssertionError if validation fails
+    """
+    if hasattr(pq, unit_name):
+        return unit_name
+    else:
+        assert False
+
+
+class PydanticUncertainQuantity(BaseModel):
+    data:int|float
+    unit_name: Annotated[str, AfterValidator(validate_unit)]
+    unit_symbol: str
+    uncertainty:float|None=None
+    
+    @property
+    def for_display(self):
+        return self.__str__()
+    
+    def as_strings(self):
+        unit_symbol = self.unit_symbol
+        if unit_symbol == "dimensionless":
+            unit_symbol = ""
+        s = ''
+
+        val_str = to_significant_digits_str(self.data, self.uncertainty)
+        return f"{val_str}", f"{unit_symbol}", f"{val_str} {unit_symbol}"
+        
+    
+    
+    def __str__(self):
+        unit_symbol = self.unit_symbol
+        if unit_symbol == "dimensionless":
+            unit_symbol = ""
+        
+        s = f"{to_significant_digits_str(self.data, self.uncertainty)} {unit_symbol}" 
+        return s
+    
+    
+unit_map = [
+    ('MGM', units.milligram),
+    ('CEL', units.celsius),
+    ('LTR', units.liter),
+    ('MLT', units.milliliter),
+    ('GRM', units.gram),
+    ('KGM', units.kilogram),
+    ('C34', units.mole),
+    ('D43',units.atomic_mass_unit),
+    ('1', units.dimensionless),
+    ('C62', units.dimensionless),
+    ('BAR',units.bar),
+    ('MBR',units.millibar),
+    ('KBA',units.kilobar),
+    ('RPM', units.rpm),
+    ('HUR', units.hour),
+    ('HTZ', units.hertz),
+    ('KHZ', units.kilohertz),
+    ('MHZ',units.megahertz),
+    ('SEC', units.second),
+    ('MIN', units.minute),
+    ('URH', units.hour)
+    
+]      
+    
+    
+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
+                
+        
+        
+
+    

labfreed/__init__.py

@@ -0,0 +1,5 @@
+''' 
+Python implementation of LabFREED building blocks
+'''
+
+__version__ = "0.0.3"

labfreed-0.0.3.dist-info/METADATA

@@ -0,0 +1,15 @@
+Metadata-Version: 2.4
+Name: labfreed
+Version: 0.0.3
+Summary: Python implementation of LabFREED building blocks
+Author-email: Reto Thürer <reto.thuerer@gmail.com>
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-Expression: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+License-File: LICENSE
+
+# LabFREED for Python
+
+A python implementation of [LabFREED](www.labfreed.com).

labfreed-0.0.3.dist-info/RECORD

@@ -0,0 +1,17 @@
+labfreed/__init__.py,sha256=ToYkbhG_8yX4YOS9mieyjvGLG2M8raraqRFDbU71d3A,87
+labfreed/DisplayNameExtension/DisplayNameExtension.py,sha256=FlT53u1EntpsLmho6GZtgIWBZBNWkl9STxzJBvojR6M,1033
+labfreed/DisplayNameExtension/base36.py,sha256=2lwmEMWm8qrFJkcrP-nMPwS0eCm2THhCJ3Vk-TdGQg0,2455
+labfreed/PAC_CAT/__init__.py,sha256=frcCV1k9oG9oKj3dpUqdJg1PxRT2RSN_XKdLCPjaYaY,2
+labfreed/PAC_CAT/data_model.py,sha256=y1cTFZknObi5XOk4aqfgeJv6_G8Rjd9mxTRwNCQR0M4,4311
+labfreed/PAC_ID/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+labfreed/PAC_ID/data_model.py,sha256=oVVqspdZ4B_C4V1rOmcde2_EqWUpDJc6vDUnX4Z1ZPw,3123
+labfreed/PAC_ID/parse.py,sha256=ZmCpuht7o6RgDZCweF7Y0k7QFTd0gLtUpmjFsIlz_wA,4668
+labfreed/PAC_ID/serialize.py,sha256=ujI4SFs-TsFb4FVU2hzwardEWu8-2MYjewE0IyC1yok,1871
+labfreed/TREXExtension/data_model.py,sha256=eT4KyQklTO6m-wA28KyJ8wzT8ONhG3fOB3JU6b19ScY,8011
+labfreed/TREXExtension/parse.py,sha256=Y04UK1KlMLG9tE_d7cQOiAJpm8Zh49UoJYjY7Lfqa4Y,1812
+labfreed/TREXExtension/uncertainty.py,sha256=l3WxrLnWTQYfX28gFisXwDcVPvT8bCAd4q6Xl02dRdE,1117
+labfreed/TREXExtension/unit_utilities.py,sha256=ZhivJnEXMvz7HxLJjI1oJ8y_pcPxW2abKkouiqTo4I4,3775
+labfreed-0.0.3.dist-info/licenses/LICENSE,sha256=gHFOv9FRKHxO8cInP3YXyPoJnuNeqrvcHjaE_wPSsQ8,1100
+labfreed-0.0.3.dist-info/WHEEL,sha256=_2ozNFCLWc93bK4WKHCO-eDUENDlo-dgc9cU3qokYO4,82
+labfreed-0.0.3.dist-info/METADATA,sha256=EAt_IEv09C97i4lu65HHBCaWCdF6y4gnmZDbp7H7TaM,449
+labfreed-0.0.3.dist-info/RECORD,,

labfreed-0.0.3.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: flit 3.11.0
+Root-Is-Purelib: true
+Tag: py3-none-any

labfreed-0.0.3.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 Reto Thürer
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.