labfreed 0.0.3__tar.gz → 0.0.5__tar.gz

{labfreed-0.0.3 → labfreed-0.0.5}/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.4
 Name: labfreed
-Version: 0.0.3
+Version: 0.0.5
 Summary: Python implementation of LabFREED building blocks
-Author-email: Reto Thürer <reto.thuerer@gmail.com>
-Requires-Python: >=3.12
+Author-email: Reto Thürer <thuerer.r@buchi.com>
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-Expression: MIT
 Classifier: Programming Language :: Python :: 3
@@ -13,3 +13,22 @@ License-File: LICENSE
 # LabFREED for Python
 
 A python implementation of [LabFREED](www.labfreed.com).
+
+
+
+# Examples:
+
+## Parse a PAC ID
+
+
+## Parse a PAC-ID with extensions
+
+
+
+## Create a PAC-ID
+
+## Create a PAC-ID and T-REX for a titration curve
+
+
+
+

labfreed-0.0.5/README.md

@@ -0,0 +1,21 @@
+# LabFREED for Python
+
+A python implementation of [LabFREED](www.labfreed.com).
+
+
+
+# Examples:
+
+## Parse a PAC ID
+
+
+## Parse a PAC-ID with extensions
+
+
+
+## Create a PAC-ID
+
+## Create a PAC-ID and T-REX for a titration curve
+
+
+

{labfreed-0.0.3 → labfreed-0.0.5}/labfreed/PAC_CAT/data_model.py

@@ -65,23 +65,23 @@ class Material_Misc(Material_Consumable):
 
 class Data_Result(CATBase):
     category_key: str = Field(default='-DR', frozen=True)
-    id:str =                    Field(              alias='240', min_length=1)
+    id:str =                    Field(              alias='21', min_length=1)
     
 class Data_Method(CATBase):
     category_key: str = Field(default='-DM', frozen=True)
-    id:str =                    Field(              alias='240', min_length=1)
+    id:str =                    Field(              alias='21', min_length=1)
     
 class Data_Calibration(CATBase):
     category_key: str = Field(default='-DC', frozen=True)
-    id:str =                    Field(              alias='240', min_length=1)
+    id:str =                    Field(              alias='21', min_length=1)
     
 class Data_Progress(CATBase):
     category_key: str = Field(default='-DP', frozen=True)
-    id:str =                    Field(              alias='240', min_length=1)
+    id:str =                    Field(              alias='21', min_length=1)
     
 class Data_Static(CATBase):
     category_key: str = Field(default='-DS', frozen=True)
-    id:str =                    Field(              alias='240', min_length=1)
+    id:str =                    Field(              alias='21', min_length=1)
     
     
     

labfreed-0.0.5/labfreed/PAC_ID/data_model.py

@@ -0,0 +1,215 @@
+import re
+from typing import Optional
+from typing_extensions import Self
+from pydantic import Field, ValidationInfo, computed_field, conlist, model_validator, field_validator
+from ..validation import BaseModelWithWarnings, ValidationWarning, hsegment_pattern, domain_name_pattern
+from abc import ABC, abstractproperty, abstractstaticmethod
+from .well_known_segment_keys import WellKnownSegmentKeys
+
+
+class IDSegment(BaseModelWithWarnings):
+    key:str|None = None
+    value:str  
+    @model_validator(mode="after")
+    def validate_segment(cls, model):
+        key = model.key or ""
+        value = model.value 
+        
+        # MUST be a valid hsegment according to RFC 1738, but without * (see PAC-ID Extension)
+        # This means it must be true for both, key and value
+        if not_allowed_chars := set(re.sub(hsegment_pattern, '', key)):
+            raise ValueError(f"id segment key {key} contains invalid characters {' '.join(not_allowed_chars)}.")
+        
+        if not_allowed_chars := set(re.sub(hsegment_pattern, '', value)):
+            raise ValueError(f"id segment key {value} contains invalid characters {' '.join(not_allowed_chars)}.")
+
+        # Segment key SHOULD be limited to A-Z, 0-9, and -+..
+        if not_recommended_chars := set(re.sub(r'[A-Z0-9-:+]', '', key)):
+            model.add_warning(
+                    source=f"id segment key {key}",
+                    type="Recommendation",
+                    msg=f"{' '.join(not_recommended_chars)} should not be used.",
+                    recommendation = "SHOULD be limited to A-Z, 0-9, and -+",
+                    highlight_pattern = key,
+                    highlight_sub = not_recommended_chars
+                )
+            
+        # Segment key should be in Well know keys
+        if key and key not in [k.value for k in WellKnownSegmentKeys]:
+            model.add_warning(
+                    source=f"id segment key {key}",
+                    type="Recommendation",
+                    msg=f"{key} is not a well known segment key.",
+                    recommendation = "RECOMMENDED to be a well-known id segment key.",
+                    highlight_pattern = key
+                )
+            
+            
+        # Segment value SHOULD be limited to A-Z, 0-9, and -+..
+        if not_recommended_chars := set(re.sub(r'[A-Z0-9-:+]', '', value)):
+            model.add_warning(
+                    source=f"id segment value {value}",
+                    type="Recommendation",
+                    msg=f"Characters {' '.join(not_recommended_chars)} should not be used.",
+                    recommendation = "SHOULD be limited to A-Z, 0-9, and -+",
+                    highlight_pattern = value,
+                    highlight_sub = not_recommended_chars
+                )
+            
+        # Segment value SHOULD be limited to A-Z, 0-9, and :-+ for new designs.
+        # this means that ":" in key or value is problematic
+        if ':' in key:
+            model.add_warning(
+                    source=f"id segment key {key}",
+                    type="Recommendation",
+                    msg=f"Character ':' should not be used in segment key, since this character is used to separate key and value this can lead to undefined behaviour.",
+                    highlight_pattern = key
+                )
+        if ':' in value:
+            model.add_warning(
+                    source=f"id segment value {value}",
+                    type="Recommendation",
+                    msg=f"Character ':' should not be used in segment value, since this character is used to separate key and value this can lead to undefined behaviour.",
+                    highlight_pattern = value
+                )
+                
+        return model
+    
+  
+    
+
+class Category(BaseModelWithWarnings):
+    key:str|None = None
+    segments: list[IDSegment]
+
+
+class Identifier(BaseModelWithWarnings):
+    segments: conlist(IDSegment, min_length=1) = Field(..., exclude=True) # type: ignore # 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
+        
+    @model_validator(mode='after')
+    def check_length(self) -> Self:
+        l = 0
+        for s in self.segments:
+            if s.key:
+                l += len(s.key)
+                l += 1 # for ":"
+            l += len(s.value)
+        l += len(self.segments) - 1 # account for "/" separating the segments
+        
+        if l > 256:
+            raise ValueError(f'Identifier is {l} characters long, Identifier must not exceed 256 characters.')
+        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, BaseModelWithWarnings): 
+    
+    @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(BaseModelWithWarnings):
+    issuer:str
+    identifier: Identifier
+    
+    @model_validator(mode="after")
+    def validate_issuer(cls, model):
+        if not re.fullmatch(domain_name_pattern, model.issuer):
+            raise ValueError("Issuer must be a valid domain name.")
+
+         
+        # recommendation that A-Z, 0-9, -, and . should be used
+        if not_recommended_chars := set(re.sub(r'[A-Z0-9\.-]', '', model.issuer)):
+            model.add_warning(
+                    source="PAC-ID",
+                    type="Recommendation",
+                    highlight_pattern=model.issuer,
+                    highlight_sub=not_recommended_chars,
+                    msg=f"Characters {' '.join(not_recommended_chars)} should not be used. Issuer SHOULD contain only the characters A-Z, 0-9, -, and . "
+                )
+        return model
+    
+    
+class PACID_With_Extensions(BaseModelWithWarnings):
+    pac_id: PACID
+    extensions: list[Extension] = Field(default_factory=list)
+
+
+
+
+

