flamepy 0.3.0__py3-none-any.whl

flamepy/__init__.py

@@ -0,0 +1,82 @@
+
+from .types import (
+    # Type aliases
+    TaskID,
+    SessionID,
+    ApplicationID,
+    Message,
+    TaskInput,
+    TaskOutput,
+    CommonData,
+    
+    # Enums
+    SessionState,
+    TaskState,
+    Shim,
+
+    FlameErrorCode,
+    
+    # Classes
+    FlameError,
+    SessionAttributes,
+    ApplicationAttributes,
+    Task,
+    Application,
+    FlameContext,
+    TaskInformer,
+)
+
+from .client import Connection, Session, TaskWatcher, connect, create_session
+from .service import (
+    FlameService,
+    ApplicationContext, SessionContext, TaskContext, TaskOutput,
+    run
+)
+__version__ = "0.1.0"
+
+__all__ = [
+    # Type aliases
+    "TaskID",
+    "SessionID", 
+    "ApplicationID",
+    "Message",
+    "TaskInput",
+    "TaskOutput",
+    "CommonData",
+    
+    # Enums
+    "SessionState",
+    "TaskState", 
+    "ApplicationState",
+    "Shim",
+    "FlameErrorCode",
+
+    # Service classes
+    "FlameService",
+    "ApplicationContext",
+    "SessionContext",
+    "TaskContext",
+    "TaskOutput",
+    "run",
+
+    # Classes
+    "FlameError",
+    "SessionAttributes",
+    "ApplicationAttributes", 
+    "Session",
+    "Task",
+    "Application",
+    "FlameContext",
+    "TaskInformer",
+    
+    # Client classes
+    "Connection",
+    "connect",
+    "create_session",
+    "TaskWatcher",
+    "Session", 
+    "Task",
+    "TaskInput",
+    "TaskOutput",
+    "CommonData",
+] 

flamepy/client.py

@@ -0,0 +1,433 @@
+"""
+Copyright 2025 The Flame Authors.
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+    http://www.apache.org/licenses/LICENSE-2.0
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+"""
+
+import asyncio
+import threading
+from typing import Optional, List, Dict, Any, Union
+from urllib.parse import urlparse
+import grpc
+import grpc.aio
+import os
+
+from datetime import datetime
+from .types import (
+    Task, Application, SessionAttributes, ApplicationAttributes,
+    SessionID, TaskID, ApplicationID, TaskInput, TaskOutput, CommonData,
+    SessionState, TaskState, ApplicationState, Shim, FlameError, FlameErrorCode,
+    TaskInformer
+)
+
+from .types_pb2 import ApplicationSpec, SessionSpec, TaskSpec
+from .frontend_pb2 import RegisterApplicationRequest, UnregisterApplicationRequest, ListApplicationRequest, CreateSessionRequest, ListSessionRequest, GetSessionRequest, CloseSessionRequest, CreateTaskRequest, WatchTaskRequest, GetTaskRequest
+from .frontend_pb2_grpc import FrontendStub
+
+async def connect(addr: str) -> "Connection":
+    """Connect to the Flame service."""
+    return await Connection.connect(addr)
+
+async def create_session(application: str, common_data: Dict[str, Any] = None, slots: int = 1) -> "Session":
+    conn = await ConnectionInstance().instance()
+    session = await conn.create_session(SessionAttributes(application=application, common_data=common_data, slots=slots))
+    return session
+
+class ConnectionInstance:
+    """Connection instance."""
+    _connection = None
+    _lock = threading.Lock()
+
+    async def instance(self) -> "Connection":
+        """Get the connection instance."""
+        with self._lock:
+            if not self._connection:
+                self._connection = await connect(os.getenv("FLAME_ENDPOINT", "http://127.0.0.1:8080"))
+            return self._connection
+
+class Connection:
+    """Connection to the Flame service."""
+    
+    def __init__(self, addr: str, channel: grpc.aio.Channel, frontend: FrontendStub):
+        self.addr = addr
+        self._channel = channel
+        self._frontend = frontend
+    
+    @classmethod
+    async def connect(cls, addr: str) -> "Connection":
+        """Establish a connection to the Flame service."""
+        if not addr:
+            raise FlameError(
+                FlameErrorCode.INVALID_CONFIG,
+                "address cannot be empty"
+            )
+        
+        try:
+            parsed_addr = urlparse(addr)
+            host = parsed_addr.hostname or parsed_addr.path
+            port = parsed_addr.port or 8080
+            
+            # Create insecure channel
+            channel = grpc.aio.insecure_channel(f"{host}:{port}")
+            
+            # Wait for channel to be ready
+            await channel.channel_ready()
+            
+            # Create frontend stub
+            frontend = FrontendStub(channel)
+            
+            return cls(addr, channel, frontend)
+            
+        except Exception as e:
+            raise FlameError(
+                FlameErrorCode.INVALID_CONFIG,
+                f"failed to connect to {addr}: {str(e)}"
+            )
+    
+    async def close(self) -> None:
+        """Close the connection."""
+        await self._channel.close()
+    
+    async def register_application(
+        self, 
+        name: str, 
+        app_attrs: Union[ApplicationAttributes, Dict[str, Any]]
+    ) -> None:
+        """Register a new application."""
+        if isinstance(app_attrs, dict):
+            app_attrs = ApplicationAttributes(**app_attrs)
+        
+        app_spec = ApplicationSpec(
+            shim=app_attrs.shim,
+            url=app_attrs.url,
+            command=app_attrs.command,
+            arguments=app_attrs.arguments or [],
+            environments=app_attrs.environments or [],
+            working_directory=app_attrs.working_directory
+        )
+        
+        request = RegisterApplicationRequest(
+            name=name,
+            application=app_spec
+        )
+        
+        try:
+            await self._frontend.RegisterApplication(request)
+        except grpc.RpcError as e:
+            raise FlameError(
+                FlameErrorCode.INTERNAL,
+                f"failed to register application: {e.details()}"
+            )
+    
+    async def unregister_application(self, name: str) -> None:
+        """Unregister an application."""
+        request = UnregisterApplicationRequest(name=name)
+        
+        try:
+            await self._frontend.UnregisterApplication(request)
+        except grpc.RpcError as e:
+            raise FlameError(
+                FlameErrorCode.INTERNAL,
+                f"failed to unregister application: {e.details()}"
+            )
+    
+    async def list_applications(self) -> List[Application]:
+        """List all applications."""
+        request = ListApplicationRequest()
+        
+        try:
+            response = await self._frontend.ListApplication(request)
+            
+            applications = []
+            for app in response.applications:
+                applications.append(Application(
+                    id=app.metadata.id,
+                    name=app.metadata.name,
+                    shim=Shim(app.spec.shim),
+                    state=ApplicationState(app.status.state),
+                    creation_time=datetime.fromtimestamp(app.status.creation_time),
+                    url=app.spec.url,
+                    command=app.spec.command,
+                    arguments=list(app.spec.arguments),
+                    environments=list(app.spec.environments),
+                    working_directory=app.spec.working_directory
+                ))
+            
+            return applications
+            
+        except grpc.RpcError as e:
+            raise FlameError(
+                FlameErrorCode.INTERNAL,
+                f"failed to list applications: {e.details()}"
+            )
+    
+    async def create_session(self, attrs: SessionAttributes) -> "Session":
+        """Create a new session."""
+        session_spec = SessionSpec(
+            application=attrs.application,
+            slots=attrs.slots,
+            common_data=attrs.common_data
+        )
+        
+        request = CreateSessionRequest(session=session_spec)
+        
+        try:
+            response = await self._frontend.CreateSession(request)
+            
+            session = Session(
+                connection=self,
+                id=response.metadata.id,
+                application=response.spec.application,
+                slots=response.spec.slots,
+                state=SessionState(response.status.state),
+                creation_time=datetime.fromtimestamp(response.status.creation_time),
+                pending=response.status.pending,
+                running=response.status.running,
+                succeed=response.status.succeed,
+                failed=response.status.failed,
+                completion_time=datetime.fromtimestamp(response.status.completion_time) if response.status.HasField('completion_time') else None
+            )
+            return session
+        except grpc.RpcError as e:
+            raise FlameError(
+                FlameErrorCode.INTERNAL,
+                f"failed to create session: {e.details()}"
+            )
+    
+    async def list_sessions(self) -> List["Session"]:
+        """List all sessions."""
+        request = ListSessionRequest()
+        
+        try:
+            response = await self._frontend.ListSession(request)
+            
+            sessions = []
+            for session in response.sessions:
+                sessions.append(Session(
+                    connection=self,
+                    id=session.metadata.id,
+                    application=session.spec.application,
+                    slots=session.spec.slots,
+                    state=SessionState(session.status.state),
+                    creation_time=datetime.fromtimestamp(session.status.creation_time),
+                    pending=session.status.pending,
+                    running=session.status.running,
+                    succeed=session.status.succeed,
+                    failed=session.status.failed,
+                    completion_time=datetime.fromtimestamp(session.status.completion_time) if session.status.HasField('completion_time') else None
+                ))
+            
+            return sessions
+            
+        except grpc.RpcError as e:
+            raise FlameError(
+                FlameErrorCode.INTERNAL,
+                f"failed to list sessions: {e.details()}"
+            )
+    
+    async def get_session(self, session_id: SessionID) -> "Session":
+        """Get a session by ID."""
+        request = GetSessionRequest(session_id=session_id)
+        
+        try:
+            response = await self._frontend.GetSession(request)
+            
+            return Session(
+                connection=self,
+                id=response.metadata.id,
+                application=response.spec.application,
+                slots=response.spec.slots,
+                state=SessionState(response.status.state),
+                creation_time=datetime.fromtimestamp(response.status.creation_time),
+                pending=response.status.pending,
+                running=response.status.running,
+                succeed=response.status.succeed,
+                failed=response.status.failed,
+                completion_time=datetime.fromtimestamp(response.status.completion_time) if response.status.HasField('completion_time') else None
+            )
+            
+        except grpc.RpcError as e:
+            raise FlameError(
+                FlameErrorCode.INTERNAL,
+                f"failed to get session: {e.details()}"
+            )
+    
+    async def close_session(self, session_id: SessionID) -> "Session":
+        """Close a session."""
+        request = CloseSessionRequest(session_id=session_id)
+        
+        try:
+            response = await self._frontend.CloseSession(request)
+            
+            return Session(
+                connection=self,
+                id=response.metadata.id,
+                application=response.spec.application,
+                slots=response.spec.slots,
+                state=SessionState(response.status.state),
+                creation_time=datetime.fromtimestamp(response.status.creation_time),
+                pending=response.status.pending,
+                running=response.status.running,
+                succeed=response.status.succeed,
+                failed=response.status.failed,
+                completion_time=datetime.fromtimestamp(response.status.completion_time) if response.status.HasField('completion_time') else None
+            )
+            
+        except grpc.RpcError as e:
+            raise FlameError(
+                FlameErrorCode.INTERNAL,
+                f"failed to close session: {e.details()}"
+            )
+
+class Session:
+    connection: Connection
+    
+    """Represents a computing session."""
+    id: SessionID
+    application: str
+    slots: int
+    state: SessionState
+    creation_time: datetime
+    pending: int = 0
+    running: int = 0
+    succeed: int = 0
+    failed: int = 0
+    completion_time: Optional[datetime] = None
+
+    """Client for session-specific operations."""
+    
+    def __init__(self, connection: Connection, id: SessionID, application: str, slots: int, state: SessionState, creation_time: datetime, pending: int, running: int, succeed: int, failed: int, completion_time: Optional[datetime]):
+        self.connection = connection
+        self.id = id
+        self.application = application
+        self.slots = slots
+        self.state = state
+        self.creation_time = creation_time
+        self.pending = pending
+        self.running = running
+        self.succeed = succeed
+        self.failed = failed
+        self.completion_time = completion_time
+
+    async def create_task(self, input_data: TaskInput) -> Task:
+        """Create a new task in the session."""
+        task_spec = TaskSpec(
+            session_id=self.id,
+            input=input_data
+        )
+        
+        request = CreateTaskRequest(task=task_spec)
+        
+        try:
+            response = await self.connection._frontend.CreateTask(request)
+            
+            return Task(
+                id=response.metadata.id,
+                session_id=self.id,
+                state=TaskState(response.status.state),
+                creation_time=datetime.fromtimestamp(response.status.creation_time),
+                input=input_data,
+                completion_time=datetime.fromtimestamp(response.status.completion_time) if response.status.HasField('completion_time') else None
+            )
+            
+        except grpc.RpcError as e:
+            raise FlameError(
+                FlameErrorCode.INTERNAL,
+                f"failed to create task: {e.details()}"
+            )
+    
+    async def get_task(self, task_id: TaskID) -> Task:
+        """Get a task by ID."""
+        request = GetTaskRequest(
+            task_id=task_id,
+            session_id=self.id
+        )
+        
+        try:
+            response = await self.connection._frontend.GetTask(request)
+            
+            return Task(
+                id=response.metadata.id,
+                session_id=self.id,
+                state=TaskState(response.status.state),
+                creation_time=datetime.fromtimestamp(response.status.creation_time),
+                input=response.spec.input,
+                output=response.spec.output,
+                completion_time=datetime.fromtimestamp(response.status.completion_time) if response.status.HasField('completion_time') else None
+            )
+            
+        except grpc.RpcError as e:
+            raise FlameError(
+                FlameErrorCode.INTERNAL,
+                f"failed to get task: {e.details()}"
+            )
+    
+    async def watch_task(self, task_id: TaskID) -> "TaskWatcher":
+        """Watch a task for updates."""
+        request = WatchTaskRequest(
+            task_id=task_id,
+            session_id=self.id
+        )
+        
+        try:
+            stream = self.connection._frontend.WatchTask(request)
+            return TaskWatcher(stream)
+            
+        except grpc.RpcError as e:
+            raise FlameError(
+                FlameErrorCode.INTERNAL,
+                f"failed to watch task: {e.details()}"
+            )
+    
+    async def invoke(self, input_data: TaskInput, informer: Optional[TaskInformer] = None) -> Task:
+        """Invoke a task with the given input and optional informer."""
+        task = await self.create_task(input_data)
+        watcher = await self.watch_task(task.id)
+        
+        async for task in watcher:
+            if informer:
+                informer.on_update(task)
+            if task.is_completed():
+                return task
+
+    async def close(self) -> None:
+        """Close the session."""
+        await self.connection.close_session(self.id)
+
+class TaskWatcher:
+    """Async iterator for watching task updates."""
+    
+    def __init__(self, stream):
+        self._stream = stream
+    
+    def __aiter__(self):
+        return self
+    
+    async def __anext__(self) -> Task:
+        try:
+            response = await self._stream.read()
+            
+            return Task(
+                id=response.metadata.id,
+                session_id=response.spec.session_id,
+                state=TaskState(response.status.state),
+                creation_time=datetime.fromtimestamp(response.status.creation_time),
+                input=response.spec.input,
+                output=response.spec.output,
+                completion_time=datetime.fromtimestamp(response.status.completion_time) if response.status.HasField('completion_time') else None
+            )
+            
+        except StopAsyncIteration:
+            raise
+        except Exception as e:
+            raise FlameError(
+                FlameErrorCode.INTERNAL,
+                f"failed to watch task: {str(e)}"
+            ) 

