labfreed 0.0.3__tar.gz

labfreed-0.0.3/.vscode/launch.json

@@ -0,0 +1,18 @@
+{
+    // Use IntelliSense to learn about possible attributes.
+    // Hover to view descriptions of existing attributes.
+    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "name": "Python Debugger: Current File",
+            "type": "debugpy",
+            "request": "launch",
+            "program": "${file}",
+            "console": "integratedTerminal",
+            "env": {
+                "PYTHONPATH": "$(pwd)"
+            }
+        }
+    ]
+}

labfreed-0.0.3/.vscode/settings.json

@@ -0,0 +1,7 @@
+{
+    "python.testing.pytestArgs": [
+        "."
+    ],
+    "python.testing.unittestEnabled": false,
+    "python.testing.pytestEnabled": true
+}

labfreed-0.0.3/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 Reto Thürer
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

labfreed-0.0.3/PKG-INFO

@@ -0,0 +1,15 @@
+Metadata-Version: 2.4
+Name: labfreed
+Version: 0.0.3
+Summary: Python implementation of LabFREED building blocks
+Author-email: Reto Thürer <reto.thuerer@gmail.com>
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-Expression: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+License-File: LICENSE
+
+# LabFREED for Python
+
+A python implementation of [LabFREED](www.labfreed.com).

labfreed-0.0.3/README.md

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

labfreed-0.0.3/labfreed/DisplayNameExtension/DisplayNameExtension.py

@@ -0,0 +1,34 @@
+import logging
+from pydantic import BaseModel
+from ..PAC_ID.data_model import Extension
+from .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)
+
+

labfreed-0.0.3/labfreed/DisplayNameExtension/base36.py

@@ -0,0 +1,66 @@
+import string
+
+def alphabet(base):
+    """ returns an alphabet, which corresponds to what pythons int(s:str, base:int=10) function used.
+    """
+    if base < 2 or base > 36:
+        ValueError('base can only be between 2 and 36')    
+    alphabet = (string.digits + string.ascii_uppercase)[0:base]
+    return alphabet
+
+def to_base36(s:str):
+    """Takes a string, encodes it in UTF-8 and then as base36 string."""
+    utf8_encoded = s.encode('utf-8')
+    num = int.from_bytes(utf8_encoded, byteorder='big', signed=False)
+    
+    # note: this cannot be arbitrarily chosen. The choice here corresponds to what pythons int(s:str, base:int=10) function used.
+    base36_chars = alphabet(base=36)
+    if num == 0:
+        return base36_chars[0]
+    base36 = []
+    _num = num
+    while _num:
+        _num, i = divmod(_num, 36)
+        base36.append(base36_chars[i])
+    return ''.join(reversed(base36))
+
+
+def from_base36(s36:str):
+    """inverse of to_base36"""
+    # this built in function interprets each character as number in a base represented by the standartd alphabet [0-9 (A-Z|a-z)][0:base] it is case INsensitive.
+    num = int(s36, 36)
+    num_bytes = (num.bit_length() + 7) // 8
+    _bytes = num.to_bytes(num_bytes, byteorder='big')
+    s = _bytes.decode('utf-8')
+    return s
+
+if __name__ == "__main__":
+    ss = ["A",
+      "B-500 B",
+      "B-500 Ba",
+      "B-500 Bal",
+      "B-500 Bala",
+      "B-500 Balanc",
+      "B-500 Balance",
+      "B-500 D",
+      "Mini Spray Dryer S-300", 
+      "w3ApashAt!!£NAGDSAF*ç%&/()",
+      "HELLOWORLD", 
+      "Helloworld",
+      "$£äö!'?^{]<@#¦&¬|¢)&§°😀你好🌍🏯😇🎵🔥你👻🐉😀你好🌍🏯😇🎵🔥你👻🐉😀你好🌍🏯😇🎵🔥你👻🐉😀你好🌍🏯😇🎵🔥你👻🐉😀你好🌍🏯😇🎵🔥你👻🐉😀你好🌍🏯😇🎵🔥你👻🐉😀你好🌍🏯😇🎵🔥你👻🐉",
+      "往跟住！師立甲錯什正再圓身升因月室",
+      "Balance BAL500 @☣️Lab",
+      "BAL500 @☣️Lab",
+      "BAL-CLEAN",
+      "Smørrebrød µ-Nutrients",
+      "Demo Result from R-300",
+      "Rotavapor R-300",
+      "Rotavapor R-250",
+      "Rotavapor R-220",
+      "SyncorePlus"
+      ]
+    for s in ss:
+        s36 = to_base36(s)
+        s_back = from_base36(s36)
+        identical = (s == s_back)
+        print(f'{s} >> {s36} >> {s_back}: match:{identical}')

