truefoundry 0.1.1__tar.gz → 0.2.0__tar.gz

{truefoundry-0.1.1 → truefoundry-0.2.0}/PKG-INFO

@@ -1,19 +1,27 @@
 Metadata-Version: 2.1
 Name: truefoundry
-Version: 0.1.1
+Version: 0.2.0
 Summary: Truefoundry CLI
 Author: Abhishek Choudhary
 Author-email: abhichoudhary06@gmail.com
-Requires-Python: >=3.8,<3.13
+Requires-Python: >=3.8.1,<3.13
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Provides-Extra: ml
-Requires-Dist: mlfoundry (==0.10.8) ; extra == "ml"
-Requires-Dist: servicefoundry (==0.10.5)
+Requires-Dist: docker (>=7.0.0,<8.0.0)
+Requires-Dist: gitignorefile (>=1.1.2,<2.0.0)
+Requires-Dist: gitpython (>=3.1.43,<4.0.0)
+Requires-Dist: inquirer (>=3.2.4,<4.0.0)
+Requires-Dist: mlfoundry (==0.10.9) ; extra == "ml"
+Requires-Dist: openai (>=1.16.2,<2.0.0)
+Requires-Dist: pydantic (>=1.10.0,<3)
+Requires-Dist: python-dotenv (>=1.0.1,<2.0.0)
+Requires-Dist: requests (>=2.31.0,<3.0.0)
+Requires-Dist: rich (>=13.7.1,<14.0.0)
+Requires-Dist: servicefoundry (==0.10.10)
 Description-Content-Type: text/markdown
 
 # Truefoundry

truefoundry-0.2.0/pyproject.toml

@@ -0,0 +1,50 @@
+[tool.poetry]
+name = "truefoundry"
+version = "0.2.0"
+description = "Truefoundry CLI"
+authors = ["Abhishek Choudhary <abhichoudhary06@gmail.com>"]
+readme = "README.md"
+
+[tool.poetry.dependencies]
+python = "^3.8.1,<3.13"
+servicefoundry = "0.10.10"
+mlfoundry = { version = "0.10.9", optional = true }
+openai = "^1.16.2"
+docker = "^7.0.0"
+pydantic = ">=1.10.0,<3"
+rich = "^13.7.1"
+requests = "^2.31.0"
+python-dotenv = "^1.0.1"
+gitignorefile = "^1.1.2"
+gitpython = "^3.1.43"
+inquirer = "^3.2.4"
+
+[tool.poetry.extras]
+ml = ["mlfoundry"]
+
+[tool.poetry.group.dev.dependencies]
+ruff = "^0.3.5"
+
+[tool.poetry-dynamic-versioning]
+enable = false
+
+[build-system]
+requires = ["poetry-core>=1.0.0", "poetry-dynamic-versioning>=1.0.0,<2.0.0"]
+build-backend = "poetry_dynamic_versioning.backend"
+
+[tool.poetry.plugins."console_scripts"]
+tfy = "truefoundry.cli.__main__:main"
+truefoundry = "truefoundry.cli.__main__:main"
+
+[tool.ruff]
+lint.select = [
+    "E",  # pycodestyle errors
+    "W",  # pycodestyle warnings
+    "F",  # pyflakes
+    "C",  # flake8-comprehensions
+    "B",  # flake8-bugbear
+    "Q",  # flake8-quotes
+    "I",
+]
+lint.ignore = ["E501"]
+exclude = ["venv", "repos"]

truefoundry-0.2.0/truefoundry/autodeploy/agents/base.py

@@ -0,0 +1,181 @@
+from __future__ import annotations
+
+import json
+from typing import ClassVar, Iterable, List, Protocol, Type, runtime_checkable
+
+from openai import OpenAI
+from openai.types.chat.chat_completion_message import ChatCompletionMessage
+from openai.types.chat.chat_completion_message_param import ChatCompletionMessageParam
+from openai.types.chat.chat_completion_system_message_param import (
+    ChatCompletionSystemMessageParam,
+)
+from openai.types.chat.chat_completion_tool_message_param import (
+    ChatCompletionToolMessageParam,
+)
+from openai.types.chat.chat_completion_tool_param import ChatCompletionToolParam
+from openai.types.chat.chat_completion_user_message_param import (
+    ChatCompletionUserMessageParam,
+)
+from openai.types.shared_params.function_definition import FunctionDefinition
+from pydantic import BaseModel, ValidationError
+
+from truefoundry.autodeploy.constants import AUTODEPLOY_MODEL_NAME
+from truefoundry.autodeploy.logger import logger
+from truefoundry.autodeploy.tools import Event, RequestEvent, Tool
+from truefoundry.autodeploy.utils.pydantic_compat import model_dump, model_json_schema
+
+
+def llm(
+    openai_client: OpenAI,
+    messages: List[ChatCompletionMessageParam],
+    tools: List[ChatCompletionToolParam],
+    model: str,
+    max_tokens: int = 4096,
+) -> ChatCompletionMessage:
+    completion = openai_client.chat.completions.create(
+        tools=tools,
+        stream=False,
+        messages=messages,
+        model=model,
+        max_tokens=max_tokens,
+        temperature=1,
+        top_p=0.01,
+        n=1,
+        frequency_penalty=0.01,
+    )
+    return completion.choices[0].message
+
+
+def format_tool_response(
+    response: BaseModel, tool_call_id: str
+) -> ChatCompletionToolMessageParam:
+    return ChatCompletionToolMessageParam(
+        role="tool",
+        content=json.dumps(model_dump(response), indent=1),
+        tool_call_id=tool_call_id,
+    )
+
+
+def format_user_response(response: str) -> ChatCompletionUserMessageParam:
+    return ChatCompletionUserMessageParam(
+        role="user",
+        content=response,
+    )
+
+
+def get_tool_descriptions(
+    tools: List, response: Type[BaseModel]
+) -> List[ChatCompletionToolParam]:
+    descriptions = []
+    for tool in tools:
+        tool = ChatCompletionToolParam(
+            type="function",
+            function=FunctionDefinition(
+                name=tool.__class__.__name__,
+                description=tool.description.strip(),
+                parameters=model_json_schema(tool.Request),
+            ),
+        )
+        descriptions.append(tool)
+
+    if response:
+        tool = ChatCompletionToolParam(
+            type="function",
+            function=FunctionDefinition(
+                name="Response",
+                parameters=model_json_schema(response),
+            ),
+        )
+        descriptions.append(tool)
+
+    return descriptions
+
+
+class ToolParamParseError(BaseModel):
+    error: str
+
+
+@runtime_checkable
+class Agent(Tool, Protocol):
+    system_prompt: ClassVar[str]
+    tools: List[Tool]
+    max_iter: ClassVar[int] = 30
+    openai_client: OpenAI
+    model: str = AUTODEPLOY_MODEL_NAME
+
+    def run(self, request: RequestEvent) -> Iterable[Event]:  # noqa: C901
+        messages: List[ChatCompletionMessageParam] = [
+            ChatCompletionSystemMessageParam(
+                role="system",
+                content=self.system_prompt + "\nrequest:\n" + request.json(),
+            ),
+        ]
+        tool_descriptions = get_tool_descriptions(self.tools, self.Response)
+        tool_map = {}
+        for tool in self.tools:
+            tool_map[tool.__class__.__name__] = tool
+        for _ in range(self.max_iter):
+            r = llm(
+                messages=messages,
+                tools=tool_descriptions,
+                openai_client=self.openai_client,
+                model=self.model,
+            )
+            messages.append(r)
+            if r.content:
+                logger.debug(r.content)
+            if not r.tool_calls:
+                messages.append(
+                    format_user_response(
+                        "You must respond with a tool call. Use the Ask tool to ask user."
+                    )
+                )
+                continue
+
+            for tool_call in r.tool_calls:
+                if tool_call.function.name == "Response":
+                    try:
+                        response = self.Response(
+                            **json.loads(tool_call.function.arguments)
+                        )
+                    except (json.decoder.JSONDecodeError, ValidationError) as ex:
+                        logger.debug(f"{tool_call.function.arguments}, {ex}")
+                        messages.append(
+                            format_tool_response(
+                                ToolParamParseError(error=str(ex)), tool_call.id
+                            )
+                        )
+                        continue
+                    logger.debug(response)
+                    yield response
+                    return response
+                tool = tool_map[tool_call.function.name]
+                try:
+                    request = tool.Request(**json.loads(tool_call.function.arguments))
+                except (json.decoder.JSONDecodeError, ValidationError) as ex:
+                    logger.debug(f"{tool_call.function.arguments}, {ex}")
+                    messages.append(
+                        format_tool_response(
+                            ToolParamParseError(error=str(ex)), tool_call.id
+                        )
+                    )
+                    continue
+                logger.debug(f"{self.__class__.__name__}, {tool_call.function.name}")
+                logger.debug(request)
+                yield request
+                tool_run = tool.run(request)
+                response = None
+                inp = None
+                while True:
+                    try:
+                        event = tool_run.send(inp)
+                        inp = yield event
+                    except StopIteration as ex:
+                        response = ex.value
+                        break
+                logger.debug(response)
+                logger.debug(f"{self.__class__.__name__}, {tool_call.function.name}")
+                messages.append(format_tool_response(response, tool_call.id))
+                if not isinstance(tool, Agent):
+                    yield response
+        raise Exception()

