code2logic 1.0.39__tar.gz → 1.0.41__tar.gz

{code2logic-1.0.39 → code2logic-1.0.41}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code2logic
-Version: 1.0.39
+Version: 1.0.41
 Summary: Code2Logic - Source code to logical representation converter for LLM analysis, featuring Tree-sitter parsing, dependency graph analysis, and multi-language support.
 License: Apache-2.0
 License-File: LICENSE
@@ -95,9 +95,9 @@ pip install code2logic[nlp]         # Enhanced intents
 ## 📖 Quick Start
 ```bash
 code2logic ./ -f yaml --compact --function-logic --with-schema -o project.yaml
-code2logic ./ -f toon --function-logic --with-schema --name project -o ./
-# Optional: include function intent/purpose column in project.functions.toon
-code2logic ./ -f toon --function-logic --does --name project -o ./
+code2logic ./ -f toon --function-logic function.toon --with-schema --name project -o ./
+# Optional: include function intent/purpose column in function.toon
+code2logic ./ -f toon --function-logic function.toon --does --name project -o ./
 ```
     
 ### Command Line

{code2logic-1.0.39 → code2logic-1.0.41}/README.md

@@ -49,9 +49,9 @@ pip install code2logic[nlp]         # Enhanced intents
 ## 📖 Quick Start
 ```bash
 code2logic ./ -f yaml --compact --function-logic --with-schema -o project.yaml
-code2logic ./ -f toon --function-logic --with-schema --name project -o ./
-# Optional: include function intent/purpose column in project.functions.toon
-code2logic ./ -f toon --function-logic --does --name project -o ./
+code2logic ./ -f toon --function-logic function.toon --with-schema --name project -o ./
+# Optional: include function intent/purpose column in function.toon
+code2logic ./ -f toon --function-logic function.toon --does --name project -o ./
 ```
     
 ### Command Line

{code2logic-1.0.39 → code2logic-1.0.41}/code2logic/__init__.py

@@ -18,7 +18,7 @@ Example:
     >>> print(output)
 """
 
-__version__ = "1.0.39"
+__version__ = "1.0.41"
 __author__ = "Softreck"
 __email__ = "info@softreck.dev"
 __license__ = "MIT"

code2logic-1.0.41/code2logic/base_generator.py

@@ -0,0 +1,6 @@
+from typing import Protocol, Any
+from .models import ProjectInfo
+
+class ProjectGenerator(Protocol):
+    def generate(self, project: ProjectInfo, **kwargs: Any) -> Any:
+        ...

{code2logic-1.0.39 → code2logic-1.0.41}/code2logic/benchmarks/common.py

@@ -5,6 +5,7 @@ from datetime import datetime
 from pathlib import Path
 
 from ..generators import CSVGenerator, JSONGenerator, YAMLGenerator
+from ..function_logic import FunctionLogicGenerator
 from ..gherkin import GherkinGenerator
 from ..logicml import LogicMLGenerator
 from ..markdown_format import MarkdownHybridGenerator
@@ -32,6 +33,15 @@ def generate_spec(project: ProjectInfo, fmt: str) -> str:
     if fmt == "gherkin":
         gen = GherkinGenerator()
         return gen.generate(project)
+    if fmt == "function.toon":
+        gen = FunctionLogicGenerator()
+        return gen.generate_toon(
+            project,
+            detail="full",
+            no_repeat_name=True,
+            no_repeat_details=True,
+            include_does=True,
+        )
     if fmt == "csv":
         gen = CSVGenerator()
         return gen.generate(project, detail="full")
@@ -179,14 +189,21 @@ Name the test class Test<ClassName> or TestFunctions."""
 
 def get_token_reproduction_prompt(spec: str, fmt: str, file_name: str, language: str = "python") -> str:
     format_hints = {
-        "json": "Parse the JSON structure and implement all classes and functions.",
-        "json_compact": "Parse the compact JSON and implement all elements.",
+        "json": "Parse the JSON structure and implement all classes and functions with exact signatures.",
+        "json_compact": "Parse the compact JSON and implement all elements with exact signatures.",
         "yaml": "Parse the YAML structure and implement all classes and functions with exact signatures.",
-        "gherkin": "Implement scenarios as SIMPLE, MINIMAL code. NO over-engineering. Keep code short and direct.",
-        "markdown": "Parse embedded Gherkin (behaviors) and YAML (structures).",
+        "gherkin": """Parse Gherkin/BDD scenarios and implement them as working code:
+- Each Feature maps to a class or module
+- Each Scenario maps to a function
+- Given/When/Then steps describe the logic flow
+- Implement actual logic, not just stubs
+Focus on the described behavior and implement it directly.""",
+        "markdown": "Parse embedded Gherkin (behaviors) and YAML (structures). Implement all described classes and functions.",
         "logicml": """Parse LogicML and generate VALID code:
 - 'sig:' lines describe function signatures (translate to the target language)
 - 'type: re-export' means this module primarily re-exports symbols
+- 'attrs:' = instance attributes to set in constructor
+- 'bases:' = parent classes to inherit from
 CRITICAL: Ensure valid syntax - balanced brackets, proper indentation, no undefined variables.""",
         "toon": """Parse TOON (Token-Oriented Object Notation) format carefully:
 
@@ -206,9 +223,32 @@ DECORATORS:
 - 'decorators: @staticmethod|@cache' = multiple decorators
 
 CRITICAL: Use imports[], function_docs, and exact signatures to reproduce code accurately.""",
+        "csv": """Parse the CSV table where each row describes a code element:
+- Columns: path, type (class/method/function), name, signature, language, intent, category, domain, imports
+- 'method' rows belong to the class in the preceding 'class' row
+- Implement all elements with the exact signatures shown
+Generate complete code with all classes, methods, and functions.""",
+        "function.toon": """Parse the function-logic TOON format:
+- 'modules[N]{path,lang,items}:' lists files
+- 'function_details:' contains per-module function listings
+- Each function has: line number, name, signature, description
+- 'ClassName.method_name' = method of that class
+- 'cc:N' after name = cyclomatic complexity
+Implement all listed functions with matching signatures and described behavior.""",
     }
 
-    max_spec = 5000
+    # Language-specific guidance appended to prompt
+    lang_hints = {
+        "javascript": "Use ES6+ syntax (const/let, arrow functions, classes). Use module.exports or export.",
+        "typescript": "Use TypeScript syntax with interfaces, type annotations, and export statements.",
+        "go": "Use proper Go syntax: package declaration, func receivers for methods, error returns.",
+        "rust": "Use proper Rust syntax: impl blocks for methods, pub fn, Result/Option types, ownership.",
+        "java": "Use proper Java syntax: public class, access modifiers, typed parameters, semicolons.",
+        "csharp": "Use proper C# syntax: namespaces, access modifiers, typed parameters, semicolons.",
+        "sql": "Use standard SQL: CREATE TABLE/VIEW/FUNCTION, proper column types, constraints.",
+    }
+
+    max_spec = 8000
     spec_truncated = spec[:max_spec] if len(spec) > max_spec else spec
 
     language_norm = (language or "python").strip().lower()
@@ -224,8 +264,11 @@ CRITICAL: Use imports[], function_docs, and exact signatures to reproduce code a
     }
     lang_label = lang_label_map.get(language_norm, language_norm)
 
+    lang_hint = lang_hints.get(language_norm, '')
+    lang_hint_line = f"\n{lang_hint}" if lang_hint else ''
+
     prompt = f"""Generate {lang_label} code from this {fmt.upper()} specification.
-{format_hints.get(fmt, '')}
+{format_hints.get(fmt, '')}{lang_hint_line}
 
 {spec_truncated}
 

{code2logic-1.0.39 → code2logic-1.0.41}/code2logic/benchmarks/runner.py

@@ -15,12 +15,14 @@ Usage:
     result.save('output/benchmark.json')
 """
 
-import sys
-import time
 import difflib
 import re
+import sys
+import time
 from pathlib import Path
-from typing import List, Optional
+from typing import Any, Dict, List, Optional
+
+from concurrent.futures import ThreadPoolExecutor, as_completed
 
 from ..analyzer import analyze_project
 from ..llm_clients import BaseLLMClient, get_client
