truefoundry 0.1.2__py3-none-any.whl → 0.2.0rc1__py3-none-any.whl

truefoundry/autodeploy/cli.py

@@ -0,0 +1,312 @@
+import logging
+import os
+import re
+import sys
+from typing import Dict, Optional
+
+import click
+import docker
+from dotenv import dotenv_values
+
+from truefoundry.autodeploy.exception import GitBinaryNotFoundException
+
+try:
+    from git import GitCommandError, Repo
+    from git.exc import InvalidGitRepositoryError
+except ImportError as ex:
+    raise GitBinaryNotFoundException from ex
+
+import requests
+from openai import OpenAI
+from rich.console import Console
+from rich.prompt import Prompt
+from rich.status import Status
+from servicefoundry import Build, DockerFileBuild, Job, LocalSource, Port, Service
+from servicefoundry.cli.const import COMMAND_CLS
+from servicefoundry.lib.auth.servicefoundry_session import ServiceFoundrySession
+
+from truefoundry.autodeploy.agents.developer import Developer
+from truefoundry.autodeploy.agents.project_identifier import (
+    ComponentType,
+    ProjectIdentifier,
+)
+from truefoundry.autodeploy.agents.tester import Tester
+from truefoundry.autodeploy.constants import (
+    AUTODEPLOY_OPENAI_API_KEY,
+    AUTODEPLOY_OPENAI_BASE_URL,
+    AUTODEPLOY_TFY_BASE_URL,
+)
+from truefoundry.autodeploy.tools.ask import AskQuestion
+from truefoundry.autodeploy.tools.commit import CommitConfirmation
+from truefoundry.autodeploy.tools.docker_run import DockerRun, DockerRunLog
+
+
+def get_openai_client() -> OpenAI:
+    session = ServiceFoundrySession()
+    if AUTODEPLOY_OPENAI_BASE_URL is not None and AUTODEPLOY_OPENAI_API_KEY is not None:
+        return OpenAI(
+            api_key=AUTODEPLOY_OPENAI_API_KEY, base_url=AUTODEPLOY_OPENAI_BASE_URL
+        )
+    try:
+        resp = requests.get(
+            f"{AUTODEPLOY_TFY_BASE_URL}/api/svc/v1/llm-gateway/access-details",
+            headers={
+                "Authorization": f"Bearer {session.access_token}",
+            },
+        )
+        resp.raise_for_status()
+        resp = resp.json()
+        return OpenAI(api_key=resp["jwtToken"], base_url=resp["inferenceBaseURL"])
+    except requests.exceptions.HTTPError as http_error:
+        raise Exception(
+            "Error occured while connecting to servicefoundry server"
+        ) from http_error
+
+
+def deploy_component(
+    workspace_fqn: str,
+    project_root_path: str,
+    dockerfile_path: str,
+    component_type: ComponentType,
+    name: str,
+    env: Dict,
+    command: Optional[str] = None,
+    port: Optional[int] = None,
+):
+    logging.basicConfig(level=logging.INFO)
+
+    if not os.path.exists(os.path.join(project_root_path, dockerfile_path)):
+        raise FileNotFoundError("Dockerfile not found in the project.")
+
+    image = Build(
+        build_spec=DockerFileBuild(
+            dockerfile_path=dockerfile_path,
+            command=command,
+        ),
+        build_source=LocalSource(project_root_path=project_root_path),
+    )
+    if component_type == ComponentType.SERVICE:
+        if port is None:
+            raise ValueError("Port is required for deploying service")
+        app = Service(
+            name=name,
+            image=image,
+            ports=[Port(port=port, expose=False)],
+            env=env,
+        )
+    else:
+        app = Job(name=name, image=image, env=env)
+    app.deploy(workspace_fqn=workspace_fqn)
+
+
+def _parse_env(project_root_path: str, env_path: str) -> Dict:
+    if not os.path.isabs(env_path):
+        env_path = os.path.join(project_root_path, env_path)
+
+    if os.path.exists(env_path):
+        return dotenv_values(env_path)
+
+    raise FileNotFoundError(f"Invalid path {env_path!r}")
+
+
+def _check_repo(project_root_path: str, console: Console):
+    try:
+        repo = Repo(project_root_path)
+        if repo.is_dirty():
+            console.print(
+                "[bold red]Error:[/] The repository has uncommitted changes. Please commit or stash them before proceeding."
+            )
+            sys.exit(1)
+        current_active_branch = repo.active_branch.name
+        console.print(
+            f"[bold magenta]TFY-Agent:[/] Current branch [green]{current_active_branch!r}[/]"
+        )
+        branch_name = Prompt.ask(
+            "[bold magenta]TFY-Agent:[/] Enter a branch name if you want to checkout to a new branch. "
+            f"Press enter to continue on [green]{current_active_branch!r}[/]",
+            console=console,
+        )
+        if branch_name:
+            repo.git.checkout("-b", branch_name)
+            console.print(
+                f"[bold magenta]TFY-Agent:[/] Switched to branch: [green]{repo.active_branch}[/]"
+            )
+        else:
+            console.print(
+                f"[bold magenta]TFY-Agent:[/] Continuing on [green]{current_active_branch!r}[/]"
+            )
+
+    except InvalidGitRepositoryError:
+        console.print(
+            "[red]Error:[/] This operation can only be performed inside a Git repository."
+        )
+        sys.exit(1)
+
+    except GitCommandError as gce:
+        console.print(
+            f"Command execution failed due to the following error:[red]{gce.stderr}[/]".replace(
+                "\n  stderr:", ""
+            )
+        )
+        console.print(
+            "[bold red]Error:[/] Unable to switch to the new branch. It's possible that this branch already exists."
+        )
+        sys.exit(1)
+
+
+def _update_status(event, status: Status):
+    if isinstance(event, (AskQuestion, CommitConfirmation)):
+        status.stop()
+
+    if isinstance(
+        event, (Developer.Request, ProjectIdentifier.Response, Tester.Response)
+    ):
+        status.update(
+            "[bold magenta]TFY-Agent[/] is currently building the project. Please wait..."
+        )
+
+    if isinstance(event, ProjectIdentifier.Request):
+        status.update(
+            "[bold magenta]TFY-Agent[/] is currently identifying the project..."
+        )
+
+    if isinstance(event, (Tester.Request, DockerRun.Response)):
+        status.update(
+            "[bold magenta]TFY-Agent[/] is currently running tests on the project..."
+        )
+
+    if isinstance(event, DockerRunLog):
+        status.update(
+            "[bold cyan]Running:[/] [bold magenta]TFY-Agent[/] is executing the Docker container. Press [yellow]control-c[/] to stop waiting for additional logs..."
+        )
+
+
+def _get_default_project_name(project_root_path: str):
+    path = os.path.abspath(project_root_path).rstrip(os.path.sep)
+    name = path.split(os.path.sep)[-1].lower()
+    name = re.sub(r"[^a-z0-9]", "-", name)
+    name = "-".join(n for n in name.split("-") if n)[:30]
+    return name
+
+
+def cli(project_root_path: str, deploy: bool):
+    openai_client = get_openai_client()
+    docker_client = docker.from_env()
+    project_root_path = os.path.abspath(project_root_path)
+    console = Console()
+    console.print(
+        "[bold magenta]TFY-Agent[/]: A tool for building and deploying [magenta]Jobs/Services[/] to the Truefoundry platform."
+    )
+    console.print(
+        "[bold reverse red]DISCLAIMER:[/] The [bold magenta]TFY-Agent[/] may use LLM resources outside of your organization. Please proceed only if you accept this."
+    )
+    console.print("Let's get started! Please answer the following questions:")
+    console.print(
+        "[bold cyan]Note:[/] All changes will be committed to a new branch. Please ensure you have a repository."
+    )
+    _check_repo(project_root_path=project_root_path, console=console)
+
+    component_type = ComponentType[
+        Prompt.ask(
+            "[bold magenta]TFY-Agent:[/] Is your project a Service? Or a Job?",
+            choices=[k.value.lower() for k in ComponentType],
+            console=console,
+            default="service",
+        ).upper()
+    ]
+    while True:
+        name = Prompt.ask(
+            "[bold magenta]TFY-Agent:[/] Name of deployment",
+            console=console,
+            default=_get_default_project_name(project_root_path),
+        )
+        if not re.match(r"^[a-z][a-z0-9\-]{1,30}[a-z0-9]$", name):
+            console.print(
+                "[bold magenta]TFY-Agent:[/] The name should be between 2-30 alphaneumaric"
+                " characters and '-'. The first character should not be a digit."
+            )
+        else:
+            break
+    command = Prompt.ask(
+        "[bold magenta]TFY-Agent:[/] Command to run the application",
+        console=console,
+        show_default=False,
+        default=None,
+    )
+
+    env_path = Prompt.ask(
+        "[bold magenta]TFY-Agent:[/] Enter .env file location for environment variables, "
+        "or press [green]Enter[/] to skip.",
+        console=console,
+    )
+    while True:
+        try:
+            env = _parse_env(project_root_path, env_path) if env_path else {}
+            break
+        except FileNotFoundError:
+            console.print("[red]Invalid location for .env[/]")
+            env_path = Prompt.ask(
+                "[bold magenta]TFY-Agent:[/]Please provide the correct path,"
+                "or press [green]Enter[/] to skip.",
+                console=console,
+            )
+            continue
+    status = console.status(
+        "[bold cyan]Starting up:[/] [bold magenta]TFY-Agent[/] is initializing. Please wait..."
+    )
+    with status:
+        developer = Developer(
+            project_root_path=project_root_path,
+            openai_client=openai_client,
+            docker_client=docker_client,
+            environment=env,
+        )
+        developer_run = developer.run(developer.Request(command=command, name=name))
+        inp = None
+        response = None
+        while True:
+            try:
+                status.start()
+                event = developer_run.send(inp)
+                _update_status(event=event, status=status)
+                inp = event.render(console)
+            except StopIteration as ex:
+                response = ex.value
+                break
+
+    if deploy:
+        workspace_fqn = Prompt.ask(
+            "Enter the Workspace FQN where you would like to deploy"
+        )
+        deploy_component(
+            workspace_fqn=workspace_fqn,
+            project_root_path=project_root_path,
+            dockerfile_path=response.dockerfile_path,
+            name=name,
+            component_type=component_type,
+            env=env,
+            command=response.command,
+            port=response.port,
+        )
+
+
+@click.command(name="auto-deploy", cls=COMMAND_CLS)
+@click.option(
+    "--path", type=click.STRING, required=True, help="The root path of the project"
+)
+@click.option(
+    "--deploy",
+    type=click.BOOL,
+    is_flag=True,
+    default=False,
+    show_default=True,
+    help="Deploy the project after successfully building it.",
+)
+def autodeploy_cli(path: str, deploy: bool):
+    """
+    Build and deploy projects using Truefoundry
+    """
+    cli(
+        project_root_path=path,
+        deploy=deploy,
+    )

