labfreed 1.0.0a4__tar.gz → 1.0.0a8__tar.gz

{labfreed-1.0.0a4 → labfreed-1.0.0a8}/CHANGELOG.md

@@ -1,4 +1,18 @@
 ## Change Log
+
+### v1.0.0
+PAC-CAT
+- added new categories 
+- BREAKING: Renamed category MM to MX
+
+
+PAC-ID Attributes
+- new building block
+  
+
+  
+
+
 ### v0.2.12
 - bugfix:no warning message if PAC-CAT has same segment key in two segments
 

{labfreed-1.0.0a4 → labfreed-1.0.0a8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: labfreed
-Version: 1.0.0a4
+Version: 1.0.0a8
 Summary: Python implementation of LabFREED building blocks
 Author-email: Reto Thürer <thuerer.r@buchi.com>
 Requires-Python: >=3.11

{labfreed-1.0.0a4 → labfreed-1.0.0a8}/labfreed/__init__.py

@@ -2,7 +2,7 @@
 Python implementation of LabFREED building blocks
 '''
 
-__version__ = "1.0.0a4"
+__version__ = "1.0.0a8"
 
 from labfreed.pac_id import *  # noqa: F403
 from labfreed.pac_cat import * # noqa: F403

{labfreed-1.0.0a4 → labfreed-1.0.0a8}/labfreed/labfreed_extended/app/app_infrastructure.py

@@ -32,7 +32,7 @@ class Labfreed_App_Infrastructure():
         self._http_client= http_client
         callback = http_attribute_request_default_callback_factory(http_client)
             
-        self._attribute_client = AttributeClient(http_post_callback=callback, cache_store=MemoryAttributeCache())
+        self._attribute_client = AttributeClient(http_post_callback=callback, cache_store=MemoryAttributeCache(), always_use_cached_value_for_minutes=1)
 
 
     def add_cit(self, cit:str):
@@ -71,7 +71,7 @@ class Labfreed_App_Infrastructure():
                 ags = {ag.key: pyAttributeGroup.from_attribute_group(ag) for ag in self._attribute_client.get_attributes(url, pac_id=pac.to_url(include_extensions=False), language_preferences=self._language_preferences)}
                 if ags:
                     attribute_groups.update(ags)
-        pac_info.attributes = attribute_groups
+        pac_info.attribute_groups = attribute_groups
        
         return pac_info
     

{labfreed-1.0.0a4 → labfreed-1.0.0a8}/labfreed/labfreed_extended/app/pac_info/pac_info.py

@@ -5,7 +5,7 @@ from pathlib import Path
 from urllib.parse import urlparse
 from jinja2 import Environment, FileSystemLoader, select_autoescape
 from pydantic import BaseModel, Field
-from labfreed.pac_attributes.pythonic.py_attributes import pyAttribute, pyAttributeGroup, pyAttributes, pyReference
+from labfreed.pac_attributes.pythonic.py_attributes import pyAttribute, pyAttributeGroup, pyAttributes, pyReference, pyResource
 from labfreed.pac_attributes.well_knonw_attribute_keys import MetaAttributeKeys
 from labfreed.pac_cat.pac_cat import PAC_CAT
 from labfreed.pac_id.pac_id import PAC_ID
@@ -20,7 +20,7 @@ class PacInfo(BaseModel):
     """A convenient collection of information about a PAC-ID"""
     pac_id:PAC_ID
     user_handovers: list[ServiceGroup] = Field(default_factory=list)
-    attributes:dict[str, pyAttributeGroup] = Field(default_factory=dict)
+    attribute_groups:dict[str, pyAttributeGroup] = Field(default_factory=dict)
     
     @property
     def pac_url(self):
@@ -44,8 +44,10 @@ class PacInfo(BaseModel):
     
     @property
     def image_url(self) -> str:
-        if meta := self.attributes.get(MetaAttributeKeys.GROUPKEY.value):
-            image_attr = meta.attributes.get(MetaAttributeKeys.IMAGE.value)
+        image_attr = self._all_attributes.get(MetaAttributeKeys.IMAGE.value)
+        if isinstance(image_attr.value, pyResource):
+            return image_attr.value.root
+        if isinstance(image_attr.value, str):
             return image_attr.value
         
         
@@ -68,12 +70,18 @@ class PacInfo(BaseModel):
     def safety_pictograms(self) -> dict[str, pyAttribute]:
         pictogram_attributes = {k: a for k, a in self._all_attributes.items() if "https://labfreed.org/ghs/pictogram/" in a.key}
         return pictogram_attributes    
+    
+    
+    @property
+    def qualification_state(self) -> pyAttribute:
+        if state := self._all_attributes.get("https://labfreed.org/qualification/status"): 
+            return state
         
         
     @cached_property
     def _all_attributes(self) -> dict[str, pyAttribute]:
         out = {}
-        for ag in self.attributes.values():
+        for ag in self.attribute_groups.values():
             out.update(ag.attributes)   
         return out
     
@@ -105,12 +113,12 @@ class PacInfo(BaseModel):
         
         
         printout.title1("Attributes")
-        for ag in self.attributes.values():  
+        for ag in self.attribute_groups.values():  
             printout.title2(f'{ag.label} (from {ag.origin})')
             for v in ag.attributes.values():
                 v:pyAttribute
                 #print(f'{k}: ({v.label})           :: {v.value}  ')
-                printout.key_value(v.label, v.value)
+                printout.key_value(v.label, ', '.join([str(e) for e in v.value_list]))
       
         out =  printout.getvalue()
 

{labfreed-1.0.0a4 → labfreed-1.0.0a8}/labfreed/pac_attributes/api_data_models/response.py

@@ -3,6 +3,8 @@ from abc import ABC
 from datetime import  datetime
 import re
 from typing import Annotated, Any,  Literal, Union, get_args
+from urllib.parse import urlparse
+
 from labfreed.utilities.ensure_utc_time import ensure_utc
 from labfreed.labfreed_infrastructure import  LabFREED_BaseModel, ValidationMsgLevel, _quote_texts
 from pydantic import   Field, field_validator, model_validator
@@ -12,22 +14,13 @@ class AttributeBase(LabFREED_BaseModel, ABC):
     key: str
     value: Any
     label: str = ""
-    
-    observed_at: datetime | None = None
-    
+        
     def __init__(self, **data):
         # Automatically inject the Literal value for `type`
         discriminator_value = self._get_discriminator_value()
         data["type"] = discriminator_value
         super().__init__(**data)       
     
-    @field_validator('observed_at', mode='before')
-    def set_utc_observed_at_if_naive(cls, value):
-        if isinstance(value, datetime):
-            return ensure_utc(value)
-        else:
-            return value
-
     @classmethod
     def _get_discriminator_value(cls) -> str:
         """Extract the Literal value from the 'type' annotation."""
@@ -40,16 +33,10 @@ class AttributeBase(LabFREED_BaseModel, ABC):
                 f"{cls.__name__} must define `type: Literal[<value>]` annotation"
             ) from e
         
-
-        
-    
-class ReferenceAttribute(AttributeBase):
-    type: Literal["reference"]
-    value: str
     
 class DateTimeAttribute(AttributeBase):
     type: Literal["datetime"] 
-    value: datetime
+    value: datetime | list[datetime]
     
     @field_validator('value', mode='before')
     def set_utc__if_naive(cls, value):
@@ -60,15 +47,59 @@ class DateTimeAttribute(AttributeBase):
     
 class BoolAttribute(AttributeBase):
     type: Literal["bool"] 
-    value: bool
+    value: bool | list[bool]
     
 class TextAttribute(AttributeBase):
     type: Literal["text"] 
-    value: str
+    value: str | list[str]
+    
+    @model_validator(mode='after')
+    def _validate_value(self):
+        l = [self.value] if isinstance(self.value, str) else self.value
+        for v in l:
+            if len(v) > 5000: 
+                self._add_validation_message(
+                    source="Text Attribute",
+                    level=ValidationMsgLevel.WARNING,  # noqa: F821
+                    msg=f"Text attribute {v} exceeds 5000 characters. It is recommended to stay below",
+                    highlight_pattern = f'{v}'
+                )
+        return self
+            
+
+class ReferenceAttribute(AttributeBase):
+    type: Literal["reference"]
+    value: str | list[str]
     
+
+class ResourceAttribute(AttributeBase):
+    type: Literal["resource"]
+    value: str | list[str]
     
+    @model_validator(mode='after')
+    def _validate_value(self):
+        value_list = self.value if isinstance(self.value, list) else [self.value]
+        for v in value_list:
+            r = urlparse(v)
+            if not all([r.scheme, r.netloc]):
+                self._add_validation_message(
+                    source="Resource Attribute",
+                    level=ValidationMsgLevel.ERROR,  # noqa: F821
+                    msg=f"Must be a valid url",
+                    highlight_pattern = f'{v}'
+                )
+            pattern = re.compile(r"\.\w{1,3}$", re.IGNORECASE)
+            if not bool(pattern.search(v)):
+                self._add_validation_message(
+                    source="Resource Attribute",
+                    level=ValidationMsgLevel.WARNING,  # noqa: F821
+                    msg=f"It is RECOMMENDED resource links end with a file extension",
+                    highlight_pattern = f'{v}'
+                )
+        return self
     
         
+        
 class NumericValue(LabFREED_BaseModel):
     numerical_value: str
     unit: str
@@ -120,11 +151,11 @@ class NumericValue(LabFREED_BaseModel):
 
 class NumericAttribute(AttributeBase):
     type: Literal["numeric"] 
-    value: NumericValue
+    value: NumericValue | list[NumericValue]
     
 class ObjectAttribute(AttributeBase):
     type: Literal["object"] 
-    value: dict[str, Any]
+    value: dict[str, Any] |list[dict[str, Any]]
            
 
      
@@ -136,27 +167,18 @@ Attribute = Annotated[
         BoolAttribute,
         TextAttribute,
         NumericAttribute,
+        ResourceAttribute,
         ObjectAttribute
     ],
     Field(discriminator="type")
 ]
 
-VALID_FOREVER = "forever"
 
 class AttributeGroup(LabFREED_BaseModel):
     key: str
     label: str = ""
     attributes: list[Attribute]
-    
-    state_of: datetime
-    valid_until: datetime | Literal["forever"] | None = None
-    
-    @field_validator('valid_until', mode='before')
-    def set_utc_valid_until_if_naive(cls, value):
-        if isinstance(value, datetime):
-            return ensure_utc(value)
-        else:
-            return value
+       
 
 
 class AttributesOfPACID(LabFREED_BaseModel):

{labfreed-1.0.0a4 → labfreed-1.0.0a8}/labfreed/pac_attributes/client/attribute_cache.py

@@ -1,6 +1,6 @@
 
 
-from datetime import datetime
+from datetime import UTC, datetime, timedelta
 from typing import Literal, Protocol
 
 
@@ -12,28 +12,15 @@ from labfreed.pac_id.pac_id import PAC_ID
 class CacheableAttributeGroup(AttributeGroup):
     origin:str
     language:str
-    valid_until: Literal['forever'] | datetime | None = None
+    value_from: datetime | None = None  
     
-    # @model_validator(mode='after')
-    # def set_valid_until(self) -> 'CacheableAttributeGroup':
-    #     vals = [a.valid_until for a in self.attributes]
-    #     if all(e == 'forever' for e in vals):
-    #         self.valid_until = 'forever'
-    #     elif any(e is None for e in vals):
-    #         self.valid_until = None
-    #     else:
-    #         self.valid_until = min(v for v in vals if isinstance(v, datetime))
-    #     return self
-    
-    
-    @property
-    def still_valid(self):
-        if self.valid_until is None:
+    def still_valid(self, accept_cache_for_minutes):
+        if self.value_from is None:
             return False
-        if self.valid_until == 'forever':
-            return True
-        
-        return self.valid_until > datetime.now()
+        else:
+            return ( datetime.now(tz=UTC) - timedelta(minutes=accept_cache_for_minutes)) > self.value_from 
+
+
 
 
 

{labfreed-1.0.0a4 → labfreed-1.0.0a8}/labfreed/pac_attributes/client/client.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
+from datetime import UTC, datetime
 from typing import Protocol, runtime_checkable
 
 import requests
@@ -85,6 +86,7 @@ class AttributeClient():
 
     http_post_callback:AttributeRequestCallback
     cache_store:AttributeCache
+    always_use_cached_value_for_minutes:int
                 
     def get_attributes(self, 
                        server_url:str, 
@@ -120,7 +122,7 @@ class AttributeClient():
             else:
                 attribute_groups = self.cache_store.get_all(server_url, pac_id)
                 
-            if attribute_groups and all([ag.still_valid for ag in attribute_groups]): 
+            if attribute_groups and all([ag.still_valid(accept_cache_for_minutes=self.always_use_cached_value_for_minutes) for ag in attribute_groups]): 
                 return attribute_groups
         
         # no valid data found in cache > request to server
@@ -154,7 +156,7 @@ class AttributeClient():
                     origin=server_url, 
                     language=r.language, 
                     label=ag.label,
-                    state_of=ag.state_of) 
+                    value_from=datetime.now(tz=UTC)) 
                 for ag in ag_for_pac.attribute_groups
                 ]
             self.cache_store.update(server_url, pac_from_response, ags)

{labfreed-1.0.0a4 → labfreed-1.0.0a8}/labfreed/pac_attributes/pythonic/excel_attribute_data_source.py

@@ -113,8 +113,7 @@ class _BaseExcelAttributeDataSource(AttributeGroupDataSource):
         attributes = [pyAttribute(key=k, value=v) for k, v in d.items()]
         return AttributeGroup(
             key=self._attribute_group_key,
-            attributes=pyAttributes(attributes).to_payload_attributes(),
-            state_of=last_changed,
+            attributes=pyAttributes(attributes).to_payload_attributes()
         )
 
 

labfreed-1.0.0a8/labfreed/pac_attributes/pythonic/py_attributes.py

@@ -0,0 +1,165 @@
+
+from datetime import date, datetime, time
+import json
+from typing import  Literal
+import warnings
+from pydantic import RootModel, field_validator
+
+from labfreed.labfreed_infrastructure import LabFREED_BaseModel
+from labfreed.pac_attributes.api_data_models.response import AttributeBase, AttributeGroup, BoolAttribute, DateTimeAttribute,  NumericAttribute, NumericValue, ObjectAttribute, ReferenceAttribute, ResourceAttribute, TextAttribute
+from labfreed.pac_attributes.client.attribute_cache import CacheableAttributeGroup
+from labfreed.pac_id.pac_id import PAC_ID
+from labfreed.trex.pythonic.quantity import Quantity
+
+
+class pyReference(RootModel[str]):
+
+    def __str__(self):
+        return str(self.root)
+    
+class pyResource(RootModel[str]):
+
+    def __str__(self):
+        return str(self.root)
+
+
+# the allowed scalar types
+AllowedValue = str | bool | datetime | pyReference | pyResource | Quantity | int | float | dict | object
+# homogeneous list of those
+AllowedList = list[AllowedValue]
+
+class pyAttribute(LabFREED_BaseModel):
+    key:str
+    label:str = ""
+    value: AllowedValue | AllowedList
+    
+    @property
+    def value_list(self):    
+        '''helper function to more conveniently iterate over value elements, even if it's scalar'''   
+        return self.value if isinstance(self.value, list) else [self.value]
+    
+    
+    @field_validator('value', mode='before')
+    def handle_one_element_list(v):
+        if isinstance(v, list) and len(v)==1:
+            return v[0]
+        else:
+            return v
+
+class pyAttributes(RootModel[list[pyAttribute]]):
+    def to_payload_attributes(self) -> list[AttributeBase]:
+        out = []
+        for e in self.root:
+            apt = self._attribute_to_attribute_payload_type(e)
+            if isinstance(apt.value, list) and len(apt.value) ==1:
+                apt.value = apt.value[0]
+            out.append(apt)
+        return out
+    
+            
+    @staticmethod        
+    def _attribute_to_attribute_payload_type(attribute:pyAttribute) -> AttributeBase:
+        common_args = {
+            "key": attribute.key,
+            "label": attribute.label,
+        }
+        value_list = attribute.value_list
+        first_value = value_list[0]
+        if isinstance(first_value, bool):
+            return BoolAttribute(value=value_list, **common_args)
+            
+        elif isinstance(first_value, datetime | date | time):
+            for v in value_list:
+                if not v.tzinfo:
+                    warnings.warn(f'No timezone given for {v}. Assuming it is in UTC.')
+            return DateTimeAttribute(value=value_list, **common_args)
+            # return DateTimeAttribute(value =_date_value_from_python_type(value).value, **common_args)
+            
+        
+        elif isinstance(first_value, Quantity|int|float):
+            values = []
+            for v in value_list:
+                if not isinstance(v, Quantity):
+                    v = Quantity(value=v, unit='dimensionless')
+                values.append(NumericValue(numerical_value=v.value_as_str(), 
+                                            unit = v.unit))
+            num_attribute = NumericAttribute(value = values, **common_args)
+            num_attribute.print_validation_messages()
+            return num_attribute
+        
+        elif isinstance(first_value, str):
+            # capture quantities in the form of "100.0e5 g/L"
+            if Quantity.from_str_with_unit(first_value):
+                values = []
+                for v in value_list:
+                    q = Quantity.from_str_with_unit(v)
+                    values.append( NumericValue(numerical_value=q.value_as_str(), unit = q.unit) )
+                return NumericAttribute(value = values,
+                                            **common_args)
+                
+            else:
+                return TextAttribute(value = value_list, **common_args)
+            
+        elif isinstance(first_value, pyReference):
+            return ReferenceAttribute(value = [v.root for v in value_list], **common_args)
+        
+        elif isinstance(first_value, pyResource):
+            return ResourceAttribute(value = [v.root for v in value_list], **common_args)
+            
+        elif isinstance(first_value, PAC_ID):
+            return ReferenceAttribute(value = [v.to_url(include_extensions=False) for v in value_list], **common_args)
+        
+        else: #this covers the last resort case of arbitrary objects. Must be json serializable.
+            try :
+                values = [json.loads(json.dumps(v)) for v in value_list]
+                return ObjectAttribute(value=values, **common_args)
+            except TypeError as e:  # noqa: F841
+                raise ValueError(f'Invalid Type: {type(first_value)} cannot be converted to attribute. You may want to use ObjectAttribute, but would have to implement the conversion from your python type yourself.')
+        
+        
+        
+    @staticmethod
+    def from_payload_attributes(attributes:list[AttributeBase]) -> 'pyAttributes':
+        out = list()
+        for a in attributes:
+            value_list = a.value if isinstance(a.value, list) else [a.value]
+            match a:
+                case ReferenceAttribute():
+                    values =  [pyReference(v) for v in value_list]
+                    
+                case ResourceAttribute():
+                    values =  [pyResource(v) for v in value_list]
+                    
+                case NumericAttribute():                                       
+                    values = [ Quantity.from_str_value(value=v.numerical_value, unit=v.unit) for v in value_list]
+
+                case BoolAttribute():
+                    values = value_list
+                    
+                case TextAttribute():
+                    values = value_list
+                    
+                case DateTimeAttribute():                    
+                    values = value_list
+                
+                case ObjectAttribute():
+                    values = value_list
+
+                       
+            attr = pyAttribute(key=a.key, 
+                               label=a.label,
+                               value=values
+            )
+            out.append(attr )
+        return out
+            
+            
+        
+class pyAttributeGroup(CacheableAttributeGroup):
+    attributes:dict[str,pyAttribute]
+    
+    @staticmethod
+    def from_attribute_group(attribute_group:AttributeGroup):
+        data = vars(attribute_group).copy()
+        data["attributes"] = {a.key: a for a in pyAttributes.from_payload_attributes(attribute_group.attributes)}
+        return pyAttributeGroup(**data)

{labfreed-1.0.0a4 → labfreed-1.0.0a8}/labfreed/pac_attributes/server/attribute_data_sources.py

@@ -1,6 +1,6 @@
 from abc import ABC, abstractmethod, abstractproperty
 from datetime import datetime, timezone
-from labfreed.pac_attributes.api_data_models.response import VALID_FOREVER, AttributeBase, AttributeGroup
+from labfreed.pac_attributes.api_data_models.response import AttributeBase, AttributeGroup
 from labfreed.pac_cat.pac_cat import PAC_CAT
 from labfreed.pac_id.pac_id import PAC_ID
 
@@ -31,13 +31,13 @@ class AttributeGroupDataSource(ABC):
     
 
 class Dict_DataSource(AttributeGroupDataSource):
-    def __init__(self, data:dict[str, list[AttributeBase]], uses_pac_cat_short_form=True, *args, **kwargs):
+    def __init__(self, data:dict[str, list[AttributeBase]], uses_pac_cat_short_form=True, pac_to_key: callable = None, *args, **kwargs):
         if not all([isinstance(e, list) for e in data.values()]):
             raise ValueError('Invalid data')
         
         self._data = data
-        self._state_of = datetime.now(tz=timezone.utc)
         self.uses_pac_cat_short_form = uses_pac_cat_short_form
+        self._pac_to_key = pac_to_key
         
         super().__init__(*args, **kwargs)       
         
@@ -54,18 +54,14 @@ class Dict_DataSource(AttributeGroupDataSource):
         except:
             ... # might as well try to match the original input
             
-        attributes = self._data.get(pac_url)
+        
+        lookup_key = self._pac_to_key(pac_url) if self._pac_to_key else pac_url
+        attributes = self._data.get(lookup_key)
         if not attributes:
             return None     
         
-        
-        valid_until = VALID_FOREVER if self._is_static else None
-        
-
         return AttributeGroup(key=self._attribute_group_key, 
-                              attributes=attributes, 
-                              state_of=self._state_of, 
-                              valid_until=valid_until)
+                              attributes=attributes)
         
         
         

