sinonym 0.2.2__tar.gz → 0.2.4__tar.gz

{sinonym-0.2.2 → sinonym-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sinonym
-Version: 0.2.2
+Version: 0.2.4
 Summary: Chinese Name Detection and Normalization Module
 Project-URL: Homepage, https://github.com/allenai/sinonym
 Project-URL: Repository, https://github.com/allenai/sinonym
@@ -148,7 +148,7 @@ Formatted Output
 ### 5. Performance
 
 *   **High-Performance with Caching**
-    *   The library is benchmarked to be very fast, capable of processing over 10,000 diverse names per second, and uses caching to significantly speed up the processing of repeated names.
+    *   The library is benchmarked to be very fast, capable of processing over 3,000 diverse names per second, and uses caching to significantly speed up the processing of repeated names.
 
 ## How It Works
 
@@ -357,6 +357,36 @@ for result in results:
     print(f"Processed: {result.result}")
 ```
 
+### Persistent Multi-Process Processing
+
+For high-throughput workloads, you can keep a persistent process pool alive and
+reuse worker processes across multiple calls. This avoids repeated process
+start-up overhead and works on Windows/macOS/Linux via `spawn`.
+
+```python
+from sinonym.detector import ChineseNameDetector
+
+def main():
+    detector = ChineseNameDetector()
+    names_a = ["Li Wei", "Wang Weiming", "Zhang Ming"]
+    names_b = ["Xin Liu", "Yang Li", "Chen Huang"]
+
+    # Reuse workers across many calls
+    with detector.create_persistent_multiprocess_pool(max_workers=6, chunk_size=64) as pool:
+        results_a = pool.normalize_names(names_a)
+        results_b = pool.normalize_names(names_b)
+
+    # One-off convenience wrapper (creates and closes a temporary pool)
+    single_batch = detector.process_name_batch_multiprocess(names_a, max_workers=6, chunk_size=64)
+    return results_a, results_b, single_batch
+
+if __name__ == "__main__":
+    main()
+```
+
+Use the `if __name__ == "__main__":` guard in scripts to ensure safe process
+spawning on Windows and macOS.
+
 ### When to Use Batch Processing
 
 *   **Academic Papers**: Author lists typically follow consistent formatting
@@ -431,14 +461,14 @@ If you'd like to contribute to Sinonym, here’s how to set up your development
 First, clone the repository:
 
 ```bash
-git clone https://github.com/yourusername/sinonym.git
+git clone https://github.com/allenai/sinonym.git
 cd sinonym
 ```
 
 Then, install the development dependencies:
 
 ```bash
-uv sync --extra dev
+uv sync --active --all-extras --dev
 ```
 
 ### Running Tests
@@ -459,6 +489,10 @@ uv run ruff check . --fix
 uv run ruff format .
 ```
 
+### Benchmarking & Profiling
+
+See [scripts/README.md](scripts/README.md) for benchmark, profiling, and test status scripts.
+
 ## License
 
 Sinonym is licensed under the Apache 2.0 License. See the `LICENSE` file for more details.

{sinonym-0.2.2 → sinonym-0.2.4}/README.md

@@ -111,7 +111,7 @@ Formatted Output
 ### 5. Performance
 
 *   **High-Performance with Caching**
-    *   The library is benchmarked to be very fast, capable of processing over 10,000 diverse names per second, and uses caching to significantly speed up the processing of repeated names.
+    *   The library is benchmarked to be very fast, capable of processing over 3,000 diverse names per second, and uses caching to significantly speed up the processing of repeated names.
 
 ## How It Works
 
@@ -320,6 +320,36 @@ for result in results:
     print(f"Processed: {result.result}")
 ```
 
+### Persistent Multi-Process Processing
+
+For high-throughput workloads, you can keep a persistent process pool alive and
+reuse worker processes across multiple calls. This avoids repeated process
+start-up overhead and works on Windows/macOS/Linux via `spawn`.
+
+```python
+from sinonym.detector import ChineseNameDetector
+
+def main():
+    detector = ChineseNameDetector()
+    names_a = ["Li Wei", "Wang Weiming", "Zhang Ming"]
+    names_b = ["Xin Liu", "Yang Li", "Chen Huang"]
+
+    # Reuse workers across many calls
+    with detector.create_persistent_multiprocess_pool(max_workers=6, chunk_size=64) as pool:
+        results_a = pool.normalize_names(names_a)
+        results_b = pool.normalize_names(names_b)
+
+    # One-off convenience wrapper (creates and closes a temporary pool)
+    single_batch = detector.process_name_batch_multiprocess(names_a, max_workers=6, chunk_size=64)
+    return results_a, results_b, single_batch
+
+if __name__ == "__main__":
+    main()
+```
+
+Use the `if __name__ == "__main__":` guard in scripts to ensure safe process
+spawning on Windows and macOS.
+
 ### When to Use Batch Processing
 
 *   **Academic Papers**: Author lists typically follow consistent formatting
@@ -394,14 +424,14 @@ If you'd like to contribute to Sinonym, here’s how to set up your development
 First, clone the repository:
 
 ```bash
-git clone https://github.com/yourusername/sinonym.git
+git clone https://github.com/allenai/sinonym.git
 cd sinonym
 ```
 
 Then, install the development dependencies:
 
 ```bash
-uv sync --extra dev
+uv sync --active --all-extras --dev
 ```
 
 ### Running Tests
@@ -422,6 +452,10 @@ uv run ruff check . --fix
 uv run ruff format .
 ```
 
+### Benchmarking & Profiling
+
+See [scripts/README.md](scripts/README.md) for benchmark, profiling, and test status scripts.
+
 ## License
 
 Sinonym is licensed under the Apache 2.0 License. See the `LICENSE` file for more details.

{sinonym-0.2.2 → sinonym-0.2.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "sinonym"
-version = "0.2.2"
+version = "0.2.4"
 description = "Chinese Name Detection and Normalization Module"
 readme = "README.md"
 requires-python = ">=3.10"

sinonym-0.2.4/scripts/README.md

@@ -0,0 +1,65 @@
+# Sinonym Scripts
+
+Utility scripts for benchmarking, profiling, testing, and model training.
+
+## Active Scripts
+
+### `check_test_status.py`
+Runs the full test suite and reports individual test case failures with detailed diagnostics. Runs performance tests separately, then exits 0/1 based on whether the failure count matches the expected baseline (`EXPECTED_FAILURES = 52`). Improvements (fewer failures) also pass; regressions fail.
+
+```bash
+uv run python scripts/check_test_status.py
+```
+
+### `benchmark_stable.py`
+Median-based performance benchmark gate. Spawns isolated worker subprocesses (fresh process per run) with controlled `PYTHONHASHSEED` and thread environment variables. Reports mean/median/stddev/CV of throughput and supports a `--min-median-names-per-sec` gate that exits non-zero on failure.
+
+```bash
+uv run python scripts/benchmark_stable.py --runs 5 --names 3000 --warmup 3000
+uv run python scripts/benchmark_stable.py --runs 7 --min-median-names-per-sec 5000
+```
+
+### `profile_hotspots.py`
+Hotspot time-share profiler. Warms caches on deterministic test names, runs one `cProfile` pass, then reports top functions and modules ranked by internal time (`tottime`) share. Use `--sinonym-only` to filter out third-party/stdlib noise.
+
+```bash
+uv run python scripts/profile_hotspots.py --names 3000 --warmup 3000 --sinonym-only
+```
+
+### `profile_run.py`
+Quick single-process profiling script. Generates deterministic test names, warms caches, takes 5 pure timing measurements (no profiling overhead) for accurate throughput stats, then runs one `cProfile` pass for a top-25 function breakdown. Good for a fast sanity check during development.
+
+```bash
+uv run python scripts/profile_run.py
+```
+
+### `profile_threaded.py`
+Multi-threaded performance and thread-safety validation. Tests `normalize_name` throughput across 1/2/4/8 threads using a shared `ChineseNameDetector` instance, verifies that multi-threaded results are identical to single-threaded results, and reports speedup and CV per thread count.
+
+```bash
+uv run python scripts/profile_threaded.py
+```
+
+### `profile_multiprocess.py`
+Persistent multi-process throughput and parity check. Compares single-process throughput to a spawn-based persistent process pool, verifies that outputs are identical for a deterministic workload, and reports median speedup.
+
+```bash
+uv run python scripts/profile_multiprocess.py --names 12000 --warmup 3000 --runs 3 --workers 6 --chunk-size 64
+```
+
+### `train_ml_classifier_for_chinese_vs_japanese.py`
+Trains the Chinese-vs-Japanese name classifier used in production. Downloads Chinese (~1.2M) and Japanese (~180K) name corpora, trains a scikit-learn pipeline (TF-IDF character n-grams + 20 linguistic heuristic features + logistic regression), and saves the model to `data/chinese_japanese_classifier.skops`.
+
+```bash
+uv run python scripts/train_ml_classifier_for_chinese_vs_japanese.py
+```
+
+## Abandoned Scripts
+
+These remain for historical reference but are not used by the library. The rule-based parser in `sinonym.services.parsing` replaced the ML approach.
+
+### `generate_chinese_name_corpus_data.py`
+Was intended to generate training data for an ML-based name parsing disambiguation model. Downloads 200K Chinese names, romanizes them, generates all possible surname/given-name parses, and creates labeled training examples. The ML parsing model did not outperform the rule-based system.
+
+### `generate_acl_data.py`
+Supplementary data generator for the abandoned ML parsing effort. Processes ACL 2025 conference author names to create additional training examples in a different distribution (romanized, Western ordering).

{sinonym-0.2.2 → sinonym-0.2.4}/sinonym/chinese_names_data.py

@@ -137,7 +137,7 @@ CANTONESE_PHONETIC_RULES = {
     "sau": "shou",
     "tau": "tao",
     "wun": "huan",
-    "kai": "qi",  # Cantonese mapping (overrides Wade-Giles "gai")
+    "kai": "kai",  # Preserve "kai" by default; avoid forcing it to "qi" without explicit Cantonese context
     "hoi": "hai",
     "ngai": "ai",
     "tsz": "zi",

{sinonym-0.2.2 → sinonym-0.2.4}/sinonym/coretypes/results.py

@@ -18,6 +18,8 @@ class ParsedName:
     parts appear when combined. For normalized output this is typically
     ["given", "middle", "surname"], while for original input order it may
     be ["surname", "given", "middle"], etc.
+    Component labels remain stable: `surname`/`given_name` always identify
+    those components regardless of `order`.
     """
     surname: str
     given_name: str

{sinonym-0.2.2 → sinonym-0.2.4}/sinonym/detector.py

@@ -164,6 +164,7 @@ data structures and the detector can be safely used from multiple threads.
 
 import logging
 import string
+import threading
 
 from sinonym.coretypes import BatchFormatPattern, BatchParseResult
 from sinonym.coretypes.results import ParsedName
@@ -181,6 +182,7 @@ from sinonym.services import (
     PinyinCacheService,
     ServiceContext,
 )
+from sinonym.services.process_pool import PersistentMultiprocessNormalizer, normalize_names_multiprocess
 
 # ════════════════════════════════════════════════════════════════════════════════
 # MAIN CHINESE NAME DETECTOR CLASS
@@ -203,6 +205,7 @@ class ChineseNameDetector:
         self._parsing_service: NameParsingService | None = None
         self._formatting_service: NameFormattingService | None = None
         self._batch_analysis_service: BatchAnalysisService | None = None
+        self._batch_threshold_lock = threading.Lock()
 
         # Initialize data structures
         self._initialize()
@@ -332,13 +335,13 @@ class ChineseNameDetector:
                     )
                     # Determine original input order and assign components accordingly
                     if token1_is_surname:
-                        # Original: surname-first → in original-order view, first part is "given"
+                        # Original: surname-first → preserve component labels and annotate order
                         order_list = ["surname", "given"]
                         parsed_original_order = ParsedName(
-                            surname=given_str,
-                            given_name=surname_str,
-                            surname_tokens=given_final,
-                            given_tokens=surname_final,
+                            surname=surname_str,
+                            given_name=given_str,
+                            surname_tokens=surname_final,
+                            given_tokens=given_final,
                             middle_name=" ".join(middle_tokens) if middle_tokens else "",
                             middle_tokens=middle_tokens,
                             order=order_list,
@@ -368,17 +371,15 @@ class ChineseNameDetector:
 
             # Try both possibilities and see which one the parsing service accepts
             # Option 1: First two tokens as compound surname + third as given
-            compound_parse = self._parsing_service.parse_name_order(
+            compound_parse = self._parsing_service.parse_name_order_tokens(
                 tokens,
                 normalized_input.norm_map,
                 normalized_input.compound_metadata,
             )
 
-            if (compound_parse.success and
-                len(compound_parse.result[0]) == 2 and
-                len(compound_parse.result[1]) == 1):
+            if compound_parse is not None and len(compound_parse[0]) == 2 and len(compound_parse[1]) == 1:
                 # Parsing service recognized first two as compound surname
-                best_result = compound_parse.result
+                best_result = (compound_parse[0], compound_parse[1])
             else:
                 # Option 2: First token as single surname + last two as given name
                 best_result = ([tokens[0]], tokens[1:])
@@ -403,12 +404,13 @@ class ChineseNameDetector:
                         middle_tokens=middle_tokens,
                         order=["given", "middle", "surname"],
                     )
-                    # For 3-character all-Chinese, original order is surname-first → swap labels
+                    # For 3-character all-Chinese, original order is surname-first
+                    # Preserve component labels and annotate only the order.
                     parsed_original_order = ParsedName(
-                        surname=given_str,
-                        given_name=surname_str,
-                        surname_tokens=given_final,
-                        given_tokens=surname_final,
+                        surname=surname_str,
+                        given_name=given_str,
+                        surname_tokens=surname_final,
+                        given_tokens=given_final,
                         middle_name=" ".join(middle_tokens) if middle_tokens else "",
                         middle_tokens=middle_tokens,
                         order=["surname", "given"],
@@ -421,76 +423,124 @@ class ChineseNameDetector:
                 except ValueError as e:
                     return ParseResult.failure(str(e))
         else:
-            # Original logic for non-all-Chinese or multi-token inputs
+            # Evaluate both order hypotheses and pick the best-scoring parse
+            original_tokens = list(normalized_input.roman_tokens)
+            best_candidate = None
+
             for order in (normalized_input.roman_tokens, normalized_input.roman_tokens[::-1]):
-                parse_result = self._parsing_service.parse_name_order(
-                    list(order),
+                order_tokens = list(order)
+                parse_result = self._parsing_service.parse_name_order_tokens(
+                    order_tokens,
                     normalized_input.norm_map,
                     normalized_input.compound_metadata,
                 )
-                if parse_result.success:
-                    surname_tokens, given_tokens = parse_result.result
-                    try:
-                        formatted_name, given_final, surname_final, surname_str, given_str, middle_tokens = (
-                            self._formatting_service.format_name_output_with_tokens(
-                                surname_tokens,
-                                given_tokens,
-                                normalized_input.norm_map,
-                                normalized_input.compound_metadata,
-                            )
+                if parse_result is None:
+                    continue
+
+                surname_tokens, given_tokens, original_compound_surname = parse_result
+                score = self._parsing_service.calculate_parse_score(
+                    surname_tokens,
+                    given_tokens,
+                    original_tokens,
+                    normalized_input.norm_map,
+                    False,
+                    original_compound_surname,
+                )
+                used_original = order_tokens == original_tokens
+
+                candidate = {
+                    "surname_tokens": surname_tokens,
+                    "given_tokens": given_tokens,
+                    "score": score,
+                    "order_tokens": order_tokens,
+                    "used_original": used_original,
+                }
+
+                if (
+                    best_candidate is None
+                    or candidate["score"] > best_candidate["score"]
+                    or (
+                        candidate["score"] == best_candidate["score"]
+                        and candidate["used_original"]
+                        and not best_candidate["used_original"]
+                    )
+                ):
+                    best_candidate = candidate
+
+            if best_candidate is not None:
+                surname_tokens = best_candidate["surname_tokens"]
+                given_tokens = best_candidate["given_tokens"]
+                order_tokens = best_candidate["order_tokens"]
+                used_original = best_candidate["used_original"]
+                try:
+                    formatted_name, given_final, surname_final, surname_str, given_str, middle_tokens = (
+                        self._formatting_service.format_name_output_with_tokens(
+                            surname_tokens,
+                            given_tokens,
+                            normalized_input.norm_map,
+                            normalized_input.compound_metadata,
                         )
-                        parsed = ParsedName(
+                    )
+                    parsed = ParsedName(
+                        surname=surname_str,
+                        given_name=given_str,
+                        surname_tokens=surname_final,
+                        given_tokens=given_final,
+                        middle_name=" ".join(middle_tokens) if middle_tokens else "",
+                        middle_tokens=middle_tokens,
+                        order=["given", "middle", "surname"],
+                    )
+                    # Determine original input order relative to detected parse
+                    k = len(surname_tokens)
+                    is_surname_first_in_this_order = list(order_tokens[:k]) == surname_tokens
+                    is_surname_last_in_this_order = list(order_tokens[-k:]) == surname_tokens
+
+                    # Compound surname fallback: surname_tokens may be sub-tokens
+                    # of a single original token (e.g. ['Ou','yang'] from 'Ouyang')
+                    if not is_surname_first_in_this_order and not is_surname_last_in_this_order:
+                        joined_surname = "".join(surname_tokens).lower()
+                        if order_tokens[0].lower() == joined_surname:
+                            is_surname_first_in_this_order = True
+                        elif order_tokens[-1].lower() == joined_surname:
+                            is_surname_last_in_this_order = True
+
+                    if used_original:
+                        original_is_given_first = is_surname_last_in_this_order
+                    else:
+                        original_is_given_first = is_surname_first_in_this_order
+
+                    if original_is_given_first:
+                        order_list = ["given"] + (["middle"] if middle_tokens else []) + ["surname"]
+                        # Keep labels as-is
+                        parsed_original_order = ParsedName(
                             surname=surname_str,
                             given_name=given_str,
                             surname_tokens=surname_final,
                             given_tokens=given_final,
                             middle_name=" ".join(middle_tokens) if middle_tokens else "",
                             middle_tokens=middle_tokens,
-                            order=["given", "middle", "surname"],
+                            order=order_list,
                         )
-                        # Determine original input order relative to detected parse
-                        used_original = order == normalized_input.roman_tokens
-                        k = len(surname_tokens)
-                        is_surname_first_in_this_order = list(order[:k]) == surname_tokens
-                        is_surname_last_in_this_order = list(order[-k:]) == surname_tokens
-
-                        if used_original:
-                            original_is_given_first = is_surname_last_in_this_order
-                        else:
-                            original_is_given_first = is_surname_first_in_this_order
-
-                        if original_is_given_first:
-                            order_list = ["given"] + (["middle"] if middle_tokens else []) + ["surname"]
-                            # Keep labels as-is
-                            parsed_original_order = ParsedName(
-                                surname=surname_str,
-                                given_name=given_str,
-                                surname_tokens=surname_final,
-                                given_tokens=given_final,
-                                middle_name=" ".join(middle_tokens) if middle_tokens else "",
-                                middle_tokens=middle_tokens,
-                                order=order_list,
-                            )
-                        else:
-                            order_list = ["surname"] + (["middle"] if middle_tokens else []) + ["given"]
-                            # Original: surname-first → swap labels to reflect "first part" as given
-                            parsed_original_order = ParsedName(
-                                surname=given_str,
-                                given_name=surname_str,
-                                surname_tokens=given_final,
-                                given_tokens=surname_final,
-                                middle_name=" ".join(middle_tokens) if middle_tokens else "",
-                                middle_tokens=middle_tokens,
-                                order=order_list,
-                            )
-
-                        return ParseResult.success_with_name(
-                            formatted_name,
-                            parsed=parsed,
-                            parsed_original_order=parsed_original_order,
+                    else:
+                        order_list = ["surname"] + (["middle"] if middle_tokens else []) + ["given"]
+                        # Original: surname-first → keep labels stable and annotate order only
+                        parsed_original_order = ParsedName(
+                            surname=surname_str,
+                            given_name=given_str,
+                            surname_tokens=surname_final,
+                            given_tokens=given_final,
+                            middle_name=" ".join(middle_tokens) if middle_tokens else "",
+                            middle_tokens=middle_tokens,
+                            order=order_list,
                         )
-                    except ValueError as e:
-                        return ParseResult.failure(str(e))
+
+                    return ParseResult.success_with_name(
+                        formatted_name,
+                        parsed=parsed,
+                        parsed_original_order=parsed_original_order,
+                    )
+                except ValueError as e:
+                    return ParseResult.failure(str(e))
 
         return ParseResult.failure("name not recognised as Chinese")
 
@@ -533,21 +583,22 @@ class ChineseNameDetector:
             individual_results = [self.normalize_name(name) for name in names]
             return self._create_fallback_batch_result(names, individual_results)
 
-        # Configure threshold for this analysis
-        original_threshold = self._batch_analysis_service._format_threshold
-        self._batch_analysis_service._format_threshold = format_threshold
-
-        try:
-            return self._batch_analysis_service.analyze_name_batch(
-                names,
-                self._normalizer,
-                self._data,
-                self._formatting_service,
-                minimum_batch_size,
-            )
-        finally:
-            # Restore original threshold
-            self._batch_analysis_service._format_threshold = original_threshold
+        with self._batch_threshold_lock:
+            # Configure threshold for this analysis
+            original_threshold = self._batch_analysis_service._format_threshold
+            self._batch_analysis_service._format_threshold = format_threshold
+
+            try:
+                return self._batch_analysis_service.analyze_name_batch(
+                    names,
+                    self._normalizer,
+                    self._data,
+                    self._formatting_service,
+                    minimum_batch_size,
+                )
+            finally:
+                # Restore original threshold
+                self._batch_analysis_service._format_threshold = original_threshold
 
     def detect_batch_format(
         self,
@@ -587,19 +638,20 @@ class ChineseNameDetector:
                 threshold_met=False,
             )
 
-        # Configure threshold for this analysis
-        original_threshold = self._batch_analysis_service._format_threshold
-        self._batch_analysis_service._format_threshold = format_threshold
+        with self._batch_threshold_lock:
+            # Configure threshold for this analysis
+            original_threshold = self._batch_analysis_service._format_threshold
+            self._batch_analysis_service._format_threshold = format_threshold
 
-        try:
-            return self._batch_analysis_service.detect_batch_format(
-                names,
-                self._normalizer,
-                self._data,
-            )
-        finally:
-            # Restore original threshold
-            self._batch_analysis_service._format_threshold = original_threshold
+            try:
+                return self._batch_analysis_service.detect_batch_format(
+                    names,
+                    self._normalizer,
+                    self._data,
+                )
+            finally:
+                # Restore original threshold
+                self._batch_analysis_service._format_threshold = original_threshold
 
     def process_name_batch(
         self,
@@ -632,8 +684,58 @@ class ChineseNameDetector:
         batch_result = self.analyze_name_batch(names, format_threshold, minimum_batch_size)
         return batch_result.results
 
+    def create_persistent_multiprocess_pool(
+        self,
+        *,
+        max_workers: int | None = None,
+        chunk_size: int = 64,
+        mp_start_method: str = "spawn",
+    ) -> PersistentMultiprocessNormalizer:
+        """
+        Create a persistent multi-process pool for repeated normalization calls.
+
+        Notes:
+        - Uses one detector instance per worker process.
+        - For Windows/macOS scripts, call this behind an
+          `if __name__ == "__main__":` guard.
+        """
+        self._ensure_initialized()
+        return PersistentMultiprocessNormalizer(
+            max_workers=max_workers,
+            chunk_size=chunk_size,
+            mp_start_method=mp_start_method,
+            detector_config=self._config,
+            detector_weights=self._weights,
+        )
+
+    def process_name_batch_multiprocess(
+        self,
+        names: list[str],
+        *,
+        max_workers: int | None = None,
+        chunk_size: int = 64,
+        mp_start_method: str = "spawn",
+    ) -> list[ParseResult]:
+        """
+        Process one batch with a temporary multi-process pool.
+
+        For repeated calls, prefer `create_persistent_multiprocess_pool()`
+        to avoid repeated process start-up overhead.
+        """
+        self._ensure_initialized()
+        return normalize_names_multiprocess(
+            names,
+            max_workers=max_workers,
+            chunk_size=chunk_size,
+            mp_start_method=mp_start_method,
+            detector_config=self._config,
+            detector_weights=self._weights,
+        )
+
     def _create_fallback_batch_result(
-        self, names: list[str], individual_results: list[ParseResult],
+        self,
+        names: list[str],
+        individual_results: list[ParseResult],
     ) -> BatchParseResult:
         """Create a fallback BatchParseResult when batch analysis is not available."""
         from sinonym.coretypes import BatchFormatPattern, IndividualAnalysis, NameFormat