result-companion 0.0.2__py3-none-any.whl → 0.0.3__py3-none-any.whl

result_companion/core/analizers/factory_common.py

@@ -12,7 +12,7 @@ from langchain_openai import AzureChatOpenAI, ChatOpenAI
 from result_companion.core.chunking.chunking import (
     accumulate_llm_results_for_summarizaton_chain,
 )
-from result_companion.core.chunking.utils import calculate_chunk_size
+from result_companion.core.chunking.utils import Chunking, calculate_chunk_size
 from result_companion.core.parsers.config import DefaultConfigModel
 from result_companion.core.utils.logging_config import get_progress_logger
 from result_companion.core.utils.progress import run_tasks_with_progress
@@ -30,6 +30,29 @@ MODELS = Tuple[
 ]
 
 
+def _stats_header(
+    status: str, chunk: Chunking, dryrun: bool = False, name: str = ""
+) -> str:
+    """Returns markdown stats line for analysis."""
+    chunks = chunk.number_of_chunks if chunk.requires_chunking else 0
+    prefix = "**[DRYRUN]** " if dryrun else ""
+    return f"""## {prefix} {name}
+
+#### Status: {status} · Chunks: {chunks} · Tokens: ~{chunk.tokens_from_raw_text} · Raw length: {chunk.raw_text_len}
+
+---
+
+"""
+
+
+async def _dryrun_result(test_case: dict) -> Tuple[str, str, list]:
+    """Returns placeholder without calling LLM."""
+    logger.info(
+        f"### Test Case: {test_case['name']}, content length: {len(str(test_case))}"
+    )
+    return ("*No LLM analysis in dryrun mode.*", test_case["name"], [])
+
+
 async def accumulate_llm_results_without_streaming(
     test_case: dict,
     question_from_config_file: str,
@@ -54,6 +77,7 @@ async def execute_llm_and_get_results(
     config: DefaultConfigModel,
     prompt: ChatPromptTemplate,
     model: MODELS,
+    dryrun: bool = False,
 ) -> dict:
     question_from_config_file = config.llm_config.question_prompt
     tokenizer = config.tokenizer
@@ -64,6 +88,7 @@ async def execute_llm_and_get_results(
 
     llm_results = dict()
     corutines = []
+    test_case_stats = {}  # name -> (chunk, status) for adding headers later
     logger.info(
         f"Executing chain, {len(test_cases)=}, {test_case_concurrency=}, {chunk_concurrency=}"
     )
@@ -73,9 +98,11 @@ async def execute_llm_and_get_results(
         chunk = calculate_chunk_size(
             raw_test_case_text, question_from_config_file, tokenizer
         )
+        test_case_stats[test_case["name"]] = (chunk, test_case.get("status", "N/A"))
 
-        # TODO: zero chunk size seems magical
-        if chunk.chunk_size == 0:
+        if dryrun:
+            corutines.append(_dryrun_result(test_case))
+        elif not chunk.requires_chunking:
             corutines.append(
                 accumulate_llm_results_without_streaming(
                     test_case, question_from_config_file, prompt, model
@@ -99,6 +126,8 @@ async def execute_llm_and_get_results(
     results = await run_tasks_with_progress(corutines, semaphore=semaphore, desc=desc)
 
     for result, name, chunks in results:
-        llm_results[name] = result
+        chunk, status = test_case_stats[name]
+        header = _stats_header(status, chunk, dryrun, name)
+        llm_results[name] = header + result
 
     return llm_results

result_companion/core/analizers/models.py

@@ -6,12 +6,15 @@ from langchain_google_genai import ChatGoogleGenerativeAI
 from langchain_ollama.llms import OllamaLLM
 from langchain_openai import AzureChatOpenAI, ChatOpenAI
 
+from result_companion.core.analizers.remote.copilot import ChatCopilot
+
 MODELS = Tuple[
     OllamaLLM
     | AzureChatOpenAI
     | BedrockLLM
     | ChatGoogleGenerativeAI
     | ChatOpenAI
-    | ChatAnthropic,
+    | ChatAnthropic
+    | ChatCopilot,
     Callable,
 ]

result_companion/core/analizers/remote/copilot.py

@@ -0,0 +1,162 @@
+"""LangChain adapter for GitHub Copilot SDK with session pooling."""
+
+import asyncio
+from contextlib import asynccontextmanager
+from typing import Any, AsyncIterator, Optional
+
+from copilot import CopilotClient
+from langchain_core.callbacks import CallbackManagerForLLMRun
+from langchain_core.language_models.chat_models import BaseChatModel
+from langchain_core.messages import AIMessage, BaseMessage, HumanMessage, SystemMessage
+from langchain_core.outputs import ChatGeneration, ChatResult
+from pydantic import ConfigDict
+
+
+def messages_to_prompt(messages: list[BaseMessage]) -> str:
+    """Converts LangChain messages to a single prompt string."""
+    prefixes = {
+        SystemMessage: "[System]",
+        HumanMessage: "[User]",
+        AIMessage: "[Assistant]",
+    }
+    parts = [f"{prefixes.get(type(m), '')}: {m.content}" for m in messages]
+    return "\n\n".join(parts)
+
+
+class SessionPool:
+    """Pool of Copilot sessions for concurrent requests."""
+
+    def __init__(self, client: Any, model: str, pool_size: int = 5):
+        self._client = client
+        self._model = model
+        self._pool_size = pool_size
+        self._available: asyncio.Queue = asyncio.Queue()
+        self._created = 0
+        self._lock = asyncio.Lock()
+
+    async def _create_session(self) -> Any:
+        """Creates a new session."""
+        return await self._client.create_session({"model": self._model})
+
+    @asynccontextmanager
+    async def acquire(self) -> AsyncIterator[Any]:
+        """Acquires a session from pool, creates if needed."""
+        session = None
+
+        # Try to get existing session or create new one
+        async with self._lock:
+            if not self._available.empty():
+                session = self._available.get_nowait()
+            elif self._created < self._pool_size:
+                session = await self._create_session()
+                self._created += 1
+
+        # If pool exhausted, wait for available session
+        if session is None:
+            session = await self._available.get()
+
+        try:
+            yield session
+        finally:
+            await self._available.put(session)
+
+    async def close(self) -> None:
+        """Destroys all sessions in the pool."""
+        while not self._available.empty():
+            session = self._available.get_nowait()
+            try:
+                await session.destroy()
+            except Exception:
+                pass
+        self._created = 0
+
+
+class ChatCopilot(BaseChatModel):
+    """LangChain adapter for GitHub Copilot SDK.
+
+    Uses session pool for concurrent requests - each request gets its own session.
+    """
+
+    model: str = "gpt-4.1"
+    cli_path: Optional[str] = None
+    cli_url: Optional[str] = None
+    timeout: int = 300
+    pool_size: int = 5
+
+    _client: Any = None
+    _pool: Optional[SessionPool] = None
+    _started: bool = False
+    _init_lock: Optional[asyncio.Lock] = None
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    @property
+    def _llm_type(self) -> str:
+        return "copilot"
+
+    def _get_init_lock(self) -> asyncio.Lock:
+        """Returns init lock, creating lazily in current event loop."""
+        if self._init_lock is None:
+            self._init_lock = asyncio.Lock()
+        return self._init_lock
+
+    async def _ensure_started(self) -> None:
+        """Ensures client and pool are initialized. Thread-safe."""
+        if self._started:
+            return
+
+        async with self._get_init_lock():
+            if self._started:
+                return
+
+            opts = {}
+            if self.cli_path:
+                opts["cli_path"] = self.cli_path
+            if self.cli_url:
+                opts["cli_url"] = self.cli_url
+
+            self._client = CopilotClient(opts) if opts else CopilotClient()
+            await self._client.start()
+            self._pool = SessionPool(self._client, self.model, self.pool_size)
+            self._started = True
+
+    async def _agenerate(
+        self,
+        messages: list[BaseMessage],
+        stop: Optional[list[str]] = None,
+        run_manager: Optional[CallbackManagerForLLMRun] = None,
+        **kwargs: Any,
+    ) -> ChatResult:
+        """Async generation using session from pool."""
+        await self._ensure_started()
+
+        prompt = messages_to_prompt(messages)
+        async with self._pool.acquire() as session:
+            response = await session.send_and_wait(
+                {"prompt": prompt}, timeout=self.timeout
+            )
+
+        content = response.data.content if response and response.data else ""
+        return ChatResult(
+            generations=[ChatGeneration(message=AIMessage(content=content))]
+        )
+
+    def _generate(
+        self,
+        messages: list[BaseMessage],
+        stop: Optional[list[str]] = None,
+        run_manager: Optional[CallbackManagerForLLMRun] = None,
+        **kwargs: Any,
+    ) -> ChatResult:
+        """Synchronous generation - wraps async implementation."""
+        return asyncio.run(self._agenerate(messages, stop, run_manager, **kwargs))
+
+    async def aclose(self) -> None:
+        """Cleanup pool and client resources."""
+        if self._pool:
+            await self._pool.close()
+            self._pool = None
+        if self._client:
+            await self._client.stop()
+            self._client = None
+        self._started = False

result_companion/core/chunking/chunking.py

@@ -90,7 +90,12 @@ async def summarize_test_case(
             logger.debug(
                 f"[{test_name}] Processing chunk {chunk_idx + 1}/{total_chunks}, length {len(chunk)}"
             )
-            return await summarization_chain.ainvoke({"text": chunk})
+            result = await summarization_chain.ainvoke({"text": chunk})
+            logger.debug(
+                f"[{test_name}] Chunk {chunk_idx + 1}/{total_chunks} completed",
+                extra={"summary": result},
+            )
+            return result
 
     chunk_tasks = [process_with_limit(chunk, i) for i, chunk in enumerate(chunks)]
     summaries = await asyncio.gather(*chunk_tasks)

result_companion/core/chunking/utils.py

@@ -15,6 +15,11 @@ class Chunking:
     tokens_from_raw_text: int
     tokenized_chunks: int
 
+    @property
+    def requires_chunking(self) -> bool:
+        """Returns True if text needs to be split into chunks."""
+        return self.chunk_size > 0
+
 
 def azure_openai_tokenizer(text: str) -> int:
     """Tokenizer for Azure OpenAI models using tiktoken."""

result_companion/core/utils/logging_config.py

@@ -11,8 +11,10 @@ from tqdm import tqdm
 class JsonFormatter(logging.Formatter):
     """Formats log records as JSON."""
 
+    STANDARD_ATTRS = frozenset(logging.LogRecord("", 0, "", 0, "", (), None).__dict__)
+
     def format(self, record: logging.LogRecord) -> str:
-        """Formats a log record as JSON."""
+        """Formats a log record as JSON, including extra fields."""
         log_data = {
             "timestamp": self.formatTime(record),
             "logger": record.name,
@@ -20,6 +22,10 @@ class JsonFormatter(logging.Formatter):
             "message": record.getMessage(),
         }
 
+        for key, value in record.__dict__.items():
+            if key not in self.STANDARD_ATTRS:
+                log_data[key] = value
+
         if record.exc_info:
             log_data["exception"] = self.formatException(record.exc_info)
 

result_companion/entrypoints/cli/cli_app.py

@@ -113,6 +113,11 @@ def analyze(
         "--chunk-concurrency",
         help="Chunks per test case in parallel (overrides config)",
     ),
+    dryrun: bool = typer.Option(
+        False,
+        "--dryrun",
+        help="Skip LLM calls, generate HTML with debug metadata",
+    ),
 ):
     """Analyze Robot Framework test results with LLM assistance."""
     typer.echo(f"Output: {output}")
@@ -147,6 +152,7 @@ def analyze(
         chunk_concurrency,
         include_tag_list,
         exclude_tag_list,
+        dryrun,
     )
 
 

result_companion/entrypoints/run_rc.py

@@ -14,6 +14,7 @@ from pydantic import ValidationError
 from result_companion.core.analizers.factory_common import execute_llm_and_get_results
 from result_companion.core.analizers.local.ollama_runner import ollama_on_init_strategy
 from result_companion.core.analizers.models import MODELS
+from result_companion.core.analizers.remote.copilot import ChatCopilot
 from result_companion.core.html.html_creator import create_llm_html_log
 from result_companion.core.parsers.config import LLMFactoryModel, load_config
 from result_companion.core.parsers.result_parser import (
@@ -25,9 +26,12 @@ from result_companion.core.utils.logging_config import logger, set_global_log_le
 
 def init_llm_with_strategy_factory(
     config: LLMFactoryModel,
+    test_case_concurrency: int = 1,
+    chunk_concurrency: int = 1,
 ) -> MODELS:
+    """Creates LLM model with optional init strategy."""
     model_type = config.model_type
-    parameters = config.parameters
+    parameters = dict(config.parameters)
 
     model_classes = {
         "OllamaLLM": (OllamaLLM, ollama_on_init_strategy),
@@ -36,6 +40,12 @@ def init_llm_with_strategy_factory(
         "ChatGoogleGenerativeAI": (ChatGoogleGenerativeAI, None),
         "ChatOpenAI": (ChatOpenAI, None),
         "ChatAnthropic": (ChatAnthropic, None),
+        "ChatCopilot": (ChatCopilot, None),
+    }
+
+    # Runtime overrides: ChatCopilot needs pool_size = max concurrent requests
+    runtime_overrides = {
+        "ChatCopilot": {"pool_size": test_case_concurrency * chunk_concurrency},
     }
 
     if model_type not in model_classes:
@@ -43,6 +53,9 @@ def init_llm_with_strategy_factory(
             f"Unsupported model type: {model_type} not in {model_classes.keys()}"
         )
 
+    if model_type in runtime_overrides:
+        parameters.update(runtime_overrides[model_type])
+
     model_class, strategy = model_classes[model_type]
     try:
         return model_class(**parameters), strategy
@@ -62,6 +75,7 @@ async def _main(
     chunk_concurrency: Optional[int] = None,
     include_tags: Optional[list[str]] = None,
     exclude_tags: Optional[list[str]] = None,
+    dryrun: bool = False,
 ) -> bool:
     set_global_log_level(str(log_level))
 
@@ -100,7 +114,9 @@ async def _main(
     question_from_config_file = parsed_config.llm_config.question_prompt
     template = parsed_config.llm_config.prompt_template
     model, model_init_strategy = init_llm_with_strategy_factory(
-        parsed_config.llm_factory
+        parsed_config.llm_factory,
+        test_case_concurrency=parsed_config.concurrency.test_case,
+        chunk_concurrency=parsed_config.concurrency.chunk,
     )
 
     if model_init_strategy:
@@ -118,6 +134,7 @@ async def _main(
         parsed_config,
         prompt_template,
         model,
+        dryrun=dryrun,
     )
 
     report_path = report if report else "rc_log.html"
@@ -150,6 +167,7 @@ def run_rc(
     chunk_concurrency: Optional[int] = None,
     include_tags: Optional[list[str]] = None,
     exclude_tags: Optional[list[str]] = None,
+    dryrun: bool = False,
 ) -> bool:
     try:
         return asyncio.run(
@@ -163,6 +181,7 @@ def run_rc(
                 chunk_concurrency=chunk_concurrency,
                 include_tags=include_tags,
                 exclude_tags=exclude_tags,
+                dryrun=dryrun,
             )
         )
     except Exception:

{result_companion-0.0.2.dist-info → result_companion-0.0.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: result-companion
-Version: 0.0.2
+Version: 0.0.3
 Summary: AI-powered analysis of Robot Framework test failures - instant insights from output.xml
 License: Apache-2.0
 License-File: LICENSE
@@ -19,6 +19,7 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Software Development :: Testing
+Requires-Dist: github-copilot-sdk (>=0.1.0,<0.2.0)
 Requires-Dist: langchain-anthropic (>=0.3.7,<0.4.0)
 Requires-Dist: langchain-aws (>=0.2.10,<0.3.0)
 Requires-Dist: langchain-community (>=0.3.9,<0.4.0)
@@ -72,7 +73,24 @@ Your enhanced `log.html` now includes:
 
 ## Quick Start
 
-### Option 1: Local AI (Free, Private)
+### Option 1: GitHub Copilot (Easiest for Users With Copilot)
+
+Already have GitHub Copilot? Use it directly—no API keys needed.
+
+```bash
+pip install result-companion
+
+# One-time setup
+brew install copilot-cli   # or: npm install -g @github/copilot
+copilot /login             # Login when prompted, then /exit
+
+# Analyze your tests
+result-companion analyze -o output.xml -c examples/copilot_config.yaml
+```
+
+See [Copilot setup guide](https://github.com/miltroj/result-companion/blob/main/examples/EXAMPLES.md#github-copilot).
+
+### Option 2: Local AI (Free, Private)
 
 ```bash
 pip install result-companion
@@ -85,7 +103,7 @@ result-companion setup model deepseek-r1:1.5b
 result-companion analyze -o output.xml
 ```
 
-### Option 2: Cloud AI ([OpenAI](https://github.com/miltroj/result-companion/blob/main/examples/EXAMPLES.md#openai), Azure, Google)
+### Option 3: Cloud AI ([OpenAI](https://github.com/miltroj/result-companion/blob/main/examples/EXAMPLES.md#openai), Azure, Google)
 
 ```bash
 pip install result-companion
@@ -148,6 +166,7 @@ See [examples/EXAMPLES.md](https://github.com/miltroj/result-companion/blob/main
 ## Configuration Examples
 
 Check [`examples/`](https://github.com/miltroj/result-companion/tree/main/examples) for ready-to-use configs:
+- **GitHub Copilot** (easiest for users with copilot)
 - Local Ollama setup (default)
 - OpenAI, Azure, Google Cloud
 - Custom endpoints (Databricks, self-hosted)

{result_companion-0.0.2.dist-info → result_companion-0.0.3.dist-info}/RECORD

@@ -1,18 +1,19 @@
 result_companion/__init__.py,sha256=RcAx4Ybuw0kE54PzDu_P8znTVXYsHBRzkcSX06dQSYE,227
 result_companion/core/analizers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 result_companion/core/analizers/common.py,sha256=gD21KHsFet-4DdrguZsAYQy9zn5dF5M5E_ziEaLWM80,1724
-result_companion/core/analizers/factory_common.py,sha256=CRXYzClKTij7vQ9NxcPqc3FoXCV7bRx13HbkQf6BRUo,3419
+result_companion/core/analizers/factory_common.py,sha256=4cxFde48UB84857D1PAeuu_FOf0PXTuXpcMTq4Ni6ho,4505
 result_companion/core/analizers/local/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 result_companion/core/analizers/local/ollama_exceptions.py,sha256=fsoBpVSfcxawmhAqNV81RGsgi5neW4GmEUtuVerTvyE,319
 result_companion/core/analizers/local/ollama_install.py,sha256=29pu3wJwOQdm7H-DEJlJDOSrlOoAeUqwvaZ7YEhNsKo,8866
 result_companion/core/analizers/local/ollama_runner.py,sha256=d2AfzuHPStLJMdTMmgk0pyKZRNtlJW7hxUMEXXAdiX4,4566
 result_companion/core/analizers/local/ollama_server_manager.py,sha256=L9k6kTDhGVb9hS48tzz2gOV7SKpBE20upuQi1QEJeFc,6572
-result_companion/core/analizers/models.py,sha256=eo5zVSNctRMrQlnYtuAc6rK-u3gak4gbXwyuneFbF3I,431
+result_companion/core/analizers/models.py,sha256=0gPCxjBnW5N6w0v8eatmA5AxR_WCvFJPgkUrtUJscYE,521
 result_companion/core/analizers/remote/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+result_companion/core/analizers/remote/copilot.py,sha256=5TNuOJy9yG2W9WeCiy3ZmFGML245Vs6bzBGqZFWnrEU,5333
 result_companion/core/analizers/remote/custom_endpoint.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 result_companion/core/analizers/remote/openai.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-result_companion/core/chunking/chunking.py,sha256=mq35yCy-917hBYvOn54P1wAcIDYHB9K9BULgVKkef5E,3623
-result_companion/core/chunking/utils.py,sha256=nogJbPtwBPNomRwJ9P8ucU8YNeovmPS_mnzW8dYsSDM,3834
+result_companion/core/chunking/chunking.py,sha256=hLB17tuT4OogIa7TLAl8JAX-dzo7MW7y_kJcghSTqx8,3815
+result_companion/core/chunking/utils.py,sha256=gaTDi2511b9mK8z26zmz2YpmkjijTvdSRhN6fuJZ8DM,3991
 result_companion/core/configs/default_config.yaml,sha256=UD9wRPf3nSbKdHNTilVISlz40R97ZmtAf7cLb6PS4gc,2396
 result_companion/core/html/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 result_companion/core/html/html_creator.py,sha256=Jmxw6jy-T-DKHF5oAWXc9bK2lUa4OnBA-ksWFSEFilY,7333
@@ -24,14 +25,14 @@ result_companion/core/results/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5N
 result_companion/core/results/visitors.py,sha256=rZ0jHt5m2gXF5X2TzYm-XtEyXFxvowpAH5ap3Paw-VM,1373
 result_companion/core/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 result_companion/core/utils/log_levels.py,sha256=64rq3mrRQs2yKBjD4mojSHh0l8ok4V60ZM8LU_foJ58,544
-result_companion/core/utils/logging_config.py,sha256=zBdjTpTz3OMC_J_yona083oObyUKo1qlnQiXbVSzza4,3495
+result_companion/core/utils/logging_config.py,sha256=hJN6SET1wsAJ61rX54bmAyI6CJjg7hDx5S2fW4YXIB0,3744
 result_companion/core/utils/progress.py,sha256=YmO1XvJg74DvYHGGeU5upQmrWol1Ote0pB4dYmcHQzw,1675
 result_companion/entrypoints/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 result_companion/entrypoints/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-result_companion/entrypoints/cli/cli_app.py,sha256=xTjE3b_SEIOc67NhK81vBtnEcID7wqmsX_qrgxNjIi8,7503
-result_companion/entrypoints/run_rc.py,sha256=76fNOElhhbWOxxNUh9x_CazSWVchsCz0h8xpvQX3qj8,6022
-result_companion-0.0.2.dist-info/METADATA,sha256=Zyq3uTFPZfLp-v_0xqWxe2VZ6sLH5DdxQKSpQW_acXw,7147
-result_companion-0.0.2.dist-info/WHEEL,sha256=3ny-bZhpXrU6vSQ1UPG34FoxZBp3lVcvK0LkgUz6VLk,88
-result_companion-0.0.2.dist-info/entry_points.txt,sha256=oK1iuYUNOtyMAIcc1GLVWntCaZqpb0Ioj_LpnJNq-qc,81
-result_companion-0.0.2.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-result_companion-0.0.2.dist-info/RECORD,,
+result_companion/entrypoints/cli/cli_app.py,sha256=khSyQ73RXXRceMdEhkSx1J_YCR29u4g2OwgQfxm74nE,7660
+result_companion/entrypoints/run_rc.py,sha256=_5v1iCe8rBzqmSLTcDmV85olt2cenOl0GL2iNo4IM9E,6792
+result_companion-0.0.3.dist-info/METADATA,sha256=3gipY-xesUmEQrNslTd-9um7iNz9ufKpQNSZ2F2K-rc,7780
+result_companion-0.0.3.dist-info/WHEEL,sha256=kJCRJT_g0adfAJzTx2GUMmS80rTJIVHRCfG0DQgLq3o,88
+result_companion-0.0.3.dist-info/entry_points.txt,sha256=oK1iuYUNOtyMAIcc1GLVWntCaZqpb0Ioj_LpnJNq-qc,81
+result_companion-0.0.3.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+result_companion-0.0.3.dist-info/RECORD,,

{result_companion-0.0.2.dist-info → result_companion-0.0.3.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 2.3.0
+Generator: poetry-core 2.3.1
 Root-Is-Purelib: true
 Tag: py3-none-any