switch to async client

Author: akosyakov

examples/anthropic_tool_use.py

@@ -1,11 +1,11 @@
 from __future__ import annotations
 
-from gitpod import Gitpod
+from gitpod import AsyncGitpod
 import gitpod.lib as util
 from anthropic import Anthropic
 from anthropic.types import ToolParam, MessageParam
 
-gpclient = Gitpod()
+gpclient = AsyncGitpod()
 llmclient = Anthropic()
 
 user_message: MessageParam = {
@@ -32,31 +32,31 @@
 ]
 
 async def create_environment(args: dict[str, str]) -> str:
-    env_class = util.find_most_used_environment_class(gpclient)
+    env_class = await util.find_most_used_environment_class(gpclient)
     if not env_class:
         raise Exception("No environment class found. Please create one first.")
-    environment_id = gpclient.environments.create(
+    environment_id = (await gpclient.environments.create(
         spec={
             "desired_phase": "ENVIRONMENT_PHASE_RUNNING",
             "content": {
                 "initializer": {"specs": [{"contextUrl": {"url": args["context_url"]}}]},
             },
             "machine": {"class": env_class.id},
         }
-    ).environment.id
+    )).environment.id
     print(f"\nCreated environment: {environment_id} - waiting for it to be ready...")
     await util.wait_for_environment_ready(gpclient, environment_id)
     print(f"\nEnvironment is ready: {environment_id}")
     return environment_id
 
 async def execute_command(args: dict[str, str]) -> str:
-    lines_iter = util.run_command(gpclient, args["environment_id"], args["command"])
+    lines_iter = await util.run_command(gpclient, args["environment_id"], args["command"])
     lines = []
     async for line in lines_iter:
         lines.append(line)
     return "\n".join(lines)
 
-async def main():
+async def main(cleanup: util.Disposables):
     messages = [user_message]
     while True:
         message = llmclient.messages.create(
@@ -80,6 +80,7 @@ async def main():
             try:
                 if tool.name == "create_environment":
                     environment_id = await create_environment(tool.input)
+                    cleanup.add(lambda: asyncio.run(gpclient.environments.delete(environment_id=environment_id)))
                     messages.append({
                         "role": "user",
                         "content": [{
@@ -115,4 +116,6 @@ async def main():
 
 if __name__ == "__main__":
     import asyncio
-    asyncio.run(main())
+    disposables = util.Disposables()
+    with disposables:
+        asyncio.run(main(disposables))

examples/fs_access.py

@@ -4,19 +4,19 @@
 import sys
 import asyncio
 import paramiko
-from gitpod import Gitpod
+from gitpod import AsyncGitpod
 import gitpod.lib as util
 from gitpod.types.environment_spec_param import EnvironmentSpecParam
 
 # Examples:
 # - ./examples/fs_access.py
 # - ./examples/fs_access.py https://github.com/gitpod-io/empty
 async def main(cleanup: util.Disposables) -> None:
-    client = Gitpod()
+    client = AsyncGitpod()
 
     context_url = sys.argv[1] if len(sys.argv) > 1 else None
 
-    env_class = util.find_most_used_environment_class(client)
+    env_class = await util.find_most_used_environment_class(client)
     if not env_class:
         print("Error: No environment class found. Please create one first.")
         sys.exit(1)
@@ -48,8 +48,8 @@ async def main(cleanup: util.Disposables) -> None:
             }]}
         }
 
-    environment_id = client.environments.create(spec=spec).environment.id
-    cleanup.add(lambda: client.environments.delete(environment_id=environment_id))
+    environment_id = (await client.environments.create(spec=spec)).environment.id
+    cleanup.add(lambda: asyncio.run(client.environments.delete(environment_id=environment_id)))
 
     env = util.EnvironmentState(client, environment_id)
     cleanup.add(lambda: asyncio.run(env.close()))

examples/run_command.py

@@ -2,15 +2,15 @@
 
 import sys
 import asyncio
-from gitpod import Gitpod
+from gitpod import AsyncGitpod
 import gitpod.lib as util
 from gitpod.types.environment_spec_param import EnvironmentSpecParam
 
 # Examples:
 # - ./examples/run_command.py 'echo "Hello World!"'
 # - ./examples/run_command.py 'echo "Hello World!"' https://github.com/gitpod-io/empty
 async def main(cleanup: util.Disposables) -> None:
-    client = Gitpod()
+    client = AsyncGitpod()
 
     if len(sys.argv) < 2:
         print("Usage: ./examples/run_command.py '<COMMAND>' [CONTEXT_URL]")
@@ -19,7 +19,7 @@ async def main(cleanup: util.Disposables) -> None:
     command = sys.argv[1]
     context_url = sys.argv[2] if len(sys.argv) > 2 else None
 
-    env_class = util.find_most_used_environment_class(client)
+    env_class = await util.find_most_used_environment_class(client)
     if not env_class:
         print("Error: No environment class found. Please create one first.")
         sys.exit(1)
@@ -39,14 +39,14 @@ async def main(cleanup: util.Disposables) -> None:
         }
 
     print("Creating environment")