{labfreed-1.0.0a4 → labfreed-1.0.0a8}/labfreed/pac_attributes/server/server.py

@@ -1,3 +1,5 @@
+import re
+import string
 import traceback
 import warnings
 
@@ -132,15 +134,22 @@ class AttributeServerRequestHandler():
             if dn := self._get_display_name_for_key(ag.key, language):
                 ag.label = dn
             else:
-                ag.label = ag.key.split('/')[-1]
+                ag.label = self.fallback_label(ag.key)
                 rich.print(f"[yellow]WARNING:[/yellow] No translation for '{ag.key}' in '{language}'. Falling back to '{ag.label}'")
             for a in ag.attributes:
                 if dn := self._get_display_name_for_key(a.key, language):
                     a.label = dn
                 else:
-                    a.label = a.key.split('/')[-1]
+                    a.label = self.fallback_label(a.key)
                     rich.print(f"[yellow]WARNING:[/yellow] No translation for '{a.key}' in '{language}'. Falling back to '{a.label}' ")
                     
+        
+    def fallback_label(self, key:str):
+        l = key.split('/')[-1]
+        l = re.sub(r'([a-z])([A-Z])', r'\1 \2', l)
+        l = re.sub(r'[-_]', ' ', l)
+        l = string.capwords(l)
+        return l                 
             
         
     def _get_display_name_for_key(self, key, language:str): 

