labfreed 0.0.4__py3-none-any.whl → 0.2.0__py3-none-any.whl

labfreed/trex/trex_base_models.py

@@ -0,0 +1,336 @@
+from datetime import date, datetime, time
+import logging
+import re
+
+
+
+from pydantic import PrivateAttr,  field_validator, model_validator
+from labfreed.labfreed_infrastructure import LabFREED_BaseModel, ValidationMsgLevel, _quote_texts
+from abc import ABC, abstractclassmethod,  abstractmethod
+
+from labfreed.utilities.base36 import base36, to_base36, from_base36
+
+
+''' Configure pdoc'''
+v_segs  = ["NumericSegment", 
+           "DateSegment", 
+           "BoolSegment", 
+           "AlphanumericSegment", 
+           "TextSegment", 
+           "BinarySegment"]
+__all__ = ["TREX"] + v_segs + ["TableSegment"]  # noqa: F822
+
+            
+           
+
+class Value(LabFREED_BaseModel, ABC):
+    '''@private
+    Helper to add validation for various types to ValueSegments and Tables
+    '''
+    value:str 
+    
+    def serialize(self):
+        return self.value
+        
+    @abstractclassmethod
+    def _from_python_type(cls, v):
+        ...
+        
+    @abstractmethod
+    def _value_to_python_type(self):
+        ...
+        
+        
+class NumericValue(Value):
+    @field_validator('value', mode='before')
+    @classmethod
+    def _from_python_type(cls, v:str| int|float):
+        if isinstance(v, str):
+            return v
+        return str(v)
+        
+    @model_validator(mode='after')
+    def _validate(self):
+        value = self.value
+        if not_allowed_chars := set(re.sub(r'[0-9\.\-E]', '', value)):
+            self._add_validation_message(
+                source=f"TREX numeric value {value}",
+                level=ValidationMsgLevel.ERROR,
+                msg=f"Characters {_quote_texts(not_allowed_chars)} are not allowed in quantity segment. Base36 encoding only allows A-Z0-9",
+                highlight_pattern = f'{value}',
+                highlight_sub=not_allowed_chars
+            )
+        if not re.fullmatch(r'-?\d+(\.\d+)?(E-?\d+)?', value):
+            self._add_validation_message(
+                source=f"TREX numeric value {value}",
+                level=ValidationMsgLevel.ERROR,
+                msg=f"{value} cannot be converted to number",
+                highlight_pattern = f'{value}'               
+            )
+        return self
+    
+    def _value_to_python_type(self) -> str:
+        v = float(self.value)  
+        if '.' not in self.value and 'E' not in self.value: 
+            return int(v)
+        else:
+            return v
+
+
+class DateValue(Value):
+    _date_time_dict:dict|None = PrivateAttr(default=None)
+    @field_validator('value', mode='before')
+    @classmethod
+    def _from_python_type(cls, v:str| date|time|datetime):
+        if isinstance(v, str):
+            return v
+        
+        sd = ""
+        st = ""
+        if isinstance(v, date) or isinstance(v, datetime):
+            sd = v.strftime('%Y%m%d')
+        if isinstance(v, time) or isinstance(v, datetime):
+            if v.microsecond:
+                st = v.strftime("T%H%M%S.") + f"{v.microsecond // 1000:03d}"
+            elif v.second:
+                st = v.strftime("T%H%M%S")
+            else:
+                st = v.strftime("T%H%M")
+                         
+        return sd + st
+    
+    @model_validator(mode='after')
+    def _validate(self):
+        pattern:str = r'((?P<year>\d{4})(?P<month>\d{2})(?P<day>\d{2}))?(T(?P<hour>\d{2})(?P<minute>\d{2})(?P<second>\d{2})?(\.(?P<millisecond>\d{3}))?)?'
+        value=self.value
+        if not re.fullmatch(pattern, value):
+            self._add_validation_message(
+                source=f"TREX date value {value}",
+                level=ValidationMsgLevel.ERROR,
+                msg=f'{value} is not in a valid format. Valid format for date: YYYYMMDD; Valid for time: THHMM, THHMMSS, THHMMSS.SSS; Datetime any combination of valid date and time',
+                highlight_pattern = f'{value}'
+            )
+            return self
+            
+        matches = re.match(pattern, value)       
+        d = matches.groupdict()  
+        d = {k: int(v) for k,v in d.items() if v }
+        if 'millisecond' in d.keys():
+            ms = d.pop('millisecond')
+            d.update({'microsecond': ms * 1000})
+        try:
+            if d.get('year'): # input is only a time
+                datetime(**d)
+            else:
+                time(**d)
+        except ValueError:
+            self._add_validation_message(
+                source=f"TREX date value {value}",
+                level=ValidationMsgLevel.ERROR,
+                msg=f'{value} is no valid date or time.',
+                highlight_pattern = f'{value}'
+            )
+            
+        self._date_time_dict = d
+        return self
+    
+    def _value_to_python_type(self) -> str:
+        d = self._date_time_dict
+        if d.get('year') and d.get('hour'): # input is only a time
+            return datetime(**d)
+        elif d.get('year'):
+            return date(**d)
+        else:
+            return time(**d)
+    
+   
+class BoolValue(Value):
+    @field_validator('value', mode='before')
+    @classmethod
+    def _from_python_type(cls, v:str| bool):
+        if isinstance(v, str):
+            return v
+        
+        return 'T' if v else 'F'
+
+    @model_validator(mode='after')
+    def _validate(self):
+        if self.value not in ['T', 'F']:
+            self._add_validation_message(
+                source=f"TREX boolean value {self.value}",
+                level= ValidationMsgLevel.ERROR,
+                msg=f'{self.value} is no valid boolean. Must be T or F',
+                highlight_pattern = f'{self.value}',
+                highlight_sub=[c for c in self.value]
+            )
+        return self
+    
+    def _value_to_python_type(self) -> str:
+        if self.value == 'T':
+            return True
+        elif self.value == 'F':
+            return False
+        else:
+            Exception(f'{self} is not valid boolean. That really should not have been possible -- Contact the maintainers of the library')
+                    
+                    
+class AlphanumericValue(Value):
+    @field_validator('value', mode='before')
+    @classmethod
+    def _from_python_type(cls, v:str):
+        return v
+        
+    @model_validator(mode='after')
+    def _validate(self):
+        if re.match(r'[a-z]', self.value):
+            self._add_validation_message(
+                    source=f"TREX value {self.value}",
+                    level= ValidationMsgLevel.ERROR,
+                    msg="Lower case characters are not allowed.",
+                    highlight_pattern = self.value
+            )
+            
+        if not_allowed_chars := set(re.sub(r'[A-Z0-9\.-]', '', self.value)):
+            self._add_validation_message(
+                    source=f"TREX value {self.value}",
+                    level= ValidationMsgLevel.ERROR,
+                    msg=f"Characters {_quote_texts(not_allowed_chars)} are not allowed in alphanumeric segment",
+                    highlight_pattern = self.value,
+                    highlight_sub=not_allowed_chars
+            )
+        return self
+           
+    def _value_to_python_type(self) -> str:
+        return self.value
+    
+    
+class TextValue(Value):
+    @field_validator('value', mode='before')
+    @classmethod
+    def _from_python_type(cls, v:base36|str):
+        if isinstance(v, str):
+            logging.info('Got str for text value > converting to base36')
+            return to_base36(v).root
+        else:
+            return v.root
+        
+    @model_validator(mode='after')
+    def _validate(self):
+        if not_allowed_chars := set(re.sub(r'[A-Z0-9]', '', self.value)):
+            self._add_validation_message(
+                    source=f"TREX value {self.value}",
+                    level= ValidationMsgLevel.ERROR,
+                    msg=f"Characters {_quote_texts(not_allowed_chars)} are not allowed in text segment. Base36 encoding only allows A-Z0-9",
+                    highlight_pattern = self.value,
+                    highlight_sub=not_allowed_chars
+            )
+        return self
+              
+    def _value_to_python_type(self) -> str:
+        decoded = from_base36(self.value)
+        return decoded
+    
+    
+class BinaryValue(Value):
+    @field_validator('value', mode='before')
+    @classmethod
+    def _from_python_type(cls, v:base36|str):
+        if isinstance(v, str):
+            return v
+        else:
+            return v.root
+        
+    @model_validator(mode='after')
+    def _validate(self):
+        if not_allowed_chars := set(re.sub(r'[A-Z0-9]', '', self.value)):
+           self._add_validation_message(
+                    source=f"TREX value {self.value}",
+                    level= ValidationMsgLevel.ERROR,
+                    msg=f"Characters {_quote_texts(not_allowed_chars)} are not allowed in text segment. Base36 encoding only allows A-Z0-9",
+                    highlight_pattern = self.value,
+                    highlight_sub=not_allowed_chars
+            )
+        return self
+              
+    def _value_to_python_type(self) -> bytes:
+        decoded = bytes(from_base36(self))
+        return decoded
+    
+    
+class ErrorValue(Value):
+    @field_validator('value', mode='before')
+    @classmethod
+    def _from_python_type(cls, v:str):
+        return v
+    
+    @model_validator(mode='after')
+    def _validate(self):
+        if not_allowed_chars := set(re.sub(r'[A-Z0-9\.-]', '', self.value)):
+            self._add_validation_message(
+                    source=f"TREX value {self.value}",
+                    level= ValidationMsgLevel.ERROR,
+                    msg=f"Characters {_quote_texts(not_allowed_chars)} are not allowed in error segment",
+                    highlight_pattern = self.value,
+                    highlight_sub=not_allowed_chars
+            )
+        return self
+       
+    
+    def _value_to_python_type(self) -> str:
+        return self.value
+
+
+class TREX_Segment(LabFREED_BaseModel, ABC):
+    '''@private
+    Abstract class representing a TREX_Segment
+    '''
+    key: str
+    
+    @abstractmethod
+    def serialize(self):
+        raise NotImplementedError("Subclasses must implement 'serialize_as_trex()' method")
+    
+    
+    @model_validator(mode='after')
+    def _validate_key(self):
+        if not_allowed_chars := set(re.sub(r'[A-Z0-9\.-]', '', self.key)):
+            self._add_validation_message(
+                source=f"TREX segment key {self.key}",
+                level=ValidationMsgLevel.ERROR,
+                msg=f"Segment key contains invalid characters: {_quote_texts(not_allowed_chars)}",
+                highlight_pattern = f'{self.key}$',
+                highlight_sub=not_allowed_chars
+            )
+        return self
+    
+
+        
+      
+ 
+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': 
+            try:
+                value = base36(s)
+            except ValueError:
+                logging.error('String given as T.T contains characters which base36 should not')
+                value = s
+            v = TextValue(value=value)
+        case 'T.X': 
+            v = BinaryValue(value=s)
+        case 'E'  : 
+            v = ErrorValue(value=s)
+        case _    : 
+            v = NumericValue(value=s)         
+    return v   
+    
+
+    
+
+

