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

labfreed/PAC_ID/data_model.py

@@ -1,215 +0,0 @@
-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/PAC_ID/parse.py

@@ -1,142 +0,0 @@
-
-
-import re
-from types import MappingProxyType
-from .data_model import *
-
-from ..validation import extract_warnings, ValidationWarning
-
-
-category_conventions = MappingProxyType(
-                            {
-                                '-MD': ['240', '21'],
-                                '-MS': ['240', '10', '20', '21', '250'],
-                                '-MC': ['240', '10', '20', '21', '250'],
-                                '-MM': ['240', '10', '20', '21', '250']
-                            }
-                        )
-
-
-extension_convention = MappingProxyType(
-                                {
-                                    0: { 'name': 'N', 'type': 'N'},
-                                    1: { 'name': 'SUM', 'type': 'TREX'}
-                                }
-                            )
-
-
-
-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) -> tuple[PACID_With_Extensions, list[ValidationWarning] ]:
-        if '*' in pac_url:
-            id_str, ext_str = pac_url.split('*', 1)
-        else:
-            id_str = pac_url
-            ext_str = ""
-            
-        pac_id = self.parse_pac_id(id_str)
-        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):
-        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
-    
-    
-    def _apply_category_defaults(self, segments_in: list[IDSegment]):
-        
-        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
-                
-            
-        
-    def parse_pac_id(self,id_str:str) -> PACID:
-        m = re.match(f'(HTTPS://)?(PAC.)?(?P<issuer>.+?\..+?)/(?P<identifier>.*)', id_str)
-        d = m.groupdict()
-        
-        id_segments = list()
-        default_keys = None
-        id_segments = self.parse_id_segments(d.get('identifier'))
-        id_segments = self._apply_category_defaults(id_segments)
-        
-        pac = PACID(issuer= d.get('issuer'),
-                     identifier=Identifier(segments=id_segments)
-        )
-        return pac
-
-
-    def parse_extensions(self, extensions_str:str|None) -> list[Extension]:    
-        extensions = list()
-        
-        if not extensions_str:
-            return extensions
-        
-        defaults = extension_convention
-        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
-            subtype = self.extension_interpreters.get(type) or UnknownExtension
-            e = subtype.from_spec_fields(name=name, type=type, data=data)
-            extensions.append(e)
-
-        return extensions
-        
- 
-
-     
-
-if __name__ == "__main__":
-    pacid_str = 'HTTPS://PAC.METTORIUS.COM/-DR/AB378/-MD/B-500/1235/-MS/AB/X:88/WWW/-MS/240:11/BB*ABCFD*A$HUR:25+B$CEL:99*BLUBB$TREX/A$HUR:25+B$CEL:99'
-    
-    pac = PAC_Parser().parse_pac(pacid_str)

labfreed/PAC_ID/serialize.py

@@ -1,60 +0,0 @@
-
-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, 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.')
-            extensions = pac.extensions
-            pac = pac.pac_id
-        issuer = pac.issuer
-        extensions_str = self._serialize_extensions(extensions, use_short_notation_for_extensions)
-        id_segments = self._serialize_id_segments(pac.identifier.segments)
-        out = f"HTTPS://PAC.{issuer}{id_segments}{extensions_str}"
-        if uppercase_only:
-            out = out.upper()
-        return out
-    
-    
-    def _serialize_id_segments(self, segments):
-        out = ''
-        for s in segments:
-            if s.key:
-                out += f'/{s.key}:{s.value}'
-            else:
-                out += f'/{s.value}'
-        return out
-    
-    
-    def _serialize_extensions(self, extensions:list[Extension], use_short_notation_for_extensions):
-        out = ''
-        short_notation = use_short_notation_for_extensions
-        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
-        
-
-   
-def main():
-    pass
-     
-
-if __name__ == "__main__":
-    main()

labfreed/TREXExtension/data_model.py