truefoundry-0.2.0/truefoundry/autodeploy/agents/developer.py

@@ -0,0 +1,113 @@
+from __future__ import annotations
+
+from typing import Dict, Optional
+
+import docker
+from openai import OpenAI
+from pydantic import Field
+
+from truefoundry.autodeploy.agents.base import Agent
+from truefoundry.autodeploy.agents.project_identifier import ProjectIdentifier
+from truefoundry.autodeploy.agents.tester import Tester
+from truefoundry.autodeploy.tools import (
+    Ask,
+    Commit,
+    DockerBuild,
+    ListFiles,
+    ReadFile,
+    RequestEvent,
+    ResponseEvent,
+)
+
+
+class Developer(Agent):
+    system_prompt = """
+You are a software engineer.
+You goal is to do whatever you have to do to succesfully run a project.
+If the project already contains a dockerfile, you can use that.
+If the project does not contain a dockerfile, you have to create one.
+You need to fix any issue to ensure that the image builds succesfully.
+Generate syntactically correct Dockerfile.
+You need to always read a file before making any changes.
+Ensure that you always make changes if you are writing a file.
+This is the rough flow you have to follow:
+Identify Project -> Build Docker Image -> Tester
+If Tester is not successful, you need to fix the issue and try Tester again.
+Tester has the final authority over whether you were successful in your task.
+Do not ask the user to manually review anything. You need to review and and take a decision.
+You can ask questions to the user but you need to take actions to run the project.
+Do not ask users how to fix an issue.
+Communicate with the user only via Ask tool.
+You should add Dockerfile path to .dockerignore file, this will speed up iteration.
+You can create a .dockerignore file if it does not exist.
+Try to download dependencies first, before you copy the whole project. This will speed up
+subsequent builds due to build cache.
+Use the Project identifier tool call to identify project.
+Avoid reading *.lock type files as they tend to be large
+If you are using multi-stage build:
+1. For a go project  the final stage should not need a go runtime.
+2. If you get a missing file error because the application is trying to load a file, you should
+   add the files in the final stage.
+3. While copying the file, be careful about the destination directory.
+
+For Golang projects:
+1. you need to ensure you know where is the main.go file. Sometimes it can be in cmd dir.
+
+    """
+    max_iter = 50
+
+    class Request(RequestEvent):
+        name: str = Field(..., description="Name of the project.")
+        command: Optional[str] = Field(
+            None,
+            description="Preferred command to run project. This can be corrected later.",
+        )
+
+    class Response(ResponseEvent):
+        command: str = Field(
+            description="""
+Final command to run the project within the container.
+This command should be same as what is expressed uning
+the entrypoint and cmd of the dockerfile.
+        """
+        )
+        dockerfile_path: str = Field(description="Path of dockerfile.")
+        port: Optional[int] = Field(description="Port in which container is running.")
+        justification: str = Field(
+            ...,
+            description="""
+            Why did you send the response back?
+        """,
+        )
+
+    def __init__(
+        self,
+        project_root_path: str,
+        docker_client: docker.DockerClient,
+        openai_client: OpenAI,
+        environment: Dict,
+    ):
+        self.tools = [
+            DockerBuild(
+                project_root_path=project_root_path,
+                docker_client=docker_client,
+            ),
+            ReadFile(
+                project_root_path=project_root_path,
+            ),
+            Commit(project_root_path=project_root_path),
+            ListFiles(
+                project_root_path=project_root_path,
+            ),
+            ProjectIdentifier(
+                project_root_path=project_root_path,
+                openai_client=openai_client,
+            ),
+            Tester(
+                openai_client=openai_client,
+                docker_client=docker_client,
+                environment=environment,
+            ),
+            Ask(),
+        ]
+        self.openai_client = openai_client

truefoundry-0.2.0/truefoundry/autodeploy/agents/project_identifier.py

@@ -0,0 +1,124 @@
+from __future__ import annotations
+
+import enum
+from typing import List, Optional
+
+from openai import OpenAI
+from pydantic import Field
+from rich.console import Console
+
+from truefoundry.autodeploy.agents.base import Agent
+from truefoundry.autodeploy.tools import (
+    Ask,
+    FileTypeCounts,
+    ListFiles,
+    ReadFile,
+    RequestEvent,
+    ResponseEvent,
+)
+
+
+class ComponentType(str, enum.Enum):
+    SERVICE = "SERVICE"
+    JOB = "JOB"
+
+
+class ProjectIdentifier(Agent):
+    description = """
+Identify the type of project.
+"""
+    system_prompt = """
+Your goal is to figure out the type of project.
+Once you figure out, send the Response tool call.
+The information will be later used to build a Dockerfile.
+Try to figure out ALL the response tool field arguments even if something is optional.
+Prefer reading files like requirements.txt, pyproject.toml, go.mod, packages.json to figure out framework.
+You should have strong justification for your response. Do not assume anything.
+Prefer using file type counts over list files.
+use the knowledge of file type counts to create the right glob pattern while listing files.
+Prefer yarn over npm if the project is using yarn.
+If there is  a lock file, the project maybe using yarn.
+Look for *.lock if there is a lock type file persent.
+Always response with a function call.
+    """
+    max_iter = 10
+
+    class Request(RequestEvent): ...
+
+    class Response(ResponseEvent):
+        component_type: Optional[ComponentType] = Field(
+            None,
+            description="""
+A Service is designed to run always and should never terminate.
+A Job is desiged to finish after sometime.
+""",
+        )
+        primary_programming_language: str = Field(
+            ...,
+            description="""
+Primary programming language used for the project.
+Ex: Go, Python, Rust, Typescript, etc.",
+""",
+        )
+        framework: Optional[str] = Field(
+            None,
+            description="""
+If the project is using any specific framework.
+Ex: FastAPI, Gin, Flask, NestJS, React, etc.
+            """,
+        )
+        version: Optional[str] = Field(
+            None,
+            description="""
+Identifies and return the exact version of the project's programming language,
+essential for successful Docker image creation and execution.""",
+        )
+        dependency_files: Optional[List[str]] = Field(
+            None,
+            descripton="""
+requirements.txt, poetry.lock, yarn.lock, Cargo.lock, go.mod, go.sum, pyproject.toml, etc.
+There can be multiple files like ["pyproject.toml", "poetry.lock"] or ["yarn.lock", "package.json"]
+                                                  """,
+        )
+        dependency_manager: Optional[str] = Field(
+            None,
+            descripton="""
+pip, poetry, yarn, go.mod, cargo.toml, npm, setup.py.
+                                                  """,
+        )
+        justification: str = Field(
+            ...,
+            description="Justification behind each response field.",
+        )
+
+        def render(self, console: Console):
+            if self.primary_programming_language is not None:
+                console.print(
+                    f"[bold magenta]TrueFoundry:[/] Identified a project using [bold cyan]{self.primary_programming_language}[/]."
+                )
+                console.print(
+                    f"[bold magenta]TrueFoundry:[/] Framework Identified: [bold cyan]{'Not applicable' if self.framework is None else self.framework}[/]"
+                )
+                console.print(
+                    f"[bold magenta]TrueFoundry:[/] Dependency Manager Identified: [bold cyan]{'Not applicable' if self.dependency_manager is None else self.dependency_manager}[/]"
+                )
+            else:
+                console.print(
+                    "[bold magenta]TrueFoundry:[/] Unable to identify any programming language in the project."
+                )
+            console.print(
+                f"[bold magenta]TrueFoundry:[/] [italic]{self.justification}[/]"
+            )
+
+    def __init__(self, project_root_path: str, openai_client: OpenAI):
+        self.tools = [
+            ReadFile(
+                project_root_path=project_root_path,
+            ),
+            ListFiles(
+                project_root_path=project_root_path,
+            ),
+            FileTypeCounts(project_root_path=project_root_path),
+            Ask(),
+        ]
+        self.openai_client = openai_client

