labfreed 0.0.5__py3-none-any.whl → 0.2.0b1__py3-none-any.whl

labfreed/__init__.py

@@ -2,4 +2,7 @@
 Python implementation of LabFREED building blocks
 '''
 
-__version__ = "0.0.5"
+__version__ = "0.2.0b1"
+
+from labfreed.pac_id import PAC_ID  # noqa: F401
+from labfreed.labfreed_infrastructure import LabFREED_ValidationError  # noqa: F401

labfreed/labfreed_infrastructure.py

@@ -0,0 +1,276 @@
+from enum import Enum, auto
+import logging
+import re
+from pydantic import BaseModel, ConfigDict, Field, PrivateAttr, field_validator
+from typing import Any, List, Set
+
+from rich import print
+from rich.table import Table
+
+''' Configure pdoc'''
+__all__ = ["LabFREED_BaseModel", "ValidationMessage", "ValidationMsgLevel", "LabFREED_ValidationError"]
+
+class PDOC_Workaround_Base(BaseModel):
+    '''@private
+    This class only exists to make pdoc work better with Pydantic models. It is set up such, that some things are not showing up in docu
+    '''
+    model_config = ConfigDict(extra="forbid")
+    """@private"""
+    def model_post_init(self, context: Any) -> None:
+        '''@private'''
+        super().model_post_init(context)
+
+
+
+
+
+class ValidationMsgLevel(Enum):
+    '''
+    Level of validation messages
+    '''
+    ERROR = auto() 
+    '''Model is **invalid**'''
+    WARNING = auto() 
+    '''Model is **valid**, but has issues'''
+    RECOMMENDATION = auto()
+    '''Model is **valid**, but recommendations apply'''
+    INFO = auto()
+    '''Model is **valid**. Something of interest was detected, which is not a recommendation.'''
+
+class ValidationMessage(PDOC_Workaround_Base):
+    '''
+    Represents one problem in the model
+    '''
+    source_id:int
+    source:str 
+    level: ValidationMsgLevel
+    msg:str
+    highlight:str = "" #this can be used to highlight problematic parts
+    highlight_sub_patterns:list[str] = Field(default_factory=list)
+
+    @field_validator('highlight_sub_patterns', mode='before')
+    @classmethod
+    def _ensure_list(cls, v):
+        if isinstance(v, str):
+            return [v]
+        return v
+
+
+    
+class LabFREED_ValidationError(ValueError):
+    '''Error which is raised, when LabFREED validation fails, i.e. when the model contains at least one error.'''
+    
+    def __init__(self, message=None, validation_msgs=None):
+        '''@private'''
+        super().__init__(message)
+        self._validation_msgs = validation_msgs
+
+    @property
+    def validation_msgs(self):
+        ''' The validation messages (errors, recommendations, info) present in the invalid model'''
+        return self._validation_msgs
+    
+    
+
+
+class LabFREED_BaseModel(PDOC_Workaround_Base):
+    """ Extension of Pydantic BaseModel, so that validator can issue warnings.
+    The purpose of that is to allow only minimal validation but on top check for stricter recommendations"""
+    
+    _validation_messages: list[ValidationMessage] = PrivateAttr(default_factory=list)
+    """Validation messages for this model"""
+    
+    @property
+    def is_valid(self) -> bool:
+        return len(self.errors()) == 0
+    
+
+    def validation_messages(self, nested=True) -> list[ValidationMessage]:
+        if nested:
+            msgs = self._get_nested_validation_messages()
+        else:
+            msgs = self._validation_messages
+        return msgs
+    
+    def errors(self, nested=True) -> list[ValidationMessage]: 
+        return _filter_errors(self.validation_messages(nested=nested))
+    
+    def warnings(self, nested=True) -> list[ValidationMessage]: 
+        return _filter_warnings(self.validation_messages(nested=nested))
+    
+
+    def _add_validation_message(self, *, msg: str, level:ValidationMsgLevel, source:str="", highlight_pattern="", highlight_sub=None):
+        if not highlight_sub:
+            highlight_sub = []
+        w = ValidationMessage(msg=msg, source=source, level=level, highlight=highlight_pattern, highlight_sub_patterns=highlight_sub, source_id=id(self))
+
+        if w not in self._validation_messages:
+            self._validation_messages.append(w)
+
+    # Function to extract warnings from a model and its nested models
+    def _get_nested_validation_messages(self, parent_name: str = "", visited: Set[int] = None) -> List['ValidationMessage']:
+        """
+        Recursively extract warnings from a Pydantic model and its nested fields, including computed fields.
+
+        :param parent_name: The name of the parent model to track the path.
+        :param visited: Set of visited object IDs to prevent infinite loops.
+        :return: List of ValidationMessages from this and nested models.
+        """
+        if visited is None:
+            visited = set()
+
+        model_id = id(self)
+        if model_id in visited:
+            return []
+        visited.add(model_id)
+
+        warnings_list = [warning for warning in self.validation_messages(nested=False)]
+
+        # Traverse regular fields
+        for field_name, field in self.__fields__.items():
+            full_path = f"{parent_name}.{field_name}" if parent_name else field_name
+            value = getattr(self, field_name)
+
+            if isinstance(value, LabFREED_BaseModel):
+                warnings_list.extend(value._get_nested_validation_messages(full_path, visited))
+            elif isinstance(value, list):
+                for index, item in enumerate(value):
+                    if isinstance(item, LabFREED_BaseModel):
+                        list_path = f"{full_path}[{index}]"
+                        warnings_list.extend(item._get_nested_validation_messages(list_path, visited))
+
+        # Traverse computed fields
+        computed_fields = getattr(self, '__pydantic_decorators__', {}).computed_fields or {}
+        for field_name in computed_fields:
+            full_path = f"{parent_name}.{field_name}" if parent_name else field_name
+            try:
+                value = getattr(self, field_name)
+            except Exception:
+                continue  # Safely skip computed properties that raise errors
+
+            if isinstance(value, LabFREED_BaseModel):
+                warnings_list.extend(value._get_nested_validation_messages(full_path, visited))
+            elif isinstance(value, list):
+                for index, item in enumerate(value):
+                    if isinstance(item, LabFREED_BaseModel):
+                        list_path = f"{full_path}[{index}]"
+                        warnings_list.extend(item._get_nested_validation_messages(list_path, visited))
+
+        return warnings_list
+        
+
+        
+    def _emphasize_in(self, validation_msg, validation_node_str:str, fmt, color='black'):
+        if validation_msg.highlight_sub_patterns:
+            replacements = validation_msg.highlight_sub_patterns
+        else:
+            replacements = [validation_msg.highlight]
+        # Sort patterns by length descending to avoid subpattern clobbering
+        sorted_patterns = sorted(replacements, key=len, reverse=True)
+        # Escape the patterns for regex safety
+        escaped_patterns = [re.escape(p) for p in sorted_patterns]
+        # Create one regex pattern with alternation (longest first)
+        pattern = re.compile("|".join(escaped_patterns))
+        
+        out = pattern.sub(lambda m: fmt(m.group(0)), validation_node_str)
+        return out
+    
+    
+    def print_validation_messages(self, target='console'):
+        msgs = self._get_nested_validation_messages()
+        
+        table = Table(title="Validation Results", show_header=False, title_justify='left')
+
+        def col(s):
+            return table.add_column(s, vertical='top')
+        col("-")
+        
+             
+        if not msgs:
+            table.add_row('All clear!', end_section=True)
+            return
+
+        for m in msgs:
+            if m.level == ValidationMsgLevel.ERROR:
+                color = 'red'
+            else:
+                color = 'yellow'
+                
+            match target:
+                case 'markdown':
+                    fmt = lambda s: f'👉{s}👈'  # noqa: E731
+                case 'console':     
+                    fmt = lambda s: f'[{color} bold]{s}[/{color} bold]'  # noqa: E731
+                case 'html':
+                    fmt = lambda s: f'<span class="val_{color}">{s}</span>'  # noqa: E731
+                case 'html_styled':
+                    fmt = lambda s: f'<b style="color:{color}>{s}</b>'  # noqa: E731
+                
+            serialized = str(self)
+            emphazised_highlight = self._emphasize_in(m, serialized, fmt=fmt, color=color)
+            emphazised_highlight = emphazised_highlight.replace('👈👉','') # removes two consecutive markers, to make it cleaner
+            
+            txt =       f'[bold {color}]{m.level.name} [/bold {color}] in {m.source}'
+            txt += '\n' + f'{m.msg}'
+            txt += '\n\n' + emphazised_highlight
+
+            table.add_row( txt)
+            table.add_section()
+
+        logging.info(table)
+        print(table)
+            
+
+        
+    
+    
+    # def print_validation_messages_(self, str_to_highlight_in=None, target='console'):
+    #     if not str_to_highlight_in:
+    #         str_to_highlight_in = str(self)
+    #     msgs = self.get_nested_validation_messages()
+    #     print('\n'.join(['\n',
+    #                      '=======================================',
+    #                      'Validation Results',
+    #                      '---------------------------------------'
+    #                     ]
+    #                     )
+    #     )
+        
+    #     if not msgs:
+    #         print('All clear!')
+    #         return
+
+    #     for m in msgs:
+    #         if m.level.casefold() == "error":
+    #             color = 'red'
+    #         else:
+    #             color = 'yellow'
+                
+    #         text = Text.from_markup(f'\n [bold {color}]{m.level} [/bold {color}] in \t {m.source}' )
+    #         print(text)
+    #         match target:
+    #             case 'markdown':
+    #                 formatted_highlight = m.emphazised_highlight.replace('emph', f'🔸').replace('[/', '').replace('[', '').replace(']', '')
+    #             case 'console':     
+    #                 formatted_highlight = m.emphazised_highlight.replace('emph', f'bold {color}')
+    #             case 'html':
+    #                 formatted_highlight = m.emphazised_highlight.replace('emph', f'b').replace('[', '<').replace(']', '>')
+    #         fmtd = str_to_highlight_in.replace(m.highlight, formatted_highlight)
+    #         fmtd = Text.from_markup(fmtd)
+    #         print(fmtd)
+    #         print(Text.from_markup(f'{m.problem_msg}'))
+        
+    
+    
+    
+    
+def _filter_errors(val_msg:list[ValidationMessage]) -> list[ValidationMessage]:
+    return [ m for m in val_msg if m.level == ValidationMsgLevel.ERROR ]
+
+def _filter_warnings(val_msg:list[ValidationMessage]) -> list[ValidationMessage]:
+    return [ m for m in val_msg if m.level != ValidationMsgLevel.ERROR  ]     
+
+def _quote_texts(texts:list[str]):
+    return ','.join([f"'{t}'" for t in texts])
+
+

labfreed/pac_cat/__init__.py

@@ -0,0 +1,17 @@
+from .pac_cat import PAC_CAT
+from .category_base import Category
+from .predefined_categories import Material_Device, Material_Substance, Material_Consumable, Material_Misc, Data_Method, Data_Result, Data_Progress, Data_Calibration, Data_Abstract
+
+__all__ = [
+    "PAC_CAT",
+    "Category",
+    "Material_Device",
+    "Material_Substance",
+    "Material_Consumable",
+    "Material_Misc",
+    "Data_Method",
+    "Data_Result",
+    "Data_Progress",
+    "Data_Calibration",
+    "Data_Abstract"
+]

labfreed/pac_cat/category_base.py

@@ -0,0 +1,51 @@
+               
+from typing import Any
+from pydantic import PrivateAttr, computed_field, model_validator
+from labfreed.labfreed_infrastructure import LabFREED_BaseModel, ValidationMsgLevel
+from labfreed.pac_id.id_segment import IDSegment
+
+
+class Category(LabFREED_BaseModel):
+    '''
+    Represents a category. \n
+    This is the base class for categories. If possible a more specific category should be used.
+    '''    
+    key:str
+    '''The category key, e.g. "-MD"'''
+    _segments: list[IDSegment] = PrivateAttr(default_factory=list)
+    
+        
+    @computed_field
+    @property
+    def segments(self) -> list[IDSegment]:
+        return self._segments
+    
+    def __init__(self, **data: Any):
+        '''@private'''
+        # Pop the user-provided value for computed segments
+        input_segments = data.pop("segments", None)
+        super().__init__(**data)
+        self._segments = input_segments
+    
+    @model_validator(mode='after')
+    def _warn_unusual_category_key(self):
+        ''' this base class is instantiated only if the key is not a known category key'''
+        if type(self) is Category:
+            self._add_validation_message(
+                        source=f"Category {self.key}",
+                        level = ValidationMsgLevel.RECOMMENDATION,
+                        msg=f'Category key {self.key} is not a well known key. It is recommended to use well known keys only',
+                        highlight_pattern = f"{self.key}"
+            )
+        return self
+    
+    
+    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 
+
+
+
+
+
+

labfreed/pac_cat/pac_cat.py

@@ -0,0 +1,159 @@
+from __future__ import annotations  # optional in 3.11, but recommended for consistency
+
+from typing import Self
+from pydantic import computed_field, model_validator
+
+from rich import print
+from rich.text import Text
+from rich.table import Table
+
+from labfreed.labfreed_infrastructure import ValidationMsgLevel
+
+from labfreed.pac_cat.category_base import Category
+from labfreed.pac_cat.predefined_categories import Data_Calibration, Data_Method, Data_Progress, Data_Result, Material_Consumable, Material_Device, Material_Misc, Material_Substance, Data_Static
+from labfreed.pac_id.id_segment import IDSegment
+from labfreed.pac_id.pac_id import PAC_ID
+
+''' Configure pdoc'''
+
+    
+class PAC_CAT(PAC_ID):
+    ''' 
+    Extends a PAC-ID with interpretation of the identifier as categories
+    '''
+    @computed_field
+    @property
+    def categories(self) -> list[Category]: 
+        '''The categories present in the PAC-ID's identifier'''
+        category_segments = self._split_segments_by_category(self.identifier)
+        categories = list()
+        for c in category_segments:
+            categories.append(self._cat_from_cat_segments(c))
+        return categories
+    
+    
+
+    def get_category(self, key) -> Category:
+        """Helper to get a category by key
+        """ 
+        tmp = [c for c in self.categories if c.key == key]
+        if not tmp:
+            return None
+        return tmp[0]
+    
+    
+    @classmethod
+    def from_categories(cls, issuer:str, categories:list[Category]) -> PAC_CAT:
+        identifier = list()
+        for category in categories:
+            identifier.append(IDSegment(value=category.key))
+            identifier.extend(category.segments)
+        return PAC_CAT(issuer=issuer, identifier=identifier)
+    
+    
+    @classmethod
+    def from_pac_id(cls, pac_id:PAC_ID) -> Self:
+        '''Constructs a PAC-CAT from a PAC-ID'''
+        return PAC_CAT(issuer=pac_id.issuer, identifier=pac_id.identifier)
+    
+
+    
+    def to_pac_id(self) -> PAC_ID:
+        return PAC_ID(issuer=self.issuer, identifier=self.identifier)
+        
+            
+    @classmethod
+    def _cat_from_cat_segments(cls, segments:list[IDSegment]) -> Category:
+        segments = segments.copy()
+        category_key = segments[0].value         
+        segments.pop(0)
+        
+        mapping  = {
+                '-MD': Material_Device,
+                '-MS': Material_Substance,
+                '-MC': Material_Consumable,
+                '-MM': Material_Misc,
+                '-DM': Data_Method,
+                '-DR': Data_Result,
+                '-DC': Data_Calibration,
+                '-DP': Data_Progress,
+                '-DS': Data_Static 
+        }
+        known_cat = mapping.get(category_key)
+        
+        if not known_cat:
+            return Category(key=category_key, segments=segments)
+
+        # implicit segment keys
+        model_dict = {v.alias: None for k, v in known_cat.model_fields.items() if v.alias and k not in ['key','additional_segments']}
+        for k, seg in zip(model_dict.keys(), segments.copy()):
+            if seg.key:
+                break
+            model_dict[k] = seg.value
+            segments.pop(0)
+            
+        # try to fill model keys if not already set
+        for s in segments.copy():
+            if s.key in model_dict.keys() and not model_dict.get(s.key):
+                model_dict[s.key] = s.value
+                segments.remove(s)
+            
+        model_dict['additional_segments'] = segments
+        model_dict['key'] = category_key
+        cat= known_cat(**model_dict)
+        return cat
+    
+    @staticmethod
+    def _split_segments_by_category(segments:list[IDSegment]) -> list[list[IDSegment]]:
+        category_segments = list()
+        c = list()
+        for s in segments:
+            # new category starts with "-"
+            if s.value[0] == '-':
+                c = [s]
+                category_segments.append(c)
+            else:
+                c.append(s)
+                
+        # first cat can be empty > remove
+        category_segments = [c for c in category_segments if len(c) > 0]
+                            
+        return category_segments
+    
+    
+    @model_validator(mode='after')
+    def _check_keys_are_unique_in_each_category(self) -> Self:
+        for c in self.categories:
+            keys = [s.key for s in c.segments if s.key]
+            duplicate_keys = [k for k in set(keys) if keys.count(k) > 1]
+            if duplicate_keys:
+                for k in duplicate_keys:
+                    self._add_validation_message(
+                        source=f"identifier {k}",
+                        level = ValidationMsgLevel.ERROR,
+                        msg=f"Duplicate key {k} in category {c.key}",
+                        highlight_pattern = k
+                    )
+            return self
+        
+    def print_categories(self):
+        table = Table(title=f'Categories in {str(self)}', show_header=False)
+        table.add_column('0')
+        table.add_column('1')
+        for i, c in enumerate(self.categories):
+            if i == 0:
+                title = Text('Main Category', style='bold')
+            else:
+                title = Text('Category', style='bold')
+            
+            table.add_row(title)
+            
+            for field_name, field_info in c.model_fields.items():
+                if not getattr(c, field_name):
+                    continue
+                table.add_row(f"{field_name} ({field_info.alias or ''})",
+                              f" {getattr(c, field_name)}"
+                              )      
+            table.add_section()        
+        print(table)
+