pygent 0.1.1__tar.gz → 0.1.3__tar.gz

{pygent-0.1.1 → pygent-0.1.3}/PKG-INFO

@@ -1,18 +1,21 @@
 Metadata-Version: 2.4
 Name: pygent
-Version: 0.1.1
-Summary: Pygent é um assistente de código minimalista que executa comandos em contêiner Docker quando disponível, com fallback para execução local. Veja https://marianochaves.github.io/pygent para a documentação e https://github.com/marianochaves/pygent para o código-fonte.
+Version: 0.1.3
+Summary: Pygent is a minimalist coding assistant that runs commands in a Docker container when available and falls back to local execution. See https://marianochaves.github.io/pygent for documentation and https://github.com/marianochaves/pygent for the source code.
 Author-email: Mariano Chaves <mchaves.software@gmail.com>
 Project-URL: Documentation, https://marianochaves.github.io/pygent
 Project-URL: Repository, https://github.com/marianochaves/pygent
 Requires-Python: >=3.9
 License-File: LICENSE
-Requires-Dist: openai>=1.0.0
 Requires-Dist: rich>=13.7.0
+Provides-Extra: llm
+Requires-Dist: openai>=1.0.0; extra == "llm"
 Provides-Extra: test
 Requires-Dist: pytest; extra == "test"
 Provides-Extra: docs
 Requires-Dist: mkdocs; extra == "docs"
 Provides-Extra: docker
 Requires-Dist: docker>=7.0.0; extra == "docker"
+Provides-Extra: ui
+Requires-Dist: gradio; extra == "ui"
 Dynamic: license-file

pygent-0.1.3/README.md