truefoundry/autodeploy/constants.py

@@ -0,0 +1,12 @@
+import os
+
+DEBUG = os.getenv("AUTODEPLOY_DEBUG", "")
+
+AUTODEPLOY_TFY_BASE_URL = os.getenv(
+    "AUTODEPLOY_TFY_BASE_URL", "https://app.devtest.truefoundry.tech"
+).strip("/")
+AUTODEPLOY_OPENAI_BASE_URL = os.environ.get("AUTODEPLOY_OPENAI_BASE_URL")
+AUTODEPLOY_OPENAI_API_KEY = os.environ.get("AUTODEPLOY_OPENAI_API_KEY")
+AUTODEPLOY_MODEL_NAME = os.environ.get(
+    "AUTODEPLOY_MODEL_NAME", "auto-deploy-openai/gpt-4-turbo-2024-04-09"
+)

truefoundry/autodeploy/exception.py

@@ -0,0 +1,2 @@
+class GitBinaryNotFoundException(Exception):
+    pass

truefoundry/autodeploy/logger.py

@@ -0,0 +1,13 @@
+import logging
+
+from rich.logging import RichHandler
+
+from truefoundry.autodeploy.constants import DEBUG
+
+logger = logging.getLogger("autodeploy")
+
+level = logging.DEBUG if DEBUG else logging.NOTSET
+handler = RichHandler(level=level, show_path=False)
+handler.setLevel(level)
+logger.addHandler(handler)
+logger.setLevel(level)

