labfreed 1.0.0a25__py3-none-any.whl → 1.0.0b26__py3-none-any.whl

labfreed/pac_attributes/api_data_models/response.py

@@ -2,40 +2,47 @@
 from abc import ABC
 from datetime import  datetime
 import re
-from typing import Annotated, Any,  Literal, Union, get_args
+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
+from pydantic import   BaseModel, Field, field_validator, model_validator
 
 
-class AttributeBase(LabFREED_BaseModel, ABC):
-    key: str
+
+class AttributeItemsElementBase(LabFREED_BaseModel, ABC):
     value: Any
-    label: str = ""
-        
-    def __init__(self, **data):
-        # Automatically inject the Literal value for `type`
-        discriminator_value = self._get_discriminator_value()
-        data["type"] = discriminator_value
-        super().__init__(**data)       
+    type:str
     
-    @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
+    @model_validator(mode="after")
+    def _no_base_instances(self):
+        if type(self) is AttributeItemsElementBase:
+            raise TypeError("AttributeItemsElementBase must not be instantiated")
+        return self
         
+    # def __init__(self, **data):
+    #     # Automatically inject the Literal value for `type`
+    #     discriminator_value = self._get_discriminator_value()
+    #     data["type"] = discriminator_value
+    #     super().__init__(**data)       
+    
+    # @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 DateTimeAttribute(AttributeBase):
-    type: Literal["datetime"] 
+class DateTimeAttributeItemsElement(AttributeItemsElementBase):
+    type: Literal["datetime"] = "datetime"
     value: datetime
     
     @field_validator('value', mode='after')
@@ -45,53 +52,24 @@ class DateTimeAttribute(AttributeBase):
         else:
             return value
         
-class DateTimeListAttribute(AttributeBase):
-    type: Literal["datetime-list"] 
-    value: list[datetime]
-    
-    @field_validator('value', mode='after')
-    def set_utc__if_naive(cls, value):
-        value_out = []
-        for v in value:
-            if isinstance(v, datetime):
-                value_out.append(ensure_utc(v))
-            else:
-                raise ValueError(f'{v} is of type {type(v)}. It must be datetime')
-        return value_out
     
     
-    
-class BoolAttribute(AttributeBase):
-    type: Literal["bool"] 
+class BoolAttributeItemsElement(AttributeItemsElementBase):
+    type: Literal["bool"] = "bool"
     value: bool
     
-class BoolListAttribute(AttributeBase):
-    type: Literal["bool-list"] 
-    value: list[bool]
-
 
 
     
-class TextAttribute(AttributeBase):
-    type: Literal["text"] 
+class TextAttributeItemsElement(AttributeItemsElementBase):
+    type: Literal["text"] = "text"
     value: str
     
     @model_validator(mode='after')
     def _validate_value(self):
         _validate_text(self, self.value)
         return self
-    
-class TextListAttribute(AttributeBase):
-    type: Literal["text-list"] 
-    value: 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:
-            _validate_text(self, v)
-        return self
-    
+       
 
 def _validate_text(mdl:LabFREED_BaseModel, v):
     if len(v) > 5000: 
@@ -104,19 +82,14 @@ def _validate_text(mdl:LabFREED_BaseModel, v):
             
 
 
-class ReferenceAttribute(AttributeBase):
-    type: Literal["reference"]
+class ReferenceAttributeItemsElement(AttributeItemsElementBase):
+    type: Literal["reference"] = "reference"
     value: str 
     
-class ReferenceListAttribute(AttributeBase):
-    type: Literal["reference-list"]
-    value: list[str]
-    
-    
-        
+          
 
-class ResourceAttribute(AttributeBase):
-    type: Literal["resource"]
+class ResourceAttributeItemsElement(AttributeItemsElementBase):
+    type: Literal["resource"] = "resource"
     value: str 
     
     @model_validator(mode='after')
@@ -124,16 +97,6 @@ class ResourceAttribute(AttributeBase):
         _validate_resource(self, self.value)
         return self
 
-class ResourceListAttribute(AttributeBase):
-    type: Literal["resource-list"]
-    value: 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:
-            _validate_resource(self, v)
-        return self
     
 def _validate_resource(mdl:LabFREED_BaseModel, v):
     r = urlparse(v)
@@ -153,15 +116,23 @@ def _validate_resource(mdl:LabFREED_BaseModel, v):
             highlight_pattern = f'{v}'
         )
     
-        
-        
-class NumericValue(LabFREED_BaseModel):
-    numerical_value: str
-    unit: str
+
+class NumericAttributeItemsElement(AttributeItemsElementBase):
+    type: Literal["numeric"] = "numeric"
+    value: str 
+    _numerical_value:str
+    _unit:str
     
     @model_validator(mode='after')