labfreed-0.0.3/labfreed/PAC_CAT/__init__.py

@@ -0,0 +1 @@
+

labfreed-0.0.3/labfreed/PAC_CAT/data_model.py

@@ -0,0 +1,109 @@
+from abc import ABC
+from pydantic import Field
+from pydantic import BaseModel
+
+from ..PAC_ID.data_model import IDSegment, Category
+
+class CATBase(BaseModel, ABC):
+    category_key:str
+    additional_segments: list[IDSegment] = Field(default_factory=list)
+    
+    class Config:
+        populate_by_name = True # this will allow field names, as well as aliases in validation
+    
+    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.category_key,
+                        segments=segments)
+                
+            
+
+
+class Material_Device(CATBase):
+    category_key: str =         Field(default='-MD', frozen=True)
+    model_number: str =         Field(              alias='240', min_length=1)
+    serial_number: str =        Field(              alias='21', min_length=1)
+    
+class Material_Substance(CATBase):
+    category_key: str =         Field(default='-MS', frozen=True)
+    product_number:str =        Field(              alias='240', min_length=1)
+    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')
+    
+class Material_Consumable(CATBase):
+    category_key: str = Field(default='-MC', frozen=True)
+    product_number:str =        Field(              alias='240', min_length=1)
+    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')
+    
+class Material_Misc(Material_Consumable):
+    category_key: str = Field(default='-MM', frozen=True)
+
+
+
+class Data_Result(CATBase):
+    category_key: str = Field(default='-DR', frozen=True)
+    id:str =                    Field(              alias='240', min_length=1)
+    
+class Data_Method(CATBase):
+    category_key: str = Field(default='-DM', frozen=True)
+    id:str =                    Field(              alias='240', min_length=1)
+    
+class Data_Calibration(CATBase):
+    category_key: str = Field(default='-DC', frozen=True)
+    id:str =                    Field(              alias='240', min_length=1)
+    
+class Data_Progress(CATBase):
+    category_key: str = Field(default='-DP', frozen=True)
+    id:str =                    Field(              alias='240', min_length=1)
+    
+class Data_Static(CATBase):
+    category_key: str = Field(default='-DS', frozen=True)
+    id:str =                    Field(              alias='240', min_length=1)
+    
+    
+    
+    
+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) -> CATBase|None:
+    raise NotImplementedError()
+
+def CAT_from_category_key(category_key) -> CATBase|None:
+    return mapping.get(category_key)
+    
+
+if __name__ == "__main__":
+    pass

labfreed-0.0.3/labfreed/PAC_ID/data_model.py

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

labfreed-0.0.3/labfreed/PAC_ID/parse.py

@@ -0,0 +1,133 @@
+
+
+import re
+from types import MappingProxyType
+from .data_model import *
+
+
+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) -> PACID_With_Extensions:
+        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)    
+        return PACID_With_Extensions(pac_id=pac_id, extensions=extensions)
+            
+            
+    def parse_id_segments(self, identifier:str):
+        if not identifier:
+            return []    
+        
+        id_segments = list()  
+        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)
+            
+        return PACID(issuer= d.get('issuer'),
+                     identifier=Identifier(segments=id_segments)
+        )
+
+
+    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-0.0.3/labfreed/PAC_ID/serialize.py

@@ -0,0 +1,57 @@
+
+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:
+        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)
+        return f"HTTPS://PAC.{issuer}{id_segments}{extensions_str}".upper()
+    
+    
+    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()