{labfreed-1.0.0a4 → labfreed-1.0.0a8}/labfreed/pac_cat/category_base.py

@@ -57,7 +57,7 @@ class Category(LabFREED_BaseModel):
                     k = f"{field_name}"
             out.update({k : v } ) 
             
-        for s in getattr(self, 'additional_segments'):
+        for s in getattr(self, 'additional_segments', []):
             out.update( {s.key or '' : s.value })
         return out
 

{labfreed-1.0.0a4 → labfreed-1.0.0a8}/labfreed/pac_cat/predefined_categories.py

@@ -116,9 +116,9 @@ class Material_Consumable(PredefinedCategory):
         return self
     
 class Material_Misc(Material_Consumable):
-    '''Represents the -MC category'''
+    '''Represents the -MX category'''
     # same fields as Consumable
-    key: str = Field(default='-MM', frozen=True)
+    key: str = Field(default='-MX', frozen=True)
     product_number:str|None =   Field(              alias='240')
     batch_number:str|None =     Field(default=None, alias='10')
     packaging_size:str|None =     Field(default=None, alias='20')
@@ -187,15 +187,63 @@ class Data_Static(Data_Abstract):
     additional_segments: list[IDSegment] = Field(default_factory=list, exclude=True)
     ''' Category segments, which are not defined in the specification'''
     