labfreed/trex/value_segments.py

@@ -0,0 +1,111 @@
+from abc import ABC
+import logging
+import re
+from typing import Literal
+from pydantic import Field, model_validator
+from labfreed.utilities.base36 import base36
+from labfreed.well_known_keys.unece.unece_units import unece_unit_codes
+from labfreed.labfreed_infrastructure import ValidationMsgLevel
+from labfreed.trex.trex_base_models import AlphanumericValue, BinaryValue, BoolValue, DateValue, ErrorValue, NumericValue, TREX_Segment, TextValue, Value
+
+
+
+class ValueSegment(TREX_Segment, Value, ABC):
+    '''@private: Abstract base class for value segments'''
+    type:str
+    
+    @model_validator(mode='after')
+    def _validate_type(self):
+        valid_types = valid_types = unece_unit_codes() + ['T.D', 'T.B', 'T.A', 'T.T', 'T.X', 'E']
+        if self.type not in valid_types:
+            self._add_validation_message(
+                    source=f"TREX value segment {self.key}",
+                    level= ValidationMsgLevel.ERROR,
+                    msg=f"Type {self.type} is invalid. Must be 'T.D', 'T.B', 'T.A', 'T.T', 'T.X', 'E' or a UNECE unit",
+                    highlight_pattern = self.type
+            )
+        return self
+        
+    
+    def serialize(self) -> str:
+        return f'{self.key}${self.type}:{self.value}'
+    
+    
+class NumericSegment(ValueSegment, NumericValue):
+    '''Represents a TREX segment holding a numeric value'''
+    type: str 
+    key:str   
+    value:str
+    
+class DateSegment(ValueSegment, DateValue):
+    '''Represents a TREX segment holding a date'''
+    type: Literal['T.D'] = Field('T.D', frozen=True)
+    key:str   
+    value:str
+          
+class BoolSegment(ValueSegment, BoolValue):
+    '''Represents a TREX segment holding a boolean value'''
+    type: Literal['T.B']  = Field('T.B', frozen=True) 
+    key:str   
+    value:str
+class AlphanumericSegment(ValueSegment, AlphanumericValue):
+    '''Represents a TREX segment holding a alphanumeric text'''
+    type: Literal['T.A'] = Field('T.A', frozen=True)
+    key:str   
+    value:str
+class TextSegment(ValueSegment, TextValue):
+    '''Represents a TREX segment holding a text with arbitrary characters'''
+    type: Literal['T.T'] = Field('T.T', frozen=True)
+    key:str   
+    value:str
+    
+class BinarySegment(ValueSegment, BinaryValue):
+    '''Represents a TREX segment holding binary data'''
+    type: Literal['T.X'] = Field('T.X', frozen=True)
+    key:str   
+    value:str
+    
+class ErrorSegment(ValueSegment, ErrorValue):
+    '''Represents a TREX segment which has erroneous content'''
+    type: Literal['E'] = Field('E', frozen=True)
+    key:str   
+    value:str
+                     
+
+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("(?P<name>.+?)\$(?P<unit>.+?):(?P<value>.+)")
+    matches = re_scalar_pattern.match(trex_segment_str)
+    if not matches:
+        return None
+    
+    key, type_, value = matches.groups()
+    
+    match type_:
+        case 'T.D':
+            out = DateSegment(key=key, value=value, type=type_)
+        case 'T.B':
+            out = BoolSegment(key=key, value=value, type=type_)
+        case 'T.A':
+            out = AlphanumericSegment(key=key, value=value, type=type_)
+        case 'T.T':
+            try:
+                value = base36(value)
+            except ValueError:
+                logging.error('String given as T.T contains characters which base36 should not')
+                value = value
+            out = TextSegment(key=key, value=value, type=type_)  # prevent repeated conversion from str to base36 and make explict that when parsing we assume the string tpo be base36 already
+        case 'T.X':
+            try:
+                value = base36(value)
+            except ValueError:
+                logging.error('String given as T.X contains characters which base36 should not')
+                value = value
+            out = BinarySegment(key=key, value=value, type=type_) # prevent repeated conversion from str to base36 and make explict that when parsing we assume the string tpo be base36 already
+        case 'E':
+            out = ErrorSegment(key=key, value=value, type=type_)
+        case _:
+            out = NumericSegment(value=value, key=key, type=type_)
+                    
+    return out    
+    

