labfreed 0.2.11__py3-none-any.whl → 0.3.0a0__py3-none-any.whl

labfreed/pac_attributes/server/server.py

@@ -0,0 +1,237 @@
+import traceback
+import warnings
+
+import rich
+
+from labfreed.pac_attributes.api_data_models.request import AttributeRequestPayload
+from labfreed.pac_attributes.api_data_models.response import AttributeResponsePayload,  AttributesOfPACID, ReferenceAttribute
+from labfreed.pac_attributes.api_data_models.server_capabilities_response import ServerCapabilities
+from labfreed.pac_attributes.server.attribute_data_sources import AttributeGroupDataSource
+from labfreed.pac_attributes.server.translation_data_sources import TranslationDataSource
+from labfreed.pac_id.pac_id import PAC_ID
+
+
+class InvalidRequestError(ValueError):
+    pass
+
+
+    
+class AttributeServerRequestHandler():
+    def __init__(self, data_sources:list[AttributeGroupDataSource], translation_data_sources:list[TranslationDataSource], default_language:str):
+        '''Initializes the AttributeServerRequestHandler.
+        - does some validation on availability of translations. NOTE: if data_sources or translation_data_sources change, this validation might get outdated'''
+        if isinstance(data_sources, AttributeGroupDataSource):
+            data_sources = [data_sources]
+        self._attribute_group_data_sources: list[AttributeGroupDataSource] = data_sources
+        
+        
+        
+        # find which languages the sources consistently know
+        self._translation_data_sources: list[TranslationDataSource] = translation_data_sources
+        supported_languages = set()
+        for tds in self._translation_data_sources:
+            supported_languages.update(tds.supported_languages)
+        if not supported_languages:
+            raise ValueError("translation_data_sources contain no common fully supported language")
+        
+        if default_language not in supported_languages:
+            raise ValueError(f"fallback language {default_language} is not supported by all translation data sources.")
+        self._supported_languages = supported_languages
+        self._default_language = default_language
+        
+        # check there are translations for all provided attributes
+        missing_translations = []
+        provided_attributes = [attr for ds in self._attribute_group_data_sources for attr in ds.provides_attributes]
+        for language in self._supported_languages:
+            for attribute_key in provided_attributes:
+                if not self._get_display_name_for_key(attribute_key, language):
+                    missing_translations.append((attribute_key, language))
+        if missing_translations:
+            rich.print('[yellow bold]WARNING: Missing translations[/yellow bold]')
+            for mt in missing_translations:
+                rich.print(f"[yellow]WARNING:[/yellow] '{mt[1]}' translation missing for '{mt[0]}'' ")
+                    
+               
+        
+    def handle_attribute_request(self, json_request_body:str) -> str:
+        try:
+            r = AttributeRequestPayload.model_validate_json(json_request_body)
+        except Exception:
+            raise InvalidRequestError
+        attributes_for_pac_id = []
+        referenced_pac_ids = set()
+        for pac_url in r.pac_urls:
+            attributes_for_pac = self._get_attributes_for_pac_id(pac_url=pac_url, 
+                                                                restrict_to_attribute_groups = r.restrict_to_attribute_groups)
+            attributes_for_pac_id.append(attributes_for_pac)
+            ref = self._get_referenced_pac_ids(attributes_for_pac)
+            if ref:
+                referenced_pac_ids.update(ref)
+            
+        # also find attributes of referenced pac-ids 
+        if not r.suppress_forward_lookup:
+            for pac_url in referenced_pac_ids:
+                attributes_for_pac = self._get_attributes_for_pac_id(pac_url=pac_url, 
+                                                                    restrict_to_attribute_groups = r.restrict_to_attribute_groups)
+                attributes_for_pac_id.append(attributes_for_pac)
+
+        # add translations
+        response_language = self._find_response_language(r.language_preferences)
+        for e in attributes_for_pac_id:
+            self._add_display_names(e, response_language)
+            
+        response = AttributeResponsePayload(pac_attributes=attributes_for_pac_id, language=response_language
+                    ).to_json()
+        return response
+    
+
+
+
+    def _get_attributes_for_pac_id(self, pac_url:str, restrict_to_attribute_groups:list[str]|None=None ) -> AttributesOfPACID:
+        attribute_groups = []
+        if restrict_to_attribute_groups:
+            relevant_data_sources = [ds for ds in self._attribute_group_data_sources if ds.attribute_group_key in restrict_to_attribute_groups]
+        else:
+            relevant_data_sources = self._attribute_group_data_sources
+        for ds in relevant_data_sources:
+            try: 
+                ag = ds.attributes(pac_url)
+                if ag:
+                    attribute_groups.append(ag)
+            except Exception as e:
+                e.add_note(f'Attribute Source {ds.attribute_group_key} encountered an error')
+                traceback.print_exc()
+                raise e
+                        
+        return AttributesOfPACID(pac_url=pac_url, # return the pac_url as given, i.e. with the extension if there was one
+                                 attribute_groups=attribute_groups)
+        
+    
+
+    def _get_referenced_pac_ids(self, attributes_for_pac:AttributesOfPACID):
+        referenced_pacs = []
+        for ag in attributes_for_pac.attribute_groups:
+            for a in ag.attributes :
+                if isinstance(a, ReferenceAttribute):
+                    try:
+                        PAC_ID.from_url(a.value)
+                        referenced_pacs.append(a.value)
+                    except Exception:
+                        pass
+        return referenced_pacs
+            
+    # def get_translations(self, attributes_for_pac_id): 
+    #     ontology_map = {}  # ontology name → list of TermTranslations
+
+    #     for ag_for_pac in attributes_for_pac_id:
+    #         for ag in ag_for_pac.attribute_groups:
+    #             ag: AttributeGroup
+    #             ontology_name = ag.ontology
+    #             translation_data_source: TranslationDataSource = self._translation_data_sources.get(ontology_name, {})
+
+    #             attribute_keys = [a.key for a in ag.attributes]
+    #             all_keys = set([ag.key] + attribute_keys)
+
+    #             for k in all_keys:
+    #                 t = translation_data_source.get_translations_for(k)
+    #                 if t:
+    #                     ontology_map.setdefault(ontology_name, []).append(t)
+
+    #     translations_by_ontology = [ TranslationsForOntology(ontology=name, terms=terms) for name, terms in ontology_map.items()
+    #                                 ]
+    #     return translations_by_ontology
+    
+    
+    # def _get_display_name_for_key(self, key, requested_languages:str): 
+    #     for tds in self._translation_data_sources:
+    #         if term := tds.get_translations_for(key):
+    #             # try the languages requested by the user
+    #             for l in requested_languages:
+    #                 if dn := term.in_language(l):
+    #                     return dn
+    #             # remove the country codes and try the again
+    #             for l_fallback in [l.split('-')[0] for l in requested_languages]:
+    #                 if dn := term.in_language(l_fallback):
+    #                     return dn
+    #             # use the server fallback language
+    #             if dn := term.in_language(self._default_language):
+    #                 return 
+    #     warnings.warn(f'No translation for {key}')
+    #     return None
+    
+    def _add_display_names(self, attributes_of_pac:AttributesOfPACID, language:str) -> str:
+        ''' 
+        adds the display names in the requested language to attribute group and attributes.
+        if no translation can be found in this language it IMMEDIATELY falls back to some - probably inappropriate- magic.
+        Note: The server checks for completeness of translations at initialization. Make sure to resolve warnings there and 
+        this function should never get into the situation not to find translations.
+        '''
+        for ag in attributes_of_pac.attribute_groups:
+            if dn := self._get_display_name_for_key(ag.key, language):
+                ag.label = dn
+            else:
+                ag.label = ag.key.split('/')[-1]
+                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]
+                    rich.print(f"[yellow]WARNING:[/yellow] No translation for '{a.key}' in '{language}'. Falling back to '{a.label}' ")
+                    
+            
+        
+            
+            
+    
+    def _get_display_name_for_key(self, key, language:str): 
+        '''call this only with a language you know there is a translation for'''
+        for tds in self._translation_data_sources:
+            if term := tds.get_translations_for(key):
+                return term.in_language(language)    
+        warnings.warn(f'No translation for {key}.')
+        return None
+                
+                
+    def _find_response_language(self, requested_languages):
+        '''finds the language the server will respond in'''
+        if not requested_languages:
+            return self._default_language
+        
+        for language in requested_languages:
+            if language in self._supported_languages:
+                return language
+            
+        # remove the country codes and try the again
+        for l_fallback in [lang.split('-')[0] for lang in requested_languages]:
+            if language in self._supported_languages:
+                return l_fallback
+
+        return self._default_language
+                
+                
+        
+    def capabilities(self):
+        return ServerCapabilities(supported_languages=self._supported_languages,
+                                  default_language=self._default_language,
+                                  available_attribute_groups= [ds.attribute_group_key for ds in self._attribute_group_data_sources]).model_dump_json()
+    
+
+            
+
+
+
+
+
+
+
+
+    
+        
+        
+        
+    
+
+    
+    
+    