truefoundry/autodeploy/tools/__init__.py

@@ -0,0 +1,26 @@
+from truefoundry.autodeploy.tools.ask import Ask
+from truefoundry.autodeploy.tools.base import Event, RequestEvent, ResponseEvent, Tool
+from truefoundry.autodeploy.tools.commit import Commit
+from truefoundry.autodeploy.tools.docker_build import DockerBuild
+from truefoundry.autodeploy.tools.docker_run import DockerRun
+from truefoundry.autodeploy.tools.file_type_counts import FileTypeCounts
+from truefoundry.autodeploy.tools.list_files import ListFiles
+from truefoundry.autodeploy.tools.read_file import ReadFile
+from truefoundry.autodeploy.tools.send_request import SendRequest
+from truefoundry.autodeploy.tools.write_file import WriteFile
+
+__all__ = [
+    "Ask",
+    "Tool",
+    "DockerBuild",
+    "DockerRun",
+    "FileTypeCounts",
+    "ListFiles",
+    "ReadFile",
+    "SendRequest",
+    "WriteFile",
+    "Commit",
+    "RequestEvent",
+    "ResponseEvent",
+    "Event",
+]

truefoundry/autodeploy/tools/ask.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+from typing import Iterable
+
+from rich.console import Console
+
+from truefoundry.autodeploy.tools.base import Event, RequestEvent, ResponseEvent, Tool
+
+
+class AskQuestion(Event):
+    question: str
+
+    def render(self, console: Console) -> str:
+        console.print(f"[bold magenta]TFY-Agent:[/] {self.question}")
+        response = console.input("[bold green]You:[/] ")
+        return response
+
+
+class Ask(Tool):
+    description = """
+Ask a question to the user.
+"""
+
+    class Request(RequestEvent):
+        question: str
+
+    class Response(ResponseEvent):
+        response: str
+
+    def run(self, request: Ask.Request) -> Iterable[Event]:
+        response = yield AskQuestion(**request.model_dump())
+        return Ask.Response(response=response)

