streamlit-octostar-utils 0.4.2.dev14__tar.gz → 0.4.2.dev16__tar.gz

{streamlit_octostar_utils-0.4.2.dev14 → streamlit_octostar_utils-0.4.2.dev16}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: streamlit-octostar-utils
-Version: 0.4.2.dev14
+Version: 0.4.2.dev16
 Summary: 
 License: MIT
 License-File: LICENSE

{streamlit_octostar_utils-0.4.2.dev14 → streamlit_octostar_utils-0.4.2.dev16}/pyproject.toml

@@ -5,7 +5,7 @@ include = '\.pyi?$'
 
 [tool.poetry]
 name = "streamlit-octostar-utils"
-version = "0.4.2-dev.14"
+version = "0.4.2-dev.16"
 description = ""
 license = "MIT"
 authors = ["Octostar"]

{streamlit_octostar_utils-0.4.2.dev14 → streamlit_octostar_utils-0.4.2.dev16}/streamlit_octostar_utils/api_crafter/celery.py

@@ -14,6 +14,7 @@ import atexit
 import redis
 import uuid
 import json
+import hashlib
 import shutil
 import threading
 from pottery import Redlock
@@ -56,12 +57,14 @@ class CeleryQueueConfig:
         max_tasks_in_queue=None,
         max_tasks_per_child=None,
         max_memory_per_child=None,
+        stall_timeout=1200,
         **options,
     ):
         self.n_workers = n_workers
         self.max_tasks_in_queue = max_tasks_in_queue
         self.max_tasks_per_child = max_tasks_per_child
         self.max_memory_per_child = max_memory_per_child  # KiB
+        self.stall_timeout = stall_timeout # seconds; None or 0 to disable
         self.options = options
 
 
@@ -90,6 +93,11 @@ class CelerySerialized:
 
 class CeleryExecutor(object):
     class QueueFullException(Exception):
+        """Queue is full. Try again later."""
+        pass
+
+    class QueueStalledException(Exception):
+        """Queue has tasks but none are being consumed — workers may be deadlocked or in a crash loop."""
         pass
 
     AWAITING = "AWAITING"
@@ -169,6 +177,12 @@ class CeleryExecutor(object):
         self.stop_event = threading.Event()
         self.worker_health_check_thread = None
         self.worker_info = {}
+
+        # Queue stall detection
+        self._queue_fingerprints = {}
+        self._queue_fingerprint_changed_at = {}
+        self._queue_stalled = {}
+
         atexit.register(self.close)
         self.set_cleanup_task()
         self.register_state_signals()
@@ -204,9 +218,20 @@ class CeleryExecutor(object):
         if self.preload_functions:
             celery_signals.worker_process_init.connect(self.preload_on_worker_init)
 
+    def set_last_completed_time(self, sender=None, task_id=None, task=None, **kwargs):
+        try:
+            queue = task.request.delivery_info.get(
+                "routing_key", self.app.conf.task_default_routing_key
+            ) if task else None
+            if queue:
+                self.redis_client.set(f"queue:last_completed:{queue}", str(time.time()))
+        except Exception:
+            pass
+
     def register_state_signals(self):
         celery_signals.before_task_publish.connect(self.set_awaiting_state)
         celery_signals.task_prerun.connect(self.set_started_state)
+        celery_signals.task_postrun.connect(self.set_last_completed_time)
 
     def cleanup_task_results(in_dir, out_dir, redis_host, redis_port, task_expires, result_expires):
         logger.info("Starting cleanup of expired task results...")
@@ -378,37 +403,87 @@ class CeleryExecutor(object):
     def _worker_health_check_loop(self):
         while not self.stop_event.is_set():
             try:
-                dead_processes = []
-                for process in self.processes:
-                    poll_result = process.poll()
-                    if poll_result is not None:
-                        queue_name, slot, command = self.worker_info[process]
-                        logger.warning(
-                            f"Worker process dead for queue '{queue_name}' slot {slot}. "
-                            f"Exit code: {poll_result}. Restarting..."
-                        )
-                        dead_processes.append(process)
-                if self.beat_process and self.beat_process.poll() is not None:
-                    logger.warning(
-                        f"Beat process dead (exit code: {self.beat_process.poll()}). Restarting..."
-                    )
-                    self.beat_process = None
-                for dead_process in dead_processes:
-                    queue_name, slot, command = self.worker_info[dead_process]
-                    self.processes.remove(dead_process)
-                    del self.worker_info[dead_process]
-                    new_process = subprocess.Popen(command)
-                    self.processes.append(new_process)
-                    self.worker_info[new_process] = (queue_name, slot, command)
-                    logger.info(f"Restarted worker for queue '{queue_name}' slot {slot} (PID: {new_process.pid})")
-                if self.beat_process is None:
-                    self.beat_process = subprocess.Popen(self.beat_command)
-                    logger.info(f"Restarted beat process (PID: {self.beat_process.pid})")
+                self._restart_dead_processes()
+                self._check_queue_stalls()
                 time.sleep(5)
             except Exception as e:
                 logger.error(f"Error in worker health check: {e}")
                 time.sleep(5)
 
+    def _restart_dead_processes(self):
+        dead_processes = []
+        for process in self.processes:
+            poll_result = process.poll()
+            if poll_result is not None:
+                queue_name, slot, command = self.worker_info[process]
+                logger.warning(
+                    f"Worker process dead for queue '{queue_name}' slot {slot}. "
+                    f"Exit code: {poll_result}. Restarting..."
+                )
+                dead_processes.append(process)
+        if self.beat_process and self.beat_process.poll() is not None:
+            logger.warning(
+                f"Beat process dead (exit code: {self.beat_process.poll()}). Restarting..."
+            )
+            self.beat_process = None
+        for dead_process in dead_processes:
+            queue_name, slot, command = self.worker_info[dead_process]
+            self.processes.remove(dead_process)
+            del self.worker_info[dead_process]
+            new_process = subprocess.Popen(command)
+            self.processes.append(new_process)
+            self.worker_info[new_process] = (queue_name, slot, command)
+            logger.info(f"Restarted worker for queue '{queue_name}' slot {slot} (PID: {new_process.pid})")
+        if self.beat_process is None:
+            self.beat_process = subprocess.Popen(self.beat_command)
+            logger.info(f"Restarted beat process (PID: {self.beat_process.pid})")
+
+    def _check_queue_stalls(self):
+        for queue_name, queue_config in self.queue_config.items():
+            if not queue_config.stall_timeout:
+                continue
+            try:
+                queue_items = self.redis_client.lrange(queue_name, 0, -1)
+                if len(queue_items) == 0:
+                    self._queue_stalled[queue_name] = False
+                    self._queue_fingerprints.pop(queue_name, None)
+                    self._queue_fingerprint_changed_at.pop(queue_name, None)
+                    continue
+
+                fingerprint = hashlib.md5(b"".join(sorted(queue_items))).hexdigest()
+                now_time = time.time()
+                prev_fingerprint = self._queue_fingerprints.get(queue_name)
+
+                if fingerprint != prev_fingerprint:
+                    self._queue_fingerprints[queue_name] = fingerprint
+                    self._queue_fingerprint_changed_at[queue_name] = now_time
+                    self._queue_stalled[queue_name] = False
+                    continue
+
+                fingerprint_age = now_time - self._queue_fingerprint_changed_at.get(queue_name, now_time)
+
+                last_completed_raw = self.redis_client.get(f"queue:last_completed:{queue_name}")
+                last_completed = float(last_completed_raw) if last_completed_raw else 0
+                time_since_completion = (now_time - last_completed) if last_completed else float("inf")
+
+                was_stalled = self._queue_stalled.get(queue_name, False)
+                is_stalled = (
+                    fingerprint_age >= queue_config.stall_timeout
+                    and time_since_completion >= queue_config.stall_timeout
+                )
+                self._queue_stalled[queue_name] = is_stalled
+
+                if is_stalled and not was_stalled:
+                    logger.error(
+                        f"Queue '{queue_name}' is STALLED: {len(queue_items)} task(s) stuck for "
+                        f"{fingerprint_age:.0f}s with no completions in {time_since_completion:.0f}s. "
+                        f"New requests will receive 503."
+                    )
+                elif not is_stalled and was_stalled:
+                    logger.info(f"Queue '{queue_name}' has recovered from stall.")
+            except Exception as e:
+                logger.error(f"Error checking stall for queue '{queue_name}': {e}")
+
     def close(self):
         self.stop_event.set()
         if self.worker_health_check_thread and self.worker_health_check_thread.is_alive():
