parseforge 0.3.0__tar.gz → 0.3.2__tar.gz

parseforge-0.3.2/PKG-INFO

@@ -0,0 +1,195 @@
+Metadata-Version: 2.4
+Name: parseforge
+Version: 0.3.2
+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>
+License: MIT
+Keywords: textfsm,network automation,cli parsing,template generator,ai,llm,netmiko,device output parsing
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Information Technology
+Classifier: Intended Audience :: System Administrators
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Software Development :: Code Generators
+Classifier: Topic :: Text Processing
+Classifier: Topic :: Utilities
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: click>=8.1
+Requires-Dist: PyYAML>=6.0
+Requires-Dist: textfsm>=1.1.0
+Requires-Dist: textfsm-ai>=0.7.1
+Requires-Dist: anyask>=0.1.1
+Provides-Extra: anthropic
+Requires-Dist: anyask[anthropic]>=0.1.1; extra == "anthropic"
+Requires-Dist: textfsm-ai[anthropic]>=0.7.1; extra == "anthropic"
+Provides-Extra: deepseek
+Requires-Dist: anyask[deepseek]>=0.1.1; extra == "deepseek"
+Requires-Dist: textfsm-ai[deepseek]>=0.7.1; extra == "deepseek"
+Provides-Extra: openai
+Requires-Dist: anyask[openai]>=0.1.1; extra == "openai"
+Requires-Dist: textfsm-ai[openai]>=0.7.1; extra == "openai"
+Provides-Extra: groq
+Requires-Dist: anyask[groq]>=0.1.1; extra == "groq"
+Requires-Dist: textfsm-ai[groq]>=0.7.1; extra == "groq"
+Provides-Extra: xai
+Requires-Dist: anyask[xai]>=0.1.1; extra == "xai"
+Requires-Dist: textfsm-ai[xai]>=0.7.1; extra == "xai"
+Provides-Extra: together
+Requires-Dist: anyask[together]>=0.1.1; extra == "together"
+Requires-Dist: textfsm-ai[together]>=0.7.1; extra == "together"
+Provides-Extra: fireworks
+Requires-Dist: anyask[fireworks]>=0.1.1; extra == "fireworks"
+Requires-Dist: textfsm-ai[fireworks]>=0.7.1; extra == "fireworks"
+Provides-Extra: perplexity
+Requires-Dist: anyask[perplexity]>=0.1.1; extra == "perplexity"
+Requires-Dist: textfsm-ai[perplexity]>=0.7.1; extra == "perplexity"
+Provides-Extra: openrouter
+Requires-Dist: anyask[openrouter]>=0.1.1; extra == "openrouter"
+Requires-Dist: textfsm-ai[openrouter]>=0.7.1; extra == "openrouter"
+Provides-Extra: moonshot
+Requires-Dist: anyask[moonshot]>=0.1.1; extra == "moonshot"
+Requires-Dist: textfsm-ai[moonshot]>=0.7.1; extra == "moonshot"
+Provides-Extra: cerebras
+Requires-Dist: anyask[cerebras]>=0.1.1; extra == "cerebras"
+Requires-Dist: textfsm-ai[cerebras]>=0.7.1; extra == "cerebras"
+Provides-Extra: mistral
+Requires-Dist: anyask[mistral]>=0.1.1; extra == "mistral"
+Requires-Dist: textfsm-ai[mistral]>=0.7.1; extra == "mistral"
+Provides-Extra: cohere
+Requires-Dist: anyask[cohere]>=0.1.1; extra == "cohere"
+Requires-Dist: textfsm-ai[cohere]>=0.7.1; extra == "cohere"
+Provides-Extra: azure
+Requires-Dist: anyask[azure]>=0.1.1; extra == "azure"
+Requires-Dist: textfsm-ai[azure]>=0.7.1; extra == "azure"
+Provides-Extra: gemini
+Requires-Dist: anyask[gemini]>=0.1.1; extra == "gemini"
+Requires-Dist: textfsm-ai[gemini]>=0.7.1; extra == "gemini"
+Provides-Extra: vertexai
+Requires-Dist: anyask[vertexai]>=0.1.1; extra == "vertexai"
+Requires-Dist: textfsm-ai[vertexai]>=0.7.1; extra == "vertexai"
+Provides-Extra: bedrock
+Requires-Dist: anyask[bedrock]>=0.1.1; extra == "bedrock"
+Requires-Dist: textfsm-ai[bedrock]>=0.7.1; extra == "bedrock"
+Provides-Extra: oci
+Requires-Dist: anyask[oci]>=0.1.1; extra == "oci"
+Requires-Dist: textfsm-ai[oci]>=0.7.1; extra == "oci"
+Provides-Extra: sampling
+Requires-Dist: netmiko>=4.0; extra == "sampling"
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=5.0.0; extra == "dev"
+Requires-Dist: ruff>=0.4.0; extra == "dev"
+Requires-Dist: black>=24.0.0; extra == "dev"
+Requires-Dist: mypy>=1.10.0; extra == "dev"
+Requires-Dist: anyask[all]>=0.1.1; extra == "dev"
+Provides-Extra: release
+Requires-Dist: bump2version; extra == "release"
+Requires-Dist: build; extra == "release"
+Dynamic: license-file
+
+# ParseForge
+
+LLM-driven pipeline that forges, cross-validates, and promotes [TextFSM](https://github.com/google/textfsm)
+templates from network device CLI output.
+
+Full design plan: [SPEC.md](https://github.com/Geeks-Trident-LLC/parseforge/blob/main/SPEC.md).
+
+## What is ParseForge?
+
+Network devices — routers, switches, firewalls — only speak in plain text:
+the output of a `show` command. To use that output in a script, dashboard,
+or automation tool, something has to turn it into structured data first.
+That "something" is a [TextFSM](https://github.com/google/textfsm)
+template: a set of parsing rules for one specific command's output.
+
+ParseForge writes those templates for you. Point it at a device (or a
+saved copy of its output) and an AI provider of your choice, and it
+produces a template, checks that the template actually parses the sample
+it was built from, and tracks the result so you can see exactly how much
+it's been tested before you trust it in production.
+
+## Why do you need ParseForge?
+
+Every network automation project eventually hits the same wall: someone
+has to write and maintain a parser for every command's output, by hand,
+in regex. It's slow, it's easy to get subtly wrong, and it only gets
+worse as you add more device types, vendors, and firmware versions —
+each with its own quirks in how the same command's output is formatted.
+
+ParseForge replaces that manual work with a repeatable pipeline: an AI
+drafts the parser, ParseForge verifies it against real output before
+trusting it, and only well-tested results get promoted to production use
+automatically — anything uncertain is queued for a quick human look
+instead of shipped blind. If your team does network automation and needs
+structured data out of CLI output, ParseForge is the part that used to be
+tedious, made fast and safe instead.
+
+## Features
+
+- **Nothing ships unreviewed.** Every AI-generated template starts as
+  unproven evidence. Once it's been tested enough times with consistent
+  results, it's promoted automatically; anything less certain waits for a
+  person to check it.
+- **Learns a command once, reuses it forever.** The first time a command
+  runs, ParseForge asks the AI to name it; every time after that, it's
+  a free, instant lookup — no repeat AI calls, no repeat cost.
+- **Checks its own work.** Every generated template is tested against the
+  real output it was built from before it's ever counted as a pass.
+- **Notices when things change.** If a device's output format changes
+  later, ParseForge catches it and automatically kicks off a retest,
+  instead of quietly parsing it wrong.
+- **Use it your way.** A command-line tool for quick, ad hoc use, or a
+  Python library for wiring straight into your own automation — same
+  functionality either way.
+
+## Supported providers
+
+Eighteen AI providers behind one common interface — mix and match, or use
+two different ones in the same run:
+
+Anthropic, OpenAI, DeepSeek, Groq, xAI, Together, Fireworks, Perplexity,
+OpenRouter, Moonshot, Cerebras, Mistral, Cohere, Azure OpenAI, Google
+Gemini, Google Vertex AI, Amazon Bedrock, and Oracle Cloud Infrastructure
+(OCI) — including the four with non-standard authentication (Azure
+deployment names, GCP Application Default Credentials, AWS's own
+credential chain, OCI request-signing), handled transparently. See
+[Providers](https://geeks-trident-llc.github.io/parseforge/guides/providers/)
+for each one's install extra, auth requirements, and default model.
+
+## Installation
+
+```bash
+# minimal install, no AI-provider SDK
+pip install parseforge
+
+# with a provider extra, e.g. anthropic
+pip install parseforge[anthropic]
+
+# local development
+pip install -e ".[dev,sampling]"
+```
+
+For the full extras list (all eighteen providers, `sampling`, combining
+extras, per-provider `requirements/` files, and the dev/test/release
+setup), see
+[Installation](https://geeks-trident-llc.github.io/parseforge/getting-started/installation/).
+
+## Reference
+
+- [Documentation site](https://geeks-trident-llc.github.io/parseforge/) ([source](./docs/index.md))
+- [Quickstart](https://geeks-trident-llc.github.io/parseforge/getting-started/quickstart/) — a full walkthrough, from a single lookup to the end-to-end workflow
+- [Providers](https://geeks-trident-llc.github.io/parseforge/guides/providers/) — every provider's extra, auth requirements, and default model
+- [CLI Guide](https://geeks-trident-llc.github.io/parseforge/guides/cli/) — every command, in full
+- [Python API guide](https://geeks-trident-llc.github.io/parseforge/guides/python-api/) — calling parseforge from Python instead of the CLI
+- [API Reference](https://geeks-trident-llc.github.io/parseforge/reference/api/) — every public function/class, by pipeline stage
+- [Changelog](https://geeks-trident-llc.github.io/parseforge/changelog/) — what shipped in each release
+- [SPEC.md](https://github.com/Geeks-Trident-LLC/parseforge/blob/main/SPEC.md) — full design plan and open questions

parseforge-0.3.2/README.md

@@ -0,0 +1,97 @@
+# ParseForge
+
+LLM-driven pipeline that forges, cross-validates, and promotes [TextFSM](https://github.com/google/textfsm)
+templates from network device CLI output.
+
+Full design plan: [SPEC.md](https://github.com/Geeks-Trident-LLC/parseforge/blob/main/SPEC.md).
+
+## What is ParseForge?
+
+Network devices — routers, switches, firewalls — only speak in plain text:
+the output of a `show` command. To use that output in a script, dashboard,
+or automation tool, something has to turn it into structured data first.
+That "something" is a [TextFSM](https://github.com/google/textfsm)
+template: a set of parsing rules for one specific command's output.
+
+ParseForge writes those templates for you. Point it at a device (or a
+saved copy of its output) and an AI provider of your choice, and it
+produces a template, checks that the template actually parses the sample
+it was built from, and tracks the result so you can see exactly how much
+it's been tested before you trust it in production.
+
+## Why do you need ParseForge?
+
+Every network automation project eventually hits the same wall: someone
+has to write and maintain a parser for every command's output, by hand,
+in regex. It's slow, it's easy to get subtly wrong, and it only gets
+worse as you add more device types, vendors, and firmware versions —
+each with its own quirks in how the same command's output is formatted.
+
+ParseForge replaces that manual work with a repeatable pipeline: an AI
+drafts the parser, ParseForge verifies it against real output before
+trusting it, and only well-tested results get promoted to production use
+automatically — anything uncertain is queued for a quick human look
+instead of shipped blind. If your team does network automation and needs
+structured data out of CLI output, ParseForge is the part that used to be
+tedious, made fast and safe instead.
+
+## Features
+
+- **Nothing ships unreviewed.** Every AI-generated template starts as
+  unproven evidence. Once it's been tested enough times with consistent
+  results, it's promoted automatically; anything less certain waits for a
+  person to check it.
+- **Learns a command once, reuses it forever.** The first time a command
+  runs, ParseForge asks the AI to name it; every time after that, it's
+  a free, instant lookup — no repeat AI calls, no repeat cost.
+- **Checks its own work.** Every generated template is tested against the
+  real output it was built from before it's ever counted as a pass.
+- **Notices when things change.** If a device's output format changes
+  later, ParseForge catches it and automatically kicks off a retest,
+  instead of quietly parsing it wrong.
+- **Use it your way.** A command-line tool for quick, ad hoc use, or a
+  Python library for wiring straight into your own automation — same
+  functionality either way.
+
+## Supported providers
+
+Eighteen AI providers behind one common interface — mix and match, or use
+two different ones in the same run:
+
+Anthropic, OpenAI, DeepSeek, Groq, xAI, Together, Fireworks, Perplexity,
+OpenRouter, Moonshot, Cerebras, Mistral, Cohere, Azure OpenAI, Google
+Gemini, Google Vertex AI, Amazon Bedrock, and Oracle Cloud Infrastructure
+(OCI) — including the four with non-standard authentication (Azure
+deployment names, GCP Application Default Credentials, AWS's own
+credential chain, OCI request-signing), handled transparently. See
+[Providers](https://geeks-trident-llc.github.io/parseforge/guides/providers/)
+for each one's install extra, auth requirements, and default model.
+
+## Installation
+
+```bash
+# minimal install, no AI-provider SDK
+pip install parseforge
+
+# with a provider extra, e.g. anthropic
+pip install parseforge[anthropic]
+
+# local development
+pip install -e ".[dev,sampling]"
+```
+
+For the full extras list (all eighteen providers, `sampling`, combining
+extras, per-provider `requirements/` files, and the dev/test/release
+setup), see
+[Installation](https://geeks-trident-llc.github.io/parseforge/getting-started/installation/).
+
+## Reference
+
+- [Documentation site](https://geeks-trident-llc.github.io/parseforge/) ([source](./docs/index.md))
+- [Quickstart](https://geeks-trident-llc.github.io/parseforge/getting-started/quickstart/) — a full walkthrough, from a single lookup to the end-to-end workflow
+- [Providers](https://geeks-trident-llc.github.io/parseforge/guides/providers/) — every provider's extra, auth requirements, and default model
+- [CLI Guide](https://geeks-trident-llc.github.io/parseforge/guides/cli/) — every command, in full
+- [Python API guide](https://geeks-trident-llc.github.io/parseforge/guides/python-api/) — calling parseforge from Python instead of the CLI
+- [API Reference](https://geeks-trident-llc.github.io/parseforge/reference/api/) — every public function/class, by pipeline stage
+- [Changelog](https://geeks-trident-llc.github.io/parseforge/changelog/) — what shipped in each release
+- [SPEC.md](https://github.com/Geeks-Trident-LLC/parseforge/blob/main/SPEC.md) — full design plan and open questions

{parseforge-0.3.0 → parseforge-0.3.2}/parseforge/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.3.0"
+__version__ = "0.3.2"
 version = __version__
 
 from .api import (  # noqa: E402

{parseforge-0.3.0 → parseforge-0.3.2}/parseforge/cli/main.py

@@ -20,7 +20,7 @@ from parseforge import (
     validation,
 )
 from parseforge.cli import config as cli_config
-from parseforge.naming.providers.azure import DEFAULT_API_VERSION
+from parseforge.naming.providers.anyask_builder import DEFAULT_API_VERSION
 
 _BUILDERS: dict[str, type[naming.RegexBuilder]] = {
     "anthropic": naming.AnthropicRegexBuilder,

parseforge-0.3.2/parseforge/naming/providers/__init__.py

@@ -0,0 +1,41 @@
+from .anyask_builder import (
+    AnthropicRegexBuilder,
+    AzureRegexBuilder,
+    BedrockRegexBuilder,
+    CerebrasRegexBuilder,
+    CohereRegexBuilder,
+    DeepSeekRegexBuilder,
+    FireworksRegexBuilder,
+    GeminiRegexBuilder,
+    GroqRegexBuilder,
+    MistralRegexBuilder,
+    MoonshotRegexBuilder,
+    OCIRegexBuilder,
+    OpenAIRegexBuilder,
+    OpenRouterRegexBuilder,
+    PerplexityRegexBuilder,
+    TogetherRegexBuilder,
+    VertexAIRegexBuilder,
+    XAIRegexBuilder,
+)
+
+__all__ = [
+    "AnthropicRegexBuilder",
+    "AzureRegexBuilder",
+    "BedrockRegexBuilder",
+    "CerebrasRegexBuilder",
+    "CohereRegexBuilder",
+    "DeepSeekRegexBuilder",
+    "FireworksRegexBuilder",
+    "GeminiRegexBuilder",
+    "GroqRegexBuilder",
+    "MistralRegexBuilder",
+    "MoonshotRegexBuilder",
+    "OCIRegexBuilder",
+    "OpenAIRegexBuilder",
+    "OpenRouterRegexBuilder",
+    "PerplexityRegexBuilder",
+    "TogetherRegexBuilder",
+    "VertexAIRegexBuilder",
+    "XAIRegexBuilder",
+]

parseforge-0.3.2/parseforge/naming/providers/anyask_builder.py

@@ -0,0 +1,248 @@
+"""Generic RegexBuilder implementation backed by the ``anyask`` package.
+
+Replaces 18 hand-rolled per-provider SDK integrations (anthropic.py,
+azure.py, bedrock.py, ...) with a single class parameterized by
+``provider``: anyask (https://github.com/Geeks-Trident-LLC/anyask) already
+implements the exact same 18 vendors behind one normalized interface
+(``anyask.get_provider(provider, **construction_kwargs).generate_sync(
+prompt, model=..., **call_kwargs)`` -> ``AskResponse``), so there's no need
+to hand-roll a client/error-classification/response-parsing dance per SDK
+here anymore.
+
+Two things anyask deliberately does NOT do, that this module still has to:
+
+1. Retry classification -- anyask raises a flat ``ProviderError`` for every
+   failed call (the original SDK exception is always attached via
+   ``__cause__``). Nothing in this package retries a naming call today (see
+   resolver.py), so no classification is reconstructed here either -- a
+   failed call always becomes a non-``ready`` LLMCLIResponse.
+2. ``finish_reason`` normalization -- anyask leaves it raw/provider-specific
+   (a plain string for most vendors, a ``FinishReason`` enum member for
+   Gemini/Vertex AI) precisely so callers can build their own truncation
+   check. See ``_is_ready`` below.
+"""
+
+from __future__ import annotations
+
+import time
+from typing import Any
+
+import anyask
+
+from ..llm import CliContext, LLMCLIResponse, TokenUsage, build_prompt
+from .models import default_model
+from .text import extract_pattern
+
+_DEFAULT_MAX_TOKENS = 1024
+
+# Matches anyask's own AzureOpenAIProvider.__init__ fallback (confirmed by
+# reading anyask/providers/azure.py) — also imported by pipeline.py/
+# cli/main.py as the generation-side Azure config's own default, since
+# textfsm-ai's Azure provider has no from_env()-style fallback of its own.
+DEFAULT_API_VERSION = "2024-02-15-preview"
+
+# finish_reason values (case-insensitively, after str()) that mean the
+# response was cut off before completing rather than stopping naturally --
+# everything else (anthropic's "end_turn", openai-family's "stop", cohere's
+# "COMPLETE", gemini/vertexai's FinishReason.STOP, ...) counts as ready.
+# Naming's prompt never triggers a tool-call or content-filter finish, so
+# this denylist -- rather than an per-vendor allowlist of every "success"
+# value -- is a safe simplification of the exact-match checks the 18
+# deleted provider files each carried individually.
+_TRUNCATED_FINISH_REASONS = frozenset({"length", "max_tokens", "max_output_tokens"})
+
+# Vertex AI is the one provider where parseforge's own constructor kwarg
+# name (`location`, matching its CLI flag --gcp-location) differs from
+# anyask's construction-kwarg name for the same concept (`region`, reused
+# from Bedrock/OCI's own "region" keyword -- see anyask/providers/
+# vertexai.py). Every other provider's kwarg names already line up exactly
+# (api_key, endpoint, api_version, deployment, project, region,
+# compartment_id).
+_CONSTRUCTION_KWARG_RENAMES: dict[str, dict[str, str]] = {
+    "vertexai": {"location": "region"},
+}
+
+# deepseek-v4-flash defaults to thinking mode ON, which burns the entire
+# max_tokens budget on chain-of-thought (returned separately as
+# reasoning_content) and leaves nothing for the actual answer in
+# `content` -- anyask's own DeepSeekProvider doesn't disable this by
+# default (confirmed by reading anyask/providers/deepseek.py), so it's
+# still disabled here explicitly, exactly as the old deepseek.py builder
+# did. See https://api-docs.deepseek.com/guides/thinking_mode/
+_DEFAULT_CALL_KWARGS: dict[str, dict[str, Any]] = {
+    "deepseek": {"extra_body": {"thinking": {"type": "disabled"}}},
+}
+
+
+def _map_construction_kwargs(provider: str, kwargs: dict[str, Any]) -> dict[str, Any]:
+    renames = _CONSTRUCTION_KWARG_RENAMES.get(provider, {})
+    mapped = {renames.get(key, key): value for key, value in kwargs.items()}
+    # Drop falsy values so anyask's own env-var fallbacks (ANTHROPIC_API_KEY,
+    # BEDROCK_REGION, VERTEXAI_PROJECT, ...) still apply exactly as they did
+    # when the old per-provider builders left an unset kwarg as None.
+    return {key: value for key, value in mapped.items() if value}
+
+
+def _is_ready(finish_reason: Any) -> bool:
+    if finish_reason is None:
+        return False
+    reason = str(getattr(finish_reason, "value", finish_reason)).lower()
+    return reason not in _TRUNCATED_FINISH_REASONS
+
+
+def _format_error_reason(exc: BaseException) -> str:
+    cause = exc.__cause__ or exc
+    return f"LLM-ERROR-{type(cause).__name__}-{cause}"
+
+
+class AnyAskRegexBuilder:
+    """Builds a cli-name regex pattern by prompting an LLM via ``anyask``.
+
+    The underlying anyask ``Provider`` instance is constructed lazily, on
+    the first actual call -- not in ``__init__`` -- so this can be used as
+    a default RegexBuilder without requiring credentials to be set for
+    cache-hit lookups, which never reach the LLM at all (see
+    resolver.cli_name). Extra ``**kwargs`` passed to ``build_pattern`` (or
+    a per-call ``model`` override) forward straight through to
+    ``anyask``'s ``generate_sync``.
+    """
+
+    #: Set on each concrete subclass below -- an anyask/parseforge provider
+    #: name, e.g. "anthropic", "azure", "bedrock".
+    provider: str = ""
+
+    def __init__(self, model: str | None = None, **kwargs: Any) -> None:
+        # Azure has no fixed model catalog in models.yaml -- its
+        # constructor's `deployment` kwarg stands in for a model choice
+        # instead (see build_pattern's own model handling below), so no
+        # default_model() lookup applies to it.
+        self.model = model or (
+            "" if self.provider == "azure" else default_model(self.provider)
+        )
+        self._construction_kwargs = _map_construction_kwargs(self.provider, kwargs)
+        self._client: anyask.Provider | None = None
+
+    def _get_client(self) -> anyask.Provider:
+        if self._client is None:
+            self._client = anyask.get_provider(
+                self.provider, **self._construction_kwargs
+            )
+        return self._client
+
+    def build_pattern(
+        self, command: str, context: CliContext, **kwargs: Any
+    ) -> LLMCLIResponse:
+        prompt = build_prompt(command, context)
+        max_tokens = kwargs.pop("max_tokens", None) or _DEFAULT_MAX_TOKENS
+        # Azure has no fixed model catalog -- its constructor's `deployment`
+        # kwarg already fixed which deployment to call, and passing a model
+        # here would just be ignored by anyask's AzureOpenAIProvider (falls
+        # back to self.deployment when model is falsy), so it's left unset.
+        model = kwargs.pop("model", None) or (
+            None if self.provider == "azure" else self.model
+        )
+        for key, value in _DEFAULT_CALL_KWARGS.get(self.provider, {}).items():
+            kwargs.setdefault(key, value)
+
+        start = time.monotonic()
+        try:
+            response = self._get_client().generate_sync(
+                prompt, model=model, max_tokens=max_tokens, **kwargs
+            )
+        except anyask.ProviderError as exc:
+            return LLMCLIResponse(
+                content="",
+                raw=exc,
+                usage=TokenUsage(input_tokens=0, output_tokens=0, total_tokens=0),
+                duration_ms=(time.monotonic() - start) * 1000,
+                reason=_format_error_reason(exc),
+                ready=False,
+            )
+        duration_ms = (time.monotonic() - start) * 1000
+
+        return LLMCLIResponse(
+            content=extract_pattern(response.content or ""),
+            raw=response.raw,
+            usage=TokenUsage(
+                input_tokens=response.usage.prompt_tokens or 0,
+                output_tokens=response.usage.completion_tokens or 0,
+                total_tokens=response.usage.total_tokens or 0,
+            ),
+            duration_ms=duration_ms,
+            reason=str(
+                getattr(response.finish_reason, "value", response.finish_reason) or ""
+            ),
+            ready=_is_ready(response.finish_reason),
+        )
+
+
+class AnthropicRegexBuilder(AnyAskRegexBuilder):
+    provider = "anthropic"
+
+
+class AzureRegexBuilder(AnyAskRegexBuilder):
+    provider = "azure"
+
+
+class BedrockRegexBuilder(AnyAskRegexBuilder):
+    provider = "bedrock"
+
+
+class CerebrasRegexBuilder(AnyAskRegexBuilder):
+    provider = "cerebras"
+
+
+class CohereRegexBuilder(AnyAskRegexBuilder):
+    provider = "cohere"
+
+
+class DeepSeekRegexBuilder(AnyAskRegexBuilder):
+    provider = "deepseek"
+
+
+class FireworksRegexBuilder(AnyAskRegexBuilder):
+    provider = "fireworks"
+
+
+class GeminiRegexBuilder(AnyAskRegexBuilder):
+    provider = "gemini"
+
+
+class GroqRegexBuilder(AnyAskRegexBuilder):
+    provider = "groq"
+
+
+class MistralRegexBuilder(AnyAskRegexBuilder):
+    provider = "mistral"
+
+
+class MoonshotRegexBuilder(AnyAskRegexBuilder):
+    provider = "moonshot"
+
+
+class OCIRegexBuilder(AnyAskRegexBuilder):
+    provider = "oci"
+
+
+class OpenAIRegexBuilder(AnyAskRegexBuilder):
+    provider = "openai"
+
+
+class OpenRouterRegexBuilder(AnyAskRegexBuilder):
+    provider = "openrouter"
+
+
+class PerplexityRegexBuilder(AnyAskRegexBuilder):
+    provider = "perplexity"
+
+
+class TogetherRegexBuilder(AnyAskRegexBuilder):
+    provider = "together"
+
+
+class VertexAIRegexBuilder(AnyAskRegexBuilder):
+    provider = "vertexai"
+
+
+class XAIRegexBuilder(AnyAskRegexBuilder):
+    provider = "xai"

{parseforge-0.3.0 → parseforge-0.3.2}/parseforge/pipeline.py

@@ -46,7 +46,7 @@ from pathlib import Path
 from typing import Any
 
 from parseforge import generation, naming, paths, sampling, validation
-from parseforge.naming.providers.azure import DEFAULT_API_VERSION
+from parseforge.naming.providers.anyask_builder import DEFAULT_API_VERSION
 
 
 class Mode(str, Enum):