truefoundry/autodeploy/tools/base.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+from typing import Any, ClassVar, Generator, Optional, Protocol, Type
+
+from pydantic import BaseModel
+from rich.console import Console
+
+
+class Event(BaseModel):
+    def render(self, _: Console) -> Optional[Any]: ...
+
+
+class RequestEvent(Event): ...
+
+
+class ResponseEvent(Event): ...
+
+
+class Tool(Protocol):
+    description: ClassVar[str]
+    Request: ClassVar[Type[RequestEvent]]
+    Response: ClassVar[Type[ResponseEvent]]
+
+    def run(self, request: RequestEvent) -> Generator[Event, Any, ResponseEvent]: ...
+
+
+class Message(Event):
+    message: Any
+
+    def render(self, console: Console):
+        console.print(self.message)

truefoundry/autodeploy/tools/commit.py

@@ -0,0 +1,138 @@
+from __future__ import annotations
+
+import os
+import tempfile
+from typing import Any, Generator, Optional
+
+from git import Repo
+from pydantic import Field
+from rich.console import Console
+from rich.padding import Padding
+from rich.prompt import Confirm
+
+from truefoundry.autodeploy.logger import logger
+from truefoundry.autodeploy.tools.base import (
+    Event,
+    Message,
+    RequestEvent,
+    ResponseEvent,
+    Tool,
+)
+from truefoundry.autodeploy.utils.diff import LLMDiff
+
+
+class CommitConfirmation(Event):
+    patch: str
+    commit_message: str
+
+    def render(self, console: Console) -> Optional["Commit.Response"]:
+        console.print("[bold magenta]TFY Agent[/] wants to make a commit,", end=" ")
+        console.print(f"with Commit Message: [green]{self.commit_message}[/]")
+        console.print("[yellow]Displaying changes to be made by the patch[/]")
+        console.print(Padding.indent(renderable=LLMDiff(self.patch), level=2))
+
+        response = Confirm.ask(
+            "Apply patch?",
+        )
+        if not response:
+            description = console.input(
+                "You chose to cancel. Can you provide a reason why? [green]>> "
+            )
+            return Commit.Response(
+                cancellation_reason=description, error="Operation cancelled by user."
+            )
+
+
+class Commit(Tool):
+    description = """
+Git commit.
+"""
+
+    class Request(RequestEvent):
+        patch: str = Field(
+            ...,
+            description="""
+Patch file content.
+
+The format starts with the same two-line header as the context format, except that the original file is preceded by "---" and the new file is preceded by "+++". Following this is one change hunk that contain the line differences in the file. Addition lines are preceded by a plus sign, and deletion lines are preceded by a minus sign.
+A hunk begins with range information and is immediately followed with the line additions, line deletions. The range information is surrounded by double at signs, and combines onto a single line what appears on two lines in the context format (above). The format of the range information line is as follows:
+@@ -l,s +l,s @@ optional section heading
+The hunk range information contains two hunk ranges. The range for the hunk of the original file is preceded by a minus symbol, and the range for the new file is preceded by a plus symbol. Each hunk range is of the format l,s where l is the starting line number and s is the number of lines the change hunk applies to for each respective file. In many versions of GNU diff, each range can omit the comma and trailing value s, in which case s defaults to 1. Note that the only really interesting value is the l line number of the first range; all the other values can be computed from the diff.
+The hunk range for the original should be the sum of deletion (including changed) hunk lines. The hunk range for the new file should be a sum of addition (including changed) hunk lines. If hunk size information does not correspond with the number of lines in the hunk, then the diff could be considered invalid and be rejected.
+If a line is modified, it is represented as a deletion and addition. Example:
+-check this dokument. On
++check this document. On
+
+Example:
+--- a/path/to/original
++++ b/path/to/new
+@@ -8,13 +14,8 @@
+-This paragraph contains
+-text that is outdated.
+-It will be deleted in the
+-near future.
+-
+ It is important to spell
+-check this dokument. On
++check this document. On
+
+
+A hunk should always contain some modifications.
+Always include a new line in the end of the patch.
+There can be only one hunk for a single file in a patch.
+Minimize number of lines that are unchanged in a hunk.
+Within hunk, you cannot ignore lines that are not changing.
+Focus on producing smaller focused hunks.
+To produce smaller hunks, you can split changes in multiple commits.
+Do not use context lines in the hunk.
+
+This will be applied using the `git apply --recount --unidiff-zero` command.
+""",
+        )
+        commit_message: str = Field(
+            ...,
+            description="""
+The commit message should be describing the patch and the reason behind the patch.
+The patch should have any changes that is not described in the commit message.
+""",
+        )
+
+    class Response(ResponseEvent):
+        cancellation_reason: Optional[str] = Field(
+            None, description="Operation cancelled by user"
+        )
+        error: Optional[str] = Field(
+            None,
+            description="Error while applying patch.",
+        )
+
+    def __init__(self, project_root_path: str):
+        self.project_root_path = project_root_path
+        self.repo = Repo(path=self.project_root_path, search_parent_directories=False)
+
+    def run(
+        self,
+        request: Commit.Request,
+    ) -> Generator[Event, Any, ResponseEvent]:
+        fp = tempfile.NamedTemporaryFile(mode="w", delete=False)
+        try:
+            interaction_response = yield CommitConfirmation(**request.model_dump())
+            if isinstance(interaction_response, Commit.Response):
+                return interaction_response
+            fp.write(request.patch)
+            fp.close()
+            self.repo.git.apply(["--recount", "--unidiff-zero", fp.name], index=True)
+            self.repo.index.commit(message=request.commit_message)
+            yield Message(
+                message=f"[bold green]Success:[/] Changes committed with the message: '{request.commit_message}'"
+            )
+            return Commit.Response()
+        except Exception as ex:
+            logger.exception("")
+            yield Message(
+                message="[red]Alert:[/] Commit failed. Attempting to retry..."
+            )
+            return Commit.Response(error=str(ex))
+        finally:
+            if os.path.exists(fp.name):
+                os.remove(fp.name)