@@ -1,239 +0,0 @@
-from datetime import datetime
-from enum import Enum
-import logging
-import re
-
-from pydantic import BaseModel, ValidationError, field_validator
-from abc import ABC
-
-from .unit_utilities import *
-from ..PAC_ID.data_model import Extension
-
-re_table_pattern = re.compile(f"(?P<tablename>[\w\.-]*?)\$\$(?P<header>[\w\.,\$:]*?)::(?P<body>.*)")
-re_col_head_pattern = re.compile(f"(?P<name>[\w\.-]*?)\$(?P<unit>[\w\.]*)")
-re_scalar_pattern = re.compile(f"(?P<name>[\w\.-]*?)\$(?P<unit>[\w\.]*?):(?P<value>.*)")
-        
-TREX_DATEFORMAT = '%Y%m%dT%H%M%S'
-TREX_TIMEFORMAT = '%Y%m%d'
-        
-class TREX_types(Enum):
-    BOOL = 'T.B'
-    DATE = 'T.D'
-    TEXT = 'T.A'
-    ERROR = 'E'
-    
-
-   
-class T_REX_Segment_ParseError(BaseException):
-    pass
-
-
-class TREX_Segment(BaseModel, ABC):
-    segment_name: str = None
-    
-    def as_trex_segment_str(self, segment_name):
-        pass
- 
-      
-class TREX_SimpleSegment(TREX_Segment):
-    type: str 
-    value: str
-    
-    @field_validator('type', mode='before')
-    def validate_type(t):
-        if isinstance(t, TREX_types):
-            t = t.value
-        return t
-          
-    @staticmethod
-    def from_trex_segmentstring(segment_str):
-       
-        matches = re_scalar_pattern.match(segment_str)
-        if not matches:
-            raise T_REX_Segment_ParseError("Segment is not a valid TREX Scalar")
-        
-        name, type_, value = matches.groups()
-        
-        out = TREX_SimpleSegment(type=type_, value=value, segment_name=name)
-        return out
-        
-    @property
-    def value_as_builtin_or_quantity_type(self) -> datetime|bool|str|PydanticUncertainQuantity:
-        return _value_as_builtin_or_quantity(self.value, self.type)
-    
-    def as_trex_segment_str(self, segment_name) -> str:
-        return f'{segment_name}${self.type}:{self.value}'
-  
-  
-class TREX_Table(TREX_Segment):
-    col_names: list[str]
-    col_types: list[str]
-    data: list[list[str]]
-        
-    @staticmethod
-    def from_trex_segmentstring( segment_str:str):
-        matches = re_table_pattern.match(segment_str) 
-        if not matches:
-            raise T_REX_Segment_ParseError(f"Segment is not a valid TREX table: {segment_str}")
-        name, header, body = matches.groups()
-                
-        column_heads = [re_col_head_pattern.match(colhead).groups() for colhead in header.split(':')]
-        col_names = [ch[0] for ch in column_heads]
-        col_types = [ch[1] for ch in column_heads]
-        
-        data = [row.split(':') for row in body.split('::') ]
-        
-        out = TREX_Table(col_names=col_names, col_types=col_types, data=data, segment_name=name)
-        return out
-     
-    def n_rows(self) -> int:
-        return len(self.data)
-    
-    def n_cols(self) -> int:
-        return len(self.col_names)
-      
-    def row_data(self, row:int) -> list:
-        out = [_value_as_builtin_or_quantity(element, self.col_types[i]) for i, element in enumerate(self.data)]
-        return out
-                
-    def col_data(self, col:str|int) -> list:
-        col_index = self._get_col_index(col)
-        type = self.col_types[col_index]
-        out =  [_value_as_builtin_or_quantity(row[col_index],type) for row in self.data]
-        return out
-     
-    def cell_data(self, row:int, col:str|int):
-        try:
-            col_index = self._get_col_index(col)
-            value = self.data[row][col_index]
-            type = self.col_types[col_index]   
-        except ValueError:
-            logging.warning(f"row {row}, column {col} not found")
-            return None
-        
-        return _value_as_builtin_or_quantity(value, type)
-            
-    def _get_col_index(self, col:str|int):
-        if isinstance(col, str):
-            col_index = self.col_names.index(col)
-        elif isinstance(col, int):
-            col_index = col
-        else:
-            raise TypeError(f"Column must be specified as string or int: {col.__name__}")
-        return col_index
-    
-    def as_trex_segment_str(self, name):
-        header = ':'.join([f'{el[0]}${el[1]}' for el in zip(self.col_names, self.col_types)])
-        date_rows = list()
-        for r in self.data:
-            row = ':'.join([str(cell) for cell in r])
-            date_rows.append(row)
-        data = '::'.join(date_rows)
-        s = f'{name}$${header}::{data}'
-        return s
-        
-
-
-class TREX(Extension, BaseModel):
-    name_:str
-    segments: dict[str,TREX_Segment]
-       
-    @property
-    def name(self)->str:
-        return self.name_
-    
-    @property
-    def type(self)->str:
-        return 'TREX'
-    
-    @property
-    def data(self)->str:
-        seg_strings = list()
-        for s_name, s in self.segments.items():
-            seg_strings.append(s.as_trex_segment_str(s_name))
-        s_out = '+'.join(seg_strings)
-        return s_out
-    
-    @staticmethod
-    def from_spec_fields(name, type, data):
-        if type != 'TREX':
-            logging.warning(f'Type {name} was given, but this extension should only be used with type "TREX". Will try to parse data as TREX')
-        
-        if not data:
-            raise ValueError(f'T-REX must be a string of non zero length')
-        
-        trex_str = data
-
-        # remove extension indicator. Precaution in case it is not done yet
-        if trex_str[0]=="*":
-            trex_str=trex_str[1:-1]
-        # remove line breaks. for editing T-REXes it's more convenient to have them in, so one never knows 
-        trex_str = re.sub(r"\s+", "", trex_str)
-                
-        segment_strings = trex_str.split('+')
-        out_segments = dict()
-        for s in segment_strings:
-            # there are only two valid options. The segment is a scalar or a table. 
-            # Constructors do the parsing anyways and raise exceptions if invalid data
-            # try both options and then let it fail
-            try:
-                segment = TREX_SimpleSegment.from_trex_segmentstring(s)
-            except T_REX_Segment_ParseError:
-                segment = TREX_Table.from_trex_segmentstring(s)
-            out_segments[segment.segment_name] = segment
-        
-        return TREX(name_=name, segments=out_segments)
-    
-    def get_segment(self, segment_id:str) -> TREX_Segment:
-        return self.segments.get(segment_id)
-    
-    
-    
-    
-class TREX_Struct(TREX_Segment):
-    """Struct is a special interpretation of a T-REX Table with one row"""
-    wrapped_table:TREX_Table
-    
-    @property
-    def segment_name_(self):
-        return self.wrapped_table.segment_name
-    
-    @field_validator('wrapped_table')
-    def validate_table(table):
-        if len(table.data) != 1:
-            raise ValidationError("Too many input rows. Struct can only have one row")
-        return table
-                
-    def get(self, key):
-        return self.wrapped_table.cell_data(0, key)
-    
-    def keys(self):
-        return self.wrapped_table.col_names
-    
-    
-    
- 
-def _to_datetime(trex_datetime):  
-    try:
-        # return datetime.fromisoformat(trex_datetime) # should work with python 3.11
-        return datetime.strptime(trex_datetime, TREX_DATEFORMAT)
-    except (ValueError , TypeError) as e:
-        try:
-            return datetime.strptime(trex_datetime, TREX_TIMEFORMAT)
-        except (ValueError, TypeError):
-            return None
-        
-def _value_as_builtin_or_quantity(v:str|list[str], type:str) -> datetime|bool|str|PydanticUncertainQuantity:
-    match type:
-        case 'T.D':
-            return _to_datetime(v)
-        case 'T.B':
-            return v == 'T' or bool(v)
-        case 'T.A':
-            return v
-        case 'T.X':
-            raise NotImplementedError("Base36 encoded T-REX segment not implemented")
-        case 'E':
-            return v
-        case _:
-            return quantity_from_UN_CEFACT(v, type)

