parseforge 0.2.6__tar.gz → 0.2.8__tar.gz

{parseforge-0.2.6/parseforge.egg-info → parseforge-0.2.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: parseforge
-Version: 0.2.6
+Version: 0.2.8
 Summary: LLM-driven pipeline that forges, validates, and promotes TextFSM templates from network CLI output
 Author-email: Tuyen Mathew Duong <tuyen@geekstrident.com>
 Maintainer-email: Tuyen Mathew Duong <tuyen@geekstrident.com>
@@ -60,6 +60,12 @@ Requires-Dist: textfsm-ai[moonshot]>=0.6.1; extra == "moonshot"
 Provides-Extra: cerebras
 Requires-Dist: openai>=1.0.0; extra == "cerebras"
 Requires-Dist: textfsm-ai[cerebras]>=0.6.1; extra == "cerebras"
+Provides-Extra: mistral
+Requires-Dist: mistralai==1.10.0; extra == "mistral"
+Requires-Dist: textfsm-ai[mistral]>=0.6.1; extra == "mistral"
+Provides-Extra: cohere
+Requires-Dist: cohere==5.21.1; extra == "cohere"
+Requires-Dist: textfsm-ai[cohere]>=0.6.1; extra == "cohere"
 Provides-Extra: sampling
 Requires-Dist: netmiko>=4.0; extra == "sampling"
 Provides-Extra: dev
@@ -70,6 +76,8 @@ Requires-Dist: black>=24.0.0; extra == "dev"
 Requires-Dist: mypy>=1.10.0; extra == "dev"
 Requires-Dist: anthropic>=0.40.0; extra == "dev"
 Requires-Dist: openai>=1.0.0; extra == "dev"
+Requires-Dist: mistralai==1.10.0; extra == "dev"
+Requires-Dist: cohere==5.21.1; extra == "dev"
 Provides-Extra: release
 Requires-Dist: bump2version; extra == "release"
 Requires-Dist: build; extra == "release"
@@ -112,11 +120,11 @@ command that's pure local processing (`canonical`/`readable`/`recognizers`,
 LLM (`name`, `check --provider`, `run`, `generate-template`, `trial`) needs the
 extra for whichever provider it uses: `anthropic`, `openai`, `deepseek`,
 `groq`, `xai`, `together`, `fireworks`, `perplexity`, `openrouter`,
-`moonshot`, or `cerebras`. `--provider` defaults to `anthropic` wherever it
-isn't required, so that's the one most setups need. `pip install
-parseforge[sampling]` adds Netmiko for live device sampling; combine extras
-as needed, e.g.
-`pip install parseforge[anthropic,openai,deepseek,groq,xai,together,fireworks,perplexity,openrouter,moonshot,cerebras,sampling]`.
+`moonshot`, `cerebras`, `mistral`, or `cohere`. `--provider` defaults to
+`anthropic` wherever it isn't required, so that's the one most setups need.
+`pip install parseforge[sampling]` adds Netmiko for live device sampling;
+combine extras as needed, e.g.
+`pip install parseforge[anthropic,openai,deepseek,groq,xai,together,fireworks,perplexity,openrouter,moonshot,cerebras,mistral,cohere,sampling]`.
 
 ## Development
 
@@ -124,11 +132,13 @@ as needed, e.g.
 pip install -e ".[dev,sampling]"
 pytest
 ```
-`dev` already includes both the `anthropic` and `openai` SDKs (tests exercise
-all eleven providers — `anthropic`, `openai`, `deepseek`, `groq`, `xai`,
-`together`, `fireworks`, `perplexity`, `openrouter`, `moonshot`, `cerebras`
-share just those two packages — and never silently skip) — add the specific
-`,<provider>` extra explicitly only if installing outside of `dev`.
+`dev` already includes the `anthropic`, `openai`, `mistralai`, and `cohere`
+SDKs (tests exercise all thirteen providers — `anthropic`, `openai`,
+`deepseek`, `groq`, `xai`, `together`, `fireworks`, `perplexity`,
+`openrouter`, `moonshot`, `cerebras` share just the first two packages, and
+`mistral`/`cohere` each need their own native SDK — and never silently
+skip) — add the specific `,<provider>` extra explicitly only if installing
+outside of `dev`.
 
 Linting/formatting/type-checking/docs run through tox instead of extras — see
 `tox.ini` (`tox -e lint`/`format`/`typecheck`/`docs`), each installing its own

{parseforge-0.2.6 → parseforge-0.2.8}/README.md

@@ -35,11 +35,11 @@ command that's pure local processing (`canonical`/`readable`/`recognizers`,
 LLM (`name`, `check --provider`, `run`, `generate-template`, `trial`) needs the
 extra for whichever provider it uses: `anthropic`, `openai`, `deepseek`,
 `groq`, `xai`, `together`, `fireworks`, `perplexity`, `openrouter`,
-`moonshot`, or `cerebras`. `--provider` defaults to `anthropic` wherever it
-isn't required, so that's the one most setups need. `pip install
-parseforge[sampling]` adds Netmiko for live device sampling; combine extras
-as needed, e.g.
-`pip install parseforge[anthropic,openai,deepseek,groq,xai,together,fireworks,perplexity,openrouter,moonshot,cerebras,sampling]`.
+`moonshot`, `cerebras`, `mistral`, or `cohere`. `--provider` defaults to
+`anthropic` wherever it isn't required, so that's the one most setups need.
+`pip install parseforge[sampling]` adds Netmiko for live device sampling;
+combine extras as needed, e.g.
+`pip install parseforge[anthropic,openai,deepseek,groq,xai,together,fireworks,perplexity,openrouter,moonshot,cerebras,mistral,cohere,sampling]`.
 
 ## Development
 
@@ -47,11 +47,13 @@ as needed, e.g.
 pip install -e ".[dev,sampling]"
 pytest
 ```
-`dev` already includes both the `anthropic` and `openai` SDKs (tests exercise
-all eleven providers — `anthropic`, `openai`, `deepseek`, `groq`, `xai`,
-`together`, `fireworks`, `perplexity`, `openrouter`, `moonshot`, `cerebras`
-share just those two packages — and never silently skip) — add the specific
-`,<provider>` extra explicitly only if installing outside of `dev`.
+`dev` already includes the `anthropic`, `openai`, `mistralai`, and `cohere`
+SDKs (tests exercise all thirteen providers — `anthropic`, `openai`,
+`deepseek`, `groq`, `xai`, `together`, `fireworks`, `perplexity`,
+`openrouter`, `moonshot`, `cerebras` share just the first two packages, and
+`mistral`/`cohere` each need their own native SDK — and never silently
+skip) — add the specific `,<provider>` extra explicitly only if installing
+outside of `dev`.
 
 Linting/formatting/type-checking/docs run through tox instead of extras — see
 `tox.ini` (`tox -e lint`/`format`/`typecheck`/`docs`), each installing its own

parseforge-0.2.8/parseforge/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.2.8"

{parseforge-0.2.6 → parseforge-0.2.8}/parseforge/cli/main.py

@@ -24,9 +24,11 @@ from parseforge.cli import config as cli_config
 _BUILDERS: dict[str, type[naming.RegexBuilder]] = {
     "anthropic": naming.AnthropicRegexBuilder,
     "cerebras": naming.CerebrasRegexBuilder,
+    "cohere": naming.CohereRegexBuilder,
     "deepseek": naming.DeepSeekRegexBuilder,
     "fireworks": naming.FireworksRegexBuilder,
     "groq": naming.GroqRegexBuilder,
+    "mistral": naming.MistralRegexBuilder,
     "moonshot": naming.MoonshotRegexBuilder,
     "openai": naming.OpenAIRegexBuilder,
     "openrouter": naming.OpenRouterRegexBuilder,
@@ -209,8 +211,8 @@ def main() -> None:
     help="Provider API key. Defaults to that provider's own API key environment "
     "variable (ANTHROPIC_API_KEY, OPENAI_API_KEY, DEEPSEEK_API_KEY, GROQ_API_KEY, "
     "XAI_API_KEY, TOGETHER_API_KEY, FIREWORKS_API_KEY, PERPLEXITY_API_KEY, "
-    "OPENROUTER_API_KEY, MOONSHOT_API_KEY, CEREBRAS_API_KEY); only needed on a "
-    "cache miss.",
+    "OPENROUTER_API_KEY, MOONSHOT_API_KEY, CEREBRAS_API_KEY, MISTRAL_API_KEY, "
+    "COHERE_API_KEY); only needed on a cache miss.",
 )
 @click.option(
     "--model",
@@ -279,8 +281,9 @@ def name_cmd(
     required=True,
     help="LLM provider for template generation (textfsm-ai's own registry, "
     'e.g. "anthropic", "openai", "deepseek", "groq", "xai", "together", '
-    '"fireworks", "perplexity", "openrouter", "moonshot", "cerebras"). Naming '
-    "uses its own separate --naming-provider, not this one.",
+    '"fireworks", "perplexity", "openrouter", "moonshot", "cerebras", '
+    '"mistral", "cohere"). Naming uses its own separate --naming-provider, '
+    "not this one.",
 )
 @click.option("--api-key", required=True, help="API key for the generation LLM call.")
 @click.option("--model", required=True, help="Model for the generation LLM call.")

{parseforge-0.2.6 → parseforge-0.2.8}/parseforge/naming/__init__.py

@@ -11,9 +11,11 @@ from .llm import (
 from .providers import (
     AnthropicRegexBuilder,
     CerebrasRegexBuilder,
+    CohereRegexBuilder,
     DeepSeekRegexBuilder,
     FireworksRegexBuilder,
     GroqRegexBuilder,
+    MistralRegexBuilder,
     MoonshotRegexBuilder,
     OpenAIRegexBuilder,
     OpenRouterRegexBuilder,
@@ -32,9 +34,11 @@ __all__ = [
     "UnimplementedRegexBuilder",
     "AnthropicRegexBuilder",
     "CerebrasRegexBuilder",
+    "CohereRegexBuilder",
     "DeepSeekRegexBuilder",
     "FireworksRegexBuilder",
     "GroqRegexBuilder",
+    "MistralRegexBuilder",
     "MoonshotRegexBuilder",
     "OpenAIRegexBuilder",
     "OpenRouterRegexBuilder",

{parseforge-0.2.6 → parseforge-0.2.8}/parseforge/naming/providers/__init__.py

@@ -1,8 +1,10 @@
 from .anthropic import AnthropicRegexBuilder
 from .cerebras import CerebrasRegexBuilder
+from .cohere import CohereRegexBuilder
 from .deepseek import DeepSeekRegexBuilder
 from .fireworks import FireworksRegexBuilder
 from .groq import GroqRegexBuilder
+from .mistral import MistralRegexBuilder
 from .moonshot import MoonshotRegexBuilder
 from .openai import OpenAIRegexBuilder
 from .openrouter import OpenRouterRegexBuilder
@@ -13,9 +15,11 @@ from .xai import XAIRegexBuilder
 __all__ = [
     "AnthropicRegexBuilder",
     "CerebrasRegexBuilder",
+    "CohereRegexBuilder",
     "DeepSeekRegexBuilder",
     "FireworksRegexBuilder",
     "GroqRegexBuilder",
+    "MistralRegexBuilder",
     "MoonshotRegexBuilder",
     "OpenAIRegexBuilder",
     "OpenRouterRegexBuilder",

parseforge-0.2.8/parseforge/naming/providers/cohere.py

@@ -0,0 +1,173 @@
+"""Cohere-backed RegexBuilder implementation.
+
+Like Mistral, Cohere's official Python SDK is not built on the OpenAI
+client library — it has its own generated client shape. Unlike Mistral's
+single client (which exposes both complete()/complete_async() on one
+object), Cohere exposes genuinely separate ``ClientV2``/``AsyncClientV2``
+classes; this builder only ever needs the sync ``ClientV2``, since
+``RegexBuilder.build_pattern()`` is a synchronous call.
+"""
+
+from __future__ import annotations
+
+import os
+import time
+from typing import TYPE_CHECKING, Any, cast
+
+from ..llm import CliContext, LLMCLIResponse, TokenUsage, build_prompt
+from .cost import estimate_cost
+from .models import default_model
+from .text import extract_pattern
+
+if TYPE_CHECKING:
+    import cohere as cohere_sdk
+
+DEFAULT_MODEL = default_model("cohere")
+
+_DEFAULT_MAX_TOKENS = 1024
+
+# HTTP statuses where retrying the exact same request can't succeed —
+# mirrors providers/errors.py's NON_RETRYABLE class-name set (BadRequest,
+# Authentication, PermissionDenied, NotFound, Conflict, RequestTooLarge,
+# UnprocessableEntity). The cohere SDK raises a family of named exception
+# classes (BadRequestError, UnauthorizedError, ForbiddenError, ...), but
+# those names don't line up with OpenAI/Anthropic's naming, and every one
+# of them carries its status on exc.status_code (see
+# cohere.core.api_error.ApiError, their shared base) — so classification
+# here is done by status code instead of exception class name.
+_NON_RETRYABLE_STATUSES = frozenset({400, 401, 403, 404, 409, 413, 422})
+
+
+def _import_cohere() -> Any:
+    """Deferred import — cohere is an optional extra (parseforge[cohere]);
+    nothing else in this module (or a cache-hit lookup, which never reaches
+    build_pattern at all — see resolver.cli_name) should require it to be
+    installed."""
+    try:
+        import cohere
+        import cohere.core.api_error  # noqa: F401  (makes cohere.core.api_error.ApiError reachable off the returned module)
+    except ImportError as exc:
+        raise ImportError(
+            "the cohere package is required to use CohereRegexBuilder — "
+            "install it via `pip install parseforge[cohere]`"
+        ) from exc
+    return cohere
+
+
+def _status_code(exc: Any) -> int | None:
+    return getattr(exc, "status_code", None)
+
+
+def _is_retryable(exc: Any) -> bool:
+    return _status_code(exc) not in _NON_RETRYABLE_STATUSES
+
+
+def _format_error_reason(exc: Any) -> str:
+    return f"LLM-ERROR-cohere_sdk-{_status_code(exc)}-{exc}"
+
+
+def _extract_text(content: Any) -> str:
+    """Cohere's AssistantMessageResponse.content is a list of content
+    blocks (text and/or thinking blocks), unlike Mistral/OpenAI's plain
+    string — join the text blocks' .text, same as textfsm-ai's own
+    CohereProvider._parse_cohere_response()."""
+    if isinstance(content, str):
+        return content
+    return "".join(getattr(block, "text", "") for block in content or [])
+
+
+class CohereRegexBuilder:
+    """Builds a cli-name regex pattern by prompting a Cohere-hosted model.
+
+    The client is constructed lazily, on the first actual call — not in
+    ``__init__`` — so this can be used as a default RegexBuilder without
+    requiring ``COHERE_API_KEY`` to be set for cache-hit lookups, which
+    never reach the LLM at all (see resolver.cli_name).
+
+    API key resolves from the ``api_key`` argument if given, otherwise the
+    ``COHERE_API_KEY`` environment variable (the SDK's own default).
+    """
+
+    provider = "cohere"
+
+    def __init__(self, model: str = DEFAULT_MODEL, api_key: str | None = None) -> None:
+        self.model = model
+        self._api_key = api_key
+        self._client: cohere_sdk.ClientV2 | None = None
+
+    def _get_client(self) -> cohere_sdk.ClientV2:
+        if self._client is None:
+            cohere = _import_cohere()
+            api_key = self._api_key or os.environ.get("COHERE_API_KEY")
+            if not api_key:
+                raise RuntimeError(
+                    "no Cohere API key — pass api_key or set COHERE_API_KEY"
+                )
+            self._client = cohere.ClientV2(api_key=api_key)
+        return self._client
+
+    def build_pattern(
+        self, command: str, context: CliContext, **kwargs: Any
+    ) -> LLMCLIResponse:
+        cohere = _import_cohere()
+        prompt = build_prompt(command, context)
+        max_tokens = kwargs.pop("max_tokens", None) or _DEFAULT_MAX_TOKENS
+
+        start = time.monotonic()
+        try:
+            response = self._get_client().chat(
+                model=self.model,
+                max_tokens=max_tokens,
+                # cast: cohere's generated stubs want a precise
+                # UserChatMessageV2/... union or matching TypedDict, but a
+                # plain {"role": "user", "content": ...} dict is exactly
+                # that shape.
+                messages=cast(Any, [{"role": "user", "content": prompt}]),
+                **kwargs,
+            )
+        except cohere.core.api_error.ApiError as exc:
+            if not _is_retryable(exc):
+                # Same request would fail the same way again — stop rather
+                # than let a caller burn another attempt on it.
+                raise
+            return LLMCLIResponse(
+                content="",
+                raw=exc,
+                usage=TokenUsage(
+                    input_tokens=0, output_tokens=0, total_tokens=0, estimated_cost=0.0
+                ),
+                duration_ms=(time.monotonic() - start) * 1000,
+                reason=_format_error_reason(exc),
+                ready=False,
+            )
+        duration_ms = (time.monotonic() - start) * 1000
+
+        text = _extract_text(response.message.content)
+        # usage/usage.tokens are both Optional, and input_tokens/
+        # output_tokens are typed float — unlike every openai-compat
+        # provider, Cohere's usage.tokens has no total_tokens field at
+        # all, so it's computed here rather than read off the response.
+        tokens = response.usage.tokens if response.usage else None
+        input_tokens = int(tokens.input_tokens or 0) if tokens else 0
+        output_tokens = int(tokens.output_tokens or 0) if tokens else 0
+        total_tokens = input_tokens + output_tokens
+
+        return LLMCLIResponse(
+            content=extract_pattern(text),
+            raw=response,
+            usage=TokenUsage(
+                input_tokens=input_tokens,
+                output_tokens=output_tokens,
+                total_tokens=total_tokens,
+                estimated_cost=estimate_cost(
+                    input_tokens=input_tokens,
+                    output_tokens=output_tokens,
+                    total_tokens=total_tokens,
+                    provider=self.provider,
+                    model=self.model,
+                ),
+            ),
+            duration_ms=duration_ms,
+            reason=response.finish_reason or "",
+            ready=response.finish_reason == "COMPLETE",
+        )

parseforge-0.2.8/parseforge/naming/providers/mistral.py

@@ -0,0 +1,163 @@
+"""Mistral AI-backed RegexBuilder implementation.
+
+Unlike the OpenAI-compatible providers (DeepSeek/Groq/xAI/Together/
+Fireworks/Perplexity/OpenRouter/Moonshot/Cerebras), Mistral's official
+Python SDK is not built on the OpenAI client library — it has its own
+generated client shape (``client.chat.complete()``), even though the
+underlying response shape (``choices[0].message.content``,
+``usage.prompt_tokens/completion_tokens/total_tokens``) closely mirrors
+OpenAI's chat-completions format. So this talks to the native
+``mistralai`` SDK directly rather than pointing the ``openai`` SDK at a
+different base_url.
+"""
+
+from __future__ import annotations
+
+import os
+import time
+from typing import TYPE_CHECKING, Any, cast
+
+from ..llm import CliContext, LLMCLIResponse, TokenUsage, build_prompt
+from .cost import estimate_cost
+from .models import default_model
+from .text import extract_pattern
+
+if TYPE_CHECKING:
+    import mistralai as mistralai_sdk
+
+DEFAULT_MODEL = default_model("mistral")
+
+_DEFAULT_MAX_TOKENS = 1024
+
+# HTTP statuses where retrying the exact same request can't succeed —
+# mirrors providers/errors.py's NON_RETRYABLE class-name set (BadRequest,
+# Authentication, PermissionDenied, NotFound, Conflict, RequestTooLarge,
+# UnprocessableEntity), but the mistralai SDK raises a single SDKError for
+# every HTTP failure (status carried on exc.raw_response.status_code)
+# rather than a family of named exception classes, so classification here
+# is done by status code instead of exception class name.
+_NON_RETRYABLE_STATUSES = frozenset({400, 401, 403, 404, 409, 413, 422})
+
+
+def _import_mistralai() -> Any:
+    """Deferred import — mistralai is an optional extra (parseforge[mistral]);
+    nothing else in this module (or a cache-hit lookup, which never reaches
+    build_pattern at all — see resolver.cli_name) should require it to be
+    installed."""
+    try:
+        import mistralai
+    except ImportError as exc:
+        raise ImportError(
+            "the mistralai package is required to use MistralRegexBuilder — "
+            "install it via `pip install parseforge[mistral]`"
+        ) from exc
+    return mistralai
+
+
+def _status_code(exc: Any) -> int | None:
+    return getattr(getattr(exc, "raw_response", None), "status_code", None)
+
+
+def _is_retryable(exc: Any) -> bool:
+    return _status_code(exc) not in _NON_RETRYABLE_STATUSES
+
+
+def _format_error_reason(exc: Any) -> str:
+    return f"LLM-ERROR-mistral_sdk-{_status_code(exc)}-{exc}"
+
+
+class MistralRegexBuilder:
+    """Builds a cli-name regex pattern by prompting a Mistral-hosted model.
+
+    The client is constructed lazily, on the first actual call — not in
+    ``__init__`` — so this can be used as a default RegexBuilder without
+    requiring ``MISTRAL_API_KEY`` to be set for cache-hit lookups, which
+    never reach the LLM at all (see resolver.cli_name).
+
+    API key resolves from the ``api_key`` argument if given, otherwise the
+    ``MISTRAL_API_KEY`` environment variable (the SDK's own default).
+    """
+
+    provider = "mistral"
+
+    def __init__(self, model: str = DEFAULT_MODEL, api_key: str | None = None) -> None:
+        self.model = model
+        self._api_key = api_key
+        self._client: mistralai_sdk.Mistral | None = None
+
+    def _get_client(self) -> mistralai_sdk.Mistral:
+        if self._client is None:
+            mistralai = _import_mistralai()
+            api_key = self._api_key or os.environ.get("MISTRAL_API_KEY")
+            if not api_key:
+                raise RuntimeError(
+                    "no Mistral API key — pass api_key or set MISTRAL_API_KEY"
+                )
+            self._client = mistralai.Mistral(api_key=api_key)
+        return self._client
+
+    def build_pattern(
+        self, command: str, context: CliContext, **kwargs: Any
+    ) -> LLMCLIResponse:
+        mistralai = _import_mistralai()
+        prompt = build_prompt(command, context)
+        max_tokens = kwargs.pop("max_tokens", None) or _DEFAULT_MAX_TOKENS
+
+        start = time.monotonic()
+        try:
+            response = self._get_client().chat.complete(
+                model=self.model,
+                max_tokens=max_tokens,
+                # cast: mistralai's generated stubs want a precise
+                # AssistantMessage/SystemMessage/... union or matching
+                # TypedDict, but a plain {"role": "user", "content": ...}
+                # dict is exactly the shape UserMessageTypedDict expects.
+                messages=cast(Any, [{"role": "user", "content": prompt}]),
+                **kwargs,
+            )
+        except mistralai.models.SDKError as exc:
+            if not _is_retryable(exc):
+                # Same request would fail the same way again — stop rather
+                # than let a caller burn another attempt on it.
+                raise
+            return LLMCLIResponse(
+                content="",
+                raw=exc,
+                usage=TokenUsage(
+                    input_tokens=0, output_tokens=0, total_tokens=0, estimated_cost=0.0
+                ),
+                duration_ms=(time.monotonic() - start) * 1000,
+                reason=_format_error_reason(exc),
+                ready=False,
+            )
+        duration_ms = (time.monotonic() - start) * 1000
+
+        choice = response.choices[0]
+        content = choice.message.content
+        text = content if isinstance(content, str) else ""
+        # prompt_tokens/completion_tokens/total_tokens are typed
+        # Optional[int] = 0 in Mistral's UsageInfo, even though the API
+        # always populates them — guard against the type, not just the
+        # runtime default.
+        input_tokens = response.usage.prompt_tokens or 0
+        output_tokens = response.usage.completion_tokens or 0
+        total_tokens = response.usage.total_tokens or 0
+        return LLMCLIResponse(
+            content=extract_pattern(text),
+            raw=response,
+            usage=TokenUsage(
+                input_tokens=input_tokens,
+                output_tokens=output_tokens,
+                total_tokens=total_tokens,
+                estimated_cost=estimate_cost(
+                    input_tokens=input_tokens,
+                    output_tokens=output_tokens,
+                    total_tokens=total_tokens,
+                    provider=self.provider,
+                    model=self.model,
+                ),
+            ),
+            duration_ms=duration_ms,
+            reason=choice.finish_reason or "",
+            ready=choice.finish_reason == "stop",
+        )

{parseforge-0.2.6 → parseforge-0.2.8}/parseforge/naming/providers/models.yaml

@@ -110,3 +110,22 @@ cerebras:
     - qwen-3-32b
     - gpt-oss-120b
   deprecated: []
+
+mistral:
+  default: mistral-small-latest
+  supported:
+    - mistral-small-latest
+    - mistral-medium-latest
+    - mistral-large-latest
+    - magistral-medium-latest
+    - codestral-latest
+  deprecated: []
+
+cohere:
+  default: command-light
+  supported:
+    - command-light
+    - command-r
+    - command-r-plus
+    - command-a
+  deprecated: []

{parseforge-0.2.6 → parseforge-0.2.8/parseforge.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: parseforge
-Version: 0.2.6
+Version: 0.2.8
 Summary: LLM-driven pipeline that forges, validates, and promotes TextFSM templates from network CLI output
 Author-email: Tuyen Mathew Duong <tuyen@geekstrident.com>
 Maintainer-email: Tuyen Mathew Duong <tuyen@geekstrident.com>
@@ -60,6 +60,12 @@ Requires-Dist: textfsm-ai[moonshot]>=0.6.1; extra == "moonshot"
 Provides-Extra: cerebras
 Requires-Dist: openai>=1.0.0; extra == "cerebras"
 Requires-Dist: textfsm-ai[cerebras]>=0.6.1; extra == "cerebras"
+Provides-Extra: mistral
+Requires-Dist: mistralai==1.10.0; extra == "mistral"
+Requires-Dist: textfsm-ai[mistral]>=0.6.1; extra == "mistral"
+Provides-Extra: cohere
+Requires-Dist: cohere==5.21.1; extra == "cohere"
+Requires-Dist: textfsm-ai[cohere]>=0.6.1; extra == "cohere"
 Provides-Extra: sampling
 Requires-Dist: netmiko>=4.0; extra == "sampling"
 Provides-Extra: dev
@@ -70,6 +76,8 @@ Requires-Dist: black>=24.0.0; extra == "dev"
 Requires-Dist: mypy>=1.10.0; extra == "dev"
 Requires-Dist: anthropic>=0.40.0; extra == "dev"
 Requires-Dist: openai>=1.0.0; extra == "dev"
+Requires-Dist: mistralai==1.10.0; extra == "dev"
+Requires-Dist: cohere==5.21.1; extra == "dev"
 Provides-Extra: release
 Requires-Dist: bump2version; extra == "release"
 Requires-Dist: build; extra == "release"
@@ -112,11 +120,11 @@ command that's pure local processing (`canonical`/`readable`/`recognizers`,
 LLM (`name`, `check --provider`, `run`, `generate-template`, `trial`) needs the
 extra for whichever provider it uses: `anthropic`, `openai`, `deepseek`,
 `groq`, `xai`, `together`, `fireworks`, `perplexity`, `openrouter`,
-`moonshot`, or `cerebras`. `--provider` defaults to `anthropic` wherever it
-isn't required, so that's the one most setups need. `pip install
-parseforge[sampling]` adds Netmiko for live device sampling; combine extras
-as needed, e.g.
-`pip install parseforge[anthropic,openai,deepseek,groq,xai,together,fireworks,perplexity,openrouter,moonshot,cerebras,sampling]`.
+`moonshot`, `cerebras`, `mistral`, or `cohere`. `--provider` defaults to
+`anthropic` wherever it isn't required, so that's the one most setups need.
+`pip install parseforge[sampling]` adds Netmiko for live device sampling;
+combine extras as needed, e.g.
+`pip install parseforge[anthropic,openai,deepseek,groq,xai,together,fireworks,perplexity,openrouter,moonshot,cerebras,mistral,cohere,sampling]`.
 
 ## Development
 
@@ -124,11 +132,13 @@ as needed, e.g.
 pip install -e ".[dev,sampling]"
 pytest
 ```
-`dev` already includes both the `anthropic` and `openai` SDKs (tests exercise
-all eleven providers — `anthropic`, `openai`, `deepseek`, `groq`, `xai`,
-`together`, `fireworks`, `perplexity`, `openrouter`, `moonshot`, `cerebras`
-share just those two packages — and never silently skip) — add the specific
-`,<provider>` extra explicitly only if installing outside of `dev`.
+`dev` already includes the `anthropic`, `openai`, `mistralai`, and `cohere`
+SDKs (tests exercise all thirteen providers — `anthropic`, `openai`,
+`deepseek`, `groq`, `xai`, `together`, `fireworks`, `perplexity`,
+`openrouter`, `moonshot`, `cerebras` share just the first two packages, and
+`mistral`/`cohere` each need their own native SDK — and never silently
+skip) — add the specific `,<provider>` extra explicitly only if installing
+outside of `dev`.
 
 Linting/formatting/type-checking/docs run through tox instead of extras — see
 `tox.ini` (`tox -e lint`/`format`/`typecheck`/`docs`), each installing its own

{parseforge-0.2.6 → parseforge-0.2.8}/parseforge.egg-info/SOURCES.txt

@@ -30,11 +30,13 @@ parseforge/naming/resolver.py
 parseforge/naming/providers/__init__.py
 parseforge/naming/providers/anthropic.py
 parseforge/naming/providers/cerebras.py
+parseforge/naming/providers/cohere.py
 parseforge/naming/providers/cost.py
 parseforge/naming/providers/deepseek.py
 parseforge/naming/providers/errors.py
 parseforge/naming/providers/fireworks.py
 parseforge/naming/providers/groq.py
+parseforge/naming/providers/mistral.py
 parseforge/naming/providers/models.py
 parseforge/naming/providers/models.yaml
 parseforge/naming/providers/moonshot.py

{parseforge-0.2.6 → parseforge-0.2.8}/parseforge.egg-info/requires.txt

@@ -11,6 +11,10 @@ textfsm-ai[anthropic]>=0.6.1
 openai>=1.0.0
 textfsm-ai[cerebras]>=0.6.1
 
+[cohere]
+cohere==5.21.1
+textfsm-ai[cohere]>=0.6.1
+
 [deepseek]
 openai>=1.0.0
 textfsm-ai[deepseek]>=0.6.1
@@ -23,6 +27,8 @@ black>=24.0.0
 mypy>=1.10.0
 anthropic>=0.40.0
 openai>=1.0.0
+mistralai==1.10.0
+cohere==5.21.1
 
 [fireworks]
 openai>=1.0.0
@@ -32,6 +38,10 @@ textfsm-ai[fireworks]>=0.6.1
 openai>=1.0.0
 textfsm-ai[groq]>=0.6.1
 
+[mistral]
+mistralai==1.10.0
+textfsm-ai[mistral]>=0.6.1
+
 [moonshot]
 openai>=1.0.0
 textfsm-ai[moonshot]>=0.6.1

{parseforge-0.2.6 → parseforge-0.2.8}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "parseforge"
-version = "0.2.6"
+version = "0.2.8"
 description = "LLM-driven pipeline that forges, validates, and promotes TextFSM templates from network CLI output"
 readme = "README.md"
 license = { text = "MIT" }
@@ -73,6 +73,14 @@ perplexity = ["openai>=1.0.0", "textfsm-ai[perplexity]>=0.6.1"]
 openrouter = ["openai>=1.0.0", "textfsm-ai[openrouter]>=0.6.1"]
 moonshot = ["openai>=1.0.0", "textfsm-ai[moonshot]>=0.6.1"]
 cerebras = ["openai>=1.0.0", "textfsm-ai[cerebras]>=0.6.1"]
+# Pinned exactly: 1.10.0 is the last mistralai release supporting Python
+# 3.9 (1.10.1+ and all 2.x require Python >=3.10), matching textfsm-ai's
+# own pin for the same reason -- this package also supports >=3.9.
+mistral = ["mistralai==1.10.0", "textfsm-ai[mistral]>=0.6.1"]
+# Pinned exactly for the same reason: 5.21.1 is the last cohere release
+# supporting Python 3.9 (6.x/7.x require Python >=3.10), matching
+# textfsm-ai's own pin.
+cohere = ["cohere==5.21.1", "textfsm-ai[cohere]>=0.6.1"]
 sampling = ["netmiko>=4.0"]
 dev = [
     "pytest>=8.0.0",
@@ -80,11 +88,13 @@ dev = [
     "ruff>=0.4.0",
     "black>=24.0.0",
     "mypy>=1.10.0",
-    # anthropic/openai are optional at runtime (see the extras above), but
-    # both providers are exercised by the CLI/tests, which should never
-    # silently skip -- so dev always pulls both in.
+    # anthropic/openai/mistralai/cohere are optional at runtime (see the
+    # extras above), but every provider is exercised by the CLI/tests,
+    # which should never silently skip -- so dev always pulls all four in.
     "anthropic>=0.40.0",
     "openai>=1.0.0",
+    "mistralai==1.10.0",
+    "cohere==5.21.1",
 ]
 # Tooling for scripts/release.ps1 and CI's own package-build step.
 # bump2version isn't otherwise installed anywhere -- release.ps1 assumes

parseforge-0.2.6/parseforge/__init__.py

@@ -1 +0,0 @@
-__version__ = "0.2.6"