-    environment_id = client.environments.create(spec=spec).environment.id
-    cleanup.add(lambda: client.environments.delete(environment_id=environment_id))
+    environment_id = (await client.environments.create(spec=spec)).environment.id
+    cleanup.add(lambda: asyncio.run(client.environments.delete(environment_id=environment_id)))
 
     print("Waiting for environment to be ready")
     await util.wait_for_environment_ready(client, environment_id)
 
     print("Running command")
-    lines = util.run_command(client, environment_id, command)
+    lines = await util.run_command(client, environment_id, command)
     async for line in lines:
         print(line)
 

examples/run_service.py

@@ -2,19 +2,19 @@
 
 import sys
 import asyncio
-from gitpod import Gitpod
+from gitpod import AsyncGitpod
 import gitpod.lib as util
 from gitpod.types.environment_spec_param import EnvironmentSpecParam
 
 # Examples:
 # - ./examples/run_service.py
 # - ./examples/run_service.py https://github.com/gitpod-io/empty
 async def main(cleanup: util.Disposables) -> None:
-    client = Gitpod()
+    client = AsyncGitpod()
 
     context_url = sys.argv[1] if len(sys.argv) > 1 else None
 
-    env_class = util.find_most_used_environment_class(client)
+    env_class = await util.find_most_used_environment_class(client)
     if not env_class:
         print("Error: No environment class found. Please create one first.")
         sys.exit(1)
@@ -40,16 +40,16 @@ async def main(cleanup: util.Disposables) -> None:
         }
 
     print("Creating environment")
-    environment_id = client.environments.create(spec=spec).environment.id
-    cleanup.add(lambda: client.environments.delete(environment_id=environment_id))
+    environment_id = (await client.environments.create(spec=spec)).environment.id
+    cleanup.add(lambda: asyncio.run(client.environments.delete(environment_id=environment_id)))
 
     print("Waiting for environment to be ready")
     env = util.EnvironmentState(client, environment_id)
     cleanup.add(lambda: asyncio.run(env.close()))
     await env.wait_until_running()
 
     print("Starting Lama Service")