+    def _validate_model(self):
+        self._numerical_value, self._unit = self.value.split(' ', 1)
+        self._validate_value()
+        self._validate_unit()
+        return self
+
+    
     def _validate_value(self):
-        value = self.numerical_value
+        value = self._numerical_value
         if not_allowed_chars := set(re.sub(r'[0-9\.\-\+Ee]', '', value)):
             self._add_validation_message(
                 source="Numeric Attribute",
@@ -177,81 +148,76 @@ class NumericValue(LabFREED_BaseModel):
                 msg=f"{value} cannot be converted to number",
                 highlight_pattern = f'{value}'               
             )
-        return self
     
-    @model_validator(mode="after")
-    def _validate_units(self):
+    def _validate_unit(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:
+        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
+                    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):
+        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
+                    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 NumericListAttribute(AttributeBase):
-    type: Literal["numeric-list"] 
-    value: list[NumericValue]
-    
     
-    
-class ObjectAttribute(AttributeBase):
-    type: Literal["object"] 
+class ObjectAttributeItemsElement(AttributeItemsElementBase):
+    type: Literal["object"] = "object"
     value: dict[str, Any]
     
     
-class ObjectListAttribute(AttributeBase):
-    type: Literal["object-list"] 
-    value: list[dict[str, Any]]
-           
-
-     
-     
-Attribute = Annotated[
+AttributeItemsElement = Annotated[
     Union[
-        ReferenceAttribute,
-        DateTimeAttribute,
-        BoolAttribute,
-        TextAttribute,
-        NumericAttribute,
-        ResourceAttribute,
-        ObjectAttribute,
-        
-        ReferenceListAttribute,
-        DateTimeListAttribute,
-        BoolListAttribute,
-        TextListAttribute,
-        NumericListAttribute,
-        ResourceListAttribute,
-        ObjectListAttribute
+        DateTimeAttributeItemsElement,
+        BoolAttributeItemsElement,
+        TextAttributeItemsElement,
+        NumericAttributeItemsElement,
+        ReferenceAttributeItemsElement,
+        ResourceAttributeItemsElement,
+        ObjectAttributeItemsElement
     ],
-    Field(discriminator="type")
+    Field(discriminator="type"),
 ]
+    
 
+           
+class Attribute(LabFREED_BaseModel):
+    key: str|None = Field(exclude=True)
+    label: str = ""
+    items: list[AttributeItemsElement]
+    
+     
 
 class AttributeGroup(LabFREED_BaseModel):
-    key: str
-    label: str = ""
-    attributes: list[Attribute]
+    group_key: str
+    group_label: str = ""
+    attributes: dict[str, Attribute]
+    
+    @field_validator("attributes", mode="before")
+    @classmethod
+    def set_attribute_keys(cls, v):
+        if not isinstance(v, dict):
+            return v
+
+        out = {}
+        for k, a in v.items():
+            if isinstance(a, dict):
+                # raw input dict -> inject key if missing
+                out[k] = {**a, "key": a.get("key") or k}
+            else:
+                # already an Attribute (or something pydantic can parse)
+                out[k] = a
+        return out
        
 
 
@@ -260,14 +226,19 @@ class AttributesOfPACID(LabFREED_BaseModel):
     attribute_groups: list[AttributeGroup]
     
     
+    
+IMPORT_URL = "https://vocab.labfreed.org/attributes/v1.jsonld"
 
 class AttributeResponsePayload(LabFREED_BaseModel):
     schema_version: str = Field(default='1.0')
     language:str 
-    pac_attributes: list[AttributesOfPACID]      
+    data: list[AttributesOfPACID]    
+    
+    context: str = Field(alias='@context', default=IMPORT_URL)
+      
     
     def to_json(self):
-        return self.model_dump_json(exclude_none=True)
+        return self.model_dump_json(exclude_none=True, by_alias=True)
     
     
 

labfreed/pac_attributes/client/client.py

@@ -3,14 +3,16 @@ from __future__ import annotations
 from dataclasses import dataclass
 from datetime import UTC, datetime
 from typing import Protocol, runtime_checkable
+from urllib.parse import quote
+import warnings
 
 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_attributes.api_data_models.request import AttributeRequestData
+from labfreed.pac_attributes.api_data_models.response import AttributeGroup, AttributeResponsePayload
+from labfreed.pac_attributes.client.client_attribute_group import ClientAttributeGroup
 from labfreed.pac_attributes.server.server import AttributeServerRequestHandler
 from labfreed.pac_id.pac_id import PAC_ID
 
@@ -31,7 +33,7 @@ class AttributeServerError(Exception):
 
 @runtime_checkable
 class AttributeRequestCallback(Protocol):
-    def __call__(self, url: str, attribute_request_body: str) -> tuple[int, str]:
+    def __call__(self, url: str, attribute_request_data: AttributeRequestData) -> tuple[int, str]:
         '''handle the request
         returns a tuple of HTTP status code and the body of the response or an error message'''
         ...
@@ -49,9 +51,14 @@ def http_attribute_request_default_callback_factory(session: requests.Session =
     if session is None:
         session = requests.Session()
 
-    def callback(url: str, attribute_request_body: str) -> tuple[int, str]:
+    def callback(url: str, attribute_request_data: AttributeRequestData) -> tuple[int, str]:
         try:
-            resp = session.post(url, data=attribute_request_body, headers={'Content-Type': 'application/json; ; charset=utf-8'}, timeout=10)
+            url = url + '/' + quote(attribute_request_data.pac_id, safe='')
+            params = attribute_request_data.request_params()           
+            resp = session.get(url, 
+                               params = params,
+                               headers=attribute_request_data.language_preference_http_header(),
+                               timeout=10)
             return resp.status_code, resp.text
         except requests.exceptions.RequestException as e:
             return 500, str(e)
@@ -68,9 +75,9 @@ def local_attribute_request_callback_factory(request_handler:AttributeServerRequ
         AttributeRequestCallback: a callback following the AttributeRequestCallback protocol.
     """
 
-    def callback(url: str, attribute_request_body: str) -> tuple[int, str]:
+    def callback(url: str, attribute_request_data: AttributeRequestData) -> tuple[int, str]:
         try:
-            resp = request_handler.handle_attribute_request(attribute_request_body)
+            resp = request_handler.handle_attribute_request(attribute_request_data)
             return 200, resp
         except requests.exceptions.RequestException as e:
             return 500, str(e)
@@ -83,18 +90,14 @@ def local_attribute_request_callback_factory(request_handler:AttributeServerRequ
 class AttributeClient():
     """ Client handling attribute requests and caching thereof.
     """
-
     http_post_callback:AttributeRequestCallback
-    cache_store:AttributeCache
-    always_use_cached_value_for_minutes:int
-                
+                   
     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]:
+                       language_preferences:list[str]|None=None
+                       ) -> list[AttributeGroup]:
         """gets the attributes from one attribute server for one PAC-ID. Uses a cached version if possible, otherwise requests from the server again.
 
         Args:
@@ -114,28 +117,21 @@ class AttributeClient():
         """
         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(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
-        attribute_request_body = AttributeRequestPayload(pac_ids=[pac_id.to_url()], 
-                                                            restrict_to_attribute_groups=restrict_to_attribute_groups,
-                                                            language_preferences=language_preferences
+        attribute_request_body = AttributeRequestData(pac_id=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())
+        response_code, response_body_str = self.http_post_callback(server_url, attribute_request_body)
 
         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 == 404:
+            print(f'No atributes found for {pac_id.to_url()}')
+            return []
         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: 
@@ -145,21 +141,19 @@ class AttributeClient():
             raise AttributeServerError("The server accepted the request, and sent a reponse. However, the response is not adhering to the PAC Attributes specifications. Contact the server admin.")
 
         
-        # update cache
         attribute_groups_out = []
-        for ag_for_pac in r.pac_attributes:
+        for ag_for_pac in r.data:
             pac_from_response = PAC_ID.from_url(ag_for_pac.pac_id)
             ags = [
-                CacheableAttributeGroup(
-                    key= ag.key, 
+                ClientAttributeGroup(
+                    group_key= ag.group_key, 
                     attributes=ag.attributes, 
                     origin=server_url, 
                     language=r.language, 
-                    label=ag.label,
-                    value_from=datetime.now(tz=UTC)) 
+                    group_label=ag.group_label
+                    ) 
                 for ag in ag_for_pac.attribute_groups
                 ]
-            self.cache_store.update(server_url, pac_from_response, ags)
             
             # compare pac_id from response with pac_id we need attributes for.
             # if identical this is the part of the response we care about. other PAC-ID are just for the cache

labfreed/pac_attributes/client/client_attribute_group.py

@@ -0,0 +1,18 @@
+
+
+from datetime import UTC, datetime, timedelta
+
+
+from labfreed.pac_attributes.api_data_models.response import AttributeGroup
+from labfreed.pac_id.pac_id import PAC_ID
+
+
+
+class ClientAttributeGroup(AttributeGroup):
+    ''' extends attribute group with info the client needs'''
+    origin:str
+    language:str
+    value_from: datetime | None = None  
+    
+
+

labfreed/pac_attributes/pythonic/attribute_server_factory.py

@@ -1,8 +1,11 @@
 from enum import Enum
+import json
+import logging
 from typing import Any, Protocol
+from urllib.parse import unquote, unquote_plus
 
-from flask import Blueprint, current_app, url_for
-from labfreed.pac_attributes.api_data_models.request import AttributeRequestPayload
+from flask import Blueprint, current_app, redirect, url_for
+from labfreed.pac_attributes.api_data_models.request import AttributeRequestData
 from labfreed.pac_attributes.server.server import AttributeGroupDataSource, AttributeServerRequestHandler, InvalidRequestError, TranslationDataSource
 
 try:
@@ -70,16 +73,22 @@ class AttributeFlaskApp(Flask):
     ) -> Blueprint:
         bp = Blueprint("attribute", __name__)
 
-        @bp.route("/", methods=["POST"], strict_slashes=False)
-        def handle_attribute_request():
+
+        @bp.get("/<path:pac_id_url_encoded>", strict_slashes=False)
+        def handle_attribute_request(pac_id_url_encoded):
+            if pac_id_url_encoded in ['favicon.ico']:
+                return ''
+            
             if authenticator and not authenticator(request):
                 return Response(
                     "Unauthorized", 401,
                     {"WWW-Authenticate": 'Basic realm="Login required"'}
                 )
             try:
-                json_request_body = request.get_data(as_text=True)
-                response_body = request_handler.handle_attribute_request(json_request_body)
+                request_data = AttributeRequestData.from_http_request(pac_id = pac_id_url_encoded,
+                                                                      params = request.args,
+                                                                     headers = request.headers)
+                response_body = request_handler.handle_attribute_request(request_data)
             except InvalidRequestError as e:
                 print(e)
                 return "Invalid request", 400
@@ -87,14 +96,26 @@ class AttributeFlaskApp(Flask):
                 print(e)
                 return "The request was valid, but the server encountered an error", 500
             return (response_body, 200, {"Content-Type": "application/json; charset=utf-8"})
-
-        @bp.route("/", methods=["GET"], strict_slashes=False)
+        
+        
+        @bp.post("/", strict_slashes=False)
+        def handle_attribute_request_legacy(pac_id):
+            if request.method == 'POST':
+                return '\n'.join(('POST request was part of the DRAFT specification, but was changed to GET.',
+                                  'You are probably using an pre-release version of the python package.',
+                                  'update to the newest version "pip install labfreed"'
+                                  )
+                )
+        
+        
+        @bp.get("/",  strict_slashes=False)
+        @bp.get("/capabilities",  strict_slashes=False)
         def capabilities():
             doc_text = current_app.config.get('DOC_TEXT', "") 
             capabilities = request_handler.capabilities()
             authentication_required = bool(current_app.config.get('AUTHENTICATOR'))
-            example_request = AttributeRequestPayload(pac_ids=['HTTPS://PAC.METTORIUS.COM/EXAMPLE'], language_preferences=['fr', 'de']).model_dump_json(indent=2, exclude_none=True, exclude_unset=True)
-            server_address = request.url.rstrip('/')
+            example_request = AttributeRequestData(pac_id='HTTPS://PAC.METTORIUS.COM/EXAMPLE', language_preferences=['fr', 'de']).model_dump_json(indent=2, exclude_none=True, exclude_unset=True)
+            server_address = request.url.replace('/capabilities','').rstrip('/')
             css_url = url_for("static", filename="style.css")
             response = f'''
                 <html>
@@ -112,12 +133,17 @@ class AttributeFlaskApp(Flask):
                         
 
                         <h2>How to use</h2>
-                        Make a <b>POST</b> request to <a href="{server_address}">{server_address}</a> with the following body:
-                        <pre>{example_request}</pre>
+                        Make a <b>GET</b> request to <a href="{server_address}">{server_address}/<url encoded PAC-ID> </a> 
+                        <br><br>
+                        Query parameters (optional):<br>
+                          attr_grps (optional): An comma separated list of attribute group keys. MUST be url-encoded.  <br>
+                          attr_fwd_lkp (optional): Boolean flag ('true' or 'false'). Instructs the server to not include attributes of PAC-IDs which are attributes of type reference of the requested PAC-ID. Defaults to true <br>
+                        
+                        <br>
                         Consult <a href="https://github.com/ApiniLabs/PAC-Attributes"> the specification </a> for details. <br>
 
                         
-                        {'This server <b> requires authentication </b> ' if authentication_required else ''}  
+                        {'<h2> Authentication </h2> This server <b> requires authentication </b> ' if authentication_required else ''}  
                         <br>
                         
                         {"<h2>Further Information</h2>"if doc_text else ""} 

labfreed/pac_attributes/pythonic/excel_attribute_data_source.py

@@ -120,7 +120,7 @@ class _BaseExcelAttributeDataSource(AttributeGroupDataSource):
             return None
         attributes = [pyAttribute(key= self._header_mappings.get(k, k), value=v) for k, v in d.items() if v is not None]
         return AttributeGroup(
-            key=self._attribute_group_key,
+            group_key=self._attribute_group_key,
             attributes=pyAttributes(attributes).to_payload_attributes()
         )