pyannotators-patterns 0.5.78__tar.gz → 0.5.82__tar.gz

{pyannotators_patterns-0.5.78 → pyannotators_patterns-0.5.82}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyannotators-patterns
-Version: 0.5.78
+Version: 0.5.82
 Summary: Annotator based on Presidio pattern recognizer
 Home-page: https://github.com/oterrier/pyannotators_patterns/
 Keywords: 
@@ -21,6 +21,7 @@ Classifier: Development Status :: 4 - Beta
 Classifier: Programming Language :: Python :: 3.8
 Requires-Dist: pymultirole-plugins>=0.5.0,<0.6.0
 Requires-Dist: spacy[lookups]==3.4.4
+Requires-Dist: log-with-context
 Requires-Dist: collections_extended
 Requires-Dist: unidecode
 Requires-Dist: presidio-analyzer>=2.2.352

{pyannotators_patterns-0.5.78 → pyannotators_patterns-0.5.82}/pyproject.toml

@@ -27,6 +27,7 @@ classifiers = [
 requires = [
     "pymultirole-plugins>=0.5.0,<0.6.0",
     "spacy[lookups]==3.4.4",
+    "log-with-context",
     "collections_extended",
     "unidecode",
     "presidio-analyzer>=2.2.352"

{pyannotators_patterns-0.5.78 → pyannotators_patterns-0.5.82}/setup.py

@@ -15,6 +15,7 @@ package_dir = \
 install_requires = \
 ['pymultirole-plugins>=0.5.0,<0.6.0',
  'spacy[lookups]==3.4.4',
+ 'log-with-context',
  'collections_extended',
  'unidecode',
  'presidio-analyzer>=2.2.352']
@@ -39,7 +40,7 @@ entry_points = \
                           'pyannotators_patterns.patterns:PatternsAnnotator']}
 
 setup(name='pyannotators-patterns',
-      version='0.5.78',
+      version='0.5.82',
       description='Annotator based on Presidio pattern recognizer',
       author='Olivier Terrier',
       author_email='olivier.terrier@kairntech.com',

{pyannotators_patterns-0.5.78 → pyannotators_patterns-0.5.82}/src/pyannotators_patterns/__init__.py

@@ -1,2 +1,2 @@
 """Annotator based on Presidio pattern recognizer"""
-__version__ = "0.5.78"
+__version__ = "0.5.82"

{pyannotators_patterns-0.5.78 → pyannotators_patterns-0.5.82}/src/pyannotators_patterns/patterns.py

@@ -4,6 +4,7 @@ from functools import lru_cache
 from typing import Type, List, cast, Dict
 
 import spacy
+from log_with_context import add_logging_context
 from presidio_analyzer import Pattern, PatternRecognizer, RecognizerRegistry, AnalyzerEngine, LemmaContextAwareEnhancer
 from presidio_analyzer.nlp_engine import SpacyNlpEngine, NerModelConfiguration
 from pydantic import BaseModel, Field
@@ -80,46 +81,46 @@ class PatternsAnnotator(AnnotatorBase):
 
         mapping = frozenset(params.mapping.items())
         labels = list(params.mapping.keys())
-        registry = get_registry(mapping)
-
         for document in documents:
-            # Retrieve nlp pipe
-            lang = document_language(document, None)
-            if lang is None or lang not in supported_languages:
-                raise AttributeError(f"Metadata language {lang} is required and must be in {SUPPORTED_LANGUAGES}")
-            nlp = get_nlp(lang)
-            analyzer = AnalyzerEngine(registry=registry,
-                                      nlp_engine=LoadedSpacyNlpEngine(lang, nlp),
-                                      default_score_threshold=0,
-                                      supported_languages=supported_languages,
-                                      context_aware_enhancer=LemmaContextAwareEnhancer(params.context_similarity_factor,
-                                                                                       params.min_score_with_context_similarity,
-                                                                                       params.context_prefix_count,
-                                                                                       params.context_suffix_count))
-
-            document.annotations = []
-            if not document.sentences:
-                document.sentences = [Span(start=0, end=len(document.text))]
-
-            for s in document.sentences:
-                if s.end > s.start:
-                    stext = document.text[s.start: s.end]
-                    results = analyzer.analyze(text=stext, entities=labels,
-                                               language=lang, return_decision_process=True,
-                                               score_threshold=params.score_threshold)  # noqa D501
-                    for result in results:
-                        start = s.start + result.start
-                        end = s.start + + result.end
-                        document.annotations.append(
-                            Annotation(
-                                start=start,
-                                end=end,
-                                text=document.text[start: end],
-                                labelName=result.entity_type,
-                                score=result.score,
-                                properties={"analysis_explanation": result.analysis_explanation}
+            with add_logging_context(docid=document.identifier):
+                # Retrieve nlp pipe
+                lang = document_language(document, None)
+                if lang is None or lang not in supported_languages:
+                    raise AttributeError(f"Metadata language {lang} is required and must be in {SUPPORTED_LANGUAGES}")
+                nlp = get_nlp(lang)
+                registry = get_registry(mapping, lang)
+                analyzer = AnalyzerEngine(registry=registry,
+                                          nlp_engine=LoadedSpacyNlpEngine(lang, nlp),
+                                          default_score_threshold=0,
+                                          supported_languages=supported_languages,
+                                          context_aware_enhancer=LemmaContextAwareEnhancer(params.context_similarity_factor,
+                                                                                           params.min_score_with_context_similarity,
+                                                                                           params.context_prefix_count,
+                                                                                           params.context_suffix_count))
+
+                document.annotations = []
+                if not document.sentences:
+                    document.sentences = [Span(start=0, end=len(document.text))]
+
+                for s in document.sentences:
+                    if s.end > s.start:
+                        stext = document.text[s.start: s.end]
+                        results = analyzer.analyze(text=stext, entities=labels,
+                                                   language=lang, return_decision_process=True,
+                                                   score_threshold=params.score_threshold)  # noqa D501
+                        for result in results:
+                            start = s.start + result.start
+                            end = s.start + + result.end
+                            document.annotations.append(
+                                Annotation(
+                                    start=start,
+                                    end=end,
+                                    text=document.text[start: end],
+                                    labelName=result.entity_type,
+                                    score=result.score,
+                                    properties={"analysis_explanation": result.analysis_explanation}
+                                )
                             )
-                        )
 
             return documents
 
@@ -162,13 +163,16 @@ class LoadedSpacyNlpEngine(SpacyNlpEngine):
 
 
 @lru_cache(maxsize=None)
-def get_registry(mapping_items):
+def get_registry(mapping_items, lang):
     recognizers = []
     for pname, pvalue in mapping_items:
-        pattern_definition = json.loads(pvalue)
+        try:
+            pattern_definition = json.loads(pvalue)
+        except BaseException:
+            logger.warning(f"Invalid json: {pvalue}", exc_info=True)
         patterns = [Pattern.from_dict(pat) for pat in pattern_definition['patterns']]
         recognizer = PatternRecognizer(
-            supported_entity=pname, patterns=patterns, context=pattern_definition.get('context', None)
+            supported_entity=pname, supported_language=lang, patterns=patterns, context=pattern_definition.get('context', None)
         )
         recognizers.append(recognizer)
     registry = RecognizerRegistry(recognizers)