labfreed/pac_attributes/server/translation_data_sources.py

@@ -0,0 +1,60 @@
+from abc import ABC, abstractmethod, abstractproperty
+import json
+
+from pydantic import ValidationError
+import rich
+from labfreed.utilities.translations import Terms, Term
+
+class TranslationDataSource(ABC):
+
+    @abstractmethod
+    def get_translations_for(self, key:str) -> Term:
+        pass
+    
+    @abstractproperty
+    def supported_languages(self) -> set[str]:
+        pass
+    
+
+class DictTranslationDataSource(TranslationDataSource):
+    def __init__(self, data:Terms, supported_languages:set[str]) -> None:
+        
+        self._data = data
+        
+        #check that there are translations for the supported languages. Adjust supported_languages if needed
+        supported_languages = set(supported_languages) # to ensure uniqueness
+        for language in supported_languages.copy():
+            if translation_missing := self._list_missing_translations_to(language):
+                rich.print(f"[bold yellow]WARNING:[/bold yellow]: Translation to '{language}' missing for {translation_missing}")
+                supported_languages.remove(language)
+                
+        self._supported_languages = supported_languages
+        
+    def _list_missing_translations_to(self, language:str):
+        translation_missing_for_keys = []
+        for term in self._data.terms:
+            if language not in [t.language_code for t in term.translations]:
+                translation_missing_for_keys.append(term.key)
+        return translation_missing_for_keys 
+    
+    def get_translations_for(self, key:str) -> Term:
+        t = self._data.translations_for_term(key)
+        return t
+    
+    @property
+    def supported_languages(self) -> set[str]:
+        return self._supported_languages
+    
+    
+   
+
+    
+class JsonFileTranslationDataSource(DictTranslationDataSource):
+    def __init__(self, path:str) -> None:
+        with open(path) as f:
+            data = json.load(f)
+        try:
+            super().__init__(data=data)
+        except ValidationError as e:
+            e.add_note('Json must be convertible to OnthologyTranslationDataSource')
+            raise e