flamepy/frontend_pb2.py

@@ -0,0 +1,68 @@
+# -*- coding: utf-8 -*-
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# NO CHECKED-IN PROTOBUF GENCODE
+# source: frontend.proto
+# Protobuf Python Version: 6.31.1
+"""Generated protocol buffer code."""
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import descriptor_pool as _descriptor_pool
+from google.protobuf import runtime_version as _runtime_version
+from google.protobuf import symbol_database as _symbol_database
+from google.protobuf.internal import builder as _builder
+_runtime_version.ValidateProtobufRuntimeVersion(
+    _runtime_version.Domain.PUBLIC,
+    6,
+    31,
+    1,
+    '',
+    'frontend.proto'
+)
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+import flamepy.types_pb2 as types__pb2
+
+
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x0e\x66rontend.proto\x12\x05\x66lame\x1a\x0btypes.proto\"W\n\x1aRegisterApplicationRequest\x12\x0c\n\x04name\x18\x01 \x01(\t\x12+\n\x0b\x61pplication\x18\x02 \x01(\x0b\x32\x16.flame.ApplicationSpec\",\n\x1cUnregisterApplicationRequest\x12\x0c\n\x04name\x18\x01 \x01(\t\"U\n\x18UpdateApplicationRequest\x12\x0c\n\x04name\x18\x01 \x01(\t\x12+\n\x0b\x61pplication\x18\x02 \x01(\x0b\x32\x16.flame.ApplicationSpec\"%\n\x15GetApplicationRequest\x12\x0c\n\x04name\x18\x01 \x01(\t\"\x18\n\x16ListApplicationRequest\";\n\x14\x43reateSessionRequest\x12#\n\x07session\x18\x01 \x01(\x0b\x32\x12.flame.SessionSpec\"*\n\x14\x44\x65leteSessionRequest\x12\x12\n\nsession_id\x18\x01 \x01(\t\"(\n\x12OpenSessionRequest\x12\x12\n\nsession_id\x18\x01 \x01(\t\")\n\x13\x43loseSessionRequest\x12\x12\n\nsession_id\x18\x01 \x01(\t\"\'\n\x11GetSessionRequest\x12\x12\n\nsession_id\x18\x01 \x01(\t\"\x14\n\x12ListSessionRequest\"2\n\x11\x43reateTaskRequest\x12\x1d\n\x04task\x18\x01 \x01(\x0b\x32\x0f.flame.TaskSpec\"8\n\x11\x44\x65leteTaskRequest\x12\x0f\n\x07task_id\x18\x01 \x01(\t\x12\x12\n\nsession_id\x18\x02 \x01(\t\"5\n\x0eGetTaskRequest\x12\x0f\n\x07task_id\x18\x01 \x01(\t\x12\x12\n\nsession_id\x18\x02 \x01(\t\"7\n\x10WatchTaskRequest\x12\x0f\n\x07task_id\x18\x01 \x01(\t\x12\x12\n\nsession_id\x18\x02 \x01(\t2\xc7\x07\n\x08\x46rontend\x12I\n\x13RegisterApplication\x12!.flame.RegisterApplicationRequest\x1a\r.flame.Result\"\x00\x12M\n\x15UnregisterApplication\x12#.flame.UnregisterApplicationRequest\x1a\r.flame.Result\"\x00\x12\x45\n\x11UpdateApplication\x12\x1f.flame.UpdateApplicationRequest\x1a\r.flame.Result\"\x00\x12\x44\n\x0eGetApplication\x12\x1c.flame.GetApplicationRequest\x1a\x12.flame.Application\"\x00\x12J\n\x0fListApplication\x12\x1d.flame.ListApplicationRequest\x1a\x16.flame.ApplicationList\"\x00\x12>\n\rCreateSession\x12\x1b.flame.CreateSessionRequest\x1a\x0e.flame.Session\"\x00\x12>\n\rDeleteSession\x12\x1b.flame.DeleteSessionRequest\x1a\x0e.flame.Session\"\x00\x12:\n\x0bOpenSession\x12\x19.flame.OpenSessionRequest\x1a\x0e.flame.Session\"\x00\x12<\n\x0c\x43loseSession\x12\x1a.flame.CloseSessionRequest\x1a\x0e.flame.Session\"\x00\x12\x38\n\nGetSession\x12\x18.flame.GetSessionRequest\x1a\x0e.flame.Session\"\x00\x12>\n\x0bListSession\x12\x19.flame.ListSessionRequest\x1a\x12.flame.SessionList\"\x00\x12\x35\n\nCreateTask\x12\x18.flame.CreateTaskRequest\x1a\x0b.flame.Task\"\x00\x12\x35\n\nDeleteTask\x12\x18.flame.DeleteTaskRequest\x1a\x0b.flame.Task\"\x00\x12/\n\x07GetTask\x12\x15.flame.GetTaskRequest\x1a\x0b.flame.Task\"\x00\x12\x35\n\tWatchTask\x12\x17.flame.WatchTaskRequest\x1a\x0b.flame.Task\"\x00\x30\x01\x42&Z$github.com/flame-sh/flame/sdk/go/rpcb\x06proto3')
+
+_globals = globals()
+_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
+_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'frontend_pb2', _globals)
+if not _descriptor._USE_C_DESCRIPTORS:
+  _globals['DESCRIPTOR']._loaded_options = None
+  _globals['DESCRIPTOR']._serialized_options = b'Z$github.com/flame-sh/flame/sdk/go/rpc'
+  _globals['_REGISTERAPPLICATIONREQUEST']._serialized_start=38
+  _globals['_REGISTERAPPLICATIONREQUEST']._serialized_end=125
+  _globals['_UNREGISTERAPPLICATIONREQUEST']._serialized_start=127
+  _globals['_UNREGISTERAPPLICATIONREQUEST']._serialized_end=171
+  _globals['_UPDATEAPPLICATIONREQUEST']._serialized_start=173
+  _globals['_UPDATEAPPLICATIONREQUEST']._serialized_end=258
+  _globals['_GETAPPLICATIONREQUEST']._serialized_start=260
+  _globals['_GETAPPLICATIONREQUEST']._serialized_end=297
+  _globals['_LISTAPPLICATIONREQUEST']._serialized_start=299
+  _globals['_LISTAPPLICATIONREQUEST']._serialized_end=323
+  _globals['_CREATESESSIONREQUEST']._serialized_start=325
+  _globals['_CREATESESSIONREQUEST']._serialized_end=384
+  _globals['_DELETESESSIONREQUEST']._serialized_start=386
+  _globals['_DELETESESSIONREQUEST']._serialized_end=428
+  _globals['_OPENSESSIONREQUEST']._serialized_start=430
+  _globals['_OPENSESSIONREQUEST']._serialized_end=470
+  _globals['_CLOSESESSIONREQUEST']._serialized_start=472
+  _globals['_CLOSESESSIONREQUEST']._serialized_end=513
+  _globals['_GETSESSIONREQUEST']._serialized_start=515
+  _globals['_GETSESSIONREQUEST']._serialized_end=554
+  _globals['_LISTSESSIONREQUEST']._serialized_start=556
+  _globals['_LISTSESSIONREQUEST']._serialized_end=576
+  _globals['_CREATETASKREQUEST']._serialized_start=578
+  _globals['_CREATETASKREQUEST']._serialized_end=628
+  _globals['_DELETETASKREQUEST']._serialized_start=630
+  _globals['_DELETETASKREQUEST']._serialized_end=686
+  _globals['_GETTASKREQUEST']._serialized_start=688
+  _globals['_GETTASKREQUEST']._serialized_end=741
+  _globals['_WATCHTASKREQUEST']._serialized_start=743
+  _globals['_WATCHTASKREQUEST']._serialized_end=798
+  _globals['_FRONTEND']._serialized_start=801
+  _globals['_FRONTEND']._serialized_end=1768
+# @@protoc_insertion_point(module_scope)