labfreed 0.0.20__py2.py3-none-any.whl → 0.1.1__py2.py3-none-any.whl

labfreed/PAC_ID_Resolver/resolver.py

@@ -0,0 +1,221 @@
+import os
+import re
+import yaml
+import json
+import jsonpath_ng.ext as jsonpath
+
+
+from labfreed.IO.parse_pac import PAC_Parser, PACID_With_Extensions
+from labfreed.PAC_ID_Resolver.data_types import CIT, CITEntry, CITEvaluated, Service
+
+from labfreed.PAC_ID_Resolver.non_needed.query_tools import JSONPathTools
+
+
+def load_cit(path):
+    with open(path, 'r') as f:
+        cit = yaml.safe_load(f)
+        cit = CIT.model_validate(cit)
+        return cit
+
+
+class PAC_ID_Resolver():
+    def __init__(self, cits:list[CIT]=None):
+        if not cits:
+            cits = []
+        self.cits = cits
+        
+        # load the default cit
+        dir = os.path.dirname(__file__)
+        fn ='cit.yaml'
+        p = os.path.join(dir, fn)       
+        with open(p, 'r') as f:
+            cit = yaml.safe_load(f)
+            cit = CIT.model_validate(cit)
+            self.cits.append(cit)
+        
+        
+    def resolve(self, pac_id:PACID_With_Extensions|str):
+        if isinstance(pac_id, str):
+            pac_id = PAC_Parser().parse(pac_id)
+        
+        pac_id_json = pac_id.model_dump(by_alias=True)
+        
+        
+        # dir = os.path.dirname(__file__)
+        # p = os.path.join(dir, 'pac-id.json')
+        # with open(p , 'r') as f:
+        #     _json = f.read()
+        #     pac_id_json = json.loads(_json)
+        
+        matches = [self._evaluate_against_cit(pac_id_json, cit) for cit in self.cits]
+        return matches
+            
+
+    def _evaluate_against_cit(self, pac_id_json, cit:CIT):
+        cit_evaluated = CITEvaluated(origin=cit.origin)   
+        for block in cit.cit:
+            _, is_applicable = self._evaluate_applicable_if(pac_id_json, block.applicable_if)
+            if not is_applicable:
+                continue
+
+            for e in block.entries:
+                url = self.eval_url_template(pac_id_json, e.template_url)
+                cit_evaluated.services.append(Service(  
+                                                        service_name=e.service_name,
+                                                        application_intents=e.application_intents,
+                                                        service_type=e.service_type,
+                                                        url = url
+                                    )
+                              )            
+        return cit_evaluated
+    
+    
+    def _evaluate_applicable_if(self, pac_id_json:str, expression) -> tuple[str, bool]:
+        expression = self._apply_convenience_substitutions(expression)
+        
+        tokens = self._tokenize_jsonpath_expression(expression)
+        expression_for_eval = self._expression_from_tokens(pac_id_json, tokens)
+        applicable = eval(expression_for_eval, {}, {})
+        
+        return expression_for_eval, applicable
+    
+    
+    def _apply_convenience_substitutions(self, query):
+        ''' applies a few substitutions, which enable abbreviated syntax.'''
+        
+        # allow access to array elements by key
+        q_mod = re.sub(r"\[('.+?')\]", r"[?(@.key == \1)]", query )
+        
+        # allow shorter path
+        # substitutions = [
+        #     (r'(?<=^)id', 'pac.id'),
+        #     (r'(?<=^)cat', 'pac.id.cat'),
+        #     (r'(?<=\.)id(?=\.)', 'identifier'),
+        #     (r'(?<=\.)cat$', 'categories'),
+        #     (r'(?<=\.)cat(?=\[)', 'categories'),
+        #     (r'(?<=\.)seg$', 'segments'),
+        #     (r'(?<=\.)seg(?=\[)', 'segments'),
+        #     (r'(?<=^)isu', 'pac.isu'),
+        #     (r'(?<=\.)isu', 'issuer'),
+        #     (r'(?<=^)ext', 'pac.ext'),
+        #     (r'(?<=\.)ext(?=$)', 'extensions'),
+        #     (r'(?<=\.)ext(?=\[)', 'extensions'),
+        # ]
+        # for sub in substitutions:
+        #     q_mod = re.sub(sub[0], sub[1], q_mod)
+        
+        return q_mod
+    
+
+    def _tokenize_jsonpath_expression(self, expr: str):
+        token_pattern = re.compile(
+            r"""
+            (?P<LPAREN>\() |
+            (?P<RPAREN>\)) |
+            (?P<LOGIC>\bAND\b|\bOR\b|\bNOT\b) |
+            (?P<OPERATOR>==|!=|<=|>=|<|>) |
+            (?P<JSONPATH>
+                \$                               # starts with $
+                (?:
+                    [^\s\[\]()]+                # path segments, dots, etc.
+                    |
+                    \[                           # open bracket
+                        (?:                     # non-capturing group
+                            [^\[\]]+            # anything but brackets
+                            |
+                            \[[^\[\]]*\]        # nested brackets (1 level)
+                        )*
+                    \]
+                )+                              # one or more bracket/segment blocks
+            ) |
+            (?P<LITERAL>
+                [A-Za-z_][\w\.\-]*[A-Za-z0-9]   # domain-like literals
+            )
+            """,
+            re.VERBOSE
+        )
+
+        tokens = []
+        pos = 0
+        while pos < len(expr):
+            match = token_pattern.match(expr, pos)
+            if match:
+                group_type = match.lastgroup
+                value = match.group().strip()
+                tokens.append((value, group_type))
+                pos = match.end()
+            elif expr[pos].isspace():
+                pos += 1  # skip whitespace
+            else:
+                raise SyntaxError(f"Unexpected character at position {pos}: {expr[pos]}")
+
+        return tokens
+    
+    
+    def _expression_from_tokens(self, pac_id_json:str, tokens: tuple[str, str]):
+        out  = []
+        for i in range(len(tokens)):
+            prev_token = tokens[i-1] if i > 0 else (None, None)
+            curr_token = tokens[i]
+            next_token = tokens[i+1] if i < len(tokens)-1 else (None, None)
+            if curr_token[1] == 'JSONPATH':
+                res = self._evaluate_jsonpath(pac_id_json, curr_token[0])
+                
+                if prev_token[1] == 'OPERATOR' or next_token[1] == 'OPERATOR':
+                    # if token is part of comparison return the value of the node
+                    if len(res) == 0:
+                        out.append('""')
+                    else:
+                        out.append(f'"{res[0].upper()}"')
+                else:
+                    # if token is not part of comparison evaluate to boolean
+                    if len(res) == 0:
+                        out.append(False)
+                    else:
+                        out.append(True)
+                        
+            elif curr_token[1] == 'LOGIC':
+                out.append(curr_token[0].lower())  
+                
+            elif curr_token[1] == 'LITERAL':
+                t = curr_token[0]
+                if t[0] != '"':
+                    t = '"' + t
+                if t[-1] != '"':
+                    t = t + '"' 
+                out.append(t.upper())    
+            else:
+                out.append(curr_token[0])
+                
+        s = ' '.join([str(e) for e in out])
+        return s
+                    
+
+    
+    
+    def eval_url_template(self, pac_id_json, url_template):
+        url = url_template
+        placeholders = re.findall(r'\{(.+?)\}', url_template)
+        for placeholder in placeholders:
+            expanded_placeholder = self._apply_convenience_substitutions(placeholder)
+            res = self._evaluate_jsonpath(pac_id_json, expanded_placeholder) or ['']
+            url = url.replace(f'{{{placeholder}}}', str(res[0]))
+            # res = self.substitute_jsonpath_expressions(expanded_placeholder, Patterns.jsonpath.value, as_bool=False)
+            # url = url.replace(f'{{{placeholder}}}', res)
+        return url
+    
+
+    
+    
+    def _evaluate_jsonpath(self, pac_id_json, jp_query):
+        jsonpath_expr = jsonpath.parse(jp_query)
+        matches = [match.value for match in jsonpath_expr.find(pac_id_json)]
+        return matches
+    
+    
+
+    
+    
+if __name__ == '__main__':
+    r = PAC_ID_Resolver()
+    r.resolve()