@@ -193,7 +195,7 @@ class BenchmarkRunner:
         """
         self.client = client
         self.config = config or BenchmarkConfig()
-        self._metrics = ReproductionMetrics()
+        # Note: avoid sharing ReproductionMetrics instance across threads.
 
     def _should_use_llm(self) -> bool:
         """Return whether this runner should call an LLM."""
@@ -215,12 +217,37 @@ class BenchmarkRunner:
         classes: List[str] = []
         functions: List[str] = []
 
-        # Common patterns
+        # Common patterns across formats
         classes.extend(re.findall(r"\bclass\s+([A-Za-z_][A-Za-z0-9_]*)", spec))
-        classes.extend(re.findall(r"^([A-Za-z_][A-Za-z0-9_]*)\s*:\s*$", spec, re.MULTILINE))
+        classes.extend(re.findall(r'"name":\s*"([A-Z][A-Za-z0-9_]*)"', spec))
         functions.extend(re.findall(r"\bdef\s+([A-Za-z_][A-Za-z0-9_]*)\s*\(", spec))
         functions.extend(re.findall(r"\bFunction:\s*([A-Za-z_][A-Za-z0-9_]*)", spec))
         functions.extend(re.findall(r"\bScenario:\s*([A-Za-z_][A-Za-z0-9_]*)", spec))
+        # TOON format: function lines like "  42,func_name,(params)"
+        functions.extend(re.findall(r'^\s+\d+,([A-Za-z_][A-Za-z0-9_]*),', spec, re.MULTILINE))
+        # TOON class.method: "  42,ClassName.method_name,"
+        for cm in re.findall(r'^\s+\d+,([A-Z][A-Za-z0-9_]*)\.([a-z_][A-Za-z0-9_]*),', spec, re.MULTILINE):
+            classes.append(cm[0])
+            functions.append(cm[1])
+        # YAML/JSON: "n: ClassName" or name patterns
+        classes.extend(re.findall(r'(?:^|\s)n:\s*([A-Z][A-Za-z0-9_]*)', spec, re.MULTILINE))
+        # CSV format: path,type,name columns
+        for row_m in re.findall(r',class,([A-Z][A-Za-z0-9_]*),', spec):
+            classes.append(row_m)
+        for row_m in re.findall(r',(?:function|method),([a-z_][A-Za-z0-9_]*),', spec):
+            functions.append(row_m)
+        # Gherkin: Feature/Scenario names
+        functions.extend(re.findall(r'Scenario(?:\s+Outline)?:\s*(?:Test\s+)?([A-Za-z_][A-Za-z0-9_]*)', spec))
+        # Non-Python: func/fn/function declarations
+        functions.extend(re.findall(r"\bfunc\s+([A-Za-z_][A-Za-z0-9_]*)", spec))
+        functions.extend(re.findall(r"\bfn\s+([A-Za-z_][A-Za-z0-9_]*)", spec))
+        functions.extend(re.findall(r"\bfunction\s+([A-Za-z_][A-Za-z0-9_]*)\s*\(", spec))
+        # Java/C# style: "public static Type methodName("
+        functions.extend(re.findall(r"(?:public|private)\s+(?:static\s+)?\w+\s+([a-z][A-Za-z0-9_]*)\s*\(", spec))
+        # Interfaces/structs/enums
+        classes.extend(re.findall(r"\binterface\s+([A-Za-z_][A-Za-z0-9_]*)", spec))
+        classes.extend(re.findall(r"\bstruct\s+([A-Za-z_][A-Za-z0-9_]*)", spec))
+        classes.extend(re.findall(r"\benum\s+([A-Za-z_][A-Za-z0-9_]*)", spec))
 
         # Deduplicate while preserving order
         def uniq(items: List[str]) -> List[str]:
@@ -395,11 +422,41 @@ class {cls}:
                 original_size=len(original),
             )
 
-            for fmt in formats:
-                fmt_result = self._test_format(
-                    single_project, original, fmt, abs_file.name, client, verbose, language=module_info.language
-                )
-                file_result.format_results[fmt] = fmt_result
+            max_workers = int(getattr(self.config, "workers", 1) or 1)
+            if max_workers < 1:
+                max_workers = 1
+
+            # Parallelize per-format reproduction (LLM calls) for the same file.
+            if len(formats) > 1 and max_workers > 1:
+                with ThreadPoolExecutor(max_workers=max_workers) as ex:
+                    futs = {
+                        ex.submit(
+                            self._test_format,
+                            single_project,
+                            original,
+                            fmt,
+                            abs_file.name,
+                            client,
+                            verbose,
+                            module_info.language,
+                        ): fmt
+                        for fmt in formats
+                    }
+                    for fut in as_completed(futs):
+                        fmt = futs[fut]
+                        file_result.format_results[fmt] = fut.result()
+            else:
+                for fmt in formats:
+                    fmt_result = self._test_format(
+                        single_project,
+                        original,
+                        fmt,
+                        abs_file.name,
+                        client,
+                        verbose,
+                        language=module_info.language,
+                    )
+                    file_result.format_results[fmt] = fmt_result
 
             # Set best result as file score
             if file_result.format_results:
@@ -472,7 +529,8 @@ class {cls}:
             # Calculate metrics
             if original and generated:
                 if language_norm == 'python':
-                    analysis = self._metrics.analyze(original, generated, spec, format_name=fmt)
+                    metrics = ReproductionMetrics()
+                    analysis = metrics.analyze(original, generated, spec, format_name=fmt)
                     result.score = analysis.overall_score
                     result.similarity = analysis.text.char_similarity
                 else:
@@ -816,33 +874,71 @@ Requirements:
             if verbose:
                 print(f"\n--- Format: {fmt.upper()} ---")
 
-            for i, module in enumerate(modules):
-                file_result = self._reproduce_module(
-                    module, fmt, project_path, client, verbose
-                )
-
-                # Add format to result
-                if file_result.format_results:
-                    fmt_result = list(file_result.format_results.values())[0]
-                else:
-                    fmt_result = FormatResult(format_name=fmt, score=file_result.score)
-                    file_result.format_results[fmt] = fmt_result
-
-                # Find existing file result or create new
-                existing = None
-                for fr in result.file_results:
-                    if fr.file_path == file_result.file_path:
-                        existing = fr
-                        break
-
-                if existing:
-                    existing.format_results[fmt] = fmt_result
-                else:
-                    result.file_results.append(file_result)
-
-                if verbose:
-                    status = "✓" if file_result.score > 50 else "○"
-                    print(f"  [{i+1}/{len(modules)}] {Path(file_result.file_path).name}: {file_result.score:.1f}% {status}")
+            max_workers = int(getattr(self.config, "workers", 1) or 1)
+            if max_workers < 1:
+                max_workers = 1
+
+            # Parallelize per-module reproduction for a given format.
+            if len(modules) > 1 and max_workers > 1:
+                with ThreadPoolExecutor(max_workers=max_workers) as ex:
+                    futs = {
+                        ex.submit(self._reproduce_module, module, fmt, project_path, client, verbose): (i, module)
+                        for i, module in enumerate(modules)
+                    }
+                    for fut in as_completed(futs):
+                        i, _module = futs[fut]
+                        file_result = fut.result()
+
+                        # Add format to result
+                        if file_result.format_results:
+                            fmt_result = list(file_result.format_results.values())[0]
+                        else:
+                            fmt_result = FormatResult(format_name=fmt, score=file_result.score)
+                            file_result.format_results[fmt] = fmt_result
+
+                        # Find existing file result or create new
+                        existing = None
+                        for fr in result.file_results:
+                            if fr.file_path == file_result.file_path:
+                                existing = fr
+                                break
+
+                        if existing:
+                            existing.format_results[fmt] = fmt_result
+                        else:
+                            result.file_results.append(file_result)
+
+                        if verbose:
+                            status = "✓" if file_result.score > 50 else "○"
+                            print(f"  [{i+1}/{len(modules)}] {Path(file_result.file_path).name}: {file_result.score:.1f}% {status}")
+            else:
+                for i, module in enumerate(modules):
+                    file_result = self._reproduce_module(
+                        module, fmt, project_path, client, verbose
+                    )
+
+                    # Add format to result
+                    if file_result.format_results:
+                        fmt_result = list(file_result.format_results.values())[0]
+                    else:
+                        fmt_result = FormatResult(format_name=fmt, score=file_result.score)
+                        file_result.format_results[fmt] = fmt_result
+
+                    # Find existing file result or create new
+                    existing = None
+                    for fr in result.file_results:
+                        if fr.file_path == file_result.file_path:
+                            existing = fr
+                            break
+
+                    if existing:
+                        existing.format_results[fmt] = fmt_result
+                    else:
+                        result.file_results.append(file_result)
+
+                    if verbose:
+                        status = "✓" if file_result.score > 50 else "○"
+                        print(f"  [{i+1}/{len(modules)}] {Path(file_result.file_path).name}: {file_result.score:.1f}% {status}")
 
         result.total_time = time.time() - start_time
 

{code2logic-1.0.39 → code2logic-1.0.41}/code2logic/function_logic.py

@@ -157,14 +157,13 @@ class FunctionLogicGenerator:
         import json
 
         schema = {
-            "$schema": "https://json-schema.org/draft/2020-12/schema",
-            "title": "Code2Logic Function-Logic TOON Schema",
+            "$schema": "http://json-schema.org/draft-07/schema#",
+            "title": "Function Logic TOON",
+            "type": "object",
             "description": (
-                "Schema for function-logic TOON output (e.g. project.functions.toon) — compact function/method index. "
-                "Conventions: name containing '.' = method (Class.method), "
-                "~prefix = async, 'cc:N' suffix = cyclomatic complexity (only when >1)."
+                "Schema for function-logic TOON output (e.g. function.toon) — compact function/method index. "
+                "Generated by code2logic with --function-logic and TOON format."
             ),
-            "type": "object",
             "properties": {
                 "project": {"type": "string", "description": "Project name"},
                 "generated": {"type": "string", "description": "ISO timestamp"},

{code2logic-1.0.39 → code2logic-1.0.41}/code2logic/parsers.py

@@ -2212,30 +2212,30 @@ class UniversalParser:
         for m in re.finditer(r'^import\s+([^;]+);', content, re.MULTILINE):
             imports.append(m.group(1).strip())
 
-        for m in re.finditer(r'^(?:public\s+)?(?:abstract\s+)?class\s+(\w+)', content, re.MULTILINE):
+        for m in re.finditer(r'^\s*(?:public\s+)?(?:abstract\s+)?class\s+(\w+)', content, re.MULTILINE):
             name = m.group(1)
             classes.append(ClassInfo(name=name, is_abstract='abstract' in m.group(0)))
             exports.append(name)
 
-        for m in re.finditer(r'^(?:public\s+)?interface\s+(\w+)', content, re.MULTILINE):
+        for m in re.finditer(r'^\s*(?:public\s+)?interface\s+(\w+)', content, re.MULTILINE):
             name = m.group(1)
             classes.append(ClassInfo(name=name, is_interface=True))
             exports.append(name)
             types.append(TypeInfo(name=name, kind='interface', definition=''))
 
-        for m in re.finditer(r'^(?:public\s+)?enum\s+(\w+)', content, re.MULTILINE):
+        for m in re.finditer(r'^\s*(?:public\s+)?enum\s+(\w+)', content, re.MULTILINE):
             name = m.group(1)
             types.append(TypeInfo(name=name, kind='enum', definition=''))
             exports.append(name)
 
-        for m in re.finditer(r'^(?:public\s+)?record\s+(\w+)\s*\(', content, re.MULTILINE):
+        for m in re.finditer(r'^\s*(?:public\s+)?record\s+(\w+)\s*\(', content, re.MULTILINE):
             name = m.group(1)
             classes.append(ClassInfo(name=name))
             types.append(TypeInfo(name=name, kind='record', definition=''))
             exports.append(name)
 
-        # Very rough method detection (only top-level class members are not tracked here)
-        for m in re.finditer(r'^(?:public|protected|private)\s+(?:static\s+)?([\w<>\[\]]+)\s+(\w+)\s*\(([^)]*)\)\s*\{', content, re.MULTILINE):
+        # Method detection – allow indented declarations inside classes
+        for m in re.finditer(r'^\s*(?:@\w+\s+)*(?:public|protected|private)\s+(?:static\s+)?(?:final\s+)?(?:synchronized\s+)?([\w<>\[\],\s]+?)\s+(\w+)\s*\(([^)]*)\)\s*(?:throws\s+[\w,\s]+)?\s*\{', content, re.MULTILINE):
             ret_type = m.group(1)
             name = m.group(2)
             params = [p.strip() for p in (m.group(3) or '').split(',') if p.strip()][:8]
@@ -2260,7 +2260,7 @@ class UniversalParser:
                 is_private=False,
             ))
 
-        for m in re.finditer(r'^(?:public\s+)?static\s+final\s+[\w<>\[\]]+\s+([A-Z][A-Z0-9_]*)\b', content, re.MULTILINE):
+        for m in re.finditer(r'^\s*(?:public\s+)?static\s+final\s+[\w<>\[\]]+\s+([A-Z][A-Z0-9_]*)\b', content, re.MULTILINE):
             constants.append(m.group(1))
 
         lines = content.split('\n')
@@ -2290,24 +2290,24 @@ class UniversalParser:
         for m in re.finditer(r'^using\s+([^;]+);', content, re.MULTILINE):
             imports.append(m.group(1).strip())
 
-        for m in re.finditer(r'^(?:public\s+)?interface\s+(I\w+)', content, re.MULTILINE):
+        for m in re.finditer(r'^\s*(?:public\s+)?interface\s+(I\w+)', content, re.MULTILINE):
             name = m.group(1)
             classes.append(ClassInfo(name=name, is_interface=True))
             exports.append(name)
             types.append(TypeInfo(name=name, kind='interface', definition=''))
 
-        for m in re.finditer(r'^(?:public\s+)?(?:abstract\s+)?class\s+(\w+)', content, re.MULTILINE):
+        for m in re.finditer(r'^\s*(?:public\s+)?(?:abstract\s+)?class\s+(\w+)', content, re.MULTILINE):
             name = m.group(1)
             classes.append(ClassInfo(name=name, is_abstract='abstract' in m.group(0)))
             exports.append(name)
 
-        for m in re.finditer(r'^(?:public\s+)?record\s+(\w+)', content, re.MULTILINE):
+        for m in re.finditer(r'^\s*(?:public\s+)?record\s+(\w+)', content, re.MULTILINE):
             name = m.group(1)
             classes.append(ClassInfo(name=name))
             exports.append(name)
             types.append(TypeInfo(name=name, kind='record', definition=''))
 
-        for m in re.finditer(r'^(?:public|private|protected|internal)\s+(?:static\s+)?([\w<>\[\]?]+)\s+(\w+)\s*\(([^)]*)\)\s*\{', content, re.MULTILINE):
+        for m in re.finditer(r'^\s*(?:public|private|protected|internal)\s+(?:static\s+)?(?:async\s+)?(?:override\s+)?(?:virtual\s+)?([\w<>\[\]?]+)\s+(\w+)\s*\(([^)]*)\)\s*\{', content, re.MULTILINE):
             ret_type = m.group(1)
             name = m.group(2)
             params = [p.strip() for p in (m.group(3) or '').split(',') if p.strip()][:8]
@@ -2332,7 +2332,7 @@ class UniversalParser:
                 is_private=False,
             ))
 
-        for m in re.finditer(r'^(?:public\s+)?const\s+[\w<>\[\]]+\s+([A-Z][A-Z0-9_]*)\b', content, re.MULTILINE):
+        for m in re.finditer(r'^\s*(?:public\s+)?const\s+[\w<>\[\]]+\s+([A-Z][A-Z0-9_]*)\b', content, re.MULTILINE):
             constants.append(m.group(1))
 
         lines = content.split('\n')

{code2logic-1.0.39 → code2logic-1.0.41}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "code2logic"
-version = "1.0.39"
+version = "1.0.41"
 description = "Code2Logic - Source code to logical representation converter for LLM analysis, featuring Tree-sitter parsing, dependency graph analysis, and multi-language support."
 readme = "README.md"
 license = "Apache-2.0"

code2logic-1.0.39/code2logic/llm_clients_new.py

@@ -1,44 +0,0 @@
-from .llm_clients import (
-    DEFAULT_MODELS,
-    DEFAULT_PROVIDER_PRIORITIES,
-    RECOMMENDED_MODELS,
-    BaseLLMClient,
-    LiteLLMClient,
-    LLMConfig,
-    LLMManager,
-    OllamaLocalClient,
-    OpenRouterClient,
-    get_client,
-    get_provider_model,
-    list_available_providers,
-)
-
-
-def get_provider_priorities_from_litellm() -> dict[str, int]:
-    try:
-        from lolm import get_provider_priorities_from_litellm as _get
-    except ImportError:
-        return {}
-
-    try:
-        raw = _get() or {}
-        return {str(k): int(v) for k, v in raw.items()}
-    except Exception:
-        return {}
-
-__all__ = [
-    'DEFAULT_MODELS',
-    'DEFAULT_PROVIDER_PRIORITIES',
-    'RECOMMENDED_MODELS',
-    'BaseLLMClient',
-    'LiteLLMClient',
-    'LLMConfig',
-    'LLMManager',
-    'OpenRouterClient',
-    'OllamaLocalClient',
-    'get_client',
-    'get_provider_model',
-    'get_provider_priorities_from_litellm',
-    'list_available_providers',
-]
-