-    lines = util.run_service(client, environment_id, {
+    lines = await util.run_service(client, environment_id, {
         "name":"Lama Service",
         "description":"Lama Service", 
         "reference":"lama-service"

src/gitpod/lib/automation.py

@@ -1,13 +1,13 @@
 import asyncio
 import httpx
-from typing import AsyncIterator
+from typing import AsyncIterator, Awaitable, Callable, Optional
 
-from gitpod import Gitpod
+from gitpod._client import AsyncGitpod
 from gitpod.types.environments.automations import service_create_params
 TASK_REFERENCE = "gitpod-python-sdk"
 
-def run_service(
-    client: Gitpod,
+async def run_service(
+    client: AsyncGitpod,
     environment_id: str,
     metadata: service_create_params.ServiceMetadataParam,
     spec: service_create_params.ServiceSpecParam
@@ -16,38 +16,38 @@ def run_service(
     if not reference:
         raise ValueError("metadata.reference is required")
 
-    services = client.environments.automations.services.list(
+    services = (await client.environments.automations.services.list(
         filter={
             "references": [reference],
             "environment_ids": [environment_id]
         }
-    ).services
+    )).services
 
     service_id = ""
     if not services:
-        service_id = client.environments.automations.services.create(
+        service_id = (await client.environments.automations.services.create(
             environment_id=environment_id,
             spec=spec,
             metadata=metadata
-        ).service.id
+        )).service.id
     else:
         service_id = services[0].id
 
-    client.environments.automations.services.start(id=service_id)
-    log_url = wait_for_service_log_url(client, environment_id, service_id)
+    await client.environments.automations.services.start(id=service_id)
+    log_url = await wait_for_service_log_url(client, environment_id, service_id)
     return stream_logs(client, environment_id, log_url)
 
-def run_command(client: Gitpod, environment_id: str, command: str) -> AsyncIterator[str]:
-    tasks = client.environments.automations.tasks.list(
+async def run_command(client: AsyncGitpod, environment_id: str, command: str) -> AsyncIterator[str]:
+    tasks = (await client.environments.automations.tasks.list(
         filter={
             "references": [TASK_REFERENCE],
             "environment_ids": [environment_id]
         }
-    ).tasks
+    )).tasks
 
     task_id = ""
     if not tasks:
-        task_id = client.environments.automations.tasks.create(
+        task_id = (await client.environments.automations.tasks.create(
             spec={
                 "command": command,
             },
@@ -57,57 +57,57 @@ def run_command(client: Gitpod, environment_id: str, command: str) -> AsyncItera
                 "description": "Gitpod Python SDK Task",
                 "reference": TASK_REFERENCE,
             },
-        ).task.id
+        )).task.id
     else:
         task_id = tasks[0].id
-        client.environments.automations.tasks.update(
+        await client.environments.automations.tasks.update(
             id=task_id,
             spec={
                 "command": command,
             },
         )
 
-    task_execution_id = client.environments.automations.tasks.start(id=task_id).task_execution.id
-    log_url = wait_for_task_log_url(client, environment_id, task_execution_id)
+    task_execution_id = (await client.environments.automations.tasks.start(id=task_id)).task_execution.id
+    log_url = await wait_for_task_log_url(client, environment_id, task_execution_id)
     return stream_logs(client, environment_id, log_url)
 
-def wait_for_task_log_url(client: Gitpod, environment_id: str, task_execution_id: str) -> str:
-    def get_log_url():
-        execution = client.environments.automations.tasks.executions.retrieve(id=task_execution_id).task_execution
+async def wait_for_task_log_url(client: AsyncGitpod, environment_id: str, task_execution_id: str) -> str:
+    async def get_log_url():
+        execution = (await client.environments.automations.tasks.executions.retrieve(id=task_execution_id)).task_execution
         return execution.status.log_url
 
-    return wait_for_log_url(client, environment_id, task_execution_id, get_log_url, "RESOURCE_TYPE_TASK_EXECUTION")
+    return await wait_for_log_url(client, environment_id, task_execution_id, get_log_url, "RESOURCE_TYPE_TASK_EXECUTION")
 
-def wait_for_service_log_url(client: Gitpod, environment_id: str, service_id: str) -> str:
-    def get_log_url():
-        service = client.environments.automations.services.retrieve(id=service_id).service
+async def wait_for_service_log_url(client: AsyncGitpod, environment_id: str, service_id: str) -> str:
+    async def get_log_url():
+        service = (await client.environments.automations.services.retrieve(id=service_id)).service
         if service.status.phase != "SERVICE_PHASE_RUNNING":
             return None
         return service.status.log_url
 
-    return wait_for_log_url(client, environment_id, service_id, get_log_url, "RESOURCE_TYPE_SERVICE")
+    return await wait_for_log_url(client, environment_id, service_id, get_log_url, "RESOURCE_TYPE_SERVICE")
 
-def wait_for_log_url(client: Gitpod, environment_id: str, resource_id: str, get_log_url_fn, resource_type: str) -> str:
-    log_url = get_log_url_fn()
+async def wait_for_log_url(client: AsyncGitpod, environment_id: str, resource_id: str, get_log_url_fn: Callable[[], Awaitable[Optional[str]]], resource_type: str) -> str:
+    log_url = await get_log_url_fn()
     if log_url:
         return log_url
 
-    event_stream = client.events.watch(environment_id=environment_id, timeout=None)
+    event_stream = await client.events.watch(environment_id=environment_id, timeout=None)
     try:
-        log_url = get_log_url_fn()
+        log_url = await get_log_url_fn()
         if log_url:
             return log_url
 
-        for event in event_stream:
+        async for event in event_stream:
             if event.resource_type == resource_type and event.resource_id == resource_id:
-                log_url = get_log_url_fn()
+                log_url = await get_log_url_fn()
                 if log_url is not None:
                     return log_url
     finally:
-        event_stream.http_response.close()
+        await event_stream.http_response.aclose()
 
-async def stream_logs(client: Gitpod, environment_id: str, log_url: str) -> AsyncIterator[str]:
-    logs_access_token = client.environments.create_logs_token(environment_id=environment_id).access_token
+async def stream_logs(client: AsyncGitpod, environment_id: str, log_url: str) -> AsyncIterator[str]:
+    logs_access_token = (await client.environments.create_logs_token(environment_id=environment_id)).access_token
     async with httpx.AsyncClient() as http_client:
         retries = 3
         while retries > 0: