codebind 0.6.23__py3-none-any.whl → 0.7.0__py3-none-any.whl

codebind/auth.py

@@ -0,0 +1,151 @@
+"""Interactive provider sign-in for the Codebind command line."""
+
+from __future__ import annotations
+
+import asyncio
+import dataclasses
+import logging
+import os
+import webbrowser
+from collections.abc import Mapping
+from typing import Any
+
+from .configuration import CodebindStore, load_models, load_store, save_store
+
+AUTH_TIMEOUT_SECONDS = 300.0
+
+logger = logging.getLogger("codebind.auth")
+
+
+class AuthError(RuntimeError):
+    """A provider sign-in could not be completed"""
+
+
+def _credential_payload(models: Any, identifier: str, value: Any) -> dict[str, Any]:
+    """Return one provider credential as a JSON-ready mapping.
+
+    A completed flow stores its token object in the authorization values, so
+    each provider serializes it through its own adapter to keep every extra
+    field it defines. A plain mapping is accepted for credentials a host wrote
+    directly.
+    """
+    if isinstance(value, Mapping):
+        payload = dict(value)
+    else:
+        adapter = next(
+            (
+                provider.oauth
+                for provider in models._runtime._providers
+                if provider.identifier == identifier and provider.oauth is not None
+            ),
+            None,
+        )
+        if adapter is not None:
+            payload = dict(adapter.serialize_tokens(value))
+        elif dataclasses.is_dataclass(value) and not isinstance(value, type):
+            payload = dataclasses.asdict(value)
+        else:
+            raise AuthError(f"cannot save {type(value).__name__} credentials for {identifier}")
+    if not payload:
+        raise AuthError(f"{identifier} returned no credentials to save")
+    return payload
+
+
+def _account_of(payload: Any) -> str:
+    if not isinstance(payload, Mapping):
+        return ""
+    for key in ("email", "account", "account_id"):
+        value = payload.get(key)
+        if value:
+            return str(value)
+    return ""
+
+
+def authenticate(provider: str, *, timeout: float = AUTH_TIMEOUT_SECONDS) -> str:
+    """Run one provider browser sign-in and save its credentials.
+
+    Returns the saved account label for the provider, or an empty string when
+    the provider returned no account information.
+    """
+    identifier = provider.strip().lower()
+    if not identifier:
+        raise AuthError("a provider name is required")
+
+    models = load_models()
+
+    async def run() -> dict[str, Any]:
+        authorization = await models.sign_in(identifier)
+        logger.info("opening your browser to authorize %s", identifier)
+        logger.info("if it does not open, visit %s", authorization.url)
+        try:
+            opened = webbrowser.open(authorization.url)
+        except Exception as error:  # a headless host still gets the logged URL
+            logger.warning("could not open a browser: %s", error)
+        else:
+            if not opened:
+                logger.warning("no browser could be opened, use the URL above")
+        try:
+            await authorization.complete(timeout=timeout)
+        finally:
+            await authorization.close()
+        return _credential_payload(models, identifier, authorization.values.get(identifier))
+
+    try:
+        payload = asyncio.run(asyncio.wait_for(run(), timeout=timeout + 15.0))
+    except AuthError:
+        raise
+    except TimeoutError as error:
+        raise AuthError(f"{identifier} did not authorize within {timeout:g} seconds") from error
+    except Exception as error:
+        raise AuthError(f"could not sign in to {identifier}: {error}") from error
+
+    account = _account_of(payload)
+    path = save_store(load_store().with_provider(identifier, payload))
+    logger.info(
+        "signed in to %s%s, saved to %s", identifier, f" as {account}" if account else "", path
+    )
+    return account
+
+
+def status() -> list[tuple[str, str, str]]:
+    """Return the stored credential state for every OAuth-capable provider."""
+    models = load_models()
+    providers = load_store().providers
+    authentication = models._runtime.authentication(providers)
+
+    rows: list[tuple[str, str, str]] = []
+    for provider in models._runtime._providers:
+        identifier = provider.identifier
+        if provider.oauth is None:
+            continue
+        if identifier in providers:
+            resolved = authentication.status(identifier)
+            if resolved.expired:
+                logger.warning(
+                    "%s credentials have expired, run: codebind auth %s", identifier, identifier
+                )
+            rows.append(
+                (identifier, "expired" if resolved.expired else "signed in", resolved.account)
+            )
+            continue
+        variables = tuple(authentication.profile(identifier).environment_variables)
+        variable = next((name for name in variables if os.environ.get(name)), "")
+        rows.append((identifier, "environment" if variable else "not signed in", variable))
+    return rows
+
+
+def logout(provider: str) -> int:
+    """Remove one provider credential, returning 1 when there was none."""
+    identifier = provider.strip().lower()
+    store = load_store()
+    if identifier not in store.providers:
+        logger.warning("not signed in to %s", identifier)
+        return 1
+    remaining = dict(store.providers)
+    remaining.pop(identifier)
+    path = save_store(CodebindStore(store.configuration, remaining))
+    logger.info("removed %s credentials from %s", identifier, path)
+    return 0
+
+
+__all__ = ["AUTH_TIMEOUT_SECONDS", "AuthError", "authenticate", "logout", "status"]

codebind/cli.py

@@ -1,17 +1,88 @@
-"""Standard IPython launcher with the Codebind extension loaded."""
+"""Codebind command line: terminal launcher and provider authentication."""
 
 from __future__ import annotations
 
 import sys
 
-from IPython import start_ipython
+import click
 
 from . import __version__
+from .logging import configure
 
 
-def main() -> None:
-    """Start ordinary IPython with Codebind loaded as an extension."""
-    if sys.argv[1:] == ["--version"]:
-        print(f"codebind {__version__}")
+@click.group(
+    invoke_without_command=True,
+    context_settings={"help_option_names": ["-h", "--help"]},
+)
+@click.version_option(__version__, "-V", "--version", prog_name="codebind")
+@click.option(
+    "--log-level",
+    default=None,
+    metavar="LEVEL",
+    help="Log level: DEBUG, INFO, WARNING, or ERROR. Defaults to $LOG_LEVEL.",
+)
+@click.pass_context
+def main(context: click.Context, log_level: str | None) -> None:
+    """Start IPython with Codebind, or run a Codebind command."""
+    configure(log_level)
+    if context.invoked_subcommand is None:
+        from IPython import start_ipython
+
+        start_ipython(argv=["--ext=codebind", *sys.argv[1:]])
+
+
+@main.command()
+@click.argument("provider")
+@click.option(
+    "--timeout",
+    default=300.0,
+    show_default=True,
+    metavar="SECONDS",
+    help="How long to wait for browser authorization",
+)
+def auth(provider: str, timeout: float) -> None:
+    """Sign in to PROVIDER in your browser and save the credentials"""
+    from .auth import AuthError, authenticate
+
+    try:
+        authenticate(provider, timeout=timeout)
+    except AuthError as error:
+        raise click.ClickException(str(error)) from error
+
+
+@main.command()
+@click.option("--provider", default=None, metavar="PROVIDER", help="Show one provider only")
+def status(provider: str | None) -> None:
+    """Show stored credentials for every supported provider"""
+    from .auth import status as provider_status
+
+    rows = provider_status()
+    if provider is not None:
+        rows = [row for row in rows if row[0] == provider.strip().lower()]
+        if not rows:
+            raise click.ClickException(f"no such provider: {provider}")
+    if not rows:
+        click.echo("no provider supports browser sign-in")
         return
-    start_ipython(argv=["--ext=codebind", *sys.argv[1:]])
+    width = max(len(row[0]) for row in rows)
+    click.echo("PROVIDER".ljust(width) + "  STATE")
+    for identifier, state, detail in rows:
+        click.echo(f"{identifier.ljust(width)}  {state}" + (f" ({detail})" if detail else ""))
+
+
+@main.command()
+@click.argument("provider")
+def logout(provider: str) -> None:
+    """Remove the stored credentials for PROVIDER"""
+    from .auth import AuthError, logout as provider_logout
+
+    try:
+        removed = provider_logout(provider)
+    except AuthError as error:
+        raise click.ClickException(str(error)) from error
+    if removed:
+        raise SystemExit(removed)
+
+
+if __name__ == "__main__":
+    main()

codebind/configuration.py

@@ -1,15 +1,46 @@
-"""XDG-backed Codebind configuration."""
+"""XDG-backed Codebind configuration and provider credentials."""
 
 from __future__ import annotations
 
-import json
 import os
+import tomllib
 from dataclasses import dataclass, field
 from pathlib import Path
 from typing import Any
 
+import tomli_w
 from models_provider import Models
 
+CONFIGURATION_FILE = "config.toml"
+
+
+@dataclass(frozen=True, slots=True)
+class CodebindConfiguration:
+    model: str
+    parameters: dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass(frozen=True, slots=True)
+class CodebindStore:
+    """One owner-only file holding the model choice and provider credentials."""
+
+    configuration: CodebindConfiguration | None = None
+    providers: dict[str, Any] = field(default_factory=dict)
+
+    def with_provider(self, provider: str, payload: Any) -> CodebindStore:
+        """Return a copy with one provider credential added or replaced."""
+        providers = dict(self.providers)
+        providers[provider.strip().lower()] = payload
+        return CodebindStore(self.configuration, providers)
+
+    def to_mapping(self) -> dict[str, Any]:
+        value: dict[str, Any] = {"providers": dict(self.providers)}
+        if self.configuration is not None:
+            value["model"] = self.configuration.model
+            if self.configuration.parameters:
+                value["parameters"] = dict(self.configuration.parameters)
+        return value
+
 
 def configuration_home() -> Path:
     xdg_home = os.environ.get("XDG_CONFIG_HOME")
@@ -20,41 +51,80 @@ def configuration_home() -> Path:
     return Path.home() / ".config"
 
 
-@dataclass(frozen=True, slots=True)
-class CodebindConfiguration:
-    model: str
-    parameters: dict[str, Any] = field(default_factory=dict)
+def configuration_directory() -> Path:
+    return configuration_home() / "codebind"
 
 
-def load_configuration() -> CodebindConfiguration:
-    path = configuration_home() / "codebind" / "configuration.json"
+def configuration_path() -> Path:
+    return configuration_directory() / CONFIGURATION_FILE
+
+
+def load_store() -> CodebindStore:
+    """Load the configuration file, or an empty store when it is absent."""
+    path = configuration_path()
     if not path.exists():
-        raise FileNotFoundError(
-            f"Codebind configuration is missing: {path}. "
-            'Create it with a JSON object such as {"model": "openai/gpt-5.6-luna"}.'
-        )
-    value = json.loads(path.read_text())
-    if not isinstance(value, dict) or not isinstance(value.get("model"), str):
-        raise ValueError(f"Codebind configuration must contain a string model: {path}")
+        return CodebindStore()
+    value = tomllib.loads(path.read_text(encoding="utf-8"))
+
+    model = value.get("model")
+    if model is not None and not isinstance(model, str):
+        raise ValueError(f"model must be a string: {path}")
     parameters = value.get("parameters", {})
     if not isinstance(parameters, dict):
-        raise ValueError(f"Codebind model parameters must be a JSON object: {path}")
-    return CodebindConfiguration(value["model"], parameters)
+        raise ValueError(f"parameters must be a table: {path}")
+
+    providers = value.get("providers", {})
+    if not isinstance(providers, dict):
+        raise ValueError(f"providers must be a table: {path}")
+
+    configuration = CodebindConfiguration(model, parameters) if isinstance(model, str) else None
+    return CodebindStore(configuration, providers)
+
+
+def save_store(store: CodebindStore) -> Path:
+    """Write the configuration atomically, readable only by its owner."""
+    path = configuration_path()
+    directory = path.parent
+    directory.mkdir(parents=True, exist_ok=True)
+    try:
+        directory.chmod(0o700)
+    except OSError:
+        pass
+    payload = tomli_w.dumps(store.to_mapping())
+    temporary = directory / f"{path.name}.{os.getpid()}.tmp"
+    descriptor = os.open(temporary, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600)
+    try:
+        with os.fdopen(descriptor, "w", encoding="utf-8") as handle:
+            handle.write(payload)
+    except BaseException:
+        temporary.unlink(missing_ok=True)
+        raise
+    os.replace(temporary, path)
+    os.chmod(path, 0o600)
+    return path
+
+
+def load_configuration() -> CodebindConfiguration:
+    """Return the configured model, or explain how to set one."""
+    configuration = load_store().configuration
+    if configuration is None:
+        raise FileNotFoundError(f"no model configured in {configuration_path()}")
+    return configuration
 
 
 def load_models() -> Models:
-    path = configuration_home() / "codebind" / "models.json"
-    if not path.exists():
-        return Models()
-    values = json.loads(path.read_text())
-    if not isinstance(values, dict):
-        raise ValueError(f"Codebind model configuration must be a JSON object: {path}")
-    return Models(values)
+    return Models(load_store().providers)
 
 
 __all__ = [
+    "CONFIGURATION_FILE",
     "CodebindConfiguration",
+    "CodebindStore",
+    "configuration_directory",
     "configuration_home",
+    "configuration_path",
     "load_configuration",
     "load_models",
+    "load_store",
+    "save_store",
 ]

codebind/extension.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 import asyncio
 import inspect
+import logging
 import sys
 from typing import Any
 
@@ -29,6 +30,8 @@ from .terminal import (
 )
 
 
+logger = logging.getLogger("codebind.extension")
+
 _STATE_ATTRIBUTE = "_codebind_extension_state"
 
 
@@ -169,7 +172,7 @@ def load_ipython_extension(ipython: InteractiveShell) -> None:
                 if full_output:
                     page(f"\x1b[90m{full_output}\x1b[0m" if sys.stdout.isatty() else full_output)
                 else:
-                    print(f"In [{number}] has no text output.")
+                    logger.warning("In [%s] has no text output", number)
 
             ipython.register_magic_function(output_magic, "line", "output")
 

codebind/instructions.md

@@ -3,7 +3,7 @@ You are a facts-rooted coding agent that works with extreme batching and paralle
 ## Communication
 
 - Keep the user oriented while working. Before meaningful tool work, emit one brief Markdown update saying what you are about to do. Between tool calls, emit another update only for a new phase, an important finding, or a change of plan. Do not perform several meaningful steps silently, but do not narrate trivial operations.
-- Keep responses brief and direct, free of jargon and human-written with a clear intent.
+- Keep responses brief and direct, free of jargon and human-written with a clear intent. Never, ever, use any emojis or cute-ish language with the user; maintain professionalism, brevity and clarity in your responses. Do not indulge in roundaboutisms with your words, especially in the concluding verses.
 
 ## Working in the live session
 
@@ -14,7 +14,7 @@ You are a facts-rooted coding agent that works with extreme batching and paralle
 
 ## Efficient execution
 
-- Prefer one batched IPython cell that completes as much of the task as practical instead of giving the user commands to run. Make Python scripts as compact and minified as practical, with extreme information density and as much useful work per tool call as possible. Extreme batching, density of work, parallelism and detached processes are expected for maximal efficiency; preserve correctness, safety, required concurrency, and bounded output.
+- Prefer one batched IPython cell that completes as much of the task as practical instead of giving the user commands to run. Make Python scripts as compact and minified as practical, with extreme information density and as much useful work per tool call as possible. Extreme batching, density of work, parallelism and detached processes are expected for maximal efficiency; preserve correctness, safety, required concurrency, and bounded output. No need to ever include in your IPython cells code any comment whatsoever.
 - Before running any IPython cell or script containing a loop or other iteration, check whether its iterations are independent. Run independent iterations concurrently with bounded workers; never silently leave parallelizable work serial. If ordering, shared state, side effects, rate limits, or trivial workload make concurrency unsafe or wasteful, keep it sequential and briefly say why.
 
 ## Deadlines and bounded output

codebind/logging.py

@@ -0,0 +1,67 @@
+"""Logging for Codebind.
+
+Records go to stderr so stdout stays reserved for data a caller may pipe. The
+level comes from LOG_LEVEL, or from an explicit argument.
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+
+from rich.console import Console
+from rich.logging import RichHandler
+
+LOGGER_NAME = "codebind"
+LOG_LEVEL_ENVIRONMENT_VARIABLE = "LOG_LEVEL"
+
+LEVELS: dict[str, int] = {
+    "CRITICAL": logging.CRITICAL,
+    "ERROR": logging.ERROR,
+    "WARNING": logging.WARNING,
+    "INFO": logging.INFO,
+    "DEBUG": logging.DEBUG,
+}
+
+_configured = False
+
+
+def level_number(level: str | int | None, *, default: int = logging.WARNING) -> int:
+    """Translate a level name or number into a logging level number."""
+    if isinstance(level, int):
+        return level
+    if level is None:
+        return default
+    return LEVELS.get(level.strip().upper(), default)
+
+
+def configure(level: str | int | None = None) -> logging.Logger:
+    """Install one stderr handler and set the level, once per process."""
+    global _configured
+    logger = logging.getLogger(LOGGER_NAME)
+    resolved = level_number(
+        level if level is not None else os.environ.get(LOG_LEVEL_ENVIRONMENT_VARIABLE)
+    )
+    if not _configured:
+        handler = RichHandler(
+            console=Console(stderr=True, soft_wrap=True),
+            show_path=False,
+            show_time=False,
+            rich_tracebacks=True,
+            markup=False,
+        )
+        handler.setFormatter(logging.Formatter("%(message)s"))
+        logger.addHandler(handler)
+        logger.propagate = False
+        _configured = True
+    logger.setLevel(resolved)
+    return logger
+
+
+__all__ = [
+    "LEVELS",
+    "LOGGER_NAME",
+    "LOG_LEVEL_ENVIRONMENT_VARIABLE",
+    "configure",
+    "level_number",
+]

{codebind-0.6.23.dist-info → codebind-0.7.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codebind
-Version: 0.6.23
+Version: 0.7.0
 Summary: A frontend-neutral model loop for persistent IPython sessions.
 Keywords: ai,ipython,llm,repl,agents
 Author: Giovanni Gravili
@@ -22,6 +22,8 @@ Requires-Dist: mistune>=3.3,<4
 Requires-Dist: pillow>=11
 Requires-Dist: resvg-py>=0.5
 Requires-Dist: rich>=14.1
+Requires-Dist: click>=8.1
+Requires-Dist: tomli-w>=1.2.0
 Requires-Python: >=3.13
 Project-URL: Repository, https://github.com/ghovax/codebind
 Project-URL: Issues, https://github.com/ghovax/codebind/issues
@@ -45,18 +47,44 @@ pip install codebind
 
 ## Configuration
 
-Codebind reads its private model choice from `$XDG_CONFIG_HOME/codebind/configuration.json`, or `~/.config/codebind/configuration.json` when `XDG_CONFIG_HOME` is unset:
+Codebind keeps everything in one file, `$XDG_CONFIG_HOME/codebind/config.toml`, or `~/.config/codebind/config.toml` when `XDG_CONFIG_HOME` is unset:
 
-```json
-{
-  "model": "openai/gpt-5.6-luna",
-  "parameters": {
-    "reasoning_effort": "medium"
-  }
-}
+```toml
+model = "openai/gpt-5.6-luna"
+
+[parameters]
+reasoning_effort = "medium"
+
+[providers.opencode]
+api_key = "oc_..."
 ```
 
-Provider credentials use the same XDG directory in `models.json`. Keep both files readable only by their owner. Loading Codebind does not add `chat`, `model`, `models`, `Models`, or any other variable to the IPython namespace.
+Codebind writes the file readable only by you and creates its directory with the same restriction. Loading Codebind does not add `chat`, `model`, `models`, `Models`, or any other variable to the IPython namespace.
+
+### Signing in
+
+`codebind auth` opens your browser, waits for you to finish authorizing, and saves the resulting credentials automatically:
+
+```console
+codebind auth openai
+```
+
+The command logs the authorization URL in case the browser does not open, and waits five minutes by default. Pass `--timeout` to wait longer or shorter. Press Ctrl+C at any time to stop without saving.
+
+```console
+codebind status                 # stored credentials for every supported provider
+codebind logout openai          # remove one provider credential
+```
+
+OpenAI signs in with your ChatGPT account, so the models available to you are the ones your subscription grants. Other providers may use an API key instead; set it under `[providers.<name>]` in the configuration.
+
+### Logging
+
+Records go to stderr, so stdout stays clean for piping. The level comes from `LOG_LEVEL` or `--log-level`:
+
+```console
+codebind --log-level DEBUG status
+```
 
 ## Terminal IPython
 
@@ -132,5 +160,5 @@ Codebind loads itself into the notebook kernel as soon as that kernel is ready,
 ## ChatGPT account access
 
 - Models Provider owns OpenAI account authorization and token refresh.
-- Save the resulting provider-values object in Codebind's XDG `models.json`; Codebind loads it privately when the extension starts.
+- `codebind auth openai` performs that authorization and stores the credentials under `[providers.openai]` in `config.toml`; Codebind loads them privately when the extension starts.
 - ChatGPT subscription access is separate from the public, pay-as-you-go OpenAI API and may require compatibility updates when the account protocol changes.

codebind-0.7.0.dist-info/RECORD

@@ -0,0 +1,31 @@
+codebind/__init__.py,sha256=GNO_K5EPAdgiK2CWsPVVY-3bAmH2TnFJ9ReAWgSbnqM,514
+codebind/async_runtime.py,sha256=ny9QJ0wrEpBcRUsd29EgPLLKUL2YJjZjZn_UbHn9WJI,654
+codebind/auth.py,sha256=Upk4TxvewTSCzOH_10bCPBzsrah28Q1fDMSroIzJWbM,5488
+codebind/cli.py,sha256=2V_KZWoeWFOBtL44SXF0p8vrltY0uDtnZaWiwels-hU,2619
+codebind/configuration.py,sha256=4BmoMd4Uk6PFHCgnrDqNf_l8TdDtMxCB7sGiKVwXw9Q,4028
+codebind/context.md,sha256=Iht9nJx7drsvjXYiTm-vG-prXx1UQU4VdMgBecWubJI,64
+codebind/context.py,sha256=Lo7WmsOrS1RE3Vk_Lo0Pig8IFK_-RVQOuRPVagvOziM,6051
+codebind/conversation.py,sha256=q7KXXilacg7-BBXOU80-ErRQNf0S6_DQ8YEZYWpYWcs,18309
+codebind/display.py,sha256=IpxcElyNcr5olRIatEduN_d-sRwpsMlaq1UtrOXocQA,494
+codebind/execution.py,sha256=jA0OeIXVlqg_qAi3mQtfGI-qgpljt6q03UPwvvSdBYI,18198
+codebind/extension.py,sha256=S9lWkTCzBkOLX6GZ7QaADxIE7ZxZ8c36qjf9PqgRL4Q,12091
+codebind/images.py,sha256=9bJHjXc75_YRBFTAqAWiknRTCjs8ApyGVVSxC_S5lio,4342
+codebind/instructions.md,sha256=IS_LHP59veMngm6NahKe2ThyS73gkh_E4bYsTYjzpQY,5711
+codebind/interrupts.py,sha256=c1pKlzhzg-hwGqme09KnImD14VB7nAH2x93nV8FCfEo,357
+codebind/jupyter.py,sha256=BCOY6mZYhFfDSBApvfhQC3M5PSQL3G01XD-jPWVp7vc,9619
+codebind/logging.py,sha256=4xsAAwdbXidjvBBrQZH5QNa-RH327YktyjhWt0Q6Eno,1780
+codebind/model_text.py,sha256=vBWLfQG7oo66DW5f5Y-VTMzB9KJnjCXs-NP6uRgX7WM,688
+codebind/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+codebind/session.py,sha256=XcuedUuIMDSTSbx-0Gr22_PeXT6Yf7JQIN8bWN4Nsqc,24468
+codebind/terminal.py,sha256=ahH13jQOmYzhh3mNdwNwRaNajikF3bAvhpPPMsLo0wo,25564
+codebind-0.7.0.dist-info/licenses/LICENSE,sha256=ujX46e0LFBIBTnCDY0u3Q7LV363B7CiI7QJZxIkEXlk,1073
+codebind-0.7.0.data/data/share/jupyter/labextensions/codebind-jupyterlab/install.json,sha256=78rEThkfrk1pXtekX5WrG9_Y0lJYi5XBEm8n9athpFE,164
+codebind-0.7.0.data/data/share/jupyter/labextensions/codebind-jupyterlab/package.json,sha256=VOc_3LpvjlTYe7He4tqKgkDk4jSvVLbAq-H8YBPueoM,1193
+codebind-0.7.0.data/data/share/jupyter/labextensions/codebind-jupyterlab/static/590.0b7494e278aa27b9.js,sha256=38LN42aeTm1y6vKdKFbdtBqaL4DFQ0wrEHKO_m3IgXA,18320
+codebind-0.7.0.data/data/share/jupyter/labextensions/codebind-jupyterlab/static/remoteEntry.8f763ad3faac0f5a.js,sha256=_jCtLZhtKjRLY5b-USF98UHC4WaxSXNdVQfN57-tvig,11795
+codebind-0.7.0.data/data/share/jupyter/labextensions/codebind-jupyterlab/static/style.js,sha256=J3BK6e4DQMUpNS1-fJIEyP9Aiwnryqctcj2f1F8wcjQ,115
+codebind-0.7.0.data/data/share/jupyter/labextensions/codebind-jupyterlab/static/third-party-licenses.json,sha256=MNToQfru1YnHAie-2Virp23yWsc5co3qG0IzrO6SEfw,20
+codebind-0.7.0.dist-info/WHEEL,sha256=VOHKyukui3UMeyUkkBf5F7N5xN_6X6W7zHVvalNVVvI,81
+codebind-0.7.0.dist-info/entry_points.txt,sha256=GiPcU63sULDlywJSKigAS4M3vaziYIrubXOb3fAg2_c,48
+codebind-0.7.0.dist-info/METADATA,sha256=_Ct_2o0D5pSXOov6SlfSu5UP2YJlh-XnyraaTu8_iNs,10312
+codebind-0.7.0.dist-info/RECORD,,

{codebind-0.6.23.dist-info → codebind-0.7.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: uv 0.12.20
+Generator: uv 0.12.21
 Root-Is-Purelib: true
 Tag: py3-none-any

codebind-0.6.23.dist-info/RECORD

@@ -1,29 +0,0 @@
-codebind/__init__.py,sha256=GNO_K5EPAdgiK2CWsPVVY-3bAmH2TnFJ9ReAWgSbnqM,514
-codebind/async_runtime.py,sha256=ny9QJ0wrEpBcRUsd29EgPLLKUL2YJjZjZn_UbHn9WJI,654
-codebind/cli.py,sha256=9LOR1L3P8sPsOOgsnpbOsA1PNUZdAj1Z9ROFKeo3EV8,423
-codebind/configuration.py,sha256=b9ux-MiepzAFfRhorZp4w2pdLLs44necescIGg_IKfo,1828
-codebind/context.md,sha256=Iht9nJx7drsvjXYiTm-vG-prXx1UQU4VdMgBecWubJI,64
-codebind/context.py,sha256=Lo7WmsOrS1RE3Vk_Lo0Pig8IFK_-RVQOuRPVagvOziM,6051
-codebind/conversation.py,sha256=q7KXXilacg7-BBXOU80-ErRQNf0S6_DQ8YEZYWpYWcs,18309
-codebind/display.py,sha256=IpxcElyNcr5olRIatEduN_d-sRwpsMlaq1UtrOXocQA,494
-codebind/execution.py,sha256=jA0OeIXVlqg_qAi3mQtfGI-qgpljt6q03UPwvvSdBYI,18198
-codebind/extension.py,sha256=lQVMuGCsnsf--4_xYJCIW6qnZaMENAvfLscrmZJH9oU,12017
-codebind/images.py,sha256=9bJHjXc75_YRBFTAqAWiknRTCjs8ApyGVVSxC_S5lio,4342
-codebind/instructions.md,sha256=Ru2XWuqsE-uad4tShWTUtKiCUDnmtJ1gKJ4nFhrCLhM,5420
-codebind/interrupts.py,sha256=c1pKlzhzg-hwGqme09KnImD14VB7nAH2x93nV8FCfEo,357
-codebind/jupyter.py,sha256=BCOY6mZYhFfDSBApvfhQC3M5PSQL3G01XD-jPWVp7vc,9619
-codebind/model_text.py,sha256=vBWLfQG7oo66DW5f5Y-VTMzB9KJnjCXs-NP6uRgX7WM,688
-codebind/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-codebind/session.py,sha256=XcuedUuIMDSTSbx-0Gr22_PeXT6Yf7JQIN8bWN4Nsqc,24468
-codebind/terminal.py,sha256=ahH13jQOmYzhh3mNdwNwRaNajikF3bAvhpPPMsLo0wo,25564
-codebind-0.6.23.dist-info/licenses/LICENSE,sha256=ujX46e0LFBIBTnCDY0u3Q7LV363B7CiI7QJZxIkEXlk,1073
-codebind-0.6.23.data/data/share/jupyter/labextensions/codebind-jupyterlab/install.json,sha256=78rEThkfrk1pXtekX5WrG9_Y0lJYi5XBEm8n9athpFE,164
-codebind-0.6.23.data/data/share/jupyter/labextensions/codebind-jupyterlab/package.json,sha256=VOc_3LpvjlTYe7He4tqKgkDk4jSvVLbAq-H8YBPueoM,1193
-codebind-0.6.23.data/data/share/jupyter/labextensions/codebind-jupyterlab/static/590.0b7494e278aa27b9.js,sha256=38LN42aeTm1y6vKdKFbdtBqaL4DFQ0wrEHKO_m3IgXA,18320
-codebind-0.6.23.data/data/share/jupyter/labextensions/codebind-jupyterlab/static/remoteEntry.8f763ad3faac0f5a.js,sha256=_jCtLZhtKjRLY5b-USF98UHC4WaxSXNdVQfN57-tvig,11795
-codebind-0.6.23.data/data/share/jupyter/labextensions/codebind-jupyterlab/static/style.js,sha256=J3BK6e4DQMUpNS1-fJIEyP9Aiwnryqctcj2f1F8wcjQ,115
-codebind-0.6.23.data/data/share/jupyter/labextensions/codebind-jupyterlab/static/third-party-licenses.json,sha256=MNToQfru1YnHAie-2Virp23yWsc5co3qG0IzrO6SEfw,20
-codebind-0.6.23.dist-info/WHEEL,sha256=766qEDcnZQDL36MOdWBQ0gowd8OjUWAOwMNC7Vgvxts,81
-codebind-0.6.23.dist-info/entry_points.txt,sha256=GiPcU63sULDlywJSKigAS4M3vaziYIrubXOb3fAg2_c,48
-codebind-0.6.23.dist-info/METADATA,sha256=r23aX_HYgOlOlt_aOB5UX5jJGtJq13qk6n_yPXVe1M4,9291
-codebind-0.6.23.dist-info/RECORD,,