labfreed 0.2.8__py3-none-any.whl → 0.2.9__py3-none-any.whl

labfreed/trex/trex_base_models.py

@@ -1,209 +1,209 @@
-from datetime import datetime, time
-import re
-
-
-
-from pydantic import PrivateAttr, model_validator
-from labfreed.labfreed_infrastructure import LabFREED_BaseModel, ValidationMsgLevel, _quote_texts
-from abc import ABC, abstractmethod
-
-
-
-''' 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
-        
-        
-        
-class NumericValue(Value):
-        
-    @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. Must be a number.",
-                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
-
-class DateValue(Value):
-    _date_time_dict:dict|None = PrivateAttr(default=None)
-    
-    @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
-    
-
-class BoolValue(Value):
-
-    @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
-                  
-                    
-class AlphanumericValue(Value):
-        
-    @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
-             
-    
-class TextValue(Value):
-        
-    @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
-                
-    
-class BinaryValue(Value):
-        
-    @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
-                 
-    
-class ErrorValue(Value):
-    
-    @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
-
-
-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
-    
-
-        
-
-
-
-    
-
-
+from datetime import datetime, time
+import re
+
+
+
+from pydantic import PrivateAttr, model_validator
+from labfreed.labfreed_infrastructure import LabFREED_BaseModel, ValidationMsgLevel, _quote_texts
+from abc import ABC, abstractmethod
+
+
+
+''' 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
+        
+        
+        
+class NumericValue(Value):
+        
+    @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. Must be a number.",
+                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
+
+class DateValue(Value):
+    _date_time_dict:dict|None = PrivateAttr(default=None)
+    
+    @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
+    
+
+class BoolValue(Value):
+
+    @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
+                  
+                    
+class AlphanumericValue(Value):
+        
+    @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
+             
+    
+class TextValue(Value):
+        
+    @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
+                
+    
+class BinaryValue(Value):
+        
+    @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
+                 
+    
+class ErrorValue(Value):
+    
+    @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
+
+
+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
+    
+
+        
+
+
+
+    
+
+

labfreed/trex/value_segments.py

@@ -1,99 +1,99 @@
-from abc import ABC
-import re
-from typing import Literal
-from pydantic import Field, model_validator
-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':
-            out = TextSegment(key=key, value=value, type=type_)  
-        case 'T.X':
-            out = BinarySegment(key=key, value=value, type=type_) 
-        case 'E':
-            out = ErrorSegment(key=key, value=value, type=type_)
-        case _:
-            out = NumericSegment(value=value, key=key, type=type_)
-                    
-    return out    
-    
+from abc import ABC
+import re
+from typing import Literal
+from pydantic import Field, model_validator
+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':
+            out = TextSegment(key=key, value=value, type=type_)  
+        case 'T.X':
+            out = BinarySegment(key=key, value=value, type=type_) 
+        case 'E':
+            out = ErrorSegment(key=key, value=value, type=type_)
+        case _:
+            out = NumericSegment(value=value, key=key, type=type_)
+                    
+    return out    
+