{labfreed-0.0.3 → labfreed-0.0.5}/labfreed/PAC_ID/parse.py

@@ -4,6 +4,8 @@ import re
 from types import MappingProxyType
 from .data_model import *
 
+from ..validation import extract_warnings, ValidationWarning
+
 
 category_conventions = MappingProxyType(
                             {
@@ -29,7 +31,7 @@ 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:
+    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:
@@ -37,8 +39,12 @@ class PAC_Parser():
             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)
+        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):
@@ -46,6 +52,8 @@ class PAC_Parser():
             return []    
         
         id_segments = list()  
+        if len(identifier) > 0 and identifier[0] == '/':
+            identifier = identifier[1:]
         for s in identifier.split('/'):
             tmp = s.split(':')
             
@@ -85,10 +93,11 @@ class PAC_Parser():
         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'),
+        
+        pac = PACID(issuer= d.get('issuer'),
                      identifier=Identifier(segments=id_segments)
         )
+        return pac
 
 
     def parse_extensions(self, extensions_str:str|None) -> list[Extension]:    

{labfreed-0.0.3 → labfreed-0.0.5}/labfreed/PAC_ID/serialize.py

@@ -4,7 +4,7 @@ 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:
+    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.')
@@ -13,7 +13,10 @@ class PAC_Serializer():
         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()
+        out = f"HTTPS://PAC.{issuer}{id_segments}{extensions_str}"
+        if uppercase_only:
+            out = out.upper()
+        return out
     
     
     def _serialize_id_segments(self, segments):

labfreed-0.0.5/labfreed/PAC_ID/well_known_segment_keys.py

@@ -0,0 +1,16 @@
+from enum import Enum
+
+
+class WellKnownSegmentKeys(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'

{labfreed-0.0.3 → labfreed-0.0.5}/labfreed/TREXExtension/unit_utilities.py

@@ -60,26 +60,35 @@ class PydanticUncertainQuantity(BaseModel):
     
 unit_map = [
     ('MGM', units.milligram),
+    ('GRM', units.gram),
+    ('KGM', units.kilogram),
+    
     ('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)
+    ('HUR', units.hour),
+    
+    ('MTR', units.meter)
     
 ]      
     

{labfreed-0.0.3 → labfreed-0.0.5}/labfreed/__init__.py

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

labfreed-0.0.5/labfreed/validation.py

@@ -0,0 +1,71 @@
+from pydantic import BaseModel, Field, PrivateAttr
+from typing import List, Set, Tuple
+
+
+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):
+    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())
+    
+    
+
+
+class BaseModelWithWarnings(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)
+
+    def add_warning(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)
+
+    def get_warnings(self) -> list[ValidationWarning]:
+        return self._warnings
+
+    def clear_warnings(self):
+        self._warnings.clear()
+    
+    
+# 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.
+    
+    :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()]
+
+    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)
+
+        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))
+
+    return warnings_list
+

{labfreed-0.0.3 → labfreed-0.0.5}/pyproject.toml

@@ -4,13 +4,13 @@ build-backend = "flit_core.buildapi"
 
 [project]
 name = "labfreed"
-authors = [{name = "Reto Thürer", email = "reto.thuerer@gmail.com"}]
+authors = [{name = "Reto Thürer", email = "thuerer.r@buchi.com"}]
 license = "MIT"
 license-files = ["LICENSE"]
 dynamic = ["version", "description"]
 
 readme = "README.md"
-requires-python = ">=3.12"
+requires-python = ">=3.10"
 classifiers = [
     "Programming Language :: Python :: 3",
     "Operating System :: OS Independent",

{labfreed-0.0.3 → labfreed-0.0.5}/tests/test_PAC_ID/test_pac_id_parse.py

@@ -14,20 +14,20 @@ parser = PAC_Parser()
 
 # Issuer
 def test_standard_base_gives_correct_issuer():
-    pac = parser.parse_pac_url("HTTPS://PAC.METTORIUS.COM/" + valid_standard_segments).pac_id
-    assert pac.issuer == "METTORIUS.COM"
+    pac, _ = parser.parse_pac_url("HTTPS://PAC.METTORIUS.COM/" + valid_standard_segments)
+    assert pac.pac_id.issuer == "METTORIUS.COM"
        
 def test_pac_can_be_missing_from_domain():
-    pac = parser.parse_pac_url("HTTPS://METTORIUS.COM/" + valid_standard_segments).pac_id
-    assert pac.issuer == "METTORIUS.COM"
+    pac, _ = parser.parse_pac_url("HTTPS://METTORIUS.COM/" + valid_standard_segments)
+    assert pac.pac_id.issuer == "METTORIUS.COM"
      
 def test_pac_can_be_missing_from_domain():
-    pac = parser.parse_pac_url("METTORIUS.COM/" + valid_standard_segments).pac_id
-    assert pac.issuer == "METTORIUS.COM"
+    pac, _ = parser.parse_pac_url("METTORIUS.COM/" + valid_standard_segments)
+    assert pac.pac_id.issuer == "METTORIUS.COM"
     
 def test_issuer_must_be_valid_domain():
     with pytest.raises(Exception):
-        pac = parser.parse_pac_url("HTTPS://METTORIUS/" + valid_standard_segments).pac_id
+        pac, _ = parser.parse_pac_url("HTTPS://METTORIUS/" + valid_standard_segments)
         
         
         
@@ -39,19 +39,20 @@ def test_pac_must_have_at_least_one_segment():
         pac = parser.parse_pac_url(valid_base = "").pac_id
           
 def test_identifier_named_segment():
-    pac = parser.parse_pac_url(valid_base + "KEY:VAL").pac_id
-    seg: IDSegment = pac.identifier.segments[0]
+    pac, _ = parser.parse_pac_url(valid_base + "KEY:VAL")
+    seg: IDSegment = pac.pac_id.identifier.segments[0]
     assert seg.key == "KEY"
     assert seg.value == "VAL"
     
 def test_identifier_unnamed_segment():
-    pac = parser.parse_pac_url(valid_base + "VAL").pac_id
-    seg: IDSegment = pac.identifier.segments[0]
+    pac, _ = parser.parse_pac_url(valid_base + "VAL")
+    seg: IDSegment = pac.pac_id.identifier.segments[0]
     assert not seg.key
     assert seg.value == "VAL"
      
 def test_identifier_combination_of_named_and_unnamed_segments():
-    pac = parser.parse_pac_url(valid_base + "KEY0:VAL0/VAL1/KEY2:VAL2").pac_id
+    pac, _ = parser.parse_pac_url(valid_base + "KEY0:VAL0/VAL1/KEY2:VAL2")
+    pac = pac.pac_id
     seg: IDSegment = pac.identifier.segments[0]
     assert seg.key == 'KEY0'
     assert seg.value == "VAL0"
@@ -66,10 +67,10 @@ def test_identifier_combination_of_named_and_unnamed_segments():
       
 def test_keys_must_be_unique():
     with pytest.raises(Exception):
-        pac = parser.parse_pac_url(valid_base + "KEY:VAL/KEY:ANOTHERVAL/KEY:VAL/KEY2:ANOTHERVAL").pac_id
+        pac, _ = parser.parse_pac_url(valid_base + "KEY:VAL/KEY:ANOTHERVAL/KEY:VAL/KEY2:ANOTHERVAL")
         
 def test_keys_can_repeat_accross_categories():
-    pac = parser.parse_pac_url(valid_base + "-MD/KEY:VAL/-MS/KEY:VAL").pac_id
+    pac, _ = parser.parse_pac_url(valid_base + "-MD/KEY:VAL/-MS/KEY:VAL")
     assert True # made it here without exception > it's fine
         
         
@@ -77,28 +78,28 @@ def test_keys_can_repeat_accross_categories():
 
 # Identifier Segments Categories (Recommendation)
 def test_basic_valid_category():
-    pac = parser.parse_pac_url(valid_base + "-MD/KEY:VAL").pac_id
-    cat: Category = pac.identifier.categories[0]
+    pac, _ = parser.parse_pac_url(valid_base + "-MD/KEY:VAL")
+    cat: Category = pac.pac_id.identifier.categories[0]
     assert cat.key == '-MD'
     assert cat.segments[0].key == 'KEY'
     assert cat.segments[0].value == 'VAL'
     
 def test_if_no_category_is_specified_default_to_unnamed_category():
-    pac = parser.parse_pac_url(valid_base + "KEY:VAL").pac_id
-    cat: Category = pac.identifier.categories[0]
+    pac, _ = parser.parse_pac_url(valid_base + "KEY:VAL")
+    cat: Category = pac.pac_id.identifier.categories[0]
     assert cat.key == None
     assert cat.segments[0].key == 'KEY'
     assert cat.segments[0].value == 'VAL'
     
 def test_missing_dash_in_category_name_is_interpreted_as_unnamed_segment():
-    pac = parser.parse_pac_url(valid_base + "MD/KEY:VAL").pac_id
-    cat: Category = pac.identifier.categories[0]
+    pac, _ = parser.parse_pac_url(valid_base + "MD/KEY:VAL")
+    cat: Category = pac.pac_id.identifier.categories[0]
     assert cat.key == None
     assert cat.segments[0].value == 'MD'
     
 def test_category_with_multiple_segments():
-    pac = parser.parse_pac_url(valid_base + "-MD/KEY0:VAL0/VAL1/KEY2:VAL2").pac_id
-    cat: Category = pac.identifier.categories[0]
+    pac, _ = parser.parse_pac_url(valid_base + "-MD/KEY0:VAL0/VAL1/KEY2:VAL2")
+    cat: Category = pac.pac_id.identifier.categories[0]
     assert cat.key == '-MD'
     
     seg: IDSegment = cat.segments[0]
@@ -114,19 +115,20 @@ def test_category_with_multiple_segments():
     assert seg.value == "VAL2"
       
 def test_two_categories():
-    pac = parser.parse_pac_url(valid_base + "-DR/KEY:VAL/-MD/KEY:VAL").pac_id
-    cat: Category = pac.identifier.categories[0]
+    pac, _ = parser.parse_pac_url(valid_base + "-DR/KEY:VAL/-MD/KEY:VAL")
+    cat: Category = pac.pac_id.identifier.categories[0]
     assert cat.key == '-DR'
     assert cat.segments[0].key == 'KEY'
     assert cat.segments[0].value == 'VAL'
     
-    cat: Category = pac.identifier.categories[1]
+    cat: Category = pac.pac_id.identifier.categories[1]
     assert cat.key == '-MD'
     assert cat.segments[0].key == 'KEY'
     assert cat.segments[0].value == 'VAL'
      
 def test_three_categories():
-    pac = parser.parse_pac_url(valid_base + "-DR/KEY0:VAL0/-MD/KEY1:VAL1/-CAT/KEY2:VAL2").pac_id
+    pac, _ = parser.parse_pac_url(valid_base + "-DR/KEY0:VAL0/-MD/KEY1:VAL1/-CAT/KEY2:VAL2")
+    pac = pac.pac_id
     cat: Category = pac.identifier.categories[0]
     assert cat.key == '-DR'
     assert cat.segments[0].key == 'KEY0'
@@ -143,14 +145,14 @@ def test_three_categories():
     assert cat.segments[0].value == 'VAL2'
     
 def test_implied_segments_of_MD_category():
-    pac = parser.parse_pac_url(valid_base + "-MD/0/1").pac_id
-    cat: Category = pac.identifier.categories[0]
+    pac, _ = parser.parse_pac_url(valid_base + "-MD/0/1")
+    cat: Category = pac.pac_id.identifier.categories[0]
     assert cat.segments[0].key == '240'
     assert cat.segments[1].key == '21'
     
 def test_implied_segments_of_MS_category():
-    pac = parser.parse_pac_url(valid_base + "-MS/0/1/2/3/4").pac_id
-    cat: Category = pac.identifier.categories[0]
+    pac, _ = parser.parse_pac_url(valid_base + "-MS/0/1/2/3/4")
+    cat: Category = pac.pac_id.identifier.categories[0]
     assert cat.segments[0].key == '240'
     assert cat.segments[1].key == '10'
     assert cat.segments[2].key == '20'
@@ -158,8 +160,8 @@ def test_implied_segments_of_MS_category():
     assert cat.segments[4].key == '250'
     
 def test_implied_segments_of_MC_category():
-    pac = parser.parse_pac_url(valid_base + "-MC/0/1/2/3/4").pac_id
-    cat: Category = pac.identifier.categories[0]
+    pac, _ = parser.parse_pac_url(valid_base + "-MC/0/1/2/3/4")
+    cat: Category = pac.pac_id.identifier.categories[0]
     assert cat.segments[0].key == '240'
     assert cat.segments[1].key == '10'
     assert cat.segments[2].key == '20'
@@ -167,8 +169,8 @@ def test_implied_segments_of_MC_category():
     assert cat.segments[4].key == '250'
     
 def test_implied_segments_of_MM_category():
-    pac = parser.parse_pac_url(valid_base + "-MM/0/1/2/3/4").pac_id
-    cat: Category = pac.identifier.categories[0]
+    pac, _ = parser.parse_pac_url(valid_base + "-MM/0/1/2/3/4")
+    cat: Category = pac.pac_id.identifier.categories[0]
     assert cat.segments[0].key == '240'
     assert cat.segments[1].key == '10'
     assert cat.segments[2].key == '20'
@@ -176,8 +178,8 @@ def test_implied_segments_of_MM_category():
     assert cat.segments[4].key == '250'
     
 def test_stop_implying_segments_after_an_explicit_one_is_found():
-    pac = parser.parse_pac_url(valid_base + "-MS/0/1/KEY:2/3/4").pac_id
-    cat: Category = pac.identifier.categories[0]
+    pac, _ = parser.parse_pac_url(valid_base + "-MS/0/1/KEY:2/3/4")
+    cat: Category = pac.pac_id.identifier.categories[0]
     assert cat.segments[0].key == '240'
     assert cat.segments[1].key == '10'
     assert cat.segments[2].key == 'KEY'
@@ -185,15 +187,16 @@ def test_stop_implying_segments_after_an_explicit_one_is_found():
     assert cat.segments[4].key == None
     
 def test_more_segments_than_implicit_keys():
-    pac = parser.parse_pac_url(valid_base + "-MD/IMPLIED1/IMPLIED2/ADDITIONAL").pac_id
-    cat: Category = pac.identifier.categories[0]
+    pac, _ = parser.parse_pac_url(valid_base + "-MD/IMPLIED1/IMPLIED2/ADDITIONAL")
+    cat: Category = pac.pac_id.identifier.categories[0]
     assert cat.segments[2].key == None
     
     
     
 # Extensions
 def test_valid_extensions():
-    extensions = parser.parse_pac_url(valid_base + valid_standard_segments + "*name1$t1/data1*name2$t2/data2").extensions
+    pac, _ = parser.parse_pac_url(valid_base + valid_standard_segments + "*name1$t1/data1*name2$t2/data2")
+    extensions = pac.extensions
     ext: Extension = extensions[0]
     assert ext.name == 'name1'
     assert ext.type == 't1'
@@ -226,7 +229,8 @@ def test_known_extension_types_are_parsed():
             'KNOWN_EXTENSION': ExtensionMockType,
     }  
     parser_with_known_extension = PAC_Parser(extension_interpreters)
-    extensions = parser_with_known_extension.parse_pac_url(valid_base + valid_standard_segments + "*name1$KNOWN_EXTENSION/data1").extensions
+    pac, _ = parser_with_known_extension.parse_pac_url(valid_base + valid_standard_segments + "*name1$KNOWN_EXTENSION/data1")
+    extensions= pac.extensions
     ext: Extension = extensions[0]
     assert isinstance(ext, ExtensionMockType)
     assert ext.name == 'name__foo'
@@ -235,7 +239,8 @@ def test_known_extension_types_are_parsed():
     
     
 def test_imply_display_name_and_summary_extension():
-    extensions = parser.parse_pac_url(valid_base + valid_standard_segments + "*data1*data2").extensions
+    pac, _ = parser.parse_pac_url(valid_base + valid_standard_segments + "*data1*data2")
+    extensions = pac.extensions
     ext: Extension = extensions[0]
     assert ext.name == 'N'
     assert ext.type == 'N'
@@ -246,7 +251,8 @@ def test_imply_display_name_and_summary_extension():
     
 def test_stop_imply_extensions_after_explicit():
     with pytest.raises(Exception):
-        _ = parser.parse_pac_url(valid_base + valid_standard_segments + "*N$T/data1*data2").extensions
+        pac, _ = parser.parse_pac_url(valid_base + valid_standard_segments + "*N$T/data1*data2")
+        pac.extensions
         
 
 def test_extension_parsing():

