agno 0.1.2__py3-none-any.whl → 2.3.13__py3-none-any.whl

agno/api/workspace.py

@@ -1,151 +0,0 @@
-from typing import Dict, List, Optional, Union
-
-from httpx import Response
-
-from agno.api.api import api, invalid_response
-from agno.api.routes import ApiRoutes
-from agno.api.schemas.team import TeamIdentifier
-from agno.api.schemas.user import UserSchema
-from agno.api.schemas.workspace import (
-    WorkspaceCreate,
-    WorkspaceEvent,
-    WorkspaceSchema,
-    WorkspaceUpdate,
-)
-from agno.cli.settings import agno_cli_settings
-from agno.utils.log import logger
-
-
-def create_workspace_for_user(
-    user: UserSchema, workspace: WorkspaceCreate, team: Optional[TeamIdentifier] = None
-) -> Optional[WorkspaceSchema]:
-    logger.debug("--**-- Creating workspace")
-    with api.AuthenticatedClient() as api_client:
-        try:
-            payload = {
-                "user": user.model_dump(include={"id_user", "email"}),
-                "workspace": workspace.model_dump(exclude_none=True),
-            }
-            if team is not None:
-                payload["team"] = team.model_dump(exclude_none=True)
-
-            r: Response = api_client.post(
-                ApiRoutes.WORKSPACE_CREATE,
-                json=payload,
-                timeout=2.0,
-            )
-            if invalid_response(r):
-                try:
-                    error_msg = r.json().get("detail", "Permission denied")
-                except Exception:
-                    error_msg = f"Could not create workspace: {r.text}"
-                logger.error(error_msg)
-                return None
-
-            response_json: Union[Dict, List] = r.json()
-            if response_json is None:
-                return None
-
-            created_workspace: WorkspaceSchema = WorkspaceSchema.model_validate(response_json)
-            if created_workspace is not None:
-                return created_workspace
-        except Exception as e:
-            logger.debug(f"Could not create workspace: {e}")
-    return None
-
-
-def update_workspace_for_user(user: UserSchema, workspace: WorkspaceUpdate) -> Optional[WorkspaceSchema]:
-    logger.debug("--**-- Updating workspace for user")
-    with api.AuthenticatedClient() as api_client:
-        try:
-            payload = {
-                "user": user.model_dump(include={"id_user", "email"}),
-                "workspace": workspace.model_dump(exclude_none=True),
-            }
-
-            r: Response = api_client.post(
-                ApiRoutes.WORKSPACE_UPDATE,
-                json=payload,
-            )
-            if invalid_response(r):
-                try:
-                    error_msg = r.json().get("detail", "Could not update workspace")
-                except Exception:
-                    error_msg = f"Could not update workspace: {r.text}"
-                logger.error(error_msg)
-                return None
-
-            response_json: Union[Dict, List] = r.json()
-            if response_json is None:
-                return None
-
-            updated_workspace: WorkspaceSchema = WorkspaceSchema.model_validate(response_json)
-            if updated_workspace is not None:
-                return updated_workspace
-        except Exception as e:
-            logger.debug(f"Could not update workspace: {e}")
-    return None
-
-
-def update_workspace_for_team(
-    user: UserSchema, workspace: WorkspaceUpdate, team: TeamIdentifier
-) -> Optional[WorkspaceSchema]:
-    logger.debug("--**-- Updating workspace for team")
-    with api.AuthenticatedClient() as api_client:
-        try:
-            payload = {
-                "user": user.model_dump(include={"id_user", "email"}),
-                "team_workspace": workspace.model_dump(exclude_none=True).update({"id_team": team.id_team}),
-            }
-
-            r: Response = api_client.post(
-                ApiRoutes.WORKSPACE_UPDATE,
-                json=payload,
-            )
-            if invalid_response(r):
-                try:
-                    error_msg = r.json().get("detail", "Could not update workspace")
-                except Exception:
-                    error_msg = f"Could not update workspace: {r.text}"
-                logger.error(error_msg)
-                return None
-
-            response_json: Union[Dict, List] = r.json()
-            if response_json is None:
-                return None
-
-            updated_workspace: WorkspaceSchema = WorkspaceSchema.model_validate(response_json)
-            if updated_workspace is not None:
-                return updated_workspace
-        except Exception as e:
-            logger.debug(f"Could not update workspace: {e}")
-    return None
-
-
-def log_workspace_event(user: UserSchema, workspace_event: WorkspaceEvent) -> bool:
-    if not agno_cli_settings.api_enabled:
-        return False
-
-    logger.debug("--**-- Log workspace event")
-    with api.AuthenticatedClient() as api_client:
-        try:
-            r: Response = api_client.post(
-                ApiRoutes.WORKSPACE_EVENT_CREATE,
-                json={
-                    "user": user.model_dump(include={"id_user", "email"}),
-                    "event": workspace_event.model_dump(exclude_none=True),
-                },
-            )
-            if invalid_response(r):
-                return False
-
-            response_json: Union[Dict, List] = r.json()
-            if response_json is None:
-                return False
-
-            if isinstance(response_json, dict) and response_json.get("status") == "success":
-                return True
-            return False
-        except Exception as e:
-            logger.debug(f"Could not log workspace event: {e}")
-    return False

