labfreed 0.0.3__py2.py3-none-any.whl

labfreed/DisplayNameExtension/DisplayNameExtension.py

@@ -0,0 +1,37 @@
+import logging
+from pydantic import BaseModel
+from labfreed.PAC_ID.extensions import Extension
+from labfreed.utilities.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)
+    
+    def __str__(self):
+        return 'Display names: '+ ';'.join(self.display_names)
+
+

labfreed/PAC_CAT/__init__.py

@@ -0,0 +1 @@
+

labfreed/PAC_CAT/data_model copy.py

@@ -0,0 +1,232 @@
+# import re
+# from typing import Optional
+# from typing_extensions import Self
+# from pydantic import Field, ValidationInfo, computed_field, conlist, model_validator, field_validator
+
+# from abc import ABC, abstractproperty, abstractstaticmethod
+
+# from labfreed.PAC_ID.data_model import PACID
+
+# from ..utilities.well_known_keys import WellKnownKeys
+# from labfreed.validation import BaseModelWithValidationMessages, ValidationMessage, hsegment_pattern, domain_name_pattern
+
+
+# # class IDSegment(BaseModelWithValidationMessages):
+# #     key:str|None = None
+# #     value:str  
+    
+# #     @model_validator(mode="after")
+# #     def validate_segment(self):
+# #         key = self.key or ""
+# #         value = self.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)):
+# #             self.add_validation_message(
+# #                     source=f"id segment key {key}",
+# #                     type="Error",
+# #                     msg=f"{' '.join(not_allowed_chars)} must not be used.",
+# #                     recommendation = "The segment key must be a valid hsegment",
+# #                     highlight_pattern = key,
+# #                     highlight_sub = not_allowed_chars
+# #             )
+        
+# #         if not_allowed_chars := set(re.sub(hsegment_pattern, '', value)):
+# #             self.add_validation_message(
+# #                     source=f"id segment key {value}",
+# #                     type="Error",
+# #                     msg=f"{' '.join(not_allowed_chars)} must not be used.",
+# #                     recommendation = "The segment key must be a valid hsegment",
+# #                     highlight_pattern = value,
+# #                     highlight_sub = 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)):
+# #             self.add_validation_message(
+# #                     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 WellKnownKeys]:
+# #             self.add_validation_message(
+# #                     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)):
+# #             self.add_validation_message(
+# #                     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:
+# #             self.add_validation_message(
+# #                     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:
+# #             self.add_validation_message(
+# #                     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 self
+     
+  
+    
+
+
+
+
+# class PAC_CAT(PACID):
+        
+#     @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:
+#                 for k in duplicate_keys:
+#                     self.add_validation_message(
+#                         source=f"identifier {k}",
+#                         type="Error",
+#                         msg=f"Duplicate key {k} in category {c.key}",
+#                         highlight_pattern = k
+#                     )
+#             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:
+#     #         self.add_validation_message(
+#     #                     source=f"identifier",
+#     #                     type="Error",
+#     #                     msg=f'Identifier is {l} characters long, Identifier must not exceed 256 characters.',
+#     #                     highlight_pattern = ""
+#     #                 )
+#     #     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 PACID(BaseModelWithValidationMessages):
+# #     issuer:str
+# #     identifier: Identifier
+    
+# #     @model_validator(mode="after")
+# #     def validate_issuer(self):
+# #         if not re.fullmatch(domain_name_pattern, self.issuer):
+# #             self.add_validation_message(
+# #                     source="PAC-ID",
+# #                     type="Error",
+# #                     highlight_pattern=self.issuer,
+# #                     msg=f"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\.-]', '', self.issuer)):
+# #             self.add_validation_message(
+# #                     source="PAC-ID",
+# #                     type="Recommendation",
+# #                     highlight_pattern=self.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 self
+    
+# #     def __str__(self):
+# #         id_segments = ''
+# #         for s in self.identifier.segments:
+# #             if s.key:
+# #                 id_segments += f'/{s.key}:{s.value}'
+# #             else:
+# #                 id_segments += f'/{s.value}'
+    
+# #         out = f"HTTPS://PAC.{self.issuer}{id_segments}"
+# #         return out
+    
+    
+    
+    
+# # class PACID_With_Extensions(BaseModelWithValidationMessages):
+# #     pac_id: PACID
+# #     extensions: list[Extension] = Field(default_factory=list)
+    
+# #     def __str__(self):
+# #         out = str(self.pac_id)
+# #         out += '*'.join(str(e) for e in self.extensions)
+        
+# #     def get_extension_of_type(self, type:str) -> list[Extension]:
+# #         return [e for e in self.extensions if e.type == type]
+    
+# #     def get_extension(self, name:str) -> Extension|None:
+# #         out = [e for e in self.extensions if e.name == name]
+# #         if not out:
+# #             return None
+# #         return out[0]
+        
+
+
+
+

labfreed/PAC_CAT/data_model.py

@@ -0,0 +1,369 @@
+from __future__ import annotations  # optional in 3.11, but recommended for consistency
+
+from abc import ABC
+from typing import Self
+from pydantic import Field, computed_field, model_validator
+
+from labfreed.validation import BaseModelWithValidationMessages
+
+from ..PAC_ID.data_model import PACID, IDSegment
+
+
+    
+class PAC_CAT(PACID):
+    ''' 
+    Extends a PAC-ID with interpretation of the identifier as categories
+    '''
+    categories:list[Category] = Field(default_factory=list())
+    
+    @property
+    def identifier(self) -> list[IDSegment]:
+        out = list()
+        for category in self.categories:
+            out.append(IDSegment(value=category.key))
+            out.extend(category.segments)
+        return out
+    
+    def get_category(self, key):
+        tmp = [c for c in self.categories if c.key == key]
+        if not tmp:
+            return None
+        return tmp[0]
+    
+    
+    @classmethod
+    def from_pac_id(cls, pac_id:PACID):
+        d = pac_id.model_dump()
+        issuer = d.get('issuer')
+        
+        category_segments = cls._split_into_categories(pac_id.identifier)
+        categories = list()
+        for c in category_segments:
+            categories.append(cls.cat_from_cat_segments(c))
+        
+        return PAC_CAT(issuer=issuer, categories=categories, identifier=pac_id.identifier)
+        
+            
+    @classmethod
+    def cat_from_cat_segments(cls, segments:list[IDSegment]):
+        segments = segments.copy()
+        category_key = segments[0].value 
+        segments.pop(0)
+        
+        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 
+        }
+        cat = mapping.get(category_key) or Category
+
+        # implicit segment keys
+        model_dict = {v.alias: None for k, v in cat.model_fields.items() if v.alias and k not in ['key','additional_segments']}
+        for k, seg in zip(model_dict.keys(), segments.copy()):
+            if seg.key:
+                break
+            model_dict[k] = seg.value
+            segments.pop(0)
+            
+        # try to fill model keys if not already set
+        for s in segments:
+            if s.key in model_dict and not model_dict.get(s.key):
+                model_dict[s.key] = s.value
+                segments.remove(s)
+            
+        model_dict['additional_segments'] = segments
+        model_dict['key'] = category_key
+        return cat(**model_dict)
+    
+    @staticmethod
+    def _split_into_categories(segments:list[IDSegment]):
+        categories = list()
+        c_segments = list()
+        categories.append(c_segments)
+        for s in segments:
+            # new category starts with "-"
+            if s.value[0] == '-':
+                cat_key = s.value
+                c = [s]
+                categories.append(c)
+            else:
+                c.append(s)
+                
+        # first cat can be empty > remove
+        categories = [c for c in categories if len(c) > 0]
+                            
+        return categories
+    
+            
+    # @computed_field
+    # @property
+    # def categories(self) -> list[Category]:
+    #     categories = list()
+    #     c = Category(segments=[])
+    #     categories.append(c)
+    #     for s in self.identifier:
+    #         s:IDSegment = s
+    #         # 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:
+                for k in duplicate_keys:
+                    self.add_validation_message(
+                        source=f"identifier {k}",
+                        type="Error",
+                        msg=f"Duplicate key {k} in category {c.key}",
+                        highlight_pattern = k
+                    )
+            return self
+        
+        
+    # @classmethod
+    # def from_categories(cls, issuer:str, categories:list[Category]):
+    #     return PAC_CAT(issuer=issuer, identifier=cls.identifier_from_categories(categories))
+        
+       
+    # @classmethod 
+    # def identifier_from_categories(cls, categories:list[Category]) :
+    #     segments = list()
+    #     for c in categories:
+    #         if c.key:
+    #             segments.append(IDSegment(value=c.key))
+    #         segments.extend(c.segments)
+    #     return segments
+    
+    
+
+                
+
+class Category(BaseModelWithValidationMessages):
+    model_config = {
+        "populate_by_name": True
+    }
+    key:str
+    additional_segments: list[IDSegment] = Field(default_factory=list)   
+    
+    @computed_field
+    @property
+    def segments(self, use_short_notation=False) -> list[IDSegment]:
+        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 ['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 segments
+
+    
+    @model_validator(mode='after')
+    def warn_unusual_category_key(self):
+        ''' this base class is instantiated only if the key is not a known category key'''
+        self.add_validation_message(
+                    source=f"Category {self.key}",
+                    type="Warning",
+                    msg=f'Category key {self.key} is not a well known key. It is recommended to use well known keys only',
+                    highlight_pattern = f"{self.key}"
+        )
+        return self
+    
+    
+    # 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.key,
+    #                     segments=segments)
+        
+        
+        
+# def _apply_category_defaults(self, segments_in: list[IDSegment]):
+        
+#         category_conventions = MappingProxyType(
+#                             {
+#                                 '-MD': ['240', '21'],
+#                                 '-MS': ['240', '10', '20', '21', '250'],
+#                                 '-MC': ['240', '10', '20', '21', '250'],
+#                                 '-MM': ['240', '10', '20', '21', '250']
+#                             }
+#                         )
+        
+#         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
+                
+            
+
+
+class Material_Device(Category):
+    key: str =         Field(default='-MD', frozen=True)
+    model_number: str|None =         Field(              alias='240')
+    serial_number: str|None =        Field(              alias='21')
+    
+    @model_validator(mode='after')
+    def validate_mandatory_fields(self):
+        if not self.model_number:
+            self.add_validation_message(
+                    source=f"Category {self.key}",
+                    type="Error",
+                    msg=f'Category key {self.key} is missing mandatory field Model NUmber',
+                    highlight_pattern = f"{self.key}"
+            )
+        if not self.serial_number:
+            self.add_validation_message(
+                    source=f"Category {self.key}",
+                    type="Error",
+                    msg=f'Category key {self.key} is missing mandatory field Serial NUmber',
+                    highlight_pattern = f"{self.key}"
+            )
+    
+class Material_Substance(Category):
+    key: str =         Field(default='-MS', frozen=True)
+    product_number:str|None =    Field(              alias='240')
+    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')
+    
+    @model_validator(mode='after')
+    def validate_mandatory_fields(self):
+        if not self.product_number:
+            self.add_validation_message(
+                    source=f"Category {self.key}",
+                    type="Error",
+                    msg=f'Category key {self.key} is missing mandatory field Product NUmber',
+                    highlight_pattern = f"{self.key}"
+            )
+    
+class Material_Consumable(Category):
+    key: str = Field(default='-MC', frozen=True)
+    product_number:str|None =   Field(              alias='240')
+    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')
+    
+    @model_validator(mode='after')
+    def validate_mandatory_fields(self):
+        if not self.product_number:
+            self.add_validation_message(
+                    source=f"Category {self.key}",
+                    type="Error",
+                    msg=f"Category key {self.key} is missing mandatory field 'Product Number'",
+                    highlight_pattern = f"{self.key}"
+            )
+    
+class Material_Misc(Material_Consumable):
+    key: str = Field(default='-MM', frozen=True)
+    
+
+
+
+class Data_Abstract(Category, ABC):
+    key: str
+    id:str|None =                    Field(              alias='21')
+    
+    @model_validator(mode='after')
+    def validate_mandatory_fields(self):
+        if not self.id:
+            self.add_validation_message(
+                    source=f"Category {self.key}",
+                    type="Error",
+                    msg=f"Category key {self.key} is missing mandatory field 'ID'",
+                    highlight_pattern = f"{self.key}"
+            )
+
+class Data_Result(Category):
+    key: str = Field(default='-DR', frozen=True)
+    
+class Data_Method(Category):
+    key: str = Field(default='-DM', frozen=True)
+    
+class Data_Calibration(Category):
+    key: str = Field(default='-DC', frozen=True)
+    
+class Data_Progress(Category):
+    key: str = Field(default='-DP', frozen=True)
+    
+class Data_Static(Category):
+    key: str = Field(default='-DS', frozen=True)
+    
+    
+    
+    
+# 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) -> Category|None:
+#     raise NotImplementedError()
+
+# def CAT_from_category_key(category_key) -> Category|None:
+#     return mapping.get(category_key)
+    
+
+# if __name__ == "__main__":
+#     pass