labfreed/pac_attributes/well_knonw_attribute_keys.py

@@ -0,0 +1,11 @@
+from enum import Enum
+
+
+class MetaAttributeKeys(Enum):
+    DISPLAYNAME = "https://schema.org/name"
+    IMAGE = "https://schema.org/image"
+    ALIAS = "https://schema.org/alternateName"
+    DESCRIPTION = "https://schema.org/description"
+    GROUPKEY = "https://labfreed.org/attribute_metadata_group"
+    
+    

labfreed/pac_cat/category_base.py

@@ -43,6 +43,25 @@ class Category(LabFREED_BaseModel):
     def __str__(self):
         s = '\n'.join( [f"{field_name} \t ({field_info.alias or ''}): \t {getattr(self, field_name)}" for  field_name, field_info in self.model_fields.items() if getattr(self, field_name)]) 
         return s 
+    
+    def segments_as_dict(self):
+        ''' returns the segments in a dict, with nice keys and values'''
+        out = dict()
+        for  field_name, field_info in self.model_fields.items():
+            if field_name =='additional_segments':
+                continue
+            if v := getattr(self, field_name):
+                if field_info.alias:
+                    k = f"{field_name} ({ field_info.alias})"
+                else:
+                    k = f"{field_name}"
+            out.update({k : v } ) 
+            
+        for s in getattr(self, 'additional_segments'):
+            out.update( {s.key or '' : s.value })
+        return out
+
+        
 
 
 