+class Data_Misc(Data_Abstract):
+    '''Represents the -DX category'''
+    key: str = Field(default='-DX', frozen=True)
+    id:str|None =                    Field(              alias='21')
+    additional_segments: list[IDSegment] = Field(default_factory=list, exclude=True)
+    ''' Category segments, which are not defined in the specification'''
+    
+
+
+
+class Processor_Abstract(PredefinedCategory, ABC):
+    '''@private'''
+    key: str
+    processor_instance:str|None =                    Field(              alias='21')
+    processor_code:str|None =                        Field(              alias='240')
+    additional_segments: list[IDSegment] = Field(default_factory=list, exclude=True)
+    ''' Category segments, which are not defined in the specification'''
+    
+    @model_validator(mode='after')
+    def _validate_mandatory_fields(self):
+        if not self.id:
+            self._add_validation_message(
+                    source=f"Category {self.key}",
+                    level = ValidationMsgLevel.ERROR,
+                    msg=f"Category key {self.key} is missing mandatory field 'processor instance'",
+                    highlight_pattern = f"{self.key}"
+            )
+        return self
+
+class Processor_Software(Processor_Abstract):
+    '''Represents the -PS category'''
+    key: str = Field(default='-PS', frozen=True)
+    processor_instance:str|None =                    Field(              alias='21')
+    processor_code:str|None =                        Field(              alias='240')
+    additional_segments: list[IDSegment] = Field(default_factory=list, exclude=True)
+    ''' Category segments, which are not defined in the specification'''
+
+class Processor_Misc(Processor_Abstract):
+    '''Represents the -PX category'''
+    key: str = Field(default='-PX', frozen=True)
+    processor_instance:str|None =                    Field(              alias='21')
+    processor_code:str|None =                        Field(              alias='240')
+    additional_segments: list[IDSegment] = Field(default_factory=list, exclude=True)
+    ''' Category segments, which are not defined in the specification'''
+    
     
 category_key_to_class_map  = {
         '-MD': Material_Device,
         '-MS': Material_Substance,
         '-MC': Material_Consumable,
-        '-MM': Material_Misc,
+        '-MX': Material_Misc,
         '-DM': Data_Method,
         '-DR': Data_Result,
         '-DC': Data_Calibration,
         '-DP': Data_Progress,
-        '-DS': Data_Static 
+        '-DS': Data_Static,
+        '-DX': Data_Misc,
+        '-PS': Processor_Software,
+        '-PX': Processor_Misc
 }