labfreed/TREX/data_model.py

@@ -8,7 +8,7 @@ from typing import Annotated, Literal
 from pydantic import PrivateAttr, RootModel, ValidationError, field_validator, model_validator, Field
 from labfreed.TREX.unece_units import unece_unit, unece_unit_codes, unece_units, unit_name, unit_symbol
 from labfreed.utilities.utility_types import DataTable, Quantity, Unit, unece_unit_code_from_quantity
-from labfreed.validation import BaseModelWithValidationMessages
+from labfreed.validation import BaseModelWithValidationMessages, ValidationMsgLevel
 from abc import ABC,  abstractmethod
 
 from labfreed.PAC_ID.extensions import Extension
@@ -180,7 +180,7 @@ class BoolValue(ValueMixin):
         if not self.value in ['T', 'F']:
             self.add_validation_message(
                 source=f"TREX boolean value {self.value}",
-                type="Error",
+                level= ValidationMsgLevel.ERROR,
                 msg=f'{self.value} is no valid boolean. Must be T or F',
                 highlight_pattern = f'{self.value}',
                 highlight_sub=[c for c in self.value]
@@ -207,7 +207,7 @@ class AlphanumericValue(ValueMixin):
         if re.match(r'[a-z]', self.value):
             self.add_validation_message(
                     source=f"TREX value {self.value}",
-                    type="Error",
+                    level= ValidationMsgLevel.ERROR,
                     msg=f"Lower case characters are not allowed.",
                     highlight_pattern = self.value
             )
@@ -215,7 +215,7 @@ class AlphanumericValue(ValueMixin):
         if not_allowed_chars := set(re.sub(r'[A-Z0-9\.-]', '', self.value)):
             self.add_validation_message(
                     source=f"TREX value {self.value}",
-                    type="Error",
+                    level= ValidationMsgLevel.ERROR,
                     msg=f"Characters {','.join(not_allowed_chars)} are not allowed in alphanumeric segment",
                     highlight_pattern = self.value,
                     highlight_sub=not_allowed_chars
@@ -242,7 +242,7 @@ class TextValue(ValueMixin):
         if not_allowed_chars := set(re.sub(r'[A-Z0-9]', '', self.value)):
             self.add_validation_message(
                     source=f"TREX value {self.value}",
-                    type="Error",
+                    level= ValidationMsgLevel.ERROR,
                     msg=f"Characters {','.join(not_allowed_chars)} are not allowed in text segment. Base36 encoding only allows A-Z0-9",
                     highlight_pattern = self.value,
                     highlight_sub=not_allowed_chars
@@ -268,7 +268,7 @@ class BinaryValue(ValueMixin):
         if not_allowed_chars := set(re.sub(r'[A-Z0-9]', '', self.value)):
            self.add_validation_message(
                     source=f"TREX value {self.value}",
-                    type="Error",
+                    tlevel= ValidationMsgLevel.ERROR,
                     msg=f"Characters {','.join(not_allowed_chars)} are not allowed in text segment. Base36 encoding only allows A-Z0-9",
                     highlight_pattern = self.value,
                     highlight_sub=not_allowed_chars
@@ -286,7 +286,7 @@ class ErrorValue(ValueMixin):
         if not_allowed_chars := set(re.sub(r'[A-Z0-9\.-]', '', self.value)):
             self.add_validation_message(
                     source=f"TREX value {self.value}",
-                    type="Error",
+                    level= ValidationMsgLevel.ERROR,
                     msg=f"Characters {','.join(not_allowed_chars)} are not allowed in error segment",
                     highlight_pattern = self.value,
                     highlight_sub=not_allowed_chars
@@ -309,7 +309,7 @@ class ValueSegment(TREX_Segment, ValueMixin, ABC):
         if not self.type in valid_types:
             self.add_validation_message(
                     source=f"TREX value segment {self.key}",
-                    type="Error",
+                    level= ValidationMsgLevel.ERROR,
                     msg=f"Type {self.type} is invalid. Must be 'T.D', 'T.B', 'T.A', 'T.T', 'T.X', 'E' or a UNECE unit",
                     highlight_pattern = self.type
             )
@@ -385,7 +385,7 @@ class ColumnHeader(BaseModelWithValidationMessages):
         if not_allowed_chars := set(re.sub(r'[A-Z0-9\.-]', '', self.key)):
             self.add_validation_message(
                 source=f"TREX table column {self.key}",
-                type="Error",
+                level= ValidationMsgLevel.ERROR,
                 msg=f"Column header key contains invalid characters: {','.join(not_allowed_chars)}",
                 highlight_pattern = f'{self.key}$',
                 highlight_sub=not_allowed_chars
@@ -398,7 +398,7 @@ class ColumnHeader(BaseModelWithValidationMessages):
         if not self.type in valid_types:
             self.add_validation_message(
                     source=f"TREX table column {self.key}",
-                    type="Error",
+                    level= ValidationMsgLevel.ERROR,
                     msg=f"Type '{self.type}' is invalid. Must be 'T.D', 'T.B', 'T.A', 'T.T', 'T.X', 'E' or a UNECE unit",
                     highlight_pattern = self.type
             )
@@ -435,7 +435,7 @@ class TREX_Table(TREX_Segment):
         if len(self.column_headers) != most_common_len:
             self.add_validation_message(
                     source=f"Table {self.key}",
-                    type="Error",
+                    level= ValidationMsgLevel.ERROR,
                     msg=f"Size mismatch: Table header contains {self.column_names} keys, while most rows have {most_common_len}",
                     highlight_pattern = self.key
             )
@@ -448,7 +448,7 @@ class TREX_Table(TREX_Segment):
             if len(row) != expected_row_len:
                 self.add_validation_message(
                     source=f"Table {self.key}",
-                    type="Error",
+                    level= ValidationMsgLevel.ERROR,
                     msg=f"Size mismatch: Table row {i} contains {len(row)} elements. Expected size is {expected_row_len}",
                     highlight_pattern = row.serialize_for_trex()
                 )
@@ -480,7 +480,7 @@ class TREX_Table(TREX_Segment):
                 except AssertionError:
                     self.add_validation_message(
                         source=f"Table {self.key}",
-                        type="Error",
+                        level= ValidationMsgLevel.ERROR,
                         msg=f"Type mismatch: Table row {i}, column {nm} is of wrong type. According to the header it should be {t_expected}",
                         highlight_pattern = row.serialize_for_trex(),
                         highlight_sub=[c for c in e.value]
@@ -490,7 +490,7 @@ class TREX_Table(TREX_Segment):
                     for m in msg:
                         self.add_validation_message(
                             source=f"Table {self.key}",
-                            type="Error",
+                            level= ValidationMsgLevel.ERROR,
                             msg=m.problem_msg,
                             highlight_pattern = row.serialize_for_trex(),
                             highlight_sub=[c for c in e.value]

labfreed/__init__.py

@@ -2,4 +2,4 @@
 Python implementation of LabFREED building blocks
 '''
 
-__version__ = "0.0.20"
+__version__ = "0.1.1"

labfreed/validation.py

@@ -1,37 +1,52 @@
+from enum import Enum, auto
+import re
 from pydantic import BaseModel, Field, PrivateAttr
 from typing import List, Set, Tuple
 
 from rich import print
 from rich.text import Text
+from rich.table import Table
 
 
 domain_name_pattern = r"(?!-)([A-Za-z0-9-]{1,63}(?<!-)\.)+[A-Za-z]{2,63}"
 hsegment_pattern = r"[A-Za-z0-9_\-\.~!$&'()+,:;=@]|%[0-9A-Fa-f]{2}"
 
 
+class ValidationMsgLevel(Enum):
+    ERROR = auto()
+    ERROR_AUTO_FIX = auto()
+    WARNING = auto()
+    RECOMMENDATION = auto()
+    INFO = auto()
+
 class ValidationMessage(BaseModel):
+    source_id:int
     source:str 
-    type: str
+    level: ValidationMsgLevel
     problem_msg:str
     recommendation_msg: str = ""
     highlight:str = "" #this can be used to highlight problematic parts
-    highlight_sub:list[str] = Field(default_factory=list())
+    highlight_sub_patterns:list[str] = Field(default_factory=list)
+
+
+    
         
-    @property
-    def emphazised_highlight(self):
-        fmt = lambda s: f'[emph]{s}[/emph]'
         
-        if not self.highlight_sub:
-            return fmt(self.highlight)
+    # @property
+    # def emphazised_highlight(self):
+    #     fmt = lambda s: f'[emph]{s}[/emph]'
+        
+    #     if not self.highlight_sub_patterns:
+    #         return fmt(self.highlight)
           
-        result = []
-        for c in self.highlight:
-            if c in self.highlight_sub:
-                result.append(fmt(c))
-            else:
-                result.append(c)
+    #     result = []
+    #     for c in self.highlight:
+    #         if c in self.highlight_sub_patterns:
+    #             result.append(fmt(c))
+    #         else:
+    #             result.append(c)
 
-        return ''.join(result)
+    #     return ''.join(result)
 
     
 class LabFREEDValidationError(ValueError):
@@ -51,10 +66,10 @@ class BaseModelWithValidationMessages(BaseModel):
     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)
 
-    def add_validation_message(self, *, msg: str, type:str, recommendation:str="", source:str="", highlight_pattern="", highlight_sub=None):
+    def add_validation_message(self, *, msg: str, level:ValidationMsgLevel, recommendation:str="", source:str="", highlight_pattern="", highlight_sub=None):
         if not highlight_sub:
             highlight_sub = []
-        w = ValidationMessage(problem_msg=msg, recommendation_msg=recommendation, source=source, type=type, highlight=highlight_pattern, highlight_sub=highlight_sub)
+        w = ValidationMessage(problem_msg=msg, recommendation_msg=recommendation, source=source, level=level, highlight=highlight_pattern, highlight_sub_patterns=highlight_sub, source_id=id(self))
 
         if not w in self._validation_messages:
             self._validation_messages.append(w)
@@ -113,43 +128,116 @@ class BaseModelWithValidationMessages(BaseModel):
         return filter_warnings(self.get_nested_validation_messages())
     
     
-    def print_validation_messages(self, str_to_highlight_in=None, target='console'):
-        if not str_to_highlight_in:
-            str_to_highlight_in = str(self)
+    def str_for_validation_msg(self, validation_msg:ValidationMessage):
+        if validation_msg.source_id == id(self):
+            return validation_msg.source_id
+            #return validation_msg.emphasize_in(self(str))
+        else:
+            return str(self)
+        
+    def str_highlighted(self):
+        raise NotImplementedError("Subclasses must implement format_special()")
+    
+    
+        
+    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()
-        print('\n'.join(['\n',
-                         '=======================================',
-                         'Validation Results',
-                         '---------------------------------------'
-                        ]
-                        )
-        )
+        
+        table = Table(title=f"Validation Results", show_header=False)
+
+        col = lambda s:  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.type.casefold() == "error":
+            if m.level == ValidationMsgLevel.ERROR:
                 color = 'red'
             else:
                 color = 'yellow'
                 
-            text = Text.from_markup(f'\n [bold {color}]{m.type} [/bold {color}] in \t {m.source}' )
-            print(text)
             match target:
                 case 'markdown':
-                    formatted_highlight = m.emphazised_highlight.replace('emph', f'🔸').replace('[/', '').replace('[', '').replace(']', '')
+                    fmt = lambda s: f'🔸{s}🔸'
                 case 'console':     
-                    formatted_highlight = m.emphazised_highlight.replace('emph', f'bold {color}')
+                    fmt = lambda s: f'[{color} bold]{s}[/{color} bold]'
                 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}'))
+                    fmt = lambda s: f'<span class="val_{color}">{s}</span>'
+                case 'html_styled':
+                    fmt = lambda s: f'<b style="color:{color}>{s}</b>'
+                
+            serialized = str(self)
+            emphazised_highlight = self._emphasize_in(m, serialized, fmt=fmt, color=color)
+            
+            txt =       f'[bold {color}]{m.level.name} [/bold {color}]'
+            txt += '\n' + f'{m.problem_msg}'
+            txt += '\n' + emphazised_highlight
+
+            table.add_row( txt)
+            table.add_section()
+
+        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.type.casefold() == "error" ]
+    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.type.casefold() != "error" ]     
+    return [ m for m in val_msg if m.level != ValidationMsgLevel.ERROR  ]