pybotchi 3.4.4__tar.gz → 3.5.0__tar.gz

{pybotchi-3.4.4 → pybotchi-3.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pybotchi
-Version: 3.4.4
+Version: 3.5.0
 Summary: A deterministic, intent-based AI agent builder.
 License-File: LICENSE
 Author: Alexie (Boyong) Madolid

{pybotchi-3.4.4 → pybotchi-3.5.0}/pybotchi/grpc/cli.py

@@ -234,7 +234,6 @@ def compile() -> None:
             f"--python_out={current_dir}",
             f"--pyi_out={current_dir}",
             f"--grpc_python_out={current_dir}",
-            f"--mypy_grpc_out={current_dir}",
             "pybotchi.proto",
         ]
     )

{pybotchi-3.4.4 → pybotchi-3.5.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "pybotchi"
-version = "3.4.4"
+version = "3.5.0"
 description = "A deterministic, intent-based AI agent builder."
 authors = ["Alexie (Boyong) Madolid <madolid.alexie@gmail.com>"]
 readme = "README.md"

pybotchi-3.4.4/pybotchi/__init__.pyi

@@ -1,6 +0,0 @@
-from .action import Action as Action, DEFAULT_ACTION as DEFAULT_ACTION, all_agents as all_agents, graph as graph
-from .common import ActionReturn as ActionReturn, ChatRole as ChatRole, Groups as Groups, UsageMetadata as UsageMetadata
-from .context import Context as Context
-from .llm import LLM as LLM
-
-__all__ = ['Action', 'DEFAULT_ACTION', 'all_agents', 'graph', 'ActionReturn', 'ChatRole', 'Groups', 'UsageMetadata', 'Context', 'LLM']

pybotchi-3.4.4/pybotchi/action.pyi

@@ -1,80 +0,0 @@
-from .common import ActionEntry as ActionEntry, ActionReturn as ActionReturn, ConcurrentBreakPoint as ConcurrentBreakPoint, Graph as Graph, Groups as Groups, ToolCall as ToolCall, UsageData as UsageData
-from .context import Context as Context
-from .utils import apply_placeholders as apply_placeholders, unwrap_exceptions as unwrap_exceptions, uuid as uuid
-from collections.abc import Generator
-from pydantic import BaseModel
-from typing import Any, Generic, Literal, TypeVar
-
-DEFAULT_ACTION: str
-DEFAULT_TOOL_CALL_PROMPT: str
-DEFAULT_MAX_ITERATION_PROMPT: str
-TAction = TypeVar('TAction', bound='Action')
-TContext = TypeVar('TContext', bound='Context')
-T = TypeVar('T')
-type ChildActions = dict[str, type['Action']]
-
-class Action(BaseModel, Generic[TContext]):
-    __enabled__: bool
-    __system_prompt__: str | None
-    __tool_call_prompt__: str | None
-    __max_iteration_prompt__: str | None
-    __temperature__: float | None
-    __max_tool_prompts__: int | None
-    __default_tool__ = DEFAULT_ACTION
-    __first_tool_only__: bool
-    __concurrent__: bool
-    __has_pre__: bool
-    __has_fallback__: bool
-    __has_on_child_init_error__: bool
-    __has_on_error__: bool
-    __has_post__: bool
-    __has_as_tool__: bool
-    __detached__: bool
-    __max_iteration__: int | None
-    __max_child_iteration__: int | None
-    __child_actions__: ChildActions
-    __agent__: bool
-    __display_name__: str
-    __groups__: Groups | set[str] | None
-    __to_commit__: bool
-    _usage: list[UsageData]
-    _actions: list[Action | ActionEntry]
-    _parent: Action | None
-    _children: list['Action']
-    @classmethod
-    def __pydantic_init_subclass__(cls, **kwargs: Any) -> None: ...
-    @classmethod
-    def __init_child_actions__(cls) -> None: ...
-    @property
-    def _tool_call(self) -> ToolCall: ...
-    @classmethod
-    async def _as_tool(cls, context: TContext) -> dict[str, Any] | type[BaseModel]: ...
-    async def pre(self, context: TContext) -> ActionReturn: ...
-    async def fallback(self, context: TContext, content: str) -> ActionReturn: ...
-    async def on_child_init_error(self, context: TContext, next_actions: list['Action'], child_cls: type[Action], child_args: dict[str, Any], exception: Exception) -> str | None: ...
-    async def on_error(self, context: TContext, exception: Exception, unwrapped_exceptions: Generator[Exception, None, None]) -> ActionReturn: ...
-    async def on_max_iteration(self, context: TContext) -> ActionReturn: ...
-    async def post(self, context: TContext) -> ActionReturn: ...
-    async def commit_context(self, parent: TContext, child: TContext) -> None: ...
-    def child_selection_prompt(self, context: TContext, tool_choice: str) -> str: ...
-    def max_iteration_prompt(self, context: TContext) -> str: ...
-    async def get_child_actions(self, context: TContext) -> ChildActions: ...
-    async def child_selection(self, context: TContext, child_actions: ChildActions | None = None) -> tuple[list['Action'], str]: ...
-    async def execute(self, context: TContext, parent: Action | None = None, append: bool = True) -> ActionReturn: ...
-    async def execute_concurrently(self, context: TContext, parent: Action | None = None, append: bool = True) -> None: ...
-    async def execution(self, context: TContext) -> ActionReturn: ...
-    async def concurrent_children_execution(self, context: TContext, next_actions: list[Action]) -> ActionReturn: ...
-    async def sequential_children_execution(self, context: TContext, next_actions: list[Action]) -> ActionReturn: ...
-    def serialize(self, mode: str | Literal['python', 'json'] = 'python') -> ActionEntry: ...
-    @classmethod
-    def add_child(cls, action: type['Action'], name: str | None = None, override: bool = False, extended: bool = True) -> None: ...
-    @classmethod
-    def add_grand_child(cls, action: type['Action'], name: str | None = None, override: bool = False, extended: bool = True) -> None: ...
-    @classmethod
-    def remove_child(cls, name: str) -> None: ...
-    @classmethod
-    def remove_grand_child(cls, name: str) -> None: ...
-
-def all_agents() -> Generator[type['Action']]: ...
-async def graph(action: type[Action], allowed_actions: dict[str, bool] | None = None) -> Graph: ...
-async def traverse(graph: Graph, action: type[Action], allowed_actions: dict[str, bool] | None) -> None: ...

pybotchi-3.4.4/pybotchi/common.pyi

@@ -1,85 +0,0 @@
-from enum import StrEnum
-from functools import cached_property as cached_property
-from pydantic import BaseModel, ConfigDict, SkipValidation as SkipValidation
-from typing import Annotated, Any, ClassVar, Literal, NotRequired, Required, TypedDict
-
-class ChatRole(StrEnum):
-    USER = 'user'
-    SYSTEM = 'system'
-    ASSISTANT = 'assistant'
-    TOOL = 'tool'
-    DEVELOPER = 'developer'
-
-class InputTokenDetails(TypedDict, total=False):
-    audio: float
-    cache_creation: float
-    cache_read: float
-
-class OutputTokenDetails(TypedDict, total=False):
-    audio: float
-    reasoning: float
-
-class UsageMetadata(TypedDict):
-    input_tokens: float
-    output_tokens: float
-    total_tokens: float
-    input_token_details: NotRequired[InputTokenDetails]
-    output_token_details: NotRequired[OutputTokenDetails]
-
-class UsageData(TypedDict):
-    name: str | None
-    model: str
-    usage: UsageMetadata
-
-class ActionItem(TypedDict):
-    name: str
-    args: dict[str, Any]
-    usages: list[UsageData]
-
-class ActionEntry(ActionItem):
-    actions: list['ActionEntry']
-
-class Groups(TypedDict, total=False):
-    grpc: set[str]
-    mcp: set[str]
-    a2a: set[str]
-
-class Function(TypedDict, total=False):
-    arguments: Required[str]
-    name: Required[str]
-
-class ToolCall(TypedDict, total=False):
-    id: Required[str]
-    function: Required[Function]
-    type: Required[Literal['function']]
-
-class Graph(BaseModel):
-    origin: str | None
-    nodes: set[str]
-    edges: set[tuple[str, str, bool, str]]
-    def flowchart(self) -> str: ...
-
-class ActionReturn(BaseModel):
-    value: Annotated[Any, None]
-    GO: ClassVar['Go']
-    BREAK: ClassVar['Break']
-    END: ClassVar['End']
-    model_config: ClassVar[ConfigDict]
-    @staticmethod
-    def end(value: Any) -> End: ...
-    @staticmethod
-    def go(value: Any) -> Go: ...
-    @cached_property
-    def is_break(self) -> bool: ...
-    @cached_property
-    def is_end(self) -> bool: ...
-
-class Go(ActionReturn): ...
-class Break(ActionReturn): ...
-class End(Break): ...
-
-class ConcurrentBreakPoint(Exception):
-    action_return: ActionReturn
-    def __init__(self, action_return: ActionReturn) -> None: ...
-
-UNSPECIFIED: str

pybotchi-3.4.4/pybotchi/context.pyi

@@ -1,45 +0,0 @@
-from .action import Action as Action, ActionReturn as ActionReturn, T as T, TAction as TAction
-from .common import ChatRole as ChatRole, ToolCall as ToolCall, UNSPECIFIED as UNSPECIFIED, UsageMetadata as UsageMetadata
-from .llm import LLM as LLM
-from asyncio import Future
-from collections.abc import Callable as Callable, Coroutine, Iterator
-from concurrent.futures import Executor
-from functools import cached_property as cached_property
-from langchain_core.language_models.chat_models import BaseChatModel
-from pydantic import BaseModel
-from typing import Any, Generic, ParamSpec, Self
-from typing_extensions import TypeVar
-
-TContext = TypeVar('TContext', bound='Context', default='Context')
-TLLM = TypeVar('TLLM', default=BaseChatModel)
-P = ParamSpec('P')
-
-class Context(BaseModel, Generic[TLLM]):
-    prompts: list[dict[str, Any]]
-    allowed_actions: dict[str, bool]
-    metadata: dict[str, Any]
-    usages: dict[str, UsageMetadata]
-    streaming: bool
-    max_self_loop: int | None
-    parent: Self | None
-    _action_call: dict[str, int]
-    @cached_property
-    def llm(self) -> TLLM: ...
-    @cached_property
-    def llm_model(self) -> str: ...
-    def shifted_prompts(self, offset: int | None) -> Iterator[dict[str, Any]]: ...
-    async def start(self, action: type[TAction], /, **kwargs: Any) -> tuple[TAction, ActionReturn]: ...
-    def check_self_recursion(self, action: Action) -> bool: ...
-    async def merge_to_usages(self, model: str, usage: UsageMetadata) -> None: ...
-    async def add_usage(self, action: Action, model: str | None, usage: UsageMetadata | None, name: str | None = None, raise_error: bool = False) -> None: ...
-    async def add_message(self, role: ChatRole, content: str, metadata: dict[str, Any] | None = None) -> None: ...
-    async def add_response(self, action: Action | ToolCall, content: str, metadata: dict[str, Any] | None = None) -> None: ...
-    async def set_metadata(self, *paths: Any, value: Any, update: bool = False) -> None: ...
-    async def update_metadata(self, *paths: Any, value: Any) -> None: ...
-    async def notify(self, message: dict[str, Any]) -> None: ...
-    def run_new_event_loop(self, task: Coroutine[Any, Any, T]) -> T: ...
-    def run_task_in_thread(self, task: Coroutine[Any, Any, T], executor: Executor | None = None) -> Future[T]: ...
-    def run_func_in_thread(self, task: Callable[P, T], executor: Executor | None = None, *args: P.args, **kwargs: P.kwargs) -> Future[T]: ...
-    async def detach_context(self) -> TContext: ...
-    def detached_kwargs(self, **kwargs: Any) -> dict[str, Any]: ...
-    async def detached_start(self, action: type['Action'], /, **kwargs: Any) -> tuple[TContext, 'Action', ActionReturn]: ...

pybotchi-3.4.4/pybotchi/grpc/__init__.pyi

@@ -1,5 +0,0 @@
-from .action import GRPCAction as GRPCAction, GRPCRemoteAction as GRPCRemoteAction, graph as graph
-from .common import GRPCConfig as GRPCConfig, GRPCConnection as GRPCConnection, GRPCIntegration as GRPCIntegration
-from .context import GRPCContext as GRPCContext
-
-__all__ = ['GRPCAction', 'GRPCRemoteAction', 'graph', 'GRPCConfig', 'GRPCConnection', 'GRPCIntegration', 'GRPCContext']

pybotchi-3.4.4/pybotchi/grpc/action.pyi

@@ -1,65 +0,0 @@
-from ..action import Action as Action, ChildActions as ChildActions
-from ..common import ActionReturn as ActionReturn, Graph as Graph
-from ..utils import unwrap_exceptions as unwrap_exceptions
-from .common import GRPCConfigLoaded as GRPCConfigLoaded, GRPCConnection as GRPCConnection, GRPCIntegration as GRPCIntegration
-from .context import TContext as TContext
-from .exception import GRPCRemoteError as GRPCRemoteError
-from .pybotchi_pb2 import ActionListRequest as ActionListRequest, ActionListResponse as ActionListResponse, ActionSchema as ActionSchema, Event as Event, TraverseGraph as TraverseGraph, TraverseRequest as TraverseRequest
-from .pybotchi_pb2_grpc import PyBotchiGRPCStub as PyBotchiGRPCStub
-from asyncio import Queue
-from collections.abc import AsyncGenerator, AsyncIterator
-from contextlib import asynccontextmanager
-from datamodel_code_generator.model import DataModelSet as DataModelSet
-from typing import Any, Generic
-
-DMT: DataModelSet
-
-class GRPCClient:
-    stub: PyBotchiGRPCStub
-    name: str
-    config: GRPCConfigLoaded
-    manual_enable: bool
-    allowed_actions: dict[str, bool]
-    remote_action_class: type['GRPCRemoteAction']
-    exclude_unset: bool
-    def __init__(self, stub: PyBotchiGRPCStub, name: str, config: GRPCConfigLoaded, manual_enable: bool, allowed_actions: dict[str, bool], remote_action_class: type['GRPCRemoteAction'] | None, exclude_unset: bool) -> None: ...
-    def build_action(self, agent_id: str, action_schema: ActionSchema) -> tuple[str, type['GRPCRemoteAction']]: ...
-    async def patch_actions(self, actions: ChildActions, grpc_actions: ChildActions) -> ChildActions: ...
-
-class GRPCAction(Action[TContext]):
-    __grpc_clients__: dict[str, GRPCClient]
-    __grpc_connections__: list[GRPCConnection]
-    __grpc_tool_actions__: ChildActions
-    __has_pre_grpc__: bool
-    @classmethod
-    def __pydantic_init_subclass__(cls, **kwargs: Any) -> None: ...
-    @classmethod
-    def __init_child_actions__(cls) -> None: ...
-    async def pre_grpc(self, context: TContext) -> ActionReturn: ...
-    _parent: Action | None
-    __to_commit__: bool
-    async def execute(self, context: TContext, parent: Action | None = None, append: bool = True) -> ActionReturn: ...
-    async def get_child_actions(self, context: TContext) -> ChildActions: ...
-    @classmethod
-    def add_child(cls, action: type['Action'], name: str | None = None, override: bool = False, extended: bool = True) -> None: ...
-
-class GRPCRemoteAction(Action[TContext], Generic[TContext]):
-    __grpc_action__: bool
-    __grpc_client__: GRPCClient
-    __grpc_group__: str
-    __grpc_action_name__: str
-    __grpc_exclude_unset__: bool
-    __grpc_queue__: Queue[Event]
-    async def grpc_event_close(self, context: TContext, event: Event) -> None: ...
-    async def grpc_event_error(self, context: TContext, event: Event) -> None: ...
-    async def grpc_event_update(self, context: TContext, event: Event) -> None: ...
-    async def grpc_queue(self, context: TContext) -> AsyncGenerator[Event, None]: ...
-    async def grpc_send(self, name: str, data: dict[str, Any] | None = None) -> None: ...
-    async def grpc_consume(self, context: TContext, event: Event) -> None: ...
-    async def grpc_connect(self, context: TContext, payload: dict[str, Any], metadata: dict[str, Any] | None = None) -> AsyncGenerator[Event, None]: ...
-    async def pre(self, context: TContext) -> ActionReturn: ...
-
-@asynccontextmanager
-async def multi_grpc_clients(integrations: dict[str, GRPCIntegration], connections: list[GRPCConnection], bypass: bool = False) -> AsyncIterator[dict[str, GRPCClient]]: ...
-async def graph(action: type[Action], allowed_actions: dict[str, bool] | None = None, integrations: dict[str, GRPCIntegration] | None = None, bypass: bool = False) -> Graph: ...
-async def traverse(graph: Graph, action: type[Action], allowed_actions: dict[str, bool] | None, integrations: dict[str, GRPCIntegration], bypass: bool = False, module: str | None = None, alias: str | None = None) -> None: ...

pybotchi-3.4.4/pybotchi/grpc/cli.pyi

@@ -1,12 +0,0 @@
-from multiprocessing import Process
-from pybotchi import Action as Action
-from pybotchi.utils import uuid as uuid
-from types import FrameType
-
-PROCESSES: list[Process]
-
-async def serve(id: str, path: str, host: str, port: str, root_certificates: bytes | None, private_key: bytes | None, certificate_chain: bytes | None, require_client_auth: bool) -> None: ...
-def terminate(sig: int, frame: FrameType | None) -> None: ...
-def start(id: str, path: str, host: str, port: str, root_certificates: bytes | None, private_key: bytes | None, certificate_chain: bytes | None, require_client_auth: bool) -> None: ...
-def main(path: str, id: str | None, host: str | None, port: str | None, workers: str | None, root_certificates: str | None, private_key: str | None, certificate_chain: str | None, require_client_auth: bool) -> None: ...
-def compile() -> None: ...

pybotchi-3.4.4/pybotchi/grpc/common.pyi

@@ -1,60 +0,0 @@
-from .action import GRPCRemoteAction as GRPCRemoteAction
-from .utils import read_cert as read_cert
-from enum import StrEnum
-from grpc.aio import ClientInterceptor as ClientInterceptor
-from typing import Any, Sequence, TypedDict
-
-class GRPCCompression(StrEnum):
-    NoCompression = 'NoCompression'
-    Deflate = 'Deflate'
-    Gzip = 'Gzip'
-
-class GRPCConfig(TypedDict, total=False):
-    secure: bool
-    url: str
-    groups: list[str]
-    root_certificates: str | bytes | None
-    private_key: str | bytes | None
-    certificate_chain: str | bytes | None
-    options: list[tuple[str, Any]] | None
-    compression: GRPCCompression | None
-    metadata: dict[str, Any] | None
-    allow_exec: bool
-
-class GRPCConfigLoaded(TypedDict):
-    url: str
-    groups: list[str]
-    secure: bool
-    root_certificates: bytes | None
-    private_key: bytes | None
-    certificate_chain: bytes | None
-    options: list[tuple[str, Any]] | None
-    compression: GRPCCompression | None
-    metadata: dict[str, Any] | None
-    allow_exec: bool
-
-class GRPCIntegration(TypedDict, total=False):
-    config: GRPCConfig
-    allowed_actions: dict[str, bool]
-    exclude_unset: bool
-
-class GRPCConnection:
-    name: str
-    url: str
-    groups: list[str]
-    secure: bool
-    root_certificates: str | bytes | None
-    private_key: str | bytes | None
-    certificate_chain: str | bytes | None
-    options: list[tuple[str, Any]] | None
-    compression: GRPCCompression | None
-    interceptors: Sequence[ClientInterceptor] | None
-    metadata: dict[str, Any] | None
-    allow_exec: bool
-    manual_enable: bool
-    allowed_actions: dict[str, bool]
-    remote_action_class: type['GRPCRemoteAction'] | None
-    exclude_unset: bool
-    require_integration: bool
-    def __init__(self, name: str, url: str = '', groups: list[str] | None = None, secure: bool = False, root_certificates: str | bytes | None = None, private_key: str | bytes | None = None, certificate_chain: str | bytes | None = None, options: list[tuple[str, Any]] | None = None, compression: GRPCCompression | None = None, interceptors: Sequence[ClientInterceptor] | None = None, metadata: dict[str, Any] | None = None, allow_exec: bool = False, manual_enable: bool = False, allowed_actions: dict[str, bool] | None = None, remote_action_class: type['GRPCRemoteAction'] | None = None, exclude_unset: bool = True, require_integration: bool = True) -> None: ...
-    async def get_config(self, override: GRPCConfig | None) -> GRPCConfigLoaded: ...

pybotchi-3.4.4/pybotchi/grpc/context.pyi

@@ -1,25 +0,0 @@
-from ..common import ToolCall as ToolCall
-from ..context import Action as Action, ChatRole as ChatRole, Context as Context, TLLM as TLLM
-from ..utils import uuid as uuid
-from .common import GRPCIntegration as GRPCIntegration
-from .pybotchi_pb2 import Event as Event
-from asyncio import Queue
-from typing import Any, Generic, TypeVar
-
-TContext = TypeVar('TContext', bound='GRPCContext')
-
-class GRPCContext(Context[TLLM], Generic[TLLM]):
-    integrations: dict[str, GRPCIntegration]
-    source_id: str | None
-    context_id: str
-    _response_queue: Queue[Event] | None
-    _request_queues: dict[str, Queue]
-    def grpc_dump(self) -> dict[str, Any]: ...
-    def grpc_sharing_dump(self) -> dict[str, Any]: ...
-    async def grpc_send_up(self, source_id: str | None, name: str, data: dict[str, Any]) -> None: ...
-    async def grpc_send_down(self, source_id: str | None, name: str, data: dict[str, Any]) -> None: ...
-    def detached_kwargs(self, **kwargs: Any) -> dict[str, Any]: ...
-    async def add_message(self, role: ChatRole, content: str, metadata: dict[str, Any] | None = None, source_id: str | None = None) -> None: ...
-    async def add_response(self, action: Action | ToolCall, content: str, metadata: dict[str, Any] | None = None, source_id: str | None = None) -> None: ...
-    async def set_metadata(self, *paths: Any, value: Any, update: bool = False, source_id: str | None = None) -> None: ...
-    async def notify(self, message: dict[str, Any]) -> None: ...

pybotchi-3.4.4/pybotchi/grpc/exception.pyi

@@ -1,8 +0,0 @@
-class GRPCRemoteError(Exception):
-    cls: str
-    alias: str
-    type: str
-    message: str
-    tracebacks: list[str]
-    def __init__(self, cls: str, alias: str, type: str, message: str, tracebacks: list[str]) -> None: ...
-    def __str__(self) -> str: ...

pybotchi-3.4.4/pybotchi/grpc/handler.pyi

@@ -1,30 +0,0 @@
-from ..action import Action as Action
-from ..common import Graph as Graph
-from ..utils import uuid as uuid
-from .action import traverse as traverse
-from .context import GRPCContext as GRPCContext, TContext as TContext
-from .exception import GRPCRemoteError as GRPCRemoteError
-from .pybotchi_pb2 import ActionListRequest as ActionListRequest, ActionListResponse as ActionListResponse, ActionSchema as ActionSchema, Edge as Edge, Event as Event, JSONSchema as JSONSchema, TraverseGraph as TraverseGraph, TraverseRequest as TraverseRequest
-from .pybotchi_pb2_grpc import PyBotchiGRPCServicer as PyBotchiGRPCServicer
-from asyncio import Queue
-from collections.abc import AsyncGenerator, AsyncIterator
-from grpc.aio import Metadata as Metadata, ServicerContext as ServicerContext
-from typing import Generic
-
-class PyBotchiGRPC(PyBotchiGRPCServicer, Generic[TContext]):
-    __context_class__: type[TContext]
-    __allow_exec__: bool
-    id: str
-    module: str
-    groups: dict[str, dict[str, type[Action]]]
-    __has_validate_metadata__: bool
-    def __init__(self, id: str, module: str, groups: dict[str, dict[str, type[Action]]]) -> None: ...
-    async def validate_metadata(self, metadata: Metadata | None) -> None: ...
-    async def consume(self, context: TContext, groups: list[str], events: AsyncIterator[Event]) -> None: ...
-    async def grpc_event_execute(self, context: TContext, groups: list[str], event: Event) -> None: ...
-    async def grpc_event_update(self, context: TContext, groups: list[str], event: Event) -> None: ...
-    async def accept(self, events: AsyncIterator[Event], context: ServicerContext) -> Queue[Event]: ...
-    async def execute_connect(self, request_iterator: AsyncIterator[Event], context: ServicerContext) -> AsyncGenerator[Event, None]: ...
-    async def connect(self, request_iterator: AsyncIterator[Event], context: ServicerContext) -> AsyncGenerator[Event, None]: ...
-    async def action_list(self, request: ActionListRequest, context: ServicerContext) -> ActionListResponse: ...
-    async def traverse(self, request: TraverseRequest, context: ServicerContext) -> TraverseGraph: ...

pybotchi-3.4.4/pybotchi/grpc/pybotchi_pb2_grpc.pyi

@@ -1,67 +0,0 @@
-"""
-@generated by mypy-protobuf.  Do not edit manually!
-isort:skip_file
-"""
-
-from collections import abc as _abc
-from grpc import aio as _aio
-import abc as _abc_1
-import grpc as _grpc
-import pybotchi_pb2 as _pybotchi_pb2
-import sys
-import typing as _typing
-
-if sys.version_info >= (3, 11):
-    from typing import Self as _Self
-else:
-    from typing_extensions import Self as _Self
-
-_T = _typing.TypeVar("_T")
-
-class _MaybeAsyncIterator(_abc.AsyncIterator[_T], _abc.Iterator[_T], metaclass=_abc_1.ABCMeta): ...
-
-class _ServicerContext(_grpc.ServicerContext, _aio.ServicerContext):  # type: ignore[misc, type-arg]
-    ...
-
-GRPC_GENERATED_VERSION: str
-GRPC_VERSION: str
-
-class PyBotchiGRPCStub:
-    @_typing.overload
-    def __new__(cls, channel: _grpc.Channel) -> _Self: ...
-    @_typing.overload
-    def __new__(cls, channel: _aio.Channel) -> PyBotchiGRPCAsyncStub: ...
-    connect: _grpc.StreamStreamMultiCallable[_pybotchi_pb2.Event, _pybotchi_pb2.Event]
-    action_list: _grpc.UnaryUnaryMultiCallable[_pybotchi_pb2.ActionListRequest, _pybotchi_pb2.ActionListResponse]
-    traverse: _grpc.UnaryUnaryMultiCallable[_pybotchi_pb2.TraverseRequest, _pybotchi_pb2.TraverseGraph]
-
-@_typing.type_check_only
-class PyBotchiGRPCAsyncStub(PyBotchiGRPCStub):
-    def __init__(self, channel: _aio.Channel) -> None: ...
-    connect: _aio.StreamStreamMultiCallable[_pybotchi_pb2.Event, _pybotchi_pb2.Event]  # type: ignore[assignment]
-    action_list: _aio.UnaryUnaryMultiCallable[_pybotchi_pb2.ActionListRequest, _pybotchi_pb2.ActionListResponse]  # type: ignore[assignment]
-    traverse: _aio.UnaryUnaryMultiCallable[_pybotchi_pb2.TraverseRequest, _pybotchi_pb2.TraverseGraph]  # type: ignore[assignment]
-
-class PyBotchiGRPCServicer(metaclass=_abc_1.ABCMeta):
-    @_abc_1.abstractmethod
-    def connect(
-        self,
-        request_iterator: _MaybeAsyncIterator[_pybotchi_pb2.Event],
-        context: _ServicerContext,
-    ) -> _typing.Union[_abc.Iterator[_pybotchi_pb2.Event], _abc.AsyncIterator[_pybotchi_pb2.Event]]: ...
-
-    @_abc_1.abstractmethod
-    def action_list(
-        self,
-        request: _pybotchi_pb2.ActionListRequest,
-        context: _ServicerContext,
-    ) -> _typing.Union[_pybotchi_pb2.ActionListResponse, _abc.Awaitable[_pybotchi_pb2.ActionListResponse]]: ...
-
-    @_abc_1.abstractmethod
-    def traverse(
-        self,
-        request: _pybotchi_pb2.TraverseRequest,
-        context: _ServicerContext,
-    ) -> _typing.Union[_pybotchi_pb2.TraverseGraph, _abc.Awaitable[_pybotchi_pb2.TraverseGraph]]: ...
-
-def add_PyBotchiGRPCServicer_to_server(servicer: PyBotchiGRPCServicer, server: _typing.Union[_grpc.Server, _aio.Server]) -> None: ...

pybotchi-3.4.4/pybotchi/grpc/utils.pyi

@@ -1,3 +0,0 @@
-CERT_CACHE: dict[str, bytes]
-
-async def read_cert(path: str) -> bytes: ...

pybotchi-3.4.4/pybotchi/llm.pyi

@@ -1,22 +0,0 @@
-from typing import Any, Literal, TypeVar, overload
-
-T = TypeVar('T')
-
-class LLM:
-    __instances__: dict[str, Any]
-    @classmethod
-    def add(cls, **llms: Any) -> None: ...
-    @classmethod
-    def base(cls, _: type[T] | None = None) -> T: ...
-    @overload
-    @classmethod
-    def get(cls, llm: str, type: type[T], throw: Literal[True]) -> T: ...
-    @overload
-    @classmethod
-    def get(cls, llm: str, type: type[T]) -> T: ...
-    @overload
-    @classmethod
-    def get(cls, llm: str, type: type[T], throw: Literal[False]) -> T | None: ...
-    @overload
-    @classmethod
-    def get(cls, llm: str) -> Any: ...

pybotchi-3.4.4/pybotchi/mcp/__init__.pyi

@@ -1,5 +0,0 @@
-from .action import MCPAction as MCPAction, MCPToolAction as MCPToolAction, build_mcp_app as build_mcp_app, graph as graph, mount_mcp_app as mount_mcp_app
-from .common import MCPConfig as MCPConfig, MCPConnection as MCPConnection, MCPIntegration as MCPIntegration, MCPMode as MCPMode
-from .context import MCPContext as MCPContext
-
-__all__ = ['MCPAction', 'MCPToolAction', 'build_mcp_app', 'graph', 'mount_mcp_app', 'MCPConfig', 'MCPConnection', 'MCPIntegration', 'MCPMode', 'MCPContext']

pybotchi-3.4.4/pybotchi/mcp/action.pyi

@@ -1,66 +0,0 @@
-from ..action import Action as Action, ChildActions as ChildActions
-from ..common import ActionReturn as ActionReturn, ChatRole as ChatRole, Graph as Graph
-from ..utils import is_camel_case as is_camel_case, unwrap_exceptions as unwrap_exceptions
-from .common import MCPConfig as MCPConfig, MCPConnection as MCPConnection, MCPIntegration as MCPIntegration, MCPMode as MCPMode
-from .context import TContext as TContext
-from collections.abc import AsyncGenerator, AsyncIterator, Awaitable
-from contextlib import AsyncExitStack, asynccontextmanager
-from datamodel_code_generator.model import DataModelSet as DataModelSet
-from mcp import ClientSession, Tool as Tool
-from mcp.server.fastmcp import FastMCP
-from mcp.shared.session import ProgressFnT as ProgressFnT
-from mcp.types import ContentBlock as ContentBlock
-from starlette.applications import AppType as AppType, Starlette
-from typing import Any, Callable, Generic, Literal
-
-DMT: DataModelSet
-
-class MCPClient:
-    session: ClientSession
-    name: str
-    config: MCPConfig
-    manual_enable: bool
-    allowed_tools: dict[str, bool]
-    tool_action_class: type['MCPToolAction']
-    exclude_unset: bool
-    def __init__(self, session: ClientSession, name: str, config: MCPConfig, manual_enable: bool, allowed_tools: dict[str, bool], tool_action_class: type['MCPToolAction'] | None, exclude_unset: bool) -> None: ...
-    def build_tool(self, tool: Tool) -> tuple[str, type['MCPToolAction']]: ...
-    async def patch_tools(self, actions: ChildActions, mcp_actions: ChildActions) -> ChildActions: ...
-
-class MCPAction(Action[TContext]):
-    __mcp_servers__: dict[str, FastMCP]
-    __mcp_clients__: dict[str, MCPClient]
-    __mcp_connections__: list[MCPConnection]
-    __mcp_tool_actions__: ChildActions
-    __has_pre_mcp__: bool
-    @classmethod
-    def __pydantic_init_subclass__(cls, **kwargs: Any) -> None: ...
-    @classmethod
-    def __init_child_actions__(cls) -> None: ...
-    async def pre_mcp(self, context: TContext) -> ActionReturn: ...
-    _parent: Action | None
-    __to_commit__: bool
-    async def execute(self, context: TContext, parent: Action | None = None, append: bool = True) -> ActionReturn: ...
-    async def get_child_actions(self, context: TContext) -> ChildActions: ...
-    @classmethod
-    def add_child(cls, action: type['Action'], name: str | None = None, override: bool = False, extended: bool = True) -> None: ...
-
-class MCPToolAction(Action[TContext], Generic[TContext]):
-    __mcp_tool__: bool
-    __mcp_client__: MCPClient
-    __mcp_tool_name__: str
-    __mcp_exclude_unset__: bool
-    def build_progress_callback(self, context: TContext) -> ProgressFnT: ...
-    def clean_content(self, content: ContentBlock) -> str: ...
-    async def pre(self, context: TContext) -> ActionReturn: ...
-
-@asynccontextmanager
-async def multi_mcp_clients(integrations: dict[str, MCPIntegration], connections: list[MCPConnection], bypass: bool = False) -> AsyncIterator[dict[str, MCPClient]]: ...
-def initialize_mcp_groups() -> None: ...
-@asynccontextmanager
-async def mount_mcp_app(app: AppType, *groups: str, transport: Literal['sse', 'streamable-http'] | dict[str, str] = 'streamable-http') -> AsyncGenerator[AsyncExitStack, None]: ...
-def build_mcp_app(*groups: str, transport: Literal['sse', 'streamable-http'] | dict[str, str] = 'streamable-http') -> Starlette: ...
-def build_mcp_entry(action: type['Action']) -> Callable[..., Awaitable[str]]: ...
-def add_mcp_tool(group: str, action: type['Action'], entry: Callable[..., Awaitable[str]]) -> None: ...
-async def graph(action: type[Action], allowed_actions: dict[str, bool] | None = None, integrations: dict[str, MCPIntegration] | None = None, bypass: bool = False) -> Graph: ...
-async def traverse(graph: Graph, action: type[Action], allowed_actions: dict[str, bool] | None, integrations: dict[str, MCPIntegration], bypass: bool = False) -> None: ...

pybotchi-3.4.4/pybotchi/mcp/common.pyi

@@ -1,60 +0,0 @@
-from .action import MCPToolAction as MCPToolAction
-from collections.abc import Callable as Callable, Mapping, Sequence
-from enum import StrEnum
-from httpx import Auth as Auth
-from httpx._types import CertTypes as CertTypes, PrimitiveData as PrimitiveData
-from mcp.client.streamable_http import McpHttpClientFactory as McpHttpClientFactory
-from typing import Any, Literal, TypedDict
-
-class MCPMode(StrEnum):
-    SSE = 'SSE'
-    SHTTP = 'SHTTP'
-
-class AsyncClientArgs(TypedDict, total=False):
-    auth: tuple[str | bytes, str | bytes] | None
-    params: Mapping[str, PrimitiveData | Sequence[PrimitiveData]] | list[tuple[str, PrimitiveData]] | tuple[tuple[str, PrimitiveData], ...] | str | bytes | None
-    cookies: dict[str, str] | list[tuple[str, str]] | None
-    verify: str | bool
-    cert: CertTypes | None
-    http1: bool
-    http2: bool
-    proxy: str | None
-    max_redirects: int
-    trust_env: bool
-    default_encoding: str
-
-class MCPConfig(TypedDict, total=False):
-    url: str
-    headers: dict[str, str] | None
-    timeout: float
-    sse_read_timeout: float
-    terminate_on_close: bool
-    httpx_client_factory: Any
-    auth: Any
-    async_client_args: AsyncClientArgs
-
-class MCPIntegration(TypedDict, total=False):
-    mode: MCPMode | Literal['SSE', 'SHTTP']
-    config: MCPConfig
-    allowed_tools: dict[str, bool]
-    exclude_unset: bool
-
-class MCPConnection:
-    name: str
-    mode: MCPMode | Literal['SSE', 'SHTTP']
-    url: str
-    headers: dict[str, str] | None
-    timeout: float
-    sse_read_timeout: float
-    terminate_on_close: bool
-    httpx_client_factory: McpHttpClientFactory
-    auth: Auth | None
-    on_session_created: Callable[[str], None] | None
-    async_client_args: AsyncClientArgs
-    manual_enable: bool
-    allowed_tools: dict[str, bool]
-    tool_action_class: type['MCPToolAction'] | None
-    exclude_unset: bool
-    require_integration: bool
-    def __init__(self, name: str, mode: MCPMode | Literal['SSE', 'SHTTP'], url: str = '', headers: dict[str, str] | None = None, timeout: float = 5.0, sse_read_timeout: float = 300.0, terminate_on_close: bool = True, httpx_client_factory: McpHttpClientFactory = ..., auth: Auth | None = None, on_session_created: Callable[[str], None] | None = None, async_client_args: AsyncClientArgs | None = None, manual_enable: bool = False, allowed_tools: dict[str, bool] | None = None, tool_action_class: type['MCPToolAction'] | None = None, exclude_unset: bool = True, require_integration: bool = True) -> None: ...
-    def get_config(self, override: MCPConfig | None) -> MCPConfig: ...

pybotchi-3.4.4/pybotchi/mcp/context.pyi

@@ -1,9 +0,0 @@
-from ..context import Context as Context, TLLM as TLLM
-from .common import MCPIntegration as MCPIntegration
-from typing import Any, Generic, TypeVar
-
-TContext = TypeVar('TContext', bound='MCPContext')
-
-class MCPContext(Context[TLLM], Generic[TLLM]):
-    integrations: dict[str, MCPIntegration]
-    def detached_kwargs(self, **kwargs: Any) -> dict[str, Any]: ...

pybotchi-3.4.4/pybotchi/utils.pyi

@@ -1,13 +0,0 @@
-from collections.abc import Generator
-from re import Pattern
-from typing import Any, Callable
-from uuid import UUID
-
-PLACEHOLDERS: Pattern
-CAMEL_CASE: Pattern
-
-def apply_placeholders(target: str, **placeholders: Any) -> str: ...
-def is_camel_case(data: str) -> bool: ...
-def unwrap_exceptions(exception: Exception) -> Generator[Exception, None, None]: ...
-
-uuid: Callable[[], UUID]