labfreed/{DisplayNameExtension → utilities}/base36.py

@@ -1,31 +1,37 @@
+import re
 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
+from pydantic import field_validator, RootModel
+
+class base36(RootModel[str]):
+    @field_validator('root')
+    @classmethod
+    def validate_format(cls, v: str) -> str:
+        if not re.fullmatch(r'[A-Z0-9]*', v):
+            raise ValueError("Value must only contain uppercase letters and digits (A-Z, 0-9)")
+        return v
+    
 
-def to_base36(s:str):
+def to_base36(s:str) -> base36:
     """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)
+    base36_chars = _alphabet(base=36)
     if num == 0:
         return base36_chars[0]
-    base36 = []
+    base_36 = []
     _num = num
     while _num:
         _num, i = divmod(_num, 36)
-        base36.append(base36_chars[i])
-    return ''.join(reversed(base36))
+        base_36.append(base36_chars[i])
+    b36_str = ''.join(reversed(base_36))
+    b36_str = base36(b36_str)
+    return b36_str
 
 
-def from_base36(s36:str):
+def from_base36(s36:base36) -> 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)
@@ -34,6 +40,16 @@ def from_base36(s36:str):
     s = _bytes.decode('utf-8')
     return s
 
+
+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
+
+
 if __name__ == "__main__":
     ss = ["A",
       "B-500 B",

labfreed/well_known_extensions/__init__.py

@@ -0,0 +1,5 @@
+from .display_name_extension import DisplayNameExtension
+from .trex_extension import TREX_Extension
+from .default_extension_interpreters import default_extension_interpreters  # noqa: F401
+
+__all__ = ["DisplayNameExtension", "TREX_Extension"]

labfreed/well_known_extensions/default_extension_interpreters.py

@@ -0,0 +1,7 @@
+from .display_name_extension import DisplayNameExtension
+from .trex_extension import TREX_Extension
+
+default_extension_interpreters = {
+    'TREX': TREX_Extension,
+    'N': DisplayNameExtension
+}

labfreed/well_known_extensions/display_name_extension.py

@@ -0,0 +1,40 @@
+import logging
+from typing import Literal, Self
+from pydantic import computed_field
+from labfreed.labfreed_infrastructure import LabFREED_BaseModel
+from labfreed.pac_id.extension import ExtensionBase
+from labfreed.utilities.base36 import from_base36, to_base36
+
+
+class DisplayNameExtension(ExtensionBase, LabFREED_BaseModel):
+    name:Literal['N'] = 'N'
+    type:Literal['N'] = 'N'
+    display_name: str       
+    
+    @computed_field
+    @property
+    def data(self)->str:
+        # return '/'.join([to_base36(dn) for dn in self.display_name])
+        return to_base36(self.display_name) 
+    
+    @staticmethod
+    def from_extension(ext:ExtensionBase) -> Self:
+        return DisplayNameExtension.create(name=ext.name,
+                                  type=ext.type,
+                                  data=ext.data)
+    
+    @staticmethod
+    def create(*, 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_name = from_base36(data)
+         
+        return DisplayNameExtension(display_name=display_name)
+    
+    def __str__(self):
+        return 'Display name: '+ self.display_name
+

labfreed/well_known_extensions/trex_extension.py

@@ -0,0 +1,31 @@
+from typing import Literal, Self
+
+from pydantic import computed_field 
+from labfreed.labfreed_infrastructure import LabFREED_BaseModel
+from labfreed.pac_id.extension import ExtensionBase
+from labfreed.trex.trex import TREX
+
+
+class TREX_Extension(ExtensionBase, LabFREED_BaseModel):
+    name:str
+    type:Literal['TREX'] = 'TREX'
+    trex:TREX
+           
+    @computed_field
+    @property
+    def data(self)->str:
+        trex_str = self.trex.serialize()
+        return trex_str
+        
+    @staticmethod
+    def from_extension(ext:ExtensionBase) -> Self:
+        return TREX_Extension.create(name=ext.name,
+                                    type=ext.type,
+                                    data=ext.data)
+    
+    @staticmethod
+    def create(*, name, data, type='TREX'):
+        trex_extension = TREX_Extension(name= name, trex = TREX.deserialize(data))
+        return trex_extension
+    
+   

labfreed/well_known_keys/gs1/__init__.py

@@ -0,0 +1,6 @@
+'''
+Data from 
+https://ref.gs1.org/ai/GS1_Application_Identifiers.jsonld
+
+processes by ChatGPT
+'''

labfreed/well_known_keys/gs1/gs1.py

@@ -0,0 +1,4 @@
+'''
+Data from 
+https://ref.gs1.org/ai/GS1_Application_Identifiers.jsonld
+'''

labfreed/well_known_keys/gs1/gs1_ai_enum_sorted.py

@@ -0,0 +1,57 @@
+from enum import Enum
+
+class GS1ApplicationIdentifier(Enum):
+    SSCC = "00"
+    GTIN = "01"
+    CONTENT = "02"
+    MTO_GTIN = "03"
+    BATCH_LOT = "10"
+    PROD_DATE = "11"
+    DUE_DATE = "12"
+    PACK_DATE = "13"
+    BEST_BEFORE_OR_BEST_BY = "15"
+    SELL_BY = "16"
+    USE_BY_OR_EXPIRY = "17"
+    VARIANT = "20"
+    SERIAL = "21"
+    CPV = "22"
+    VAR_COUNT = "30"
+    COUNT = "37"
+    INTERNAL = "90"
+    TPX = "235"
+    ADDITIONAL_ID = "240"
+    CUST_PART_NO = "241"
+    MTO_VARIANT = "242"
+    PCN = "243"
+    SECONDARY_SERIAL = "250"
+    REF_TO_SOURCE = "251"
+    GDTI = "253"
+    GLN_EXTENSION_COMPONENT = "254"
+    GCN = "255"
+    ORDER_NUMBER = "400"
+    GINC = "401"
+    GSIN = "402"
+    ROUTE = "403"
+    SHIP_TO_LOC = "410"
+    BILL_TO = "411"
+    PURCHASE_FROM = "412"
+    SHIP_FOR_LOC = "413"
+    LOC_NO = "414"
+    PAY_TO = "415"
+    PROD_SERV_LOC = "416"
+    PARTY = "417"
+    SHIP_TO_POST = "420"
+    ORIGIN = "422"
+    COUNTRY___INITIAL_PROCESS = "423"
+    COUNTRY___PROCESS = "424"
+    COUNTRY___DISASSEMBLY = "425"
+    COUNTRY___FULL_PROCESS = "426"
+    ORIGIN_SUBDIVISION = "427"
+    NHRN_PZN = "710"
+    NHRN_CIP = "711"
+    NHRN_CN = "712"
+    NHRN_DRN = "713"
+    NHRN_AIM = "714"
+    NHRN_NDC = "715"
+    NHRN_AIC = "716"
+  

labfreed/well_known_keys/labfreed/well_known_keys.py

@@ -0,0 +1,16 @@
+from enum import Enum
+
+
+class WellKnownKeys(Enum):
+    GTIN = '01'
+    BATCH = '10'
+    SERIAL = '21'
+    ADDITIONAL_IDINTIFIER = '240'
+    RUN_ID_ABSOLUTE = 'RNR'
+    SAMPLE_ID = 'SMP'
+    EXPERIMENT_ID = 'EXP'
+    RESULT_ID = 'RST'
+    METHOD_ID = 'MTD'
+    REPORT_ID = 'RPT'
+    TIMESTAMP = 'TS'
+    VERSION = 'V'