truefoundry-0.2.0/truefoundry/autodeploy/agents/tester.py

@@ -0,0 +1,75 @@
+from __future__ import annotations
+
+from typing import Dict, Optional
+
+import docker
+from openai import OpenAI
+from pydantic import Field
+from rich.console import Console
+
+from truefoundry.autodeploy.agents.base import Agent
+from truefoundry.autodeploy.agents.project_identifier import ProjectIdentifier
+from truefoundry.autodeploy.tools import (
+    Ask,
+    DockerRun,
+    RequestEvent,
+    ResponseEvent,
+    SendRequest,
+)
+
+
+class Tester(Agent):
+    description = """
+Tester
+"""
+    system_prompt = """
+Your goal is to test a docker image.
+In case the image is running a service, you can send a request to the endpoint to verify everything is running fine.
+If you find any port number in the logs. Re run the docker image by exposing that port correctly.
+
+If the image is not running a service, try to identify whether there is any issue.
+Your goal is not to fix the issue. Your goal is to create a very detailed justification and report whether
+the testing was succesful.
+Always response with a function call.
+Return response once you are done testing.
+    """
+    max_iter = 30
+
+    class Request(RequestEvent):
+        project_identity: ProjectIdentifier.Response
+        image_tag: str
+        command: str
+        port_to_be_exposed: Optional[int] = None
+
+    class Response(ResponseEvent):
+        successful: bool = Field(..., description="is everything fine?")
+        justification: str = Field(
+            ...,
+            description="""
+Why was the testing a failure or successful?
+        """,
+        )
+        logs: str
+
+        def render(self, console: Console):
+            console.print(
+                f"[bold cyan]TrueFoundry:[/] The given project has been {'[bold green]successfully built[/]' if self.successful else '[bold red]failed to build[/]'}"
+            )
+            console.print(
+                f"[bold magenta]TrueFoundry:[/] [italic]{self.justification}[/]"
+            )
+            if not self.successful:
+                console.print(f"[cyan]logs:[/] {self.logs}")
+
+    def __init__(
+        self,
+        docker_client: docker.DockerClient,
+        openai_client: OpenAI,
+        environment: Dict,
+    ):
+        self.tools = [
+            SendRequest(),
+            Ask(),
+            DockerRun(docker_client=docker_client, environment=environment),
+        ]
+        self.openai_client = openai_client