agno/cli/auth_server.py

@@ -1,118 +0,0 @@
-from http.server import BaseHTTPRequestHandler, HTTPServer
-from typing import Optional
-
-from agno.cli.settings import agno_cli_settings
-
-
-class CliAuthRequestHandler(BaseHTTPRequestHandler):
-    """Request Handler to accept the CLI auth token after the web based auth flow.
-    References:
-        https://medium.com/@hasinthaindrajee/browser-sso-for-cli-applications-b0be743fa656
-        https://gist.github.com/mdonkers/63e115cc0c79b4f6b8b3a6b797e485c7
-
-    TODO:
-        * Fix the header and limit to only localhost or agno.com
-    """
-
-    def _set_response(self):
-        self.send_response(204)
-        self.send_header("Access-Control-Allow-Origin", "*")
-        self.send_header("Access-Control-Allow-Headers", "*")
-        self.send_header("Access-Control-Allow-Methods", "POST")
-        self.end_headers()
-
-    # def do_GET(self):
-    #     logger.info("GET request,\nPath: %s\nHeaders:\n%s\n", str(self.path), str(self.headers))
-    #     self._set_response()
-    #     self.wfile.write("GET request for {}".format(self.path).encode('utf-8'))
-
-    def do_OPTIONS(self):
-        # logger.debug(
-        #     "OPTIONS request,\nPath: %s\nHeaders:\n%s\n",
-        #     str(self.path),
-        #     str(self.headers),
-        # )
-        self._set_response()
-        # self.wfile.write("OPTIONS request for {}".format(self.path).encode('utf-8'))
-
-    def do_POST(self):
-        content_length = int(self.headers["Content-Length"])  # <--- Gets the size of data
-        post_data = self.rfile.read(content_length)  # <--- Gets the data itself
-        decoded_post_data = post_data.decode("utf-8")
-        # logger.debug(
-        #     "POST request,\nPath: {}\nHeaders:\n{}\n\nBody:\n{}\n".format(
-        #         str(self.path), str(self.headers), decoded_post_data
-        #     )
-        # )
-        # logger.debug("Data: {}".format(decoded_post_data))
-        # logger.info("type: {}".format(type(post_data)))
-        agno_cli_settings.tmp_token_path.parent.mkdir(parents=True, exist_ok=True)
-        agno_cli_settings.tmp_token_path.touch(exist_ok=True)
-        agno_cli_settings.tmp_token_path.write_text(decoded_post_data)
-        # TODO: Add checks before shutting down the server
-        self.server.running = False  # type: ignore
-        self._set_response()
-
-    def log_message(self, format, *args):
-        pass
-
-
-class CliAuthServer:
-    """
-    Source: https://stackoverflow.com/a/38196725/10953921
-    """
-
-    def __init__(self, port: int = 9191):
-        import threading
-
-        self._server = HTTPServer(("", port), CliAuthRequestHandler)
-        self._thread = threading.Thread(target=self.run)
-        self._thread.daemon = True
-        self._server.running = False  # type: ignore
-
-    def run(self):
-        self._server.running = True  # type: ignore
-        while self._server.running:  # type: ignore
-            self._server.handle_request()
-
-    def start(self):
-        self._thread.start()
-
-    def shut_down(self):
-        self._thread.close()  # type: ignore
-
-
-def check_port(port: int):
-    import socket
-
-    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
-        try:
-            return s.connect_ex(("localhost", port)) == 0
-        except Exception as e:
-            print(f"Error occurred: {e}")
-            return False
-
-
-def get_port_for_auth_server():
-    starting_port = 9191
-    for port in range(starting_port, starting_port + 100):
-        if not check_port(port):
-            return port
-
-
-def get_auth_token_from_web_flow(port: int) -> Optional[str]:
-    """
-    GET request: curl http://localhost:9191
-    POST request: curl -d "foo=bar&bin=baz" http://localhost:9191
-    """
-    import json
-
-    server = CliAuthServer(port)
-    server.run()
-
-    if agno_cli_settings.tmp_token_path.exists() and agno_cli_settings.tmp_token_path.is_file():
-        auth_token_str = agno_cli_settings.tmp_token_path.read_text()
-        auth_token_json = json.loads(auth_token_str)
-        agno_cli_settings.tmp_token_path.unlink()
-        return auth_token_json.get("AuthToken", None)
-    return None

agno/cli/config.py

@@ -1,275 +0,0 @@
-from collections import OrderedDict
-from pathlib import Path
-from typing import Dict, List, Optional
-
-from agno.api.schemas.team import TeamSchema
-from agno.api.schemas.user import UserSchema
-from agno.api.schemas.workspace import WorkspaceSchema
-from agno.cli.console import print_heading, print_info
-from agno.cli.settings import agno_cli_settings
-from agno.utils.json_io import read_json_file, write_json_file
-from agno.utils.log import logger
-from agno.workspace.config import WorkspaceConfig
-
-
-class AgnoCliConfig:
-    """The AgnoCliConfig class manages user data for the agno cli"""
-
-    def __init__(
-        self,
-        user: Optional[UserSchema] = None,
-        active_ws_dir: Optional[str] = None,
-        ws_config_map: Optional[Dict[str, WorkspaceConfig]] = None,
-    ) -> None:
-        # Current user, populated after authenticating with the api
-        # To add a user, use the user setter
-        self._user: Optional[UserSchema] = user
-
-        # Active ws dir - used as the default for `ag` commands
-        # To add an active workspace, use the active_ws_dir setter
-        self._active_ws_dir: Optional[str] = active_ws_dir
-
-        # Mapping from ws_root_path to ws_config
-        self.ws_config_map: Dict[str, WorkspaceConfig] = ws_config_map or OrderedDict()
-
-    ######################################################
-    ## User functions
-    ######################################################
-
-    @property
-    def user(self) -> Optional[UserSchema]:
-        return self._user
-
-    @user.setter
-    def user(self, user: Optional[UserSchema]) -> None:
-        """Sets the user"""
-        if user is not None:
-            logger.debug(f"Setting user to: {user.email}")
-            clear_user_cache = (
-                self._user is not None  # previous user is not None
-                and self._user.email != "anon"  # previous user is not anon
-                and (user.email != self._user.email or user.id_user != self._user.id_user)  # new user is different
-            )
-            self._user = user
-            if clear_user_cache:
-                self.clear_user_cache()
-            self.save_config()
-
-    def clear_user_cache(self) -> None:
-        """Clears the user cache"""
-        logger.debug("Clearing user cache")
-        self.ws_config_map.clear()
-        self._active_ws_dir = None
-        agno_cli_settings.ai_conversations_path.unlink(missing_ok=True)
-        logger.info("Workspaces cleared, please setup again using `ag ws setup`")
-
-    ######################################################
-    ## Workspace functions
-    ######################################################
-
-    @property
-    def active_ws_dir(self) -> Optional[str]:
-        return self._active_ws_dir
-
-    def set_active_ws_dir(self, ws_root_path: Optional[Path]) -> None:
-        if ws_root_path is not None:
-            logger.debug(f"Setting active workspace to: {str(ws_root_path)}")
-            self._active_ws_dir = str(ws_root_path)
-            self.save_config()
-
-    @property
-    def available_ws(self) -> List[WorkspaceConfig]:
-        return list(self.ws_config_map.values())
-
-    def _add_or_update_ws_config(
-        self,
-        ws_root_path: Path,
-        ws_schema: Optional[WorkspaceSchema] = None,
-        ws_team: Optional[TeamSchema] = None,
-        ws_api_key: Optional[str] = None,
-    ) -> Optional[WorkspaceConfig]:
-        """The main function to create, update or refresh a WorkspaceConfig.
-
-        This function does not call self.save_config(). Remember to save_config() after calling this function.
-        """
-
-        # Validate ws_root_path
-        if ws_root_path is None or not isinstance(ws_root_path, Path):
-            raise ValueError(f"Invalid ws_root: {ws_root_path}")
-        ws_root_str = str(ws_root_path)
-
-        ######################################################
-        # Create new ws_config if one does not exist
-        ######################################################
-        if ws_root_str not in self.ws_config_map:
-            logger.debug(f"Creating workspace at: {ws_root_str}")
-            new_workspace_config = WorkspaceConfig(
-                ws_root_path=ws_root_path,
-                ws_schema=ws_schema,
-                ws_team=ws_team,
-                ws_api_key=ws_api_key,
-            )
-            self.ws_config_map[ws_root_str] = new_workspace_config
-            logger.debug(f"Workspace created at: {ws_root_str}")
-
-            # Return the new_workspace_config
-            return new_workspace_config
-
-        ######################################################
-        # Update ws_config
-        ######################################################
-        logger.debug(f"Updating workspace at: {ws_root_str}")
-        # By this point there should be a WorkspaceConfig object for this ws_name
-        existing_ws_config: Optional[WorkspaceConfig] = self.ws_config_map.get(ws_root_str, None)
-        if existing_ws_config is None:
-            logger.error(f"Could not find workspace at: {ws_root_str}, please run `ag ws setup`")
-            return None
-
-        # Update the ws_schema if it's not None and different from the existing one
-        if ws_schema is not None and existing_ws_config.ws_schema != ws_schema:
-            existing_ws_config.ws_schema = ws_schema
-
-        # Update the ws_team if it's not None and different from the existing one
-        if ws_team is not None and existing_ws_config.ws_team != ws_team:
-            existing_ws_config.ws_team = ws_team
-
-        # Update the ws_api_key if it's not None and different from the existing one
-        if ws_api_key is not None and existing_ws_config.ws_api_key != ws_api_key:
-            existing_ws_config.ws_api_key = ws_api_key
-
-        # Swap the existing ws_config with the updated one
-        self.ws_config_map[ws_root_str] = existing_ws_config
-
-        # Return the updated_ws_config
-        return existing_ws_config
-
-    def add_new_ws_to_config(
-        self, ws_root_path: Path, ws_team: Optional[TeamSchema] = None
-    ) -> Optional[WorkspaceConfig]:
-        """Adds a newly created workspace to the AgnoCliConfig"""
-
-        ws_config = self._add_or_update_ws_config(ws_root_path=ws_root_path, ws_team=ws_team)
-        self.save_config()
-        return ws_config
-
-    def create_or_update_ws_config(
-        self,
-        ws_root_path: Path,
-        ws_schema: Optional[WorkspaceSchema] = None,
-        ws_team: Optional[TeamSchema] = None,
-        set_as_active: bool = True,
-    ) -> Optional[WorkspaceConfig]:
-        """Creates or updates a WorkspaceConfig and returns the WorkspaceConfig"""
-
-        ws_config = self._add_or_update_ws_config(
-            ws_root_path=ws_root_path,
-            ws_schema=ws_schema,
-            ws_team=ws_team,
-        )
-        if set_as_active:
-            self._active_ws_dir = str(ws_root_path)
-        self.save_config()
-        return ws_config
-
-    def delete_ws(self, ws_root_path: Path) -> None:
-        """Handles Deleting a workspace from the AgnoCliConfig and api"""
-
-        ws_root_str = str(ws_root_path)
-        print_heading(f"Deleting record for workspace: {ws_root_str}")
-
-        ws_config: Optional[WorkspaceConfig] = self.ws_config_map.pop(ws_root_str, None)
-        if ws_config is None:
-            logger.warning(f"No record of workspace at {ws_root_str}")
-            return
-
-        # Check if we're deleting the active workspace, if yes, unset the active ws
-        if self._active_ws_dir is not None and self._active_ws_dir == ws_root_str:
-            print_info(f"Removing {ws_root_str} as the active workspace")
-            self._active_ws_dir = None
-        self.save_config()
-        print_info("Workspace record deleted")
-        print_info("Note: this does not delete any data locally or from agno.com, please delete them manually\n")
-
-    def get_ws_config_by_dir_name(self, ws_dir_name: str) -> Optional[WorkspaceConfig]:
-        ws_root_str: Optional[str] = None
-        for k, v in self.ws_config_map.items():
-            if v.ws_root_path.stem == ws_dir_name:
-                ws_root_str = k
-                break
-
-        if ws_root_str is None or ws_root_str not in self.ws_config_map:
-            return None
-
-        return self.ws_config_map[ws_root_str]
-
-    def get_ws_config_by_path(self, ws_root_path: Path) -> Optional[WorkspaceConfig]:
-        return self.ws_config_map[str(ws_root_path)] if str(ws_root_path) in self.ws_config_map else None
-
-    def get_active_ws_config(self) -> Optional[WorkspaceConfig]:
-        if self.active_ws_dir is not None and self.active_ws_dir in self.ws_config_map:
-            return self.ws_config_map[self.active_ws_dir]
-        return None
-
-    ######################################################
-    ## Save AgnoCliConfig
-    ######################################################
-
-    def save_config(self):
-        config_data = {
-            "user": self.user.model_dump() if self.user else None,
-            "active_ws_dir": self.active_ws_dir,
-            "ws_config_map": {k: v.to_dict() for k, v in self.ws_config_map.items()},
-        }
-        write_json_file(file_path=agno_cli_settings.config_file_path, data=config_data)
-
-    @classmethod
-    def from_saved_config(cls) -> Optional["AgnoCliConfig"]:
-        try:
-            config_data = read_json_file(file_path=agno_cli_settings.config_file_path)
-            if config_data is None or not isinstance(config_data, dict):
-                logger.debug("No config found")
-                return None
-
-            user_dict = config_data.get("user")
-            user_schema = UserSchema.model_validate(user_dict) if user_dict else None
-            active_ws_dir = config_data.get("active_ws_dir")
-
-            # Create a new config
-            new_config = cls(user_schema, active_ws_dir)
-
-            # Add all the workspaces
-            for k, v in config_data.get("ws_config_map", {}).items():
-                _ws_config = WorkspaceConfig.model_validate(v)
-                if _ws_config is not None:
-                    new_config.ws_config_map[k] = _ws_config
-            return new_config
-        except Exception as e:
-            logger.warning(e)
-            logger.warning("Please setup the workspace using `ag ws setup`")
-            return None
-
-    ######################################################
-    ## Print AgnoCliConfig
-    ######################################################
-
-    def print_to_cli(self, show_all: bool = False):
-        if self.user:
-            print_heading(f"User: {self.user.email}\n")
-        if self.active_ws_dir:
-            print_heading(f"Active workspace directory: {self.active_ws_dir}\n")
-        else:
-            print_info("No active workspace found.")
-            print_info(
-                "Please create a workspace using `ag ws create` or setup an existing workspace using `ag ws setup`"
-            )
-
-        if show_all and len(self.ws_config_map) > 0:
-            print_heading("Available workspaces:\n")
-            c = 1
-            for k, v in self.ws_config_map.items():
-                print_info(f"  {c}. Path: {k}")
-                if v.ws_schema and v.ws_schema.ws_name:
-                    print_info(f"     Name: {v.ws_schema.ws_name}")
-                if v.ws_team and v.ws_team.name:
-                    print_info(f"     Team: {v.ws_team.name}")
-                c += 1

agno/cli/console.py

@@ -1,88 +0,0 @@
-from rich.console import Console
-from rich.style import Style
-
-from agno.utils.log import logger
-
-console = Console()
-
-######################################################
-## Styles
-# Standard Colors: https://rich.readthedocs.io/en/stable/appendix/colors.html#appendix-colors
-######################################################
-
-heading_style = Style(
-    color="green",
-    bold=True,
-    underline=True,
-)
-subheading_style = Style(
-    color="chartreuse3",
-    bold=True,
-)
-success_style = Style(color="chartreuse3")
-fail_style = Style(color="red")
-error_style = Style(color="red")
-info_style = Style()
-warn_style = Style(color="magenta")
-
-
-######################################################
-## Print functions
-######################################################
-
-
-def print_heading(msg: str) -> None:
-    console.print(msg, style=heading_style)
-
-
-def print_subheading(msg: str) -> None:
-    console.print(msg, style=subheading_style)
-
-
-def print_info(msg: str) -> None:
-    console.print(msg, style=info_style)
-
-
-def log_config_not_available_msg() -> None:
-    logger.error("Agno config not found, please run `ag init` and try again")
-
-
-def log_active_workspace_not_available() -> None:
-    logger.error("Could not find an active workspace. You can:")
-    logger.error("- Run `ag ws setup` to setup a workspace at the current path")
-    logger.error("- Run `ag ws create` to create a new workspace")
-
-
-def print_available_workspaces(avl_ws_list) -> None:
-    avl_ws_names = [w.ws_root_path.stem for w in avl_ws_list] if avl_ws_list else []
-    print_info("Available Workspaces:\n  - {}".format("\n  - ".join(avl_ws_names)))
-
-
-def confirm_yes_no(question, default: str = "yes") -> bool:
-    """Ask a yes/no question via raw_input().
-
-    "question" is a string that is presented to the user.
-    "default" is the presumed answer if the user just hits <Enter>.
-            It must be "yes" (the default), "no" or None (meaning
-            an answer is required of the user).
-
-    The "answer" return value is True for "yes" or False for "no".
-    """
-    inp_to_result_map = {"yes": True, "y": True, "ye": True, "no": False, "n": False}
-    if default is None:
-        prompt = " [y/n]: "
-    elif default == "yes":
-        prompt = " [Y/n]: "
-    elif default == "no":
-        prompt = " [y/N]: "
-    else:
-        raise ValueError(f"Invalid default answer: {default}")
-
-    choice = console.input(prompt=(question + prompt)).lower()
-    if default is not None and choice == "":
-        return inp_to_result_map[default]
-    elif choice in inp_to_result_map:
-        return inp_to_result_map[choice]
-    else:
-        logger.error(f"{choice} invalid")
-        return False

agno/cli/credentials.py

@@ -1,23 +0,0 @@
-from typing import Dict, Optional
-
-from agno.cli.settings import agno_cli_settings
-from agno.utils.json_io import read_json_file, write_json_file
-
-
-def save_auth_token(auth_token: str):
-    # logger.debug(f"Storing {auth_token} to {str(agno_cli_settings.credentials_path)}")
-    _data = {"token": auth_token}
-    write_json_file(agno_cli_settings.credentials_path, _data)
-
-
-def read_auth_token() -> Optional[str]:
-    # logger.debug(f"Reading token from {str(agno_cli_settings.credentials_path)}")
-    _data: Dict = read_json_file(agno_cli_settings.credentials_path)  # type: ignore
-    if _data is None:
-        return None
-
-    try:
-        return _data.get("token")
-    except Exception:
-        pass
-    return None