pygent 0.1.0__tar.gz → 0.1.2__tar.gz

pygent-0.1.2/PKG-INFO

@@ -0,0 +1,19 @@
+Metadata-Version: 2.4
+Name: pygent
+Version: 0.1.2
+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: 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"
+Dynamic: license-file

pygent-0.1.2/README.md

@@ -0,0 +1,81 @@
+# 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.
+
+## 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.
+* `PYGENT_MODEL` – model name used for requests (default `gpt-4o-mini-preview`).
+* `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.
+
+## 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.
+
+## 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.0 → pygent-0.1.2}/pygent/__init__.py

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

{pygent-0.1.0 → pygent-0.1.2}/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,7 +8,10 @@ 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
 
@@ -55,8 +58,8 @@ class Agent:
             console.print(assistant_msg.content)
 
 
-def run_interactive() -> None:  # pragma: no cover
-    agent = Agent()
+def run_interactive(use_docker: bool | None = None) -> None:  # pragma: no cover
+    agent = Agent(runtime=Runtime(use_docker=use_docker))
     console.print("[bold green]Pygent[/] iniciado. (digite /exit para sair)")
     try:
         while True:

pygent-0.1.2/pygent/cli.py

@@ -0,0 +1,12 @@
+"""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="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.2/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.2/pygent/runtime.py

@@ -0,0 +1,86 @@
+"""Run commands in a Docker container, falling back to local execution if needed."""
+from __future__ import annotations
+
+import os
+import shutil
+import subprocess
+import tempfile
+import uuid
+from pathlib import Path
+from typing import Union
+
+try:  # Docker may not be available (e.g. Windows without Docker)
+    import docker  # type: ignore
+except Exception:  # pragma: no cover - optional dependency
+    docker = None
+
+
+class Runtime:
+    """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_"))
+        self.image = image or os.getenv("PYGENT_IMAGE", "python:3.12-slim")
+        env_opt = os.getenv("PYGENT_USE_DOCKER")
+        if use_docker is None:
+            use_docker = (env_opt != "0") if env_opt is not None else True
+        self._use_docker = bool(docker) and use_docker
+        if self._use_docker:
+            try:
+                self.client = docker.from_env()
+                self.container = self.client.containers.run(
+                    self.image,
+                    name=f"pygent-{uuid.uuid4().hex[:8]}",
+                    command="sleep infinity",
+                    volumes={str(self.base_dir): {"bind": "/workspace", "mode": "rw"}},
+                    working_dir="/workspace",
+                    detach=True,
+                    tty=True,
+                    network_disabled=True,
+                    mem_limit="512m",
+                    pids_limit=256,
+                )
+            except Exception:
+                self._use_docker = False
+        if not self._use_docker:
+            self.client = None
+            self.container = None
+
+    # ---------------- public API ----------------
+    def bash(self, cmd: str, timeout: int = 30) -> str:
+        """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,
+                workdir="/workspace",
+                demux=True,
+                tty=False,
+                timeout=timeout,
+            )
+            stdout, stderr = (
+                res.output if isinstance(res.output, tuple) else (res.output, b"")
+            )
+            return (stdout or b"").decode() + (stderr or b"").decode()
+        proc = subprocess.run(
+            cmd,
+            shell=True,
+            cwd=self.base_dir,
+            capture_output=True,
+            text=True,
+            timeout=timeout,
+        )
+        return proc.stdout + proc.stderr
+
+    def write_file(self, rel_path: Union[str, Path], content: str) -> str:
+        p = self.base_dir / rel_path
+        p.parent.mkdir(parents=True, exist_ok=True)
+        p.write_text(content)
+        return f"Wrote {p.relative_to(self.base_dir)}"
+
+    def cleanup(self) -> None:
+        if self._use_docker and self.container is not None:
+            try:
+                self.container.kill()
+            finally:
+                self.container.remove(force=True)
+        shutil.rmtree(self.base_dir, ignore_errors=True)

{pygent-0.1.0 → pygent-0.1.2}/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.2/pygent.egg-info/PKG-INFO

@@ -0,0 +1,19 @@
+Metadata-Version: 2.4
+Name: pygent
+Version: 0.1.2
+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: 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"
+Dynamic: license-file

{pygent-0.1.0 → pygent-0.1.2}/pygent.egg-info/SOURCES.txt

@@ -4,6 +4,7 @@ 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-0.1.0 → pygent-0.1.2}/pygent.egg-info/requires.txt

@@ -1,9 +1,13 @@
-openai>=1.0.0
-docker>=7.0.0
 rich>=13.7.0
 
+[docker]
+docker>=7.0.0
+
 [docs]
 mkdocs
 
+[llm]
+openai>=1.0.0
+
 [test]
 pytest

pygent-0.1.2/pyproject.toml

@@ -0,0 +1,30 @@
+[project]
+name = "pygent"
+version = "0.1.2"
+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 = [
+    "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"]
+
+[project.urls]
+Documentation = "https://marianochaves.github.io/pygent"
+Repository = "https://github.com/marianochaves/pygent"
+
+[project.scripts]
+pygent = "pygent.cli:main"
+
+
+[tool.setuptools.package-data]
+"pygent" = ["py.typed"]
+
+[build-system]
+requires = ["setuptools>=64", "wheel"]
+build-backend = "setuptools.build_meta"

pygent-0.1.0/PKG-INFO

@@ -1,15 +0,0 @@
-Metadata-Version: 2.4
-Name: pygent
-Version: 0.1.0
-Summary: A minimal agentic coding assistant that runs each task in a secure container.
-Author-email: Mariano Chaves <mchaves.software@gmail.com>
-Requires-Python: >=3.9
-License-File: LICENSE
-Requires-Dist: openai>=1.0.0
-Requires-Dist: docker>=7.0.0
-Requires-Dist: rich>=13.7.0
-Provides-Extra: test
-Requires-Dist: pytest; extra == "test"
-Provides-Extra: docs
-Requires-Dist: mkdocs; extra == "docs"
-Dynamic: license-file

pygent-0.1.0/README.md

@@ -1,40 +0,0 @@
-# Pygent
-
-Pygent é um assistente de código minimalista que executa cada tarefa em um
-container Docker isolado. O objetivo é facilitar execução de comandos de forma
-segura e reprodutível, mantendo o histórico de mensagens da conversa.
-
-## Instalação
-
-Recomendação mais simples é usar `pip`:
-
-```bash
-pip install -e .
-```
-
-O projeto requer Python ≥ 3.9 e depende de `docker`, `openai` e `rich`.
-
-## Uso via CLI
-
-Após instalado, inicie a interface interativa com:
-
-```bash
-pygent
-```
-
-Digita mensagens normalmente e utilize `/exit` para sair.
-
-## Uso via API
-
-Também é possível integrar diretamente com o código Python:
-
-```python
-from pygent import Agent
-
-ag = Agent()
-ag.step("echo hello")  # roda dentro do container
-ag.runtime.cleanup()
-```
-
-Veja a pasta `examples/` para scripts mais completos.
-

pygent-0.1.0/pygent/cli.py

@@ -1,5 +0,0 @@
-"""Ponto de entrada da CLI do Pygent."""
-from .agent import run_interactive
-
-def main() -> None:  # pragma: no cover
-    run_interactive()

pygent-0.1.0/pygent/runtime.py

@@ -1,53 +0,0 @@
-"""Isola as execuções num container Docker efêmero."""
-from __future__ import annotations
-
-import os
-import shutil
-import tempfile
-import subprocess
-import uuid
-from pathlib import Path
-from typing import Union
-
-import docker
-
-
-class Runtime:
-    """Cada instância corresponde a um diretório + container dedicados."""
-
-    def __init__(self, image: str | None = None) -> None:
-        self.base_dir = Path(tempfile.mkdtemp(prefix="pygent_"))
-        self.image = image or os.getenv("PYGENT_IMAGE", "python:3.12-slim")
-        self.client = docker.from_env()
-        self.container = self.client.containers.run(
-            self.image,
-            name=f"pygent-{uuid.uuid4().hex[:8]}",
-            command="sleep infinity",
-            volumes={str(self.base_dir): {"bind": "/workspace", "mode": "rw"}},
-            working_dir="/workspace",
-            detach=True,
-            tty=True,
-            network_disabled=True,
-            mem_limit="512m",
-            pids_limit=256,
-        )
-
-    # ---------------- public API ----------------
-    def bash(self, cmd: str, timeout: int = 30) -> str:
-        """Roda comando dentro do container e devolve saída combinada."""
-        res = self.container.exec_run(cmd, workdir="/workspace", demux=True, tty=False, timeout=timeout)
-        stdout, stderr = res.output if isinstance(res.output, tuple) else (res.output, b"")
-        return (stdout or b"").decode() + (stderr or b"").decode()
-
-    def write_file(self, rel_path: Union[str, Path], content: str) -> str:
-        p = self.base_dir / rel_path
-        p.parent.mkdir(parents=True, exist_ok=True)
-        p.write_text(content)
-        return f"Wrote {p.relative_to(self.base_dir)}"
-
-    def cleanup(self) -> None:
-        try:
-            self.container.kill()
-        finally:
-            self.container.remove(force=True)
-            shutil.rmtree(self.base_dir, ignore_errors=True)

pygent-0.1.0/pygent.egg-info/PKG-INFO

@@ -1,15 +0,0 @@
-Metadata-Version: 2.4
-Name: pygent
-Version: 0.1.0
-Summary: A minimal agentic coding assistant that runs each task in a secure container.
-Author-email: Mariano Chaves <mchaves.software@gmail.com>
-Requires-Python: >=3.9
-License-File: LICENSE
-Requires-Dist: openai>=1.0.0
-Requires-Dist: docker>=7.0.0
-Requires-Dist: rich>=13.7.0
-Provides-Extra: test
-Requires-Dist: pytest; extra == "test"
-Provides-Extra: docs
-Requires-Dist: mkdocs; extra == "docs"
-Dynamic: license-file

pygent-0.1.0/pyproject.toml

@@ -1,25 +0,0 @@
-[project]
-name = "pygent"
-version = "0.1.0"
-description = "A minimal agentic coding assistant that runs each task in a secure container."
-authors = [ { name = "Mariano Chaves", email = "mchaves.software@gmail.com" } ]
-requires-python = ">=3.9"
-dependencies = [
-    "openai>=1.0.0",   # interface com modelos da OpenAI
-    "docker>=7.0.0",    # manipular containers
-    "rich>=13.7.0"      # saídas coloridas (opcional)
-]
-
-[project.scripts]
-pygent = "pygent.cli:main"
-
-[project.optional-dependencies]
-test = ["pytest"]
-docs = ["mkdocs"]
-
-[tool.setuptools.package-data]
-"pygent" = ["py.typed"]
-
-[build-system]
-requires = ["setuptools>=64", "wheel"]
-build-backend = "setuptools.build_meta"