@@ -0,0 +1,104 @@
+# Pygent
+
+Pygent is a coding assistant that executes each request inside an isolated Docker container whenever possible. If Docker is unavailable (for instance on some Windows setups) the commands are executed locally instead.
+
+## Features
+
+* Runs commands in ephemeral containers (default image `python:3.12-slim`).
+* Integrates with OpenAI-compatible models to orchestrate each step.
+* Persists the conversation history during the session.
+* Provides a small Python API for use in other projects.
+* Optional web interface via `pygent-ui`.
+
+## Installation
+
+Installing from source is recommended:
+
+```bash
+pip install -e .
+```
+
+Python ≥ 3.9 is required. The only runtime dependency is `rich`.
+Install any OpenAI-compatible library such as `openai` or `litellm` separately to enable model access.
+To run commands in Docker containers also install `pygent[docker]`.
+
+## Configuration
+
+Behaviour can be adjusted via environment variables:
+
+* `OPENAI_API_KEY` – key used to access the OpenAI API.
+  Set this to your API key or a key from any compatible provider.
+* `OPENAI_BASE_URL` – base URL for OpenAI-compatible APIs
+  (defaults to ``https://api.openai.com/v1``).
+* `PYGENT_MODEL` – model name used for requests (default `gpt-4.1-mini`).
+* `PYGENT_IMAGE` – Docker image to create the container (default `python:3.12-slim`).
+* `PYGENT_USE_DOCKER` – set to `0` to disable Docker and run locally.
+
+## CLI usage
+
+After installing run:
+
+```bash
+pygent
+```
+
+Use `--docker` to run commands inside a container (requires
+`pygent[docker]`). Use `--no-docker` or set `PYGENT_USE_DOCKER=0`
+to force local execution.
+
+Type messages normally; use `/exit` to end the session. Each command is executed
+in the container and the result shown in the terminal.
+For a minimal web interface run `pygent-ui` instead (requires `pygent[ui]`).
+
+
+## API usage
+
+You can also interact directly with the Python code:
+
+```python
+from pygent import Agent
+
+ag = Agent()
+ag.step("echo 'Hello World'")
+# ... more steps
+ag.runtime.cleanup()
+```
+
+See the `examples/` folder for more complete scripts.
+
+### Using OpenAI and other providers
+
+Set your OpenAI key:
+
+```bash
+export OPENAI_API_KEY="sk-..."
+```
+
+To use a different provider, set `OPENAI_BASE_URL` to the provider
+endpoint and keep `OPENAI_API_KEY` pointing to the correct key:
+
+```bash
+export OPENAI_BASE_URL="https://openrouter.ai/api/v1"
+export OPENAI_API_KEY="your-provider-key"
+```
+
+## Development
+
+1. Install the test dependencies:
+
+```bash
+pip install -e .[test]
+```
+
+2. Run the test suite:
+
+```bash
+pytest
+```
+
+Use `mkdocs serve` to build the documentation locally.
+
+## License
+
+This project is released under the MIT license. See the `LICENSE` file for details.
+

{pygent-0.1.1 → pygent-0.1.3}/pygent/__init__.py

@@ -1,4 +1,4 @@
-"""Pacote Pygent."""
+"""Pygent package."""
 from importlib import metadata as _metadata
 
 try:

{pygent-0.1.1 → pygent-0.1.3}/pygent/agent.py

@@ -1,4 +1,4 @@
-"""Camada de orquestração: recebe mensagens, chama OpenAI, delega ferramentas."""
+"""Orchestration layer: receives messages, calls the OpenAI-compatible backend and dispatches tools."""
 
 import json
 import os
@@ -8,14 +8,17 @@ import time
 from dataclasses import dataclass, field
 from typing import Any, Dict, List
 
-import openai
+try:
+    import openai  # type: ignore
+except ModuleNotFoundError:  # pragma: no cover - fallback to bundled client
+    from . import openai_compat as openai
 from rich.console import Console
 from rich.panel import Panel
 
 from .runtime import Runtime
 from .tools import TOOL_SCHEMAS, execute_tool
 
-MODEL = os.getenv("PYGENT_MODEL", "gpt-4o-mini-preview")
+MODEL = os.getenv("PYGENT_MODEL", "gpt-4.1-mini")
 SYSTEM_MSG = (
     "You are Pygent, a sandboxed coding assistant.\n"
     "Respond with JSON when you need to use a tool."

{pygent-0.1.1 → pygent-0.1.3}/pygent/cli.py

@@ -1,12 +1,12 @@
-"""Ponto de entrada da CLI do Pygent."""
+"""Command-line entry point for Pygent."""
 import argparse
 
 from .agent import run_interactive
 
 def main() -> None:  # pragma: no cover
     parser = argparse.ArgumentParser(prog="pygent")
-    parser.add_argument("--docker", dest="use_docker", action="store_true", help="executar em container Docker")
-    parser.add_argument("--no-docker", dest="use_docker", action="store_false", help="executar localmente")
+    parser.add_argument("--docker", dest="use_docker", action="store_true", help="run commands in a Docker container")
+    parser.add_argument("--no-docker", dest="use_docker", action="store_false", help="run locally")
     parser.set_defaults(use_docker=None)
     args = parser.parse_args()
     run_interactive(use_docker=args.use_docker)

pygent-0.1.3/pygent/openai_compat.py

@@ -0,0 +1,71 @@
+import os
+import json
+from dataclasses import dataclass
+from typing import Any, Dict, List
+from urllib import request
+
+OPENAI_BASE_URL = os.getenv("OPENAI_BASE_URL", "https://api.openai.com/v1")
+OPENAI_API_KEY = os.getenv("OPENAI_API_KEY", "")
+
+@dataclass
+class ToolCallFunction:
+    name: str
+    arguments: str
+
+@dataclass
+class ToolCall:
+    id: str
+    type: str
+    function: ToolCallFunction
+
+@dataclass
+class Message:
+    role: str
+    content: str | None = None
+    tool_calls: List[ToolCall] | None = None
+
+@dataclass
+class Choice:
+    message: Message
+
+@dataclass
+class ChatCompletion:
+    choices: List[Choice]
+
+
+def _post(path: str, payload: Dict[str, Any]) -> Dict[str, Any]:
+    data = json.dumps(payload).encode()
+    headers = {"Content-Type": "application/json"}
+    if OPENAI_API_KEY:
+        headers["Authorization"] = f"Bearer {OPENAI_API_KEY}"
+    req = request.Request(f"{OPENAI_BASE_URL}{path}", data=data, headers=headers)
+    with request.urlopen(req) as resp:
+        return json.loads(resp.read().decode())
+
+
+class _ChatCompletions:
+    def create(self, model: str, messages: List[Dict[str, Any]], tools: Any = None, tool_choice: str | None = "auto") -> ChatCompletion:
+        payload: Dict[str, Any] = {"model": model, "messages": messages}
+        if tools is not None:
+            payload["tools"] = tools
+        if tool_choice is not None:
+            payload["tool_choice"] = tool_choice
+        raw = _post("/chat/completions", payload)
+        choices: List[Choice] = []
+        for ch in raw.get("choices", []):
+            msg_data = ch.get("message", {})
+            tool_calls = []
+            for tc in msg_data.get("tool_calls", []):
+                func = ToolCallFunction(**tc.get("function", {}))
+                tool_calls.append(ToolCall(id=tc.get("id", ""), type=tc.get("type", ""), function=func))
+            msg = Message(role=msg_data.get("role", ""), content=msg_data.get("content"), tool_calls=tool_calls or None)
+            choices.append(Choice(message=msg))
+        return ChatCompletion(choices=choices)
+
+
+class _Chat:
+    def __init__(self) -> None:
+        self.completions = _ChatCompletions()
+
+
+chat = _Chat()

{pygent-0.1.1 → pygent-0.1.3}/pygent/runtime.py

@@ -1,4 +1,4 @@
-"""Executa comandos em um container Docker, caindo para execução local se necessário."""
+"""Run commands in a Docker container, falling back to local execution if needed."""
 from __future__ import annotations
 
 import os
@@ -16,7 +16,7 @@ except Exception:  # pragma: no cover - optional dependency
 
 
 class Runtime:
-    """Executa comandos em um container Docker ou localmente se Docker faltar."""
+    """Executes commands in a Docker container or locally if Docker is unavailable."""
 
     def __init__(self, image: str | None = None, use_docker: bool | None = None) -> None:
         self.base_dir = Path(tempfile.mkdtemp(prefix="pygent_"))
@@ -48,7 +48,7 @@ class Runtime:
 
     # ---------------- public API ----------------
     def bash(self, cmd: str, timeout: int = 30) -> str:
-        """Roda comando no container ou localmente e devolve a saída."""
+        """Run a command in the container or locally and return the output."""
         if self._use_docker and self.container is not None:
             res = self.container.exec_run(
                 cmd,

{pygent-0.1.1 → pygent-0.1.3}/pygent/tools.py

@@ -1,4 +1,4 @@
-"""Mapa de ferramentas disponíveis para o agente."""
+"""Map of tools available to the agent."""
 from __future__ import annotations
 import json
 from typing import Any, Dict

pygent-0.1.3/pygent/ui.py

@@ -0,0 +1,36 @@
+from .agent import Agent, _chat
+from .runtime import Runtime
+from .tools import execute_tool
+
+
+def run_gui(use_docker: bool | None = None) -> None:
+    """Launch a simple Gradio chat interface."""
+    try:
+        import gradio as gr
+    except ModuleNotFoundError as exc:  # pragma: no cover - optional
+        raise SystemExit(
+            "Gradio is required for the GUI. Install with 'pip install pygent[ui]'"
+        ) from exc
+
+    agent = Agent(runtime=Runtime(use_docker=use_docker))
+
+    def _respond(message: str, history: list[tuple[str, str]] | None) -> str:
+        agent.history.append({"role": "user", "content": message})
+        assistant_msg = _chat(agent.history)
+        agent.history.append(assistant_msg)
+        reply = assistant_msg.content or ""
+        if assistant_msg.tool_calls:
+            for call in assistant_msg.tool_calls:
+                output = execute_tool(call, agent.runtime)
+                agent.history.append({"role": "tool", "content": output, "tool_call_id": call.id})
+                reply += f"\n\n[tool:{call.function.name}]\n{output}"
+        return reply
+
+    try:
+        gr.ChatInterface(_respond, title="Pygent").launch()
+    finally:
+        agent.runtime.cleanup()
+
+
+def main() -> None:  # pragma: no cover
+    run_gui()

{pygent-0.1.1 → pygent-0.1.3}/pygent.egg-info/PKG-INFO

@@ -1,18 +1,21 @@
 Metadata-Version: 2.4
 Name: pygent
-Version: 0.1.1
-Summary: Pygent é um assistente de código minimalista que executa comandos em contêiner Docker quando disponível, com fallback para execução local. Veja https://marianochaves.github.io/pygent para a documentação e https://github.com/marianochaves/pygent para o código-fonte.
+Version: 0.1.3
+Summary: Pygent is a minimalist coding assistant that runs commands in a Docker container when available and falls back to local execution. See https://marianochaves.github.io/pygent for documentation and https://github.com/marianochaves/pygent for the source code.
 Author-email: Mariano Chaves <mchaves.software@gmail.com>
 Project-URL: Documentation, https://marianochaves.github.io/pygent
 Project-URL: Repository, https://github.com/marianochaves/pygent
 Requires-Python: >=3.9
 License-File: LICENSE
-Requires-Dist: openai>=1.0.0
 Requires-Dist: rich>=13.7.0
+Provides-Extra: llm
+Requires-Dist: openai>=1.0.0; extra == "llm"
 Provides-Extra: test
 Requires-Dist: pytest; extra == "test"
 Provides-Extra: docs
 Requires-Dist: mkdocs; extra == "docs"
 Provides-Extra: docker
 Requires-Dist: docker>=7.0.0; extra == "docker"
+Provides-Extra: ui
+Requires-Dist: gradio; extra == "ui"
 Dynamic: license-file

{pygent-0.1.1 → pygent-0.1.3}/pygent.egg-info/SOURCES.txt

@@ -4,9 +4,11 @@ pyproject.toml
 pygent/__init__.py
 pygent/agent.py
 pygent/cli.py
+pygent/openai_compat.py
 pygent/py.typed
 pygent/runtime.py
 pygent/tools.py
+pygent/ui.py
 pygent.egg-info/PKG-INFO
 pygent.egg-info/SOURCES.txt
 pygent.egg-info/dependency_links.txt

{pygent-0.1.1 → pygent-0.1.3}/pygent.egg-info/entry_points.txt

@@ -1,2 +1,3 @@
 [console_scripts]
 pygent = pygent.cli:main
+pygent-ui = pygent.ui:main

{pygent-0.1.1 → pygent-0.1.3}/pygent.egg-info/requires.txt

@@ -1,4 +1,3 @@
-openai>=1.0.0
 rich>=13.7.0
 
 [docker]
@@ -7,5 +6,11 @@ docker>=7.0.0
 [docs]
 mkdocs
 
+[llm]
+openai>=1.0.0
+
 [test]
 pytest
+
+[ui]
+gradio

{pygent-0.1.1 → pygent-0.1.3}/pyproject.toml

@@ -1,25 +1,28 @@
 [project]
 name = "pygent"
-version = "0.1.1"
-description = "Pygent é um assistente de código minimalista que executa comandos em contêiner Docker quando disponível, com fallback para execução local. Veja https://marianochaves.github.io/pygent para a documentação e https://github.com/marianochaves/pygent para o código-fonte."
+version = "0.1.3"
+description = "Pygent is a minimalist coding assistant that runs commands in a Docker container when available and falls back to local execution. See https://marianochaves.github.io/pygent for documentation and https://github.com/marianochaves/pygent for the source code."
 authors = [ { name = "Mariano Chaves", email = "mchaves.software@gmail.com" } ]
 requires-python = ">=3.9"
 dependencies = [
-    "openai>=1.0.0",   # interface com modelos da OpenAI
-    "rich>=13.7.0"      # saídas coloridas (opcional)
+    "rich>=13.7.0"      # colored output (optional)
 ]
 
+[project.optional-dependencies]
+llm = ["openai>=1.0.0"]  # OpenAI-compatible library (optional)
+test = ["pytest"]
+docs = ["mkdocs"]
+docker = ["docker>=7.0.0"]
+ui = ["gradio"]
+
 [project.urls]
 Documentation = "https://marianochaves.github.io/pygent"
 Repository = "https://github.com/marianochaves/pygent"
 
 [project.scripts]
 pygent = "pygent.cli:main"
+pygent-ui = "pygent.ui:main"
 
-[project.optional-dependencies]
-test = ["pytest"]
-docs = ["mkdocs"]
-docker = ["docker>=7.0.0"]
 
 [tool.setuptools.package-data]
 "pygent" = ["py.typed"]

pygent-0.1.1/README.md

@@ -1,79 +0,0 @@
-# Pygent
-
-Pygent é um assistente de código que executa cada solicitação em um container Docker isolado sempre que possível. Caso Docker não esteja disponível (por exemplo em algumas instalações do Windows), o Pygent ainda funciona executando os comandos localmente.
-
-## Recursos
-
-* Execução de comandos em containers efêmeros (imagem padrão `python:3.12-slim`).
-* Integração com modelos da OpenAI para orquestração das etapas.
-* Histórico persistente das interações durante a sessão.
-* API Python simples para integração em outros projetos.
-
-## Instalação
-
-Recomenda-se instalar a partir do código fonte:
-
-```bash
-pip install -e .
-```
-
-É necessário possuir Python ≥ 3.9. As dependências de runtime são `openai` e `rich`. Para executar dentro de containers Docker instale também `pygent[docker]`.
-
-## Configuração
-
-O comportamento pode ser ajustado via variáveis de ambiente:
-
-* `OPENAI_API_KEY` – chave para acesso à API da OpenAI.
-* `PYGENT_MODEL` – modelo utilizado nas chamadas (padrão `gpt-4o-mini-preview`).
-* `PYGENT_IMAGE` – imagem Docker para criar o container (padrão `python:3.12-slim`).
-* `PYGENT_USE_DOCKER` – defina `0` para desabilitar Docker e executar localmente.
-
-## Uso via CLI
-
-Após instalar, execute:
-
-```bash
-pygent
-```
-
-Use `--docker` para executar os comandos dentro de um container (requere
-`pygent[docker]`). Utilize `--no-docker` ou defina `PYGENT_USE_DOCKER=0`
-para forçar a execução local.
-
-Digite mensagens normalmente; utilize `/exit` para encerrar a sessão. Todo comando é executado dentro do container e o resultado é exibido no terminal.
-
-## Uso via API
-
-Também é possível interagir diretamente com o código Python:
-
-```python
-from pygent import Agent
-
-ag = Agent()
-ag.step("echo 'Ola Mundo'")
-# ... demias passos
-ag.runtime.cleanup()
-```
-
-Confira a pasta `examples/` para scripts mais completos.
-
-## Desenvolvimento
-
-1. Instale as dependências de teste:
-
-```bash
-pip install -e .[test]
-```
-
-2. Rode o conjunto de testes:
-
-```bash
-pytest
-```
-
-Para gerar a documentação localmente utilize `mkdocs serve`.
-
-## Licença
-
-Este projeto é distribuído sob a licença MIT. Consulte o arquivo `LICENSE` para mais detalhes.
-