labfreed 0.2.12__py3-none-any.whl → 0.3.0a1__py3-none-any.whl

labfreed/pac_attributes/api_data_models/response.py

@@ -0,0 +1,184 @@
+
+from abc import ABC
+from datetime import  datetime
+import re
+from typing import Annotated, Any,  Literal, Union, get_args
+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
+
+
+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."""
+        try:
+            type_annotation = cls.__annotations__["type"]
+            literal_value = get_args(type_annotation)[0]
+            return literal_value
+        except Exception as e:
+            raise TypeError(
+                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
+    
+    @field_validator('value', mode='before')
+    def set_utc__if_naive(cls, value):
+        if isinstance(value, datetime):
+            return ensure_utc(value)
+        else:
+            return value
+    
+class BoolAttribute(AttributeBase):
+    type: Literal["bool"] 
+    value: bool
+    
+class TextAttribute(AttributeBase):
+    type: Literal["text"] 
+    value: str
+    
+    
+    
+        
+class NumericValue(LabFREED_BaseModel):
+    magnitude: str
+    unit: str
+    
+    @model_validator(mode='after')
+    def _validate_value(self):
+        value = self.magnitude
+        if not_allowed_chars := set(re.sub(r'[0-9\.\-\+Ee]', '', value)):
+            self._add_validation_message(
+                source="Numeric Attribute",
+                level=ValidationMsgLevel.ERROR,  # noqa: F821
+                msg=f"Characters {_quote_texts(not_allowed_chars)} are not allowed in quantity segment. Must be a number.",
+                highlight_pattern = f'{value}',
+                highlight_sub=not_allowed_chars
+            )
+        if not re.fullmatch(r'-?\d+(\.\d+)?([Ee][\+-]?\d+)?', value):
+            self._add_validation_message(
+                source="Numeric Attribute",
+                level=ValidationMsgLevel.ERROR,
+                msg=f"{value} cannot be converted to number",
+                highlight_pattern = f'{value}'               
+            )
+        return self
+    
+    @model_validator(mode="after")
+    def _validate_units(self):
+        '''A sanity check on unit complying with UCUM. NOTE: It is not a complete validation
+        - I check for blankspaces and ^, which are often used for units, but are invalid.
+        - the general structure of a ucum unit is validated, but 1)parentheses are not matched 2) units are not validated 3)prefixes are not checked
+        '''
+        if ' ' in self.unit or '^' in self.unit:
+            self._add_validation_message(
+                    source="Numeric Attribute",
+                    level= ValidationMsgLevel.ERROR,
+                    msg=f"Unit {self.unit} is invalid. Must not contain blankspace  or '^'.",
+                    highlight_pattern = self.unit
+            )
+        elif not re.fullmatch(r"^(((?P<unit>[\w\[\]]+?)(?P<exponent>\-?\d+)?|(?P<annotation>)\{\w+?\})(?P<operator>[\./]?)?)+", self.unit):
+            self._add_validation_message(
+                    source="Numeric Attribute",
+                    level= ValidationMsgLevel.WARNING,
+                    msg=f"Unit {self.unit} is probably invalid. Ensure it complies with UCUM specifications.",
+                    highlight_pattern = self.unit
+            )
+        return self
+    
+    
+
+
+class NumericAttribute(AttributeBase):
+    type: Literal["numeric"] 
+    value: NumericValue
+    
+class ObjectAttribute(AttributeBase):
+    type: Literal["object"] 
+    value: dict[str, Any]
+           
+
+     
+     
+Attribute = Annotated[
+    Union[
+        ReferenceAttribute,
+        DateTimeAttribute,
+        BoolAttribute,
+        TextAttribute,
+        NumericAttribute,
+        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):
+    pac_url: str
+    attribute_groups: list[AttributeGroup]
+    
+    
+
+class AttributeResponsePayload(LabFREED_BaseModel):
+    schema_version: str = Field(default='1.0')
+    language:str 
+    pac_attributes: list[AttributesOfPACID]      
+    
+    def to_json(self):
+        return self.model_dump_json(exclude_none=True)
+    
+    
+
+
+
+
+
+
+
+

labfreed/pac_attributes/api_data_models/server_capabilities_response.py

@@ -0,0 +1,7 @@
+from pydantic import BaseModel
+
+
+class ServerCapabilities(BaseModel):
+    supported_languages: list[str]
+    default_language: str
+    available_attribute_groups: list[str]

labfreed/pac_attributes/client/__init__.py

@@ -0,0 +1 @@
+import labfreed.utilities.translations

labfreed/pac_attributes/client/attribute_cache.py

@@ -0,0 +1,78 @@
+
+
+from datetime import datetime
+from typing import Literal, Protocol
+
+
+from labfreed.pac_attributes.api_data_models.response import AttributeGroup
+from labfreed.pac_id.pac_id import PAC_ID
+
+
+
+class CacheableAttributeGroup(AttributeGroup):
+    origin:str
+    language:str
+    valid_until: Literal['forever'] | 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:
+            return False
+        if self.valid_until == 'forever':
+            return True
+        
+        return self.valid_until > datetime.now()
+
+
+
+
+class AttributeCache(Protocol):
+    def get_all(self, service_url:str, pac:PAC_ID) -> list[CacheableAttributeGroup]:
+        pass
+    
+    def get_attribute_groups(self, service_url:str, pac:PAC_ID, attribute_groups:list[str]):
+        pass
+        
+    def update(self, service_url:str, pac:PAC_ID, attribute_groups:list[CacheableAttributeGroup]):
+        pass
+    
+
+            
+class MemoryAttributeCache(AttributeCache):
+    '''simple in-memory implementation of AttributeCache'''
+    def __init__(self):
+        self._store = dict()
+    
+    def get_all(self, service_url:str, pac:PAC_ID|str) -> list[CacheableAttributeGroup]:
+        if isinstance(pac, str):
+            pac = PAC_ID.from_url(pac)
+        k = self._generate_dict_key(service_url=service_url, pac=pac)
+        
+        ags = [CacheableAttributeGroup.model_validate(e) for e in self._store.get(k, [])]
+        return ags
+    
+    def get_attribute_groups(self, service_url:str, pac:PAC_ID, attribute_groups:list[str]):
+        all_ags = self.get_all(service_url=service_url, pac=pac)
+        selected_ags = [ag for ag in all_ags if ag.key in attribute_groups]
+        return selected_ags
+        
+    def update(self, service_url:str, pac:PAC_ID, attribute_groups: list[CacheableAttributeGroup] ):
+        k = self._generate_dict_key(service_url=service_url, pac=pac)
+        self._store.update({k: [e.model_dump() for e in attribute_groups]})
+    
+    @staticmethod
+    def _generate_dict_key(service_url:str, pac:PAC_ID):
+        key = service_url +";"+ pac.to_url(include_extensions=False) 
+        return key

labfreed/pac_attributes/client/client.py

@@ -0,0 +1,148 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Protocol, runtime_checkable
+
+import requests
+
+from pydantic import ValidationError
+
+from labfreed.pac_attributes.api_data_models.request import AttributeRequestPayload
+from labfreed.pac_attributes.api_data_models.response import AttributeResponsePayload
+from labfreed.pac_attributes.client.attribute_cache import AttributeCache, CacheableAttributeGroup
+from labfreed.pac_id.pac_id import PAC_ID
+
+
+class AuthenticationError(Exception):
+    '''Server rejected authentication. '''
+    pass
+
+class AttributeClientInternalError(Exception):
+    '''The error is on client side. Possibly a bug on client side'''
+    pass
+
+class AttributeServerError(Exception):
+    '''The error is on server side. Needs to contact the server admin'''
+    pass
+
+
+
+@runtime_checkable
+class AttributeRequestCallback(Protocol):
+    def __call__(self, url: str, attribute_request_body: str) -> tuple[int, str]:
+        '''handle the request
+        returns a tuple of HTTP status code and the body of the response or an error message'''
+        ...
+
+
+def attribute_request_default_callback_factory(session: requests.Session = None) -> AttributeRequestCallback:
+    """ Returns a default implementation of AttributeRequestCallback using `requests` package.
+
+    Args:
+        session (requests.Session, optional): A requests.Session object. Pass such an object if you need control over authentication and such things. If omitted a default Session is used.
+
+    Returns:
+        AttributeRequestCallback: a callback following the AttributeRequestCallback protocol.
+    """
+    if session is None:
+        session = requests.Session()
+
+    def callback(url: str, attribute_request_body: str) -> tuple[int, str]:
+        try:
+            resp = session.post(url, data=attribute_request_body, headers={'Content-Type': 'application/json'})
+            return resp.status_code, resp.text
+        except requests.exceptions.RequestException as e:
+            return 500, str(e)
+    return callback
+
+        
+    
+
+@dataclass 
+class AttributeClient():
+    """ Client handling attribute requests and caching thereof.
+    """
+
+    http_post_callback:AttributeRequestCallback
+    cache_store:AttributeCache
+                
+    def get_attributes(self, 
+                       server_url:str, 
+                       pac_id:PAC_ID|str, 
+                       restrict_to_attribute_groups:list[str]|None=None, 
+                       language_preferences:list[str]|None=None,
+                       force_server_request=False
+                       ) -> list[CacheableAttributeGroup]:
+        """gets the attributes from one attribute server for one PAC-ID. Uses a cached version if possible, otherwise requests from the server again.
+
+        Args:
+            server_url (str): _description_
+            pac_id (PAC_ID | str): _description_
+            restrict_to_attribute_groups (list[str] | None, optional): _description_. Defaults to None.
+            language_preferences (list[str] | None, optional): _description_. Defaults to None.
+            force_server_request (bool, optional): _description_. Defaults to False.
+
+        Raises:
+            AuthenticationError: 
+            AttributeClientInternalError: 
+            AttributeServerError: 
+
+        Returns:
+            list[CacheableAttributeGroup]: attribute groups for the PAC-ID
+        """
+        if isinstance(pac_id, str):
+            pac_id = PAC_ID.from_url(pac_id)
+        
+        # try the cache
+        if not force_server_request: 
+            if restrict_to_attribute_groups:
+                attribute_groups = self.cache_store.get_attribute_groups(server_url, pac_id, restrict_to_attribute_groups)
+            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]): 
+                return attribute_groups
+        
+        # no valid data found in cache > request to server
+        attribute_request_body = AttributeRequestPayload(pac_urls=[pac_id.to_url()], 
+                                                            restrict_to_attribute_groups=restrict_to_attribute_groups,
+                                                            language_preferences=language_preferences
+                                )
+        response_code, response_body_str = self.http_post_callback(server_url, attribute_request_body.model_dump_json())
+
+        if response_code == 400:
+            raise AttributeClientInternalError(f"The server did not accept the request. Server message: '{response_body_str}'")
+        if response_code == 401:
+            raise AuthenticationError(f"Failed to authorize at the server. Server message: {response_body_str}")
+        if response_code == 500:
+            raise AttributeServerError(f"The server accepted the request, but encountered an internal error. Contact the server admin. Server message: {response_body_str}")
+        try: 
+            r = AttributeResponsePayload.model_validate_json(response_body_str)
+        except ValidationError as e:
+            print(e)
+            raise AttributeServerError("The server accepted the request, and sent a reponse. However, the response is adhering to the PAC Attributes specifications. Contact the server admin.")
+
+        
+        # update cache
+        for ag_for_pac in r.pac_attributes:
+            pac = PAC_ID.from_url(ag_for_pac.pac_url)
+            ags = [
+                CacheableAttributeGroup(
+                    key= ag.key, 
+                    attributes=ag.attributes, 
+                    origin=server_url, 
+                    language=r.language, 
+                    label=ag.label,
+                    state_of=ag.state_of) 
+                for ag in ag_for_pac.attribute_groups
+                ]
+            self.cache_store.update(server_url, pac, ags)
+            
+            if pac_id == pac:
+                attribute_groups_out = ags
+        return attribute_groups_out
+            
+                
+    
+
+

labfreed/pac_attributes/server/attribute_data_sources.py

@@ -0,0 +1,69 @@
+from abc import ABC, abstractmethod, abstractproperty
+from datetime import datetime, timezone
+from labfreed.pac_attributes.api_data_models.response import VALID_FOREVER, AttributeGroup
+from labfreed_extended.pac_attributes.py_attributes import pyAttributes
+
+
+class AttributeGroupDataSource(ABC):
+    
+    def __init__(self, attribute_group_key:str, include_extensions:bool=False, is_static:bool=False, ):
+        self._attribute_group_key = attribute_group_key
+        self._include_extensions = include_extensions
+        self._is_static = is_static
+       
+    @property
+    def is_static(self) -> bool:
+        return self._is_static
+    
+    
+    @property
+    def attribute_group_key(self):
+        return self._attribute_group_key
+    
+    @abstractproperty
+    def provides_attributes(self):
+        pass
+    
+    @abstractmethod
+    def attributes(self, pac_url: str) -> AttributeGroup:
+        pass
+    
+
+class Dict_DataSource(AttributeGroupDataSource):
+    def __init__(self, data:dict[str, pyAttributes], *args, **kwargs):
+        if not all([isinstance(e, pyAttributes) for e in data.values()]):
+            raise ValueError('Invalid data')
+        self._data:pyAttributes = data
+        self._state_of = datetime.now(tz=timezone.utc)
+        
+        super().__init__(*args, **kwargs)       
+        
+    
+    @property
+    def provides_attributes(self):
+        return [a.key for attributes in self._data.values() for a in attributes.root]
+    
+           
+    def attributes(self, pac_url: str) -> AttributeGroup:
+        if not self._include_extensions:
+            pac_url = pac_url.split('*')[0]
+        
+        attributes:pyAttributes = self._data.get(pac_url)
+        if not attributes:
+            return None
+        attributes = attributes.to_payload_attributes()
+        
+        
+        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)
+        
+        
+        
+
+    
+