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

labfreed/pac_id/url_parser.py

@@ -1,156 +1,156 @@
-
-
-import logging
-import re
-from types import MappingProxyType
-
-from labfreed.labfreed_infrastructure import LabFREED_ValidationError
-
-from labfreed.pac_id.id_segment import IDSegment
-from labfreed.pac_id.extension import Extension
-
-from labfreed.pac_cat import PAC_CAT
-from labfreed.well_known_extensions import default_extension_interpreters
-
-
-from typing import TYPE_CHECKING
-if TYPE_CHECKING:
-    # only imported during type checking
-    from labfreed.pac_id import PAC_ID
-    from labfreed.pac_cat import PAC_CAT
-
-class PAC_Parser():
-    '''@private
-    Knows how to parse a PAC-ID. 
-    From a SW engineering perspective it would be best to have no dependencies from other modules to pac_id.
-    However from a Python users convenience perspective it is better to have one place where a pac url can be parsed and magically the extensions are in a meaningful type (e.g. TREX in TREX aware format) and categories are known of possible.
-
-    >> We have given priority to convenient usage and therefore chose to have dependencies from pac_id to pac_cat and well_known_extensions
-   '''
-      
-    @classmethod
-    def from_url(cls, pac_url:str, 
-                 *, 
-                 extension_interpreters = 'default', 
-                 try_pac_cat = True,
-                 suppress_validation_errors=False
-                 ) -> "PAC_ID":
-        """Parses a PAC-ID with extensions
-
-        Args:
-            pac_url (str): pac id with optional extensions: e.g. HTTPS://PAC.METTORIUS.COM/-MD/BAL500/1234*N$N/ABC*SUM$TREX/A$T.A:ABC
-
-        Raises:
-            LabFREED_ValidationError: When validation fails. Note,that with suppress_errors no such error is raises
-
-        Returns:
-            PACID including extensions. If possible PAC-CAT is applied and extensions are cast to a known type, which knows how to inetrprete the data
-        """
-        if extension_interpreters == 'default':
-            extension_interpreters = default_extension_interpreters
-        
-        if '*' in pac_url:
-            id_str, ext_str = pac_url.split('*', 1)
-        else:
-            id_str = pac_url
-            ext_str = ""
-                    
-        pac_id = cls._parse_pac_id(id_str)
-        
-        # try converting to PAC-CAT. This can fail, in which case a regular PAC-ID is returned
-        if try_pac_cat:
-            try:
-                pac_cat = PAC_CAT.from_pac_id(pac_id)
-                if pac_cat.categories:
-                    pac_id = pac_cat
-            except LabFREED_ValidationError:
-                pass 
-              
-        extensions = cls._parse_extensions(ext_str)
-        if extensions and extension_interpreters:
-            for i, e in enumerate(extensions):
-                if interpreter := extension_interpreters.get(e.type):
-                    extensions[i] = interpreter.from_extension(e)
-        pac_id.extensions = extensions
-            
-        if not pac_id.is_valid and not suppress_validation_errors:
-            logging.error(pac_id.print_validation_messages())
-            raise LabFREED_ValidationError(validation_msgs = pac_id._get_nested_validation_messages())
-        
-        return pac_id
-            
-    @classmethod
-    def _parse_pac_id(cls,id_str:str) -> "PAC_ID":
-        # m = re.match('(HTTPS://)?(PAC.)?(?P<issuer>.+?\..+?)/(?P<identifier>.*)', id_str)
-        m = re.match('(HTTPS://)?(PAC.)?(?P<issuer>.+?)/(?P<identifier>.*)', id_str)
-        d = m.groupdict()
-        
-        id_segments = list()
-        id_segments = cls._parse_id_segments(d.get('identifier'))
-        
-        from labfreed.pac_id import PAC_ID
-        pac = PAC_ID(issuer= d.get('issuer'),
-                     identifier=id_segments
-        )
-        
-        return pac
-    
-    @classmethod
-    def _parse_id_segments(cls, identifier:str):
-        if not identifier:
-            return []    
-        
-        id_segments = list()  
-        if len(identifier) > 0 and identifier[0] == '/':
-            identifier = identifier[1:]
-        for s in identifier.split('/'):
-            tmp = s.split(':')
-            
-            if len(tmp) == 1:
-                segment = IDSegment(value=tmp[0])
-            elif len(tmp) == 2:
-                segment = IDSegment(key=tmp[0], value=tmp[1])
-            else:
-                raise ValueError(f'invalid segment: {s}')
-                
-            id_segments.append(segment)
-        return id_segments
-    
-
-    @classmethod
-    def _parse_extensions(cls, extensions_str:str|None) -> list["Extension"]:    
-        
-        extensions = list()
-        
-        if not extensions_str:
-            return extensions
-        
-        defaults =  MappingProxyType(
-                                {
-                                    0: { 'name': 'N', 'type': 'N'},
-                                    1: { 'name': 'SUM', 'type': 'TREX'}
-                                }
-        )
-        for i, e in enumerate(extensions_str.split('*')):
-            if e == '': #this will happen if first extension starts with *
-                continue
-            d = re.match('((?P<name>.+)\$(?P<type>.+)/)?(?P<data>.+)', e).groupdict()
-            
-            name = d.get('name')
-            type = d.get('type') 
-            data = d.get('data')
-    
-            if name:
-                defaults = None # once a name was specified no longer assign defaults
-            else:
-                if defaults:
-                    name = defaults.get(i).get('name')
-                    type = defaults.get(i).get('type')
-                else:
-                    raise ValueError('extension number {i}, must have name and type')
-            
-            #convert to subtype if they were given
-            e = Extension.create(name=name, type=type, data=data)
-            extensions.append(e)
-
+
+
+import logging
+import re
+from types import MappingProxyType
+
+from labfreed.labfreed_infrastructure import LabFREED_ValidationError
+
+from labfreed.pac_id.id_segment import IDSegment
+from labfreed.pac_id.extension import Extension
+
+from labfreed.pac_cat import PAC_CAT
+from labfreed.well_known_extensions import default_extension_interpreters
+
+
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+    # only imported during type checking
+    from labfreed.pac_id import PAC_ID
+    from labfreed.pac_cat import PAC_CAT
+
+class PAC_Parser():
+    '''@private
+    Knows how to parse a PAC-ID. 
+    From a SW engineering perspective it would be best to have no dependencies from other modules to pac_id.
+    However from a Python users convenience perspective it is better to have one place where a pac url can be parsed and magically the extensions are in a meaningful type (e.g. TREX in TREX aware format) and categories are known of possible.
+
+    >> We have given priority to convenient usage and therefore chose to have dependencies from pac_id to pac_cat and well_known_extensions
+   '''
+      
+    @classmethod
+    def from_url(cls, pac_url:str, 
+                 *, 
+                 extension_interpreters = 'default', 
+                 try_pac_cat = True,
+                 suppress_validation_errors=False
+                 ) -> "PAC_ID":
+        """Parses a PAC-ID with extensions
+
+        Args:
+            pac_url (str): pac id with optional extensions: e.g. HTTPS://PAC.METTORIUS.COM/-MD/BAL500/1234*N$N/ABC*SUM$TREX/A$T.A:ABC
+
+        Raises:
+            LabFREED_ValidationError: When validation fails. Note,that with suppress_errors no such error is raises
+
+        Returns:
+            PACID including extensions. If possible PAC-CAT is applied and extensions are cast to a known type, which knows how to inetrprete the data
+        """
+        if extension_interpreters == 'default':
+            extension_interpreters = default_extension_interpreters
+        
+        if '*' in pac_url:
+            id_str, ext_str = pac_url.split('*', 1)
+        else:
+            id_str = pac_url
+            ext_str = ""
+                    
+        pac_id = cls._parse_pac_id(id_str)
+        
+        # try converting to PAC-CAT. This can fail, in which case a regular PAC-ID is returned
+        if try_pac_cat:
+            try:
+                pac_cat = PAC_CAT.from_pac_id(pac_id)
+                if pac_cat.categories:
+                    pac_id = pac_cat
+            except LabFREED_ValidationError:
+                pass 
+              
+        extensions = cls._parse_extensions(ext_str)
+        if extensions and extension_interpreters:
+            for i, e in enumerate(extensions):
+                if interpreter := extension_interpreters.get(e.type):
+                    extensions[i] = interpreter.from_extension(e)
+        pac_id.extensions = extensions
+            
+        if not pac_id.is_valid and not suppress_validation_errors:
+            logging.error(pac_id.print_validation_messages())
+            raise LabFREED_ValidationError(validation_msgs = pac_id._get_nested_validation_messages())
+        
+        return pac_id
+            
+    @classmethod
+    def _parse_pac_id(cls,id_str:str) -> "PAC_ID":
+        # m = re.match('(HTTPS://)?(PAC.)?(?P<issuer>.+?\..+?)/(?P<identifier>.*)', id_str)
+        m = re.match('(HTTPS://)?(PAC.)?(?P<issuer>.+?)/(?P<identifier>.*)', id_str)
+        d = m.groupdict()
+        
+        id_segments = list()
+        id_segments = cls._parse_id_segments(d.get('identifier'))
+        
+        from labfreed.pac_id import PAC_ID
+        pac = PAC_ID(issuer= d.get('issuer'),
+                     identifier=id_segments
+        )
+        
+        return pac
+    
+    @classmethod
+    def _parse_id_segments(cls, identifier:str):
+        if not identifier:
+            return []    
+        
+        id_segments = list()  
+        if len(identifier) > 0 and identifier[0] == '/':
+            identifier = identifier[1:]
+        for s in identifier.split('/'):
+            tmp = s.split(':')
+            
+            if len(tmp) == 1:
+                segment = IDSegment(value=tmp[0])
+            elif len(tmp) == 2:
+                segment = IDSegment(key=tmp[0], value=tmp[1])
+            else:
+                raise ValueError(f'invalid segment: {s}')
+                
+            id_segments.append(segment)
+        return id_segments
+    
+
+    @classmethod
+    def _parse_extensions(cls, extensions_str:str|None) -> list["Extension"]:    
+        
+        extensions = list()
+        
+        if not extensions_str:
+            return extensions
+        
+        defaults =  MappingProxyType(
+                                {
+                                    0: { 'name': 'N', 'type': 'N'},
+                                    1: { 'name': 'SUM', 'type': 'TREX'}
+                                }
+        )
+        for i, e in enumerate(extensions_str.split('*')):
+            if e == '': #this will happen if first extension starts with *
+                continue
+            d = re.match('((?P<name>.+)\$(?P<type>.+)/)?(?P<data>.+)', e).groupdict()
+            
+            name = d.get('name')
+            type = d.get('type') 
+            data = d.get('data')
+    
+            if name:
+                defaults = None # once a name was specified no longer assign defaults
+            else:
+                if defaults:
+                    name = defaults.get(i).get('name')
+                    type = defaults.get(i).get('type')
+                else:
+                    raise ValueError('extension number {i}, must have name and type')
+            
+            #convert to subtype if they were given
+            e = Extension.create(name=name, type=type, data=data)
+            extensions.append(e)
+
         return extensions