truefoundry/autodeploy/tools/docker_build.py

@@ -0,0 +1,109 @@
+from __future__ import annotations
+
+import itertools
+import re
+from typing import Any, Generator, Iterable, Optional
+
+import docker
+from docker.models.images import BuildError, json_stream
+from pydantic import Field
+from rich.console import Console, ConsoleOptions, RenderResult
+from rich.padding import Padding
+from rich.text import Text
+
+from truefoundry.autodeploy.tools.base import (
+    Event,
+    Message,
+    RequestEvent,
+    ResponseEvent,
+    Tool,
+)
+
+
+class DockerBuildLog(Event):
+    log: str
+
+    def render(self, console: Console):
+        console.print(Padding.indent(renderable=Text.from_ansi(self.log), level=2))
+
+
+# vendored from
+# https://github.com/docker/docker-py/blob/9ad4bddc9ee23f3646f256280a21ef86274e39bc/docker/models/images.py#L220
+def _build(docker_client: docker.DockerClient, **kwargs) -> Iterable[DockerBuildLog]:
+    resp = docker_client.images.client.api.build(**kwargs)
+    if isinstance(resp, str):
+        return docker_client.images.get(resp)
+    last_event = None
+    image_id = None
+    result_stream, internal_stream = itertools.tee(json_stream(resp))
+    for chunk in internal_stream:
+        if "error" in chunk:
+            raise BuildError(chunk["error"], result_stream)
+        if "stream" in chunk:
+            yield DockerBuildLog(log=chunk["stream"])
+            match = re.search(
+                r"(^Successfully built |sha256:)([0-9a-f]+)$", chunk["stream"]
+            )
+            if match:
+                image_id = match.group(2)
+        last_event = chunk
+    if image_id:
+        return None
+    raise BuildError(last_event or "Unknown", result_stream)
+
+
+class DockerBuild(Tool):
+    description = """
+Build a docker image.
+    """
+
+    class Request(RequestEvent):
+        dockerfile_path: str = Field(
+            ...,
+            pattern=r"^[a-zA-Z0-9\.]{1}.*$",
+            description="Dockerfile path. ",
+        )
+        image_tag: str = Field(..., description="image tag")
+
+    class Response(ResponseEvent):
+        error: Optional[str] = Field(None, description="Error raised while building")
+        build_logs: Optional[str] = Field(None, description="Build logs")
+
+        def __rich_console__(
+            self, console: Console, options: ConsoleOptions
+        ) -> RenderResult:
+            none_text = "[italic magenta]None[/]"
+            error_text = (
+                f"[green]'{self.error}'[/]" if self.error is not None else none_text
+            )
+            yield Text.from_markup("[bold magenta]Response[/](")
+            if self.build_logs is not None:
+                yield Text.from_markup('  [yellow]build_logs[/]= "')
+                yield Text.from_ansi(self.build_logs)
+                yield Text.from_markup('"')
+            else:
+                yield Text.from_markup(f"  [yellow]build_logs[/]={none_text}")
+            yield Text.from_markup(f"  [yellow]error[/]={error_text}\n)")
+
+    def __init__(self, project_root_path: str, docker_client: docker.DockerClient):
+        self.project_root_path = project_root_path
+        self.docker_client = docker_client
+
+    def run(self, request: DockerBuild.Request) -> Generator[Event, Any, ResponseEvent]:
+        yield Message(message="[bold cyan]Processing:[/] Building Docker image...")
+        yield Message(message="[bold yellow]Docker build logs:[/]")
+        try:
+            for message in _build(
+                self.docker_client,
+                path=self.project_root_path,
+                tag=request.image_tag,
+            ):
+                yield message
+            return DockerBuild.Response()
+        except BuildError as ex:
+            logs = ""
+            for log_line in ex.build_log:
+                logs += log_line.get("stream", "")
+            return DockerBuild.Response(error=str(ex), build_logs=logs[-800:])
+        except (docker.errors.APIError, docker.errors.DockerException) as ex:
+            return DockerBuild.Response(error=str(ex), build_logs="")