labfreed/TREXExtension/parse.py

@@ -1,46 +0,0 @@
-import logging
-import re
-
-from .data_model import TREX, T_REX_Segment_ParseError, TREX_SimpleSegment, TREX_Table
-
-
-def from_trex_string(trex_str, enforce_type=True) -> TREX:
-    if not trex_str:
-        raise ValueError(f'T-REX must be a string of non zero length')
-
-    # remove extension indicator. Precaution in case it is not done yet
-    if trex_str[0]=="*":
-        trex_str=trex_str[1:-1]
-    # remove line breaks. for editing T-REXes it's more convenient to have them in, so one never knows 
-    trex_str = trex_str.replace('\n','')
-    
-    d = re.match('((?P<name>.+)\$(?P<type>.+)/)?(?P<data>.+)', trex_str).groupdict()     
-    if not d:
-        raise ValueError('TREX is invalid.') 
-    type = d.get('type')
-    name = d.get('name')
-    data = d.get('data')
-    
-    if not type:
-        logging.warning('No type given. Assume its trex')
-    elif type != 'TREX' and enforce_type:
-        logging.error(f'Extension type {type} is not TREX. Aborting')
-        raise ValueError(f'Extension type {type} is not TREX.')
-    else:
-        logging.warning('Extension type {type} is not TREX. Try anyways')
-    
-            
-    segment_strings = data.split('+')
-    out_segments = dict()
-    for s in segment_strings:
-        # there are only two valid options. The segment is a scalar or a table. 
-        # Constructors do the parsing anyways and raise exceptions if invalid data
-        # try both options and then let it fail
-        try:
-            segment = TREX_SimpleSegment.from_trex_segmentstring(s)
-        except T_REX_Segment_ParseError:
-            segment = TREX_Table.from_trex_segmentstring(s)
-        out_segments[segment.segment_name] = segment
-    trex = TREX(name_= name, segments=out_segments)
-    trex._trex_str = trex_str
-    return trex