labfreed/pac_id/url_serializer.py

@@ -1,84 +1,85 @@
-from labfreed.pac_cat.pac_cat import PAC_CAT
-from labfreed.pac_cat.predefined_categories import PredefinedCategory
-from labfreed.pac_id.id_segment import IDSegment
-from labfreed.pac_id.extension import Extension
-from labfreed.pac_id import PAC_ID  
-
-
-class PACID_Serializer():
-    '''Represents a PAC-ID including it's extensions'''
-  
-    @classmethod
-    def to_url(cls, pac:PAC_ID, use_short_notation:bool|None=None, uppercase_only=False) -> str:
-        """Serializes the PAC-ID including extensions.
-
-        Args:
-            use_short_notation (bool|None, optional): None (default): Preserves the identifier as is. Extensions use short form
-                                                      True: forces short notation for categories and extensions
-                                                      False: forces long notation for categories and extensions
-            uppercase_only (bool, optional): Forces all uppercase letters (results in smaller QR)..
-
-        Returns:
-            str: Something like this HTTPS://PAC.METTORIUS.COM/-MD/BAL500/1234*N$N/ABC*SUM$TREX/A$T.A:ABC
-
-        """
-        identifier_str = cls._serialize_identifier(pac, use_short_notation=use_short_notation)
-        
-        use_short_notation_for_extensions = True if use_short_notation is None else use_short_notation 
-        extensions_str = cls._serialize_extensions(pac.extensions, use_short_notation=use_short_notation_for_extensions)
-        out = f"HTTPS://PAC.{pac.issuer}{identifier_str}{extensions_str}"
-        
-        if uppercase_only:
-            out = out.upper()
-        return out
-    
-    @classmethod
-    def _serialize_identifier(cls, pac:PAC_ID|PAC_CAT, use_short_notation:None|bool=None):
-        ''' Serializes the PAC-ID'''
-        
-        if isinstance(pac, PAC_CAT) and use_short_notation is not None:
-            for c in pac.categories:
-                segments = [IDSegment(value=c.key)]
-                if isinstance(c, PredefinedCategory):
-                    segments += c._get_segments(use_short_notation=use_short_notation)
-                else:
-                    segments += c.segments
-        else:
-            segments = pac.identifier
-        
-        identifier_str = ''
-        for s in segments:
-            s:IDSegment = s
-            if s.key:
-                identifier_str += f'/{s.key}:{s.value}'
-            else:
-                identifier_str += f'/{s.value}'
-        return identifier_str
-          
-
-    @classmethod
-    def _serialize_extensions(cls, extensions:list[Extension], use_short_notation):
-        out = ''
-        short_notation = use_short_notation
-        for i, e in enumerate(extensions):
-            
-            if short_notation and i==0:
-                if e.name=='N':
-                    out += f'*{e.data}'
-                    continue
-                else: 
-                    short_notation = False
-            if short_notation and i==1:
-                if e.name=='SUM':
-                    out += f'*{e.data}'
-                    continue
-                else: 
-                    short_notation = False
-                
-            out += f'*{e.name}${e.type}/{e.data}'
-        return out
-        
-
-
-
-
+from labfreed.pac_cat.pac_cat import PAC_CAT
+from labfreed.pac_cat.predefined_categories import PredefinedCategory
+from labfreed.pac_id.id_segment import IDSegment
+from labfreed.pac_id.extension import Extension
+from labfreed.pac_id import PAC_ID  
+
+
+class PACID_Serializer():
+    '''Represents a PAC-ID including it's extensions'''
+  
+    @classmethod
+    def to_url(cls, pac:PAC_ID, use_short_notation:bool|None=None, uppercase_only=False) -> str:
+        """Serializes the PAC-ID including extensions.
+
+        Args:
+            use_short_notation (bool|None, optional): None (default): Preserves the identifier as is. Extensions use short form
+                                                      True: forces short notation for categories and extensions
+                                                      False: forces long notation for categories and extensions
+            uppercase_only (bool, optional): Forces all uppercase letters (results in smaller QR)..
+
+        Returns:
+            str: Something like this HTTPS://PAC.METTORIUS.COM/-MD/BAL500/1234*N$N/ABC*SUM$TREX/A$T.A:ABC
+
+        """
+        identifier_str = cls._serialize_identifier(pac, use_short_notation=use_short_notation)
+        
+        use_short_notation_for_extensions = True if use_short_notation is None else use_short_notation 
+        extensions_str = cls._serialize_extensions(pac.extensions, use_short_notation=use_short_notation_for_extensions)
+        out = f"HTTPS://PAC.{pac.issuer}{identifier_str}{extensions_str}"
+        
+        if uppercase_only:
+            out = out.upper()
+        return out
+    
+    @classmethod
+    def _serialize_identifier(cls, pac:PAC_ID|PAC_CAT, use_short_notation:None|bool=None):
+        ''' Serializes the PAC-ID'''
+        
+        if isinstance(pac, PAC_CAT) and use_short_notation is not None:
+            segments = []
+            for c in pac.categories:
+                segments.append(IDSegment(value=c.key))
+                if isinstance(c, PredefinedCategory):
+                    segments += c._get_segments(use_short_notation=use_short_notation)
+                else:
+                    segments += c.segments
+        else:
+            segments = pac.identifier
+        
+        identifier_str = ''
+        for s in segments:
+            s:IDSegment = s
+            if s.key:
+                identifier_str += f'/{s.key}:{s.value}'
+            else:
+                identifier_str += f'/{s.value}'
+        return identifier_str
+          
+
+    @classmethod
+    def _serialize_extensions(cls, extensions:list[Extension], use_short_notation):
+        out = ''
+        short_notation = use_short_notation
+        for i, e in enumerate(extensions):
+            
+            if short_notation and i==0:
+                if e.name=='N':
+                    out += f'*{e.data}'
+                    continue
+                else: 
+                    short_notation = False
+            if short_notation and i==1:
+                if e.name=='SUM':
+                    out += f'*{e.data}'
+                    continue
+                else: 
+                    short_notation = False
+                
+            out += f'*{e.name}${e.type}/{e.data}'
+        return out
+        
+
+
+
+

labfreed/pac_id_resolver/__init__.py

@@ -1,2 +1,2 @@
-from .resolver import PAC_ID_Resolver, load_cit  # noqa: F401
-from .services import ServiceGroup  # noqa: F401
+from .resolver import PAC_ID_Resolver, load_cit  # noqa: F401
+from .services import ServiceGroup  # noqa: F401

labfreed/pac_id_resolver/cit_common.py

@@ -1,82 +1,82 @@
-from enum import Enum
-import re
-from labfreed.labfreed_infrastructure import LabFREED_BaseModel, ValidationMsgLevel, _quote_texts
-
-
-
-class ServiceType(Enum):
-    USER_HANDOVER_GENERIC = 'userhandover-generic'
-    ATTRIBUTE_SERVICE_GENERIC = 'attributes-generic'
-
-
-def _validate_service_name(service_name):
-    msg_dict = []
-    if not_allowed_chars := set(re.sub(r'[A-Za-z0-9\-\x20]', '', service_name)):
-        msg_dict.append( {
-                "level": ValidationMsgLevel.ERROR,
-                "msg": f'Service name ontains invalid characters {_quote_texts(not_allowed_chars)}',
-                "highlight_sub": not_allowed_chars
-            }
-        )
-    
-    if len(service_name) == 0 or len(service_name) > 255:
-        msg_dict.append( {
-                "level": ValidationMsgLevel.ERROR,
-                "msg": 'Service name must be at least one and maximum 255 characters long'
-            }
-        )
-    return msg_dict
-        
-    
-def _validate_application_intent(intent):
-    msg_dict = []
-    if re.fullmatch('.*-generic$',  intent):
-        msg_dict.append( {
-                "level": ValidationMsgLevel.ERROR,
-                "msg": "Application intent ends with '-generic'. This is not permitted, since it is reserved for future uses'",
-                "highlight_sub": [intent]
-            }
-        )
-
-    if not_allowed_chars := set(re.sub(r'[A-Za-z0-9\-]', '', intent)):
-        msg_dict.append( {
-                "level": ValidationMsgLevel.ERROR,
-                "msg": f'Application intent contains invalid characters {_quote_texts(not_allowed_chars)}',
-                "highlight_sub": not_allowed_chars
-            }
-        )
-        
-    if len(intent) == 0 or len(intent) > 255:
-        msg_dict.append( {
-                "level": ValidationMsgLevel.ERROR,
-                "source": f'Application intent  {intent}',
-                "msg": 'Must be at least one and maximum 255 characters long'
-            }
-        )
-    return msg_dict
-
-    
-def _validate_service_type(service_type):
-    msg_dict = []
-    if isinstance(service_type, ServiceType):
-            service_type= service_type.value
-    else:
-        service_type= service_type
-    allowed_types = [ServiceType.ATTRIBUTE_SERVICE_GENERIC.value, ServiceType.USER_HANDOVER_GENERIC.value]
-    if service_type not in allowed_types:
-        msg_dict.append( {
-                "level": ValidationMsgLevel.ERROR,
-                "msg": f'Invalid service type. Must be {_quote_texts(allowed_types)} must be at least one and maximum 255 characters long',
-                "highlight_sub": service_type
-            }
-        )
-    return msg_dict
-
-
-def _add_msg_to_cit_entry_model(msg_dict, model):
-    for m in msg_dict:
-        m.update({"source": model.service_name})
-        model._add_validation_message(**m)
-    return model
-    
+from enum import Enum
+import re
+from labfreed.labfreed_infrastructure import LabFREED_BaseModel, ValidationMsgLevel, _quote_texts
+
+
+
+class ServiceType(Enum):
+    USER_HANDOVER_GENERIC = 'userhandover-generic'
+    ATTRIBUTE_SERVICE_GENERIC = 'attributes-generic'
+
+
+def _validate_service_name(service_name):
+    msg_dict = []
+    if not_allowed_chars := set(re.sub(r'[A-Za-z0-9\-\x20]', '', service_name)):
+        msg_dict.append( {
+                "level": ValidationMsgLevel.ERROR,
+                "msg": f'Service name ontains invalid characters {_quote_texts(not_allowed_chars)}',
+                "highlight_sub": not_allowed_chars
+            }
+        )
+    
+    if len(service_name) == 0 or len(service_name) > 255:
+        msg_dict.append( {
+                "level": ValidationMsgLevel.ERROR,
+                "msg": 'Service name must be at least one and maximum 255 characters long'
+            }
+        )
+    return msg_dict
+        
+    
+def _validate_application_intent(intent):
+    msg_dict = []
+    if re.fullmatch('.*-generic$',  intent):
+        msg_dict.append( {
+                "level": ValidationMsgLevel.ERROR,
+                "msg": "Application intent ends with '-generic'. This is not permitted, since it is reserved for future uses'",
+                "highlight_sub": [intent]
+            }
+        )
+
+    if not_allowed_chars := set(re.sub(r'[A-Za-z0-9\-]', '', intent)):
+        msg_dict.append( {
+                "level": ValidationMsgLevel.ERROR,
+                "msg": f'Application intent contains invalid characters {_quote_texts(not_allowed_chars)}',
+                "highlight_sub": not_allowed_chars
+            }
+        )
+        
+    if len(intent) == 0 or len(intent) > 255:
+        msg_dict.append( {
+                "level": ValidationMsgLevel.ERROR,
+                "source": f'Application intent  {intent}',
+                "msg": 'Must be at least one and maximum 255 characters long'
+            }
+        )
+    return msg_dict
+
+    
+def _validate_service_type(service_type):
+    msg_dict = []
+    if isinstance(service_type, ServiceType):
+            service_type= service_type.value
+    else:
+        service_type= service_type
+    allowed_types = [ServiceType.ATTRIBUTE_SERVICE_GENERIC.value, ServiceType.USER_HANDOVER_GENERIC.value]
+    if service_type not in allowed_types:
+        msg_dict.append( {
+                "level": ValidationMsgLevel.ERROR,
+                "msg": f'Invalid service type. Must be {_quote_texts(allowed_types)} must be at least one and maximum 255 characters long',
+                "highlight_sub": service_type
+            }
+        )
+    return msg_dict
+
+
+def _add_msg_to_cit_entry_model(msg_dict, model):
+    for m in msg_dict:
+        m.update({"source": model.service_name})
+        model._add_validation_message(**m)
+    return model
+