labfreed-1.0.0a4/labfreed/pac_attributes/pythonic/py_attributes.py

@@ -1,133 +0,0 @@
-
-from datetime import date, datetime, time
-import json
-from typing import  Literal
-import warnings
-from pydantic import RootModel
-
-from labfreed.labfreed_infrastructure import LabFREED_BaseModel
-from labfreed.pac_attributes.api_data_models.response import AttributeBase, AttributeGroup, BoolAttribute, DateTimeAttribute,  NumericAttribute, NumericValue, ObjectAttribute, ReferenceAttribute, TextAttribute
-from labfreed.pac_attributes.client.attribute_cache import CacheableAttributeGroup
-from labfreed.pac_id.pac_id import PAC_ID
-from labfreed.trex.pythonic.quantity import Quantity
-
-
-class pyReference(RootModel[str]):
-    pass
-
-    def __str__(self):
-        return str(self.root)
-
-
-class pyAttribute(LabFREED_BaseModel):
-    key:str
-    label:str = ""
-    value: str|bool|datetime|pyReference|Quantity|int|float|dict|object
-    valid_until: datetime | Literal["forever"] | None = None
-    observed_at: datetime | None = None
-    
-          
-
-class pyAttributes(RootModel[list[pyAttribute]]):
-    def to_payload_attributes(self) -> list[AttributeBase]:
-        return [self._attribute_to_attribute_payload_type(e) for e in self.root]
-    
-            
-    @staticmethod        
-    def _attribute_to_attribute_payload_type(attribute:pyAttribute) -> AttributeBase:
-        common_args = {
-            "key": attribute.key,
-            "label": attribute.label,
-            "observed_at": attribute.observed_at
-        }
-        value = attribute.value
-        
-        if isinstance(value, bool):
-            return  BoolAttribute(value=value, **common_args)
-            
-        elif isinstance(value, datetime | date | time):
-            if not value.tzinfo:
-                warnings.warn(f'No timezone given for {value}. Assuming it is in UTC.')
-            return DateTimeAttribute(value =value, **common_args)
-            # return DateTimeAttribute(value =_date_value_from_python_type(value).value, **common_args)
-            
-           
-        elif isinstance(attribute.value, Quantity|int|float):
-            if not isinstance(attribute.value, Quantity):
-                value = Quantity(value=attribute.value, unit='dimensionless')
-            num_attribute = NumericAttribute(value = NumericValue(numerical_value=value.value_as_str(), 
-                                             unit = value.unit),
-                                              **common_args)
-            num_attribute.print_validation_messages()
-            return num_attribute
-        
-        elif isinstance(value, str):
-            # capture quantities in the form of "100.0e5 g/L"
-            if q := Quantity.from_str_with_unit(value):
-                return NumericAttribute(value = NumericValue(numerical_value=q.value_as_str(), 
-                                             unit = q.unit),
-                                              **common_args)
-            else:
-                return TextAttribute(value = value, **common_args)
-            
-        elif isinstance(value, pyReference):
-            return ReferenceAttribute(value = value.root, **common_args)
-            
-        elif isinstance(value, PAC_ID):
-            return ReferenceAttribute(value = value.to_url(include_extensions=False), **common_args)
-        
-        
-        
-        else: #this covers the last resort case of arbitrary objects. Must be json serializable.
-            try :
-                value = json.loads(json.dumps(value))
-                return ObjectAttribute(value=value, **common_args)
-            except TypeError as e:  # noqa: F841
-                raise ValueError(f'Invalid Type: {type(value)} cannot be converted to attribute. You may want to use ObjectAttribute, but would have to implement the conversion from your python type yourself.')
-        
-        
-    @staticmethod
-    def from_payload_attributes(attributes:list[AttributeBase]) -> 'pyAttributes':
-        out = list()
-        for a in attributes:
-            match a:
-                
-                case ReferenceAttribute():
-                    value =  pyReference(a.value)
-                    
-                case NumericAttribute():                                       
-                    value = Quantity.from_str_value(value=a.value.numerical_value, unit=a.value.unit)
-
-                case BoolAttribute():
-                    value = a.value
-                    
-                case TextAttribute():
-                    value = a.value
-                    
-                case DateTimeAttribute():                    
-                    value = a.value
-                
-                case ObjectAttribute():
-                    value = a.value
-
-                       
-            attr = pyAttribute(key=a.key, 
-                               label=a.label,
-                               value=value,
-                               observed_at=a.observed_at
-                            #    valid_until=datetime(**_parse_date_time_str(a.valid_until)),
-                            #    observed_at=datetime(**_parse_date_time_str(a.value))
-            )
-            out.append(attr )
-        return out
-            
-            
-        
-class pyAttributeGroup(CacheableAttributeGroup):
-    attributes:dict[str,pyAttribute]
-    
-    @staticmethod
-    def from_attribute_group(attribute_group:AttributeGroup):
-        data = vars(attribute_group).copy()
-        data["attributes"] = {a.key: a for a in pyAttributes.from_payload_attributes(attribute_group.attributes)}
-        return pyAttributeGroup(**data)