labfreed/pac_cat/pac_cat.py

@@ -52,7 +52,7 @@ class PAC_CAT(PAC_ID):
     
     
     @classmethod
-    def from_pac_id(cls, pac_id:PAC_ID) -> Self:
+    def from_pac_id(cls, pac_id:PAC_ID) -> PAC_CAT:
         '''Constructs a PAC-CAT from a PAC-ID'''
         return PAC_CAT(issuer=pac_id.issuer, identifier=pac_id.identifier)
     
@@ -125,6 +125,13 @@ class PAC_CAT(PAC_ID):
                     )
             return self
         
+        
+    @model_validator(mode='after')
+    def _check_identifier_segment_keys_are_unique(self) -> Self:
+        ''' override the validator of PAC-ID: in PAC-CAT segments can replicate in different categories'''
+        return self
+    
+        
     def print_categories(self):
         table = Table(title=f'Categories in {str(self)}', show_header=False)
         table.add_column('0')

labfreed/pac_id/extension.py

@@ -3,12 +3,12 @@ from abc import ABC, abstractproperty
 
 from pydantic import model_validator
 
-from labfreed.labfreed_infrastructure import LabFREED_BaseModel
+from labfreed.labfreed_infrastructure import LabFREED_BaseModel, ValidationMsgLevel
 
     
 class ExtensionBase(ABC):
-    name: str
-    type: str
+    name: str|None
+    type: str|None
 
 
     @abstractproperty
@@ -16,14 +16,17 @@ class ExtensionBase(ABC):
         raise NotImplementedError("Subclasses must implement 'data'")
     
     def __str__(self):
-        return f'{self.name}${self.type}/{self.data}'
+        if self.name and self.type:
+            return f'{self.name}${self.type}/{self.data}'
+        else:
+            return self.data
     
 
 
 class Extension(LabFREED_BaseModel,ExtensionBase):
     '''Implementation of Extension for unknown extension types'''
-    name:str
-    type:str
+    name:str|None
+    type:str|None
     data_:str
     
     @property
@@ -31,7 +34,7 @@ class Extension(LabFREED_BaseModel,ExtensionBase):
         return self.data_
        
     @staticmethod
-    def create(*, name, type, data):
+    def create(*, name:str|None, type:str|None, data:str):
         return Extension(name=name, type=type, data=data)
     
     @model_validator(mode='before')
@@ -44,5 +47,27 @@ class Extension(LabFREED_BaseModel,ExtensionBase):
     model_config = {
         "extra": "allow",  # Allow extra keys during pre-validation
     }
+        
+    @model_validator(mode='after')
+    def validate_model(self):
+        if self.name and not self.type:
+            raise ValueError('Extension has a name, but no type. Either set both or none')
+        
+        if self.type and not self.name:
+            raise ValueError('Extension has a type, but no name. Either set both or none')
+        
+        if not self.type and not self.name:
+            self._add_validation_message(msg="Extensions has no name and type. It is RECOMMENDED to specify name and type.",
+                                         level=ValidationMsgLevel.RECOMMENDATION, 
+                                         source=f"Extension '{self.data[0:10] if len(self.data)>10 else self.data}'",
+                                         highlight_pattern=self.data)
+        
+        return self
+            
+        
+    
+    model_config = {
+        "extra": "allow",  # Allow extra keys during pre-validation
+    }
     
 

labfreed/pac_id/pac_id.py

@@ -45,9 +45,9 @@ class PAC_ID(LabFREED_BaseModel):
         from labfreed.pac_id.url_parser import PAC_Parser
         return PAC_Parser.from_url(url, try_pac_cat=try_pac_cat, suppress_validation_errors=suppress_validation_errors, extension_interpreters=extension_interpreters)
     
-    def to_url(self, use_short_notation:None|bool=None, uppercase_only=False) -> str:
+    def to_url(self, use_short_notation:None|bool=None, uppercase_only=False, include_extensions:bool=True) -> str:
         from labfreed.pac_id.url_serializer import PACID_Serializer
-        return PACID_Serializer.to_url(self, use_short_notation=use_short_notation, uppercase_only=uppercase_only)
+        return PACID_Serializer.to_url(self, use_short_notation=use_short_notation, uppercase_only=uppercase_only, include_extensions=include_extensions)
     
     def to_json(self, indent=None) -> str:
         if not indent:

labfreed/pac_id/url_parser.py

@@ -69,7 +69,7 @@ class PAC_Parser():
         extensions = cls._parse_extensions(ext_str)
         if extensions and extension_interpreters:
             for i, e in enumerate(extensions):
-                if interpreter := extension_interpreters.get(e.type):
+                if interpreter := extension_interpreters.get(e.type or ''):
                     extensions[i] = interpreter.from_extension(e)
         pac_id.extensions = extensions
             
@@ -83,6 +83,8 @@ class PAC_Parser():
     def _parse_pac_id(cls,id_str:str) -> "PAC_ID":
         # m = re.match('(HTTPS://)?(PAC.)?(?P<issuer>.+?\..+?)/(?P<identifier>.*)', id_str)
         m = re.match('(HTTPS://)?(PAC.)?(?P<issuer>.+?)/(?P<identifier>.*)', id_str)
+        if not m:
+            raise LabFREED_ValidationError(f'{id_str} does not match the pattern expected for PAC-ID')
         d = m.groupdict()
         
         id_segments = list()
@@ -127,7 +129,7 @@ class PAC_Parser():
         
         defaults =  MappingProxyType(
                                 {
-                                    0: { 'name': 'N', 'type': 'N'},
+                                    0: { 'name': 'N', 'type': 'TEXT'},
                                     1: { 'name': 'SUM', 'type': 'TREX'}
                                 }
         )
@@ -146,8 +148,6 @@ class PAC_Parser():
                 if defaults:
                     name = defaults.get(i).get('name')
                     type = defaults.get(i).get('type')
-                else:
-                    raise ValueError('extension number {i}, must have name and type')
             
             #convert to subtype if they were given
             e = Extension.create(name=name, type=type, data=data)

labfreed/pac_id/url_serializer.py

@@ -9,7 +9,7 @@ class PACID_Serializer():
     '''Represents a PAC-ID including it's extensions'''
   
     @classmethod
-    def to_url(cls, pac:PAC_ID, use_short_notation:bool|None=None, uppercase_only=False) -> str:
+    def to_url(cls, pac:PAC_ID, use_short_notation:bool|None=None, uppercase_only=False, include_extensions:bool=True) -> str:
         """Serializes the PAC-ID including extensions.
 
         Args:
@@ -24,8 +24,12 @@ class PACID_Serializer():
         """
         identifier_str = cls._serialize_identifier(pac, use_short_notation=use_short_notation)
         
-        use_short_notation_for_extensions = True if use_short_notation is None else use_short_notation 
-        extensions_str = cls._serialize_extensions(pac.extensions, use_short_notation=use_short_notation_for_extensions)
+        if include_extensions:
+            use_short_notation_for_extensions = True if use_short_notation is None else use_short_notation 
+            extensions_str = cls._serialize_extensions(pac.extensions, use_short_notation=use_short_notation_for_extensions)
+        else: 
+            extensions_str = ""
+            
         out = f"HTTPS://PAC.{pac.issuer}{identifier_str}{extensions_str}"
         
         if uppercase_only:
@@ -75,8 +79,10 @@ class PACID_Serializer():
                     continue
                 else: 
                     short_notation = False
-                
-            out += f'*{e.name}${e.type}/{e.data}'
+            if e.name and e.type:
+                out += f'*{e.name}${e.type}/{e.data}'
+            else:
+                out += f'*{e.data}'
         return out
         
 

labfreed/pac_id_resolver/cit_common.py

@@ -1,6 +1,6 @@
 from enum import Enum
 import re
-from labfreed.labfreed_infrastructure import LabFREED_BaseModel, ValidationMsgLevel, _quote_texts
+from labfreed.labfreed_infrastructure import ValidationMsgLevel, _quote_texts
 
 
 

labfreed/pac_id_resolver/cit_v1.py

@@ -1,8 +1,5 @@
 
-from enum import Enum
-import logging
 import re
-import traceback
 
 from pydantic import Field, model_validator
 from labfreed.labfreed_infrastructure import LabFREED_BaseModel, ValidationMessage, ValidationMsgLevel

labfreed/pac_id_resolver/cit_v2.py

@@ -1,4 +1,3 @@
-from enum import Enum
 import json
 import re
 from typing import Self
@@ -9,11 +8,7 @@ import jsonpath_ng.ext as jsonpath
 
 from labfreed.pac_id_resolver.services import Service, ServiceGroup
 from labfreed.labfreed_infrastructure import LabFREED_BaseModel, ValidationMsgLevel, _quote_texts
-from labfreed.pac_id_resolver.cit_common import ( _add_msg_to_cit_entry_model, 
-                                                 _validate_service_name, 
-                                                 _validate_application_intent, 
-                                                 _validate_service_type,
-                                                 ServiceType)
+from labfreed.pac_id_resolver.cit_common import ( ServiceType)
 
 
 __all__ = [

labfreed/pac_id_resolver/resolver.py

@@ -1,8 +1,6 @@
 from functools import lru_cache
 import logging
-import traceback
 from typing import Self
-import yaml
 from requests import get
 
 
@@ -32,7 +30,7 @@ def cit_from_str(s:str, origin:str='') -> CIT_v1|CIT_v2:
         cit2 = None
     try:
         cit1 = CIT_v1.from_csv(s, origin)
-        cit_version = 'v1'
+        cit_version = 'v1'  # noqa: F841
     except Exception:
         cit1 = None
     
@@ -66,11 +64,18 @@ class PAC_ID_Resolver():
         self._cits = cits
             
         
-    def resolve(self, pac_url:PAC_ID|str, check_service_status=True, use_issuer_cit=True) -> list[ServiceGroup]:
+    def resolve(self, pac_id:PAC_ID|str, check_service_status=True, use_issuer_cit=True) -> list[ServiceGroup]:
         '''Resolve a PAC-ID'''
-        if isinstance(pac_url, str):
-            pac_id = PAC_CAT.from_url(pac_url)
-            pac_id_catless = PAC_ID.from_url(pac_url, try_pac_cat=False)
+        if isinstance(pac_id, str):
+            pac_id = PAC_CAT.from_url(pac_id)
+            pac_id_catless = PAC_ID.from_url(pac_id, try_pac_cat=False)
+        
+        # it's likely to h
+        if isinstance(pac_id, PAC_ID):
+            pac_id_catless = PAC_ID.from_url(pac_id.to_url(), try_pac_cat=False)
+        else:
+            raise ValueError('pac_id is invalid. Should be a PAC-ID in url form or a PAC-ID object')
+    
                 
         cits = self._cits.copy()
         if use_issuer_cit:

labfreed/pac_id_resolver/services.py

@@ -6,7 +6,6 @@ import requests
 
 from concurrent.futures import ThreadPoolExecutor, as_completed
 
-import requests
 from rich import print
 from rich.table import Table