labfreed 0.0.9__tar.gz → 0.0.10__tar.gz

{labfreed-0.0.9 → labfreed-0.0.10}/.vscode/launch.json

@@ -23,6 +23,16 @@
             "env": {
                 "PYTHONPATH": "$(pwd)"
             }
+        },
+        {
+            "name": "Python Debugger: Examples",
+            "type": "debugpy",
+            "request": "launch",
+            "program": "examples.py",
+            "console": "integratedTerminal",
+            "env": {
+                "PYTHONPATH": "$(pwd)"
+            }
         }
     ]
 }

labfreed-0.0.10/.vscode/settings.json

@@ -0,0 +1,11 @@
+{
+    "python.testing.pytestArgs": [
+        ".",
+        "-s"
+    ],
+    "python.testing.unittestEnabled": false,
+    "python.testing.pytestEnabled": true,
+    "python.analysis.extraPaths": [
+        "./labfreed/utilities"
+    ]
+}

{labfreed-0.0.9 → labfreed-0.0.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: labfreed
-Version: 0.0.9
+Version: 0.0.10
 Summary: Python implementation of LabFREED building blocks
 Author-email: Reto Thürer <thuerer.r@buchi.com>
 License-Expression: MIT

labfreed-0.0.10/README.md

@@ -0,0 +1,60 @@
+# LabFREED for Python
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE) [![PyPI](https://img.shields.io/pypi/v/labfreed.svg)](https://pypi.org/project/labfreed/) ![Python Version](https://img.shields.io/pypi/pyversions/labfreed)
+
+<!--
+[![Tests](https://github.com/retothuerer/LabFREED/actions/workflows/ci.yml/badge.svg)](https://github.com/retothuerer/LabFREED/actions/workflows/ci.yml)
+-->
+
+This is a Python implementation of [LabFREED](www.labfreed.wega-it.com) building blocks.
+
+## Supported Building Blocks
+- PAC-ID
+- PAC-CAT
+- TREX
+- Display Extension
+
+## Installation
+You can install LabFREED from [PyPI](https://pypi.org/project/labfreed/) using pip:
+
+```bash
+pip install labfreed
+```
+
+
+## Usage Examples
+<!-- BEGIN EXAMPLES -->
+```python
+
+# Parse a PAC ID
+from labfreed.PAC_ID.parse import PAC_Parser
+pac_str = 'HTTPS://PAC.METTORIUS.COM/-MD/BAL500/1234'
+pac = PAC_Parser().parse_pac_id(pac_str)
+
+## Check validity
+pac.is_valid()
+pac.print_validation_messages()
+
+
+## Parse a PAC-ID with extensions
+from labfreed.utilities.extension_intertpreters import well_known_interpreters as extension_interpreters
+pac_str = 'HTTPS://PAC.METTORIUS.COM/-MD/BAL500/1234*NAME$N/WM633OV3E5DGJW2BEG0PDM1EA7*SUM$TREX/WEIGHT$GRM:67.89'
+pac = PAC_Parser(extension_interpreters).parse_pac_id(pac_str)
+
+## Create a PAC-ID
+
+## Create a PAC-ID and T-REX for a titration curve
+
+
+
+```
+
+<!-- END EXAMPLES -->
+
+
+
+## Change Log
+
+### v0.0.9
+- supports PAC-ID, PAC-CAT, TREX and DisplayName
+- ok-ish test coverage

labfreed-0.0.10/examples.py

@@ -0,0 +1,114 @@
+from datetime import datetime
+from typing import Annotated
+
+# Parse a PAC ID
+from labfreed.PAC_ID.data_model import PACID, IDSegment
+from labfreed.parse_pac import PAC_Parser, PACID_With_Extensions
+from utility_types import Quantity
+pac_str = 'HTTPS://PAC.METTORIUS.COM/-MD/BAL500/1234'
+pac = PAC_Parser().parse_pac_id(pac_str)
+
+## Check validity
+pac_str = 'HTTPS://PAC.METTORIUS.COM/-MD/bal500/@1234'
+pac = PAC_Parser().parse_pac_id(pac_str)
+is_valid = pac.is_valid()
+print('PAC-ID is valid: {is_valid}')
+
+# Show recommendations
+pac.print_validation_messages()
+
+
+
+
+## Parse a PAC-ID with extensions
+pac_str = 'HTTPS://PAC.METTORIUS.COM/-MD/BAL500/1234*N$N/WM633OV3E5DGJW2BEG0PDM1EA7*SUM$TREX/WEIGHT$GRM:67.89'
+pac = PAC_Parser().parse_pac_with_extensions(pac_str)
+
+# Display Name
+display_names = pac.get_extension('N')
+print(f'\nDisplay names: {display_names}')
+
+# TREX
+from labfreed.TREX.data_model import TREX, ColumnHeader, TREX_Table, TableRow
+trexes = pac.get_extension_of_type('TREX')
+trex:TREX = trexes[0]
+v = trex.get_segment('WEIGHT').to_python_type()
+
+
+
+
+## Create a PAC-ID
+from labfreed.utilities.well_known_keys import WellKnownKeys
+pac = PACID(issuer='METTORIUS:COM', identifier=[IDSegment(key=WellKnownKeys.SERIAL, value='1234')])
+pac_str = pac.serialize()
+pac_str = pac.serialize()
+print(pac_str)
+
+
+
+
+# create a TREX
+from labfreed.TREX.data_model import TREX, DateSegment, NumericSegment, BoolSegment, AlphanumericSegment, TextSegment, BinarySegment
+
+trex = TREX(name_='DEMO-TREX')
+
+trex.segments.append(DateSegment(key='START',value='20240505T1204'))
+trex.segments.append(DateSegment(key='STOP', value=datetime(year=2024,month=5,day=5,hour=13,minute=6)) )
+
+trex.segments.append(NumericSegment(key='TEMP',type='KEL', value=10.15) )
+trex.segments.append(BoolSegment(key='OK', value=False) )
+trex.segments.append(AlphanumericSegment(key='COMMENT', value='FOO') )
+trex.segments.append(TextSegment(key='COMMENT2', value='🐯') )
+trex.segments.append(TextSegment(key='COMMENT2', value='BAR') )
+
+# if the sting is already in base36 you have to be explicit
+from labfreed.utilities.base36 import base36
+trex.segments.append(TextSegment(key='COMMENT3', value=base36('1URIOQ7')) )
+
+# table
+table = TREX_Table(key='TABLE', 
+                   column_headers=[
+                                    ColumnHeader(key='COL1', type='HUR'), 
+                                    ColumnHeader(key='COL2', type='T.A'),
+                                    ColumnHeader(key='COL3', type='T.D'),
+                                    ColumnHeader(key='COL4', type='T.B')
+                                    ],
+                   data=[
+                       TableRow()
+                   ])
+trex.segments.append(table)
+
+if trex.is_valid():
+    print(trex.data)
+else:
+    trex.print_validation_messages()
+    
+
+p = PACID_With_Extensions(pac_id=pac, extensions=[trex])
+print(p.serialize())
+
+
+
+
+
+# for convenience a TREX can be created from a dict
+trex2 = TREX(name_='DEMO-TREX2')
+trex2.update(   
+                    {
+                        'STOP': datetime(year=2024,month=5,day=5,hour=13,minute=6),
+                        'TEMP': Quantity(value=10.15, unit_name='meter', unit_symbol='m'),
+                        'OK':False,
+                        'COMMENT': 'FOO',
+                        'COMMENT2':'🐯'
+                    }
+)
+
+d = trex2.dict()
+
+
+
+    
+
+
+
+

{labfreed-0.0.9 → labfreed-0.0.10}/labfreed/DisplayNameExtension/DisplayNameExtension.py

@@ -1,6 +1,6 @@
 import logging
 from pydantic import BaseModel
-from ..PAC_ID.data_model import Extension
+from labfreed.PAC_ID.extensions import Extension
 from labfreed.utilities.base36 import from_base36, to_base36
 
 
@@ -20,7 +20,7 @@ class DisplayNames(Extension, BaseModel):
         return '/'.join([to_base36(dn) for dn in self.display_names])
     
     @staticmethod
-    def from_spec_fields(name, type, data):
+    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')
             
@@ -30,5 +30,8 @@ class DisplayNames(Extension, BaseModel):
         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-0.0.10/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]
+        
+
+
+
+