@@ -507,6 +582,10 @@ class CeleryExecutor(object):
             self.app.conf.dev_preload = True
 
         def _reserve_queue_slot(queue_name):
+            if self._queue_stalled.get(queue_name, False):
+                raise CeleryExecutor.QueueStalledException(
+                    f"Queue '{queue_name}' is stalled. Service temporarily unavailable."
+                )
             limit = self.queue_config[queue_name].max_tasks_in_queue
             if limit:
                 reservation_key = f"queue:reserved:{queue_name}"
@@ -540,6 +619,12 @@ class CeleryExecutor(object):
         def _send_task(task_fn, task_id, options):
             task_fn.apply_async(task_id=task_id, **options)
 
+        def _store_task_queue_mapping(task_id, queue_name):
+            self.redis_client.set(
+                f"task:queue:{task_id}", queue_name,
+                ex=self.app.conf.result_expires,
+            )
+
         task_id = str(uuid.uuid4())
         queue_name = self.app.conf.task_default_routing_key
         queue_name = getattr(task_fn, "queue", queue_name)
@@ -560,6 +645,9 @@ class CeleryExecutor(object):
             await asyncio.get_running_loop().run_in_executor(
                 self.set_thread_pool, _send_task, task_fn, task_id, options
             )
+            await asyncio.get_running_loop().run_in_executor(
+                self.set_thread_pool, _store_task_queue_mapping, task_id, queue_name
+            )
         except asyncio.CancelledError:
             logger.info(f"Cancelling task {task_id} due to disconnect!")
             await self.terminate_task(task_id)
@@ -596,6 +684,14 @@ class CeleryExecutor(object):
         def _poll_task_state(celery_app, task_id):
             task = celery_app.AsyncResult(task_id)
             ready, state = task.ready(), task.state
+            if not ready and state == CeleryExecutor.AWAITING:
+                task_queue = self.redis_client.get(f"task:queue:{task_id}")
+                if task_queue:
+                    queue_name = task_queue.decode() if isinstance(task_queue, bytes) else task_queue
+                    if self._queue_stalled.get(queue_name, False):
+                        raise CeleryExecutor.QueueStalledException(
+                            f"Task {task_id} is in stalled queue '{queue_name}'. Service temporarily unavailable."
+                        )
             return ready, state
 
         return await asyncio.get_running_loop().run_in_executor(
@@ -704,7 +800,7 @@ class FastAPICeleryTaskRoute(Route):
                 or (state not in ["SUCCESS", "FAILURE", "RETRY", "REVOKED"])
             )
             if state in ["FAILURE", "RETRY", "REVOKED"]:
-                error_response = DefaultErrorRoute.format_error(exc, debug=True).body.decode("utf-8")
+                error_response = DefaultErrorRoute.format_error(exc, internal=True).body.decode("utf-8")
                 data = {
                     "task_state": state,
                     "task_id": task_id,
@@ -747,28 +843,33 @@ class CeleryRoute(Route, ABC):
 
 
 class CeleryErrorRoute(DefaultErrorRoute):
-    DEFAULT_STATUS_CODE_MAPPINGS = {CeleryExecutor.QueueFullException: lambda exc: 429}
-    DEFAULT_SILENCED_EXCEPTIONS = {CeleryExecutor.QueueFullException: lambda exc: True}
+    DEFAULT_STATUS_CODE_MAPPINGS = {
+        CeleryExecutor.QueueFullException: lambda exc: 429,
+        CeleryExecutor.QueueStalledException: lambda exc: 503,
+    }
+    DEFAULT_SILENCED_EXCEPTIONS = {
+        CeleryExecutor.QueueFullException: lambda exc: True,
+    }
 
     def add_default_exceptions_handler(
         fs_app,
-        debug=False,
+        internal=False,
+        internal_prefixes=None,
         excs_to_status_codes=None,
         silenced_excs=None,
     ):
-        extra_status = {CeleryExecutor.QueueFullException: lambda exc: 429}
-        extra_silence = {CeleryExecutor.QueueFullException: lambda exc: True}
-
         status_codes = {
             **DefaultErrorRoute.DEFAULT_STATUS_CODE_MAPPINGS,
+            **CeleryErrorRoute.DEFAULT_STATUS_CODE_MAPPINGS,
             **(excs_to_status_codes or {}),
-            **extra_status,
         }
 
         silenced = {
             **DefaultErrorRoute.DEFAULT_SILENCED_EXCEPTIONS,
+            **CeleryErrorRoute.DEFAULT_SILENCED_EXCEPTIONS,
             **(silenced_excs or {}),
-            **extra_silence,
         }
 
-        super(CeleryErrorRoute, CeleryErrorRoute).add_default_exceptions_handler(fs_app, debug, status_codes, silenced)
+        super(CeleryErrorRoute, CeleryErrorRoute).add_default_exceptions_handler(
+            fs_app, internal, internal_prefixes, status_codes, silenced,
+        )

{streamlit_octostar_utils-0.4.2.dev14 → streamlit_octostar_utils-0.4.2.dev16}/streamlit_octostar_utils/api_crafter/fastapi.py

@@ -21,7 +21,6 @@ from octostar.client import make_client
 
 MAX_ERROR_MESSAGE_BYTES = 256
 MAX_ERROR_TRACEBACK_BYTES = 10240
-DEFAULT_PROCESSOR_SUFFIX = "main"
 
 
 class CommonParsers(object):
@@ -314,7 +313,7 @@ class DefaultErrorRoute:
         },
     }
 
-    def format_error(exc, body=b"", debug=False, excs_to_status_codes=DEFAULT_STATUS_CODE_MAPPINGS):
+    def format_error(exc, body=b"", internal=False, excs_to_status_codes=DEFAULT_STATUS_CODE_MAPPINGS):
         """Generic Error Handler"""
         status_code = 500
         for exc_type, handler in excs_to_status_codes.items():
@@ -325,7 +324,7 @@ class DefaultErrorRoute:
             message = exc.message
         except:
             message = str(exc)
-        if debug:
+        if internal:
             message += "\n" + str(body)
         if len(message) > MAX_ERROR_MESSAGE_BYTES:
             message = message[-MAX_ERROR_MESSAGE_BYTES:]
@@ -336,16 +335,18 @@ class DefaultErrorRoute:
         except:
             tcbk = None
         response_content = {"message": message, "status": "error"}
-        if debug:
+        if internal:
+            response_content["exception_class"] = f"python.{type(exc).__module__}.{type(exc).__qualname__}"
             response_content["traceback"] = tcbk
         return JSONResponse(status_code=status_code, content=response_content)
 
-    async def handle_error(body: bytes, exc: Exception, debug: bool, excs_to_status_codes: dict):
-        return DefaultErrorRoute.format_error(exc, body, debug, excs_to_status_codes)
+    async def handle_error(body: bytes, exc: Exception, internal: bool, excs_to_status_codes: dict):
+        return DefaultErrorRoute.format_error(exc, body, internal, excs_to_status_codes)
 
     def add_default_exceptions_handler(
             fs_app,
-            debug=False,
+            internal=False,
+            internal_prefixes=None,
             excs_to_status_codes=None,
             silenced_excs=None,
     ):
@@ -353,9 +354,13 @@ class DefaultErrorRoute:
             excs_to_status_codes = DefaultErrorRoute.DEFAULT_STATUS_CODE_MAPPINGS
         if silenced_excs is None:
             silenced_excs = DefaultErrorRoute.DEFAULT_SILENCED_EXCEPTIONS
+        internal_prefixes = tuple(internal_prefixes or [])
 
         async def _async_handle_error(request: Request, exc: Exception):
-            return await DefaultErrorRoute.handle_error(b"", exc, debug, excs_to_status_codes)
+            is_internal = internal or (
+                internal_prefixes and request.url.path.startswith(internal_prefixes)
+            )
+            return await DefaultErrorRoute.handle_error(b"", exc, is_internal, excs_to_status_codes)
 
         # Added all three since FastAPI seems to intercept some exceptions before Exception
         fs_app.add_exception_handler(RequestValidationError, _async_handle_error)

{streamlit_octostar_utils-0.4.2.dev14 → streamlit_octostar_utils-0.4.2.dev16}/streamlit_octostar_utils/api_crafter/nifi.py

@@ -385,9 +385,12 @@ class NifiContextManager(object):
         return [entity for entity in self.jsonify(self.out_entities)["content"]]
 
     def raise_exception(self, entity, exc):
-        error_response = DefaultErrorRoute.format_error(exc)
+        error_response = DefaultErrorRoute.format_error(exc, internal=True)
+        error_body = json.loads(error_response.body)
         entity.request["exception"]["code"] = error_response.status_code
-        entity.request["exception"]["body"] = json.loads(error_response.body)["message"]
+        entity.request["exception"]["body"] = error_body["message"]
+        entity.request["exception"]["exception_class"] = error_body.get("exception_class")
+        entity.request["exception"]["traceback"] = error_body.get("traceback")
         travel_dict(entity.request["nifi_attributes"], ["invokehttp", "response", "body"], "w")(
             entity.request["exception"]["body"]
         )

{streamlit_octostar_utils-0.4.2.dev14 → streamlit_octostar_utils-0.4.2.dev16}/streamlit_octostar_utils/nlp/ner.py

@@ -4,7 +4,7 @@ import math
 import multiprocessing
 import re
 from contextlib import contextmanager
-from typing import Optional, List, Tuple
+from typing import Optional, List, Tuple, Union
 
 from iso639.exceptions import InvalidLanguageValue
 from pydantic import BaseModel, ConfigDict, Field
@@ -202,8 +202,57 @@ class FlairRecognizer(EntityRecognizer):
 
                 results.append(flair_result)
 
+        sentences.clear_embeddings()
+
         return results
 
+    def analyze_batch(
+            self, texts: List[str], entities: List[str], nlp_artifacts_list: List[NlpArtifacts] = None
+    ) -> List[List[RecognizerResult]]:
+        """
+        Batch analyze using Flair's native Sentence batching.
+
+        Creates one Sentence per text, runs model.predict() in a single
+        forward pass, then extracts results per-Sentence.
+        
+        Args:
+            texts: List of input texts
+            entities: Entity types to detect
+            nlp_artifacts_list: Ignored (Flair uses its own tokenization)
+
+        Returns:
+            List of lists of RecognizerResult, one inner list per input text
+        """
+        sentences = [Sentence(text) for text in texts]
+        self.model.predict(sentences)
+
+        if not entities:
+            entities = self.supported_entities
+
+        all_results = []
+        for sentence in sentences:
+            results = []
+            for entity in entities:
+                if entity not in self.supported_entities:
+                    continue
+                for ent in sentence.get_spans("ner"):
+                    if not self.__check_label(
+                            entity, ent.labels[0].value, self.check_label_groups
+                    ):
+                        continue
+                    textual_explanation = self.DEFAULT_EXPLANATION.format(
+                        ent.labels[0].value
+                    )
+                    explanation = self.build_flair_explanation(
+                        round(ent.score, 2), textual_explanation
+                    )
+                    flair_result = self._convert_to_recognizer_result(ent, explanation)
+                    results.append(flair_result)
+            sentence.clear_embeddings()
+            all_results.append(results)
+
+        return all_results
+
     def build_flair_explanation(self, original_score: float, explanation: str) -> AnalysisExplanation:
         explanation = AnalysisExplanation(
             recognizer=self.__class__.__name__,
@@ -740,6 +789,128 @@ def compute_ner_presidio(
     return ner_objects
 
 
+def _ensure_analyze_batch(recognizer):
+    """Monkey-patch a loop-based analyze_batch onto recognizers that lack native batch support."""
+    if hasattr(recognizer, 'analyze_batch'):
+        return
+    _analyze = recognizer.analyze
+
+    def analyze_batch(texts, entities, nlp_artifacts_list=None):
+        return [
+            _analyze(text, entities, nlp_artifacts_list[i] if nlp_artifacts_list else None)
+            for i, text in enumerate(texts)
+        ]
+
+    recognizer.analyze_batch = analyze_batch
+
+
+def _compute_ner_batch(
+        texts,
+        language,
+        analyzer,
+        entities=None,
+        score_threshold=0.5,
+        context_width=150,
+        with_comentions=True,
+        with_context=True,
+        batch_size=32,
+        n_process=None,
+):
+    """
+    Batch NER across multiple texts using the analyzer's recognizers.
+
+    Recognizers with a native analyze_batch (e.g. FlairRecognizer) run a
+    single batched forward pass. Others fall back to a per-text loop via
+    monkey-patched analyze_batch. Per-text postprocessing (threshold,
+    context, co-mentions) is applied individually — each text is standalone.
+
+    Args:
+        texts: List of preprocessed text strings
+        language: Language code
+        analyzer: Pre-built AnalyzerEngine
+        entities: Optional list of entity types to detect (None = all)
+        score_threshold: Minimum confidence score
+        context_width: Character width for context and co-mention proximity
+        with_comentions: Include co-mentioned entities
+        with_context: Include surrounding context
+        batch_size: Batch size for NLP engine preprocessing
+        n_process: Number of processes for NLP engine (default 1)
+
+    Returns:
+        List of lists of NERObject, one inner list per input text
+    """
+    expanded_entities = expand_entities_for_analyzer(entities) if entities else None
+
+    # Batch NLP preprocessing (spaCy tokenization / NER)
+    with silence_logging(logging.ERROR):
+        nlp_artifacts_batch = list(
+            analyzer.nlp_engine.process_batch(
+                texts=texts,
+                language=language,
+                batch_size=batch_size,
+            )
+        )
+
+    batch_texts = [text for text, _ in nlp_artifacts_batch]
+    batch_nlp = [na for _, na in nlp_artifacts_batch]
+
+    # Ensure all recognizers have analyze_batch
+    with silence_logging(logging.ERROR):
+        recognizers = analyzer.registry.get_recognizers(
+            language=language,
+            entities=expanded_entities,
+            all_fields=not expanded_entities,
+        )
+
+    for recognizer in recognizers:
+        _ensure_analyze_batch(recognizer)
+
+    # Run batch analysis per recognizer
+    per_text_results = [[] for _ in texts]
+    for recognizer in recognizers:
+        recognizer_entities = expanded_entities
+        if not recognizer_entities:
+            recognizer_entities = recognizer.get_supported_entities()
+
+        batch_results = recognizer.analyze_batch(
+            batch_texts,
+            recognizer_entities,
+            batch_nlp,
+        )
+        for i, results in enumerate(batch_results):
+            per_text_results[i].extend(results)
+
+    # Per-text postprocessing → NERObjects
+    all_ner_objects = []
+    for text, results in zip(batch_texts, per_text_results):
+        ner_objects = []
+        for result in results:
+            if result.score >= score_threshold:
+                context_start = max(0, result.start - math.floor(context_width / 2))
+                context_end = min(len(text), result.end + math.ceil(context_width / 2))
+                context = text[context_start:context_end] if with_context else None
+                ner_objects.append(NERObject(
+                    name=text[result.start:result.end],
+                    label=normalize_presidio_label(result.entity_type),
+                    score=float(result.score),
+                    start=int(result.start),
+                    count=1,
+                    context=context,
+                ))
+        if with_comentions:
+            for i in range(len(ner_objects)):
+                entity = ner_objects[i]
+                comentions = [
+                    ner_objects[j].name
+                    for j in range(len(ner_objects))
+                    if j != i and abs(ner_objects[j].start - entity.start) < math.ceil(context_width / 2)
+                ]
+                ner_objects[i].comentions = comentions
+        all_ner_objects.append(ner_objects)
+
+    return all_ner_objects
+
+
 def get_extractive_summary(text, language, max_chars, fast=False, with_scores=False):
     tokenizer = get_nltk_tokenizer(language)
     stemmer = Stemmer(language)
@@ -837,6 +1008,77 @@ def _strip_honorifics_for_ner(text: str) -> str:
     return result
 
 
+def _preprocess_text_for_ner(text, language, fast, compression_ratio, preprocess_newlines):
+    """Preprocess a single text for NER (newlines, honorifics, compression)."""
+    if preprocess_newlines:
+        text = _preprocess_newlines_for_ner(text)
+    text = _strip_honorifics_for_ner(text)
+
+    cr = compression_ratio
+    if cr == "auto":
+        cr = max(1.0, len(text) / 15000) if fast else 1.0
+
+    if cr > 1.0:
+        sentences = get_extractive_summary(
+            text, language, int(len(text) / cr), fast=fast, with_scores=True
+        )
+        text = " ".join([s[0] for s in sentences])
+
+    return text
+
+
+def _ner_pipe_batch(
+        texts,
+        language,
+        model,
+        engine_type="spacy",
+        fast=False,
+        compression_ratio="auto",
+        with_comentions=True,
+        with_context=True,
+        entities=None,
+        score_threshold=0.5,
+        batch_size=32,
+        n_process=None,
+        preprocess_newlines=True,
+        _analyzer=None
+):
+    """
+    Internal batch processing path for ner_pipe.
+
+    Uses a unified path for all engine types. Recognizers with native
+    analyze_batch (FlairRecognizer) get true batched inference. Others
+    fall back to a per-text loop via monkey-patched analyze_batch.
+    Per-text postprocessing is applied individually.
+    """
+    processed_texts = []
+    for t in texts:
+        if not isinstance(t, str):
+            raise TypeError(f"Each text must be str, not {type(t).__name__}")
+        processed_texts.append(
+            _preprocess_text_for_ner(t, language, fast, compression_ratio, preprocess_newlines)
+        )
+
+    if _analyzer is None:
+        _analyzer = build_presidio_analyzer(
+            language=language,
+            engine_type=engine_type,
+            model=model,
+        )
+
+    return _compute_ner_batch(
+        processed_texts,
+        language,
+        _analyzer,
+        entities=entities,
+        score_threshold=score_threshold,
+        with_comentions=with_comentions,
+        with_context=with_context,
+        batch_size=batch_size,
+        n_process=n_process,
+    )
+
+
 def ner_pipe(
         text,
         language,
@@ -851,15 +1093,21 @@ def ner_pipe(
         score_threshold=0.5,
         batch_size=32,
         n_process=None,
-        preprocess_newlines=True
+        preprocess_newlines=True,
+        _analyzer=None
 ):
     """
-    Run NER pipeline on text.
-    
+    Run NER pipeline on text or a batch of texts.
+
     Args:
-        text: Input text (str). For multiple texts, iterate and call this function for each.
+        text: Input text (str) or list of texts (list[str]).
+              When a list is provided and engine_type is 'flair', texts are
+              processed in a single batched forward pass using native Flair
+              Sentence objects. For other engines, texts are processed
+              individually through Presidio (still benefiting from a reused
+              analyzer when called via get_ner_handler).
         language: Language code (e.g., 'en', 'de', 'fr')
-        model: Model name for spacy/flair engine
+        model: Model name or instance for spacy/flair engine
         engine_type: 'regex', 'flair', 'spacy' or 'custom'
         fast: Use fast summarization for long texts
         compression_ratio: Compression ratio for long texts ('auto' or float)
@@ -868,38 +1116,42 @@ def ner_pipe(
         with_context: Include surrounding context
         entities: List of entity types to detect (None = all)
         score_threshold: Minimum confidence score
-        batch_size: Batch size for processing
+        batch_size: Batch size for processing (used as mini_batch_size for Flair)
         n_process: Number of parallel processes
         preprocess_newlines: Replace newlines with ' — ' to prevent entity merging
+
+    Returns:
+        list[NERObject] when text is a str
+        list[list[NERObject]] when text is a list[str]
     """
     if with_scores:
         raise NotImplementedError("with_scores functionality is not implemented yet")
-    
-    if not isinstance(text, str):
-        raise TypeError(f"text must be str, not {type(text).__name__}")
 
-    analyzer = build_presidio_analyzer(
-        language=language,
-        engine_type=engine_type,
-        model=model,
-    )
+    if isinstance(text, list):
+        return _ner_pipe_batch(
+            text, language, model, engine_type, fast, compression_ratio,
+            with_comentions=with_comentions, with_context=with_context,
+            entities=entities, score_threshold=score_threshold,
+            batch_size=batch_size, n_process=n_process,
+            preprocess_newlines=preprocess_newlines, _analyzer=_analyzer
+        )
 
-    if preprocess_newlines:
-        text = _preprocess_newlines_for_ner(text)
-    text = _strip_honorifics_for_ner(text)
+    if not isinstance(text, str):
+        raise TypeError(f"text must be str or list[str], not {type(text).__name__}")
 
-    if compression_ratio == "auto":
-        compression_ratio = max(1.0, len(text) / 15000) if fast else 1.0
+    if _analyzer is None:
+        _analyzer = build_presidio_analyzer(
+            language=language,
+            engine_type=engine_type,
+            model=model,
+        )
 
-    if compression_ratio > 1.0:
-        sentences = get_extractive_summary(text, language, int(len(text) / compression_ratio), fast=fast,
-                                           with_scores=True)
-        text = " ".join([s[0] for s in sentences])
+    text = _preprocess_text_for_ner(text, language, fast, compression_ratio, preprocess_newlines)
 
     ner = compute_ner_presidio(
         text,
         language,
-        analyzer,
+        _analyzer,
         engine_type,
         entities,
         score_threshold,
@@ -928,6 +1180,12 @@ def get_ner_handler(
     except LookupError:
         language = "en"
 
+    analyzer = build_presidio_analyzer(
+        language=language,
+        engine_type=engine_type,
+        model=model,
+    )
+
     return lambda text, compression_ratio="auto", with_scores=False, with_comentions=True, with_context=True: ner_pipe(
         text,
         language,
@@ -942,7 +1200,8 @@ def get_ner_handler(
         score_threshold,
         batch_size,
         n_process,
-        preprocess_newlines
+        preprocess_newlines,
+        _analyzer=analyzer
     )