{labfreed-0.0.3 → labfreed-0.0.5}/tests/test_PAC_ID/test_pac_id_serialization.py

@@ -19,13 +19,29 @@ pac_id = PACID(issuer = 'mettorius.com',
                                         ])
 )
 extensions= [
+    UnknownExtension(name_= 'N', type_= 'T.T', data_= 'DATA'),
+    UnknownExtension(name_= 'SUM', type_= 'TREX', data_= 'DATA'),
     UnknownExtension(name_= 'FOO', type_= 'T', data_= 'DATA'),
     UnknownExtension(name_= 'BAR', type_= 'T2', data_= 'DATA')
 ]
 
 
 def test_url_serialization():
-    url = serializer.to_url(pac_id, extensions)
+    url = serializer.to_url(pac_id, extensions, use_short_notation_for_extensions=False, uppercase_only=True)
+    assert url == 'HTTPS://PAC.METTORIUS.COM/-DR/999/-MD/240:1/21:2*N$T.T/DATA*SUM$TREX/DATA*FOO$T/DATA*BAR$T2/DATA'
+    
+def test_url_serialization_short_notation_for_N_and_SUM_extensions():
+    url = serializer.to_url(pac_id, extensions, use_short_notation_for_extensions=True, uppercase_only=True)
+    assert url == 'HTTPS://PAC.METTORIUS.COM/-DR/999/-MD/240:1/21:2*DATA*DATA*FOO$T/DATA*BAR$T2/DATA'
+    
+def test_url_serialization_short_notation_for_N_extensions():
+    ext = [extensions[i] for i in (0,2,3)]
+    url = serializer.to_url(pac_id, ext, use_short_notation_for_extensions=True, uppercase_only=True)
+    assert url == 'HTTPS://PAC.METTORIUS.COM/-DR/999/-MD/240:1/21:2*DATA*FOO$T/DATA*BAR$T2/DATA'
+    
+def test_url_serialization_short_notation_stop_implying_when_specific_extension():
+    ext = [extensions[i] for i in (2,3)]
+    url = serializer.to_url(pac_id, ext, use_short_notation_for_extensions=True, uppercase_only=True)
     assert url == 'HTTPS://PAC.METTORIUS.COM/-DR/999/-MD/240:1/21:2*FOO$T/DATA*BAR$T2/DATA'
     
     

labfreed-0.0.3/README.md

@@ -1,3 +0,0 @@
-# LabFREED for Python
-
-A python implementation of [LabFREED](www.labfreed.com).

labfreed-0.0.3/labfreed/PAC_ID/data_model.py

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