{children}
+ 
-
-
-
-
-
-
- We're hosting a Hackathon!
-
- Click the banner above for details and registration!
-
-
-
-
+
+
+
This is a test post.
", + "content_format": "html", + "tags": ["test", "automation"], + "license": "all-rights-reserved", + "notify_followers": False, + "publish_status": PublishToMediumStatus.DRAFT.value, + "credentials": TEST_CREDENTIALS_INPUT, + }, + test_output=[ + ("post_id", "e6f36a"), + ("post_url", "https://medium.com/@username/test-post-e6f36a"), + ("published_at", 1626282600), + ], + test_mock={ + "create_post": lambda *args, **kwargs: { + "data": { + "id": "e6f36a", + "url": "https://medium.com/@username/test-post-e6f36a", + "authorId": "1234567890abcdef", + "publishedAt": 1626282600, + } + } + }, + test_credentials=TEST_CREDENTIALS, + ) + + def create_post( + self, + api_key: SecretStr, + author_id, + title, + content, + content_format, + tags, + canonical_url, + publish_status, + license, + notify_followers, + ): + headers = { + "Authorization": f"Bearer {api_key.get_secret_value()}", + "Content-Type": "application/json", + "Accept": "application/json", + } + + data = { + "title": title, + "content": content, + "contentFormat": content_format, + "tags": tags, + "canonicalUrl": canonical_url, + "publishStatus": publish_status, + "license": license, + "notifyFollowers": notify_followers, + } + + response = requests.post( + f"https://api.medium.com/v1/users/{author_id}/posts", + headers=headers, + json=data, + ) + + return response.json() + + def run( + self, input_data: Input, *, credentials: APIKeyCredentials, **kwargs + ) -> BlockOutput: + response = self.create_post( + credentials.api_key, + input_data.author_id.get_secret_value(), + input_data.title, + input_data.content, + input_data.content_format, + input_data.tags, + input_data.canonical_url, + input_data.publish_status, + input_data.license, + input_data.notify_followers, + ) + + if "data" in response: + yield "post_id", response["data"]["id"] + yield "post_url", response["data"]["url"] + yield "published_at", response["data"]["publishedAt"] + else: + error_message = response.get("errors", [{}])[0].get( + "message", "Unknown error occurred" + ) + raise RuntimeError(f"Failed to create Medium post: {error_message}") diff --git a/autogpt_platform/backend/backend/blocks/mem0.py b/autogpt_platform/backend/backend/blocks/mem0.py new file mode 100644 index 000000000000..90245e0e0a4e --- /dev/null +++ b/autogpt_platform/backend/backend/blocks/mem0.py @@ -0,0 +1,338 @@ +from typing import Any, Literal, Optional, Union + +from mem0 import MemoryClient +from pydantic import BaseModel, SecretStr + +from backend.data.block import Block, BlockOutput, BlockSchema +from backend.data.model import ( + APIKeyCredentials, + CredentialsField, + CredentialsMetaInput, + SchemaField, +) +from backend.integrations.providers import ProviderName + +TEST_CREDENTIALS = APIKeyCredentials( + id="ed55ac19-356e-4243-a6cb-bc599e9b716f", + provider="mem0", + api_key=SecretStr("mock-mem0-api-key"), + title="Mock Mem0 API key", + expires_at=None, +) + +TEST_CREDENTIALS_INPUT = { + "provider": TEST_CREDENTIALS.provider, + "id": TEST_CREDENTIALS.id, + "type": TEST_CREDENTIALS.type, + "title": TEST_CREDENTIALS.title, +} + + +class Mem0Base: + """Base class with shared utilities for Mem0 blocks""" + + @staticmethod + def _get_client(credentials: APIKeyCredentials) -> MemoryClient: + """Get initialized Mem0 client""" + return MemoryClient(api_key=credentials.api_key.get_secret_value()) + + +Filter = dict[str, list[dict[str, str | dict[str, list[str]]]]] + + +class Conversation(BaseModel): + discriminator: Literal["conversation"] + messages: list[dict[str, str]] + + +class Content(BaseModel): + discriminator: Literal["content"] + content: str + + +class AddMemoryBlock(Block, Mem0Base): + """Block for adding memories to Mem0 + + Always limited by user_id and optional graph_id and graph_exec_id""" + + class Input(BlockSchema): + credentials: CredentialsMetaInput[ + Literal[ProviderName.MEM0], Literal["api_key"] + ] = CredentialsField(description="Mem0 API key credentials") + content: Union[Content, Conversation] = SchemaField( + discriminator="discriminator", + description="Content to add - either a string or list of message objects as output from an AI block", + default=Content(discriminator="content", content="I'm a vegetarian"), + ) + metadata: dict[str, Any] = SchemaField( + description="Optional metadata for the memory", default={} + ) + + limit_memory_to_run: bool = SchemaField( + description="Limit the memory to the run", default=False + ) + limit_memory_to_agent: bool = SchemaField( + description="Limit the memory to the agent", default=False + ) + + class Output(BlockSchema): + action: str = SchemaField(description="Action of the operation") + memory: str = SchemaField(description="Memory created") + error: str = SchemaField(description="Error message if operation fails") + + def __init__(self): + super().__init__( + id="dce97578-86be-45a4-ae50-f6de33fc935a", + description="Add new memories to Mem0 with user segmentation", + input_schema=AddMemoryBlock.Input, + output_schema=AddMemoryBlock.Output, + test_input=[ + { + "content": { + "discriminator": "conversation", + "messages": [{"role": "user", "content": "I'm a vegetarian"}], + }, + "metadata": {"food": "vegetarian"}, + "credentials": TEST_CREDENTIALS_INPUT, + }, + { + "content": { + "discriminator": "content", + "content": "I am a vegetarian", + }, + "metadata": {"food": "vegetarian"}, + "credentials": TEST_CREDENTIALS_INPUT, + }, + ], + test_output=[("action", "NO_CHANGE"), ("action", "NO_CHANGE")], + test_credentials=TEST_CREDENTIALS, + test_mock={"_get_client": lambda credentials: MockMemoryClient()}, + ) + + def run( + self, + input_data: Input, + *, + credentials: APIKeyCredentials, + user_id: str, + graph_id: str, + graph_exec_id: str, + **kwargs + ) -> BlockOutput: + try: + client = self._get_client(credentials) + + if isinstance(input_data.content, Conversation): + messages = input_data.content.messages + else: + messages = [{"role": "user", "content": input_data.content}] + + params = { + "user_id": user_id, + "output_format": "v1.1", + "metadata": input_data.metadata, + } + + if input_data.limit_memory_to_run: + params["run_id"] = graph_exec_id + if input_data.limit_memory_to_agent: + params["agent_id"] = graph_id + + # Use the client to add memory + result = client.add( + messages, + **params, + ) + + if len(result.get("results", [])) > 0: + for result in result.get("results", []): + yield "action", result["event"] + yield "memory", result["memory"] + else: + yield "action", "NO_CHANGE" + + except Exception as e: + yield "error", str(object=e) + + +class SearchMemoryBlock(Block, Mem0Base): + """Block for searching memories in Mem0""" + + class Input(BlockSchema): + credentials: CredentialsMetaInput[ + Literal[ProviderName.MEM0], Literal["api_key"] + ] = CredentialsField(description="Mem0 API key credentials") + query: str = SchemaField( + description="Search query", + advanced=False, + ) + trigger: bool = SchemaField( + description="An unused field that is used to (re-)trigger the block when you have no other inputs", + default=False, + advanced=False, + ) + categories_filter: list[str] = SchemaField( + description="Categories to filter by", + default=[], + advanced=True, + ) + limit_memory_to_run: bool = SchemaField( + description="Limit the memory to the run", default=False + ) + limit_memory_to_agent: bool = SchemaField( + description="Limit the memory to the agent", default=True + ) + + class Output(BlockSchema): + memories: Any = SchemaField(description="List of matching memories") + error: str = SchemaField(description="Error message if operation fails") + + def __init__(self): + super().__init__( + id="bd7c84e3-e073-4b75-810c-600886ec8a5b", + description="Search memories in Mem0 by user", + input_schema=SearchMemoryBlock.Input, + output_schema=SearchMemoryBlock.Output, + test_input={ + "query": "vegetarian preferences", + "credentials": TEST_CREDENTIALS_INPUT, + "top_k": 10, + "rerank": True, + }, + test_output=[ + ("memories", [{"id": "test-memory", "content": "test content"}]) + ], + test_credentials=TEST_CREDENTIALS, + test_mock={"_get_client": lambda credentials: MockMemoryClient()}, + ) + + def run( + self, + input_data: Input, + *, + credentials: APIKeyCredentials, + user_id: str, + graph_id: str, + graph_exec_id: str, + **kwargs + ) -> BlockOutput: + try: + client = self._get_client(credentials) + + filters: Filter = { + # This works with only one filter, so we can allow others to add on later + "AND": [ + {"user_id": user_id}, + ] + } + if input_data.categories_filter: + filters["AND"].append( + {"categories": {"contains": input_data.categories_filter}} + ) + if input_data.limit_memory_to_run: + filters["AND"].append({"run_id": graph_exec_id}) + if input_data.limit_memory_to_agent: + filters["AND"].append({"agent_id": graph_id}) + + result: list[dict[str, Any]] = client.search( + input_data.query, version="v2", filters=filters + ) + yield "memories", result + + except Exception as e: + yield "error", str(e) + + +class GetAllMemoriesBlock(Block, Mem0Base): + """Block for retrieving all memories from Mem0""" + + class Input(BlockSchema): + credentials: CredentialsMetaInput[ + Literal[ProviderName.MEM0], Literal["api_key"] + ] = CredentialsField(description="Mem0 API key credentials") + trigger: bool = SchemaField( + description="An unused field that is used to trigger the block when you have no other inputs", + default=False, + advanced=False, + ) + categories: Optional[list[str]] = SchemaField( + description="Filter by categories", default=None + ) + limit_memory_to_run: bool = SchemaField( + description="Limit the memory to the run", default=False + ) + limit_memory_to_agent: bool = SchemaField( + description="Limit the memory to the agent", default=False + ) + + class Output(BlockSchema): + memories: Any = SchemaField(description="List of memories") + error: str = SchemaField(description="Error message if operation fails") + + def __init__(self): + super().__init__( + id="45aee5bf-4767-45d1-a28b-e01c5aae9fc1", + description="Retrieve all memories from Mem0 with pagination", + input_schema=GetAllMemoriesBlock.Input, + output_schema=GetAllMemoriesBlock.Output, + test_input={ + "user_id": "test_user", + "credentials": TEST_CREDENTIALS_INPUT, + }, + test_output=[ + ("memories", [{"id": "test-memory", "content": "test content"}]), + ], + test_credentials=TEST_CREDENTIALS, + test_mock={"_get_client": lambda credentials: MockMemoryClient()}, + ) + + def run( + self, + input_data: Input, + *, + credentials: APIKeyCredentials, + user_id: str, + graph_id: str, + graph_exec_id: str, + **kwargs + ) -> BlockOutput: + try: + client = self._get_client(credentials) + + filters: Filter = { + "AND": [ + {"user_id": user_id}, + ] + } + if input_data.limit_memory_to_run: + filters["AND"].append({"run_id": graph_exec_id}) + if input_data.limit_memory_to_agent: + filters["AND"].append({"agent_id": graph_id}) + if input_data.categories: + filters["AND"].append( + {"categories": {"contains": input_data.categories}} + ) + + memories: list[dict[str, Any]] = client.get_all( + filters=filters, + version="v2", + ) + + yield "memories", memories + + except Exception as e: + yield "error", str(e) + + +# Mock client for testing +class MockMemoryClient: + """Mock Mem0 client for testing""" + + def add(self, *args, **kwargs): + return {"memory_id": "test-memory-id", "status": "success"} + + def search(self, *args, **kwargs) -> list[dict[str, str]]: + return [{"id": "test-memory", "content": "test content"}] + + def get_all(self, *args, **kwargs) -> list[dict[str, str]]: + return [{"id": "test-memory", "content": "test content"}] diff --git a/autogpt_platform/backend/backend/blocks/nvidia/_auth.py b/autogpt_platform/backend/backend/blocks/nvidia/_auth.py new file mode 100644 index 000000000000..46f28f009e0d --- /dev/null +++ b/autogpt_platform/backend/backend/blocks/nvidia/_auth.py @@ -0,0 +1,32 @@ +from typing import Literal + +from pydantic import SecretStr + +from backend.data.model import APIKeyCredentials, CredentialsField, CredentialsMetaInput +from backend.integrations.providers import ProviderName + +NvidiaCredentials = APIKeyCredentials +NvidiaCredentialsInput = CredentialsMetaInput[ + Literal[ProviderName.NVIDIA], + Literal["api_key"], +] + +TEST_CREDENTIALS = APIKeyCredentials( + id="01234567-89ab-cdef-0123-456789abcdef", + provider="nvidia", + api_key=SecretStr("mock-nvidia-api-key"), + title="Mock Nvidia API key", + expires_at=None, +) + +TEST_CREDENTIALS_INPUT = { + "provider": TEST_CREDENTIALS.provider, + "id": TEST_CREDENTIALS.id, + "type": TEST_CREDENTIALS.type, + "title": TEST_CREDENTIALS.title, +} + + +def NvidiaCredentialsField() -> NvidiaCredentialsInput: + """Creates an Nvidia credentials input on a block.""" + return CredentialsField(description="The Nvidia integration requires an API Key.") diff --git a/autogpt_platform/backend/backend/blocks/nvidia/deepfake.py b/autogpt_platform/backend/backend/blocks/nvidia/deepfake.py new file mode 100644 index 000000000000..a90bb0282679 --- /dev/null +++ b/autogpt_platform/backend/backend/blocks/nvidia/deepfake.py @@ -0,0 +1,90 @@ +from backend.blocks.nvidia._auth import ( + NvidiaCredentials, + NvidiaCredentialsField, + NvidiaCredentialsInput, +) +from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema +from backend.data.model import SchemaField +from backend.util.request import requests + + +class NvidiaDeepfakeDetectBlock(Block): + class Input(BlockSchema): + credentials: NvidiaCredentialsInput = NvidiaCredentialsField() + image_base64: str = SchemaField( + description="Image to analyze for deepfakes", image_upload=True + ) + return_image: bool = SchemaField( + description="Whether to return the processed image with markings", + default=False, + ) + + class Output(BlockSchema): + status: str = SchemaField( + description="Detection status (SUCCESS, ERROR, CONTENT_FILTERED)", + default="", + ) + image: str = SchemaField( + description="Processed image with detection markings (if return_image=True)", + default="", + image_output=True, + ) + is_deepfake: float = SchemaField( + description="Probability that the image is a deepfake (0-1)", + default=0.0, + ) + + def __init__(self): + super().__init__( + id="8c7d0d67-e79c-44f6-92a1-c2600c8aac7f", + description="Detects potential deepfakes in images using Nvidia's AI API", + categories={BlockCategory.SAFETY}, + input_schema=NvidiaDeepfakeDetectBlock.Input, + output_schema=NvidiaDeepfakeDetectBlock.Output, + ) + + def run( + self, input_data: Input, *, credentials: NvidiaCredentials, **kwargs + ) -> BlockOutput: + url = "https://ai.api.nvidia.com/v1/cv/hive/deepfake-image-detection" + + headers = { + "accept": "application/json", + "content-type": "application/json", + "Authorization": f"Bearer {credentials.api_key.get_secret_value()}", + } + + image_data = f"data:image/jpeg;base64,{input_data.image_base64}" + + payload = { + "input": [image_data], + "return_image": input_data.return_image, + } + + try: + response = requests.post(url, headers=headers, json=payload) + response.raise_for_status() + data = response.json() + + result = data.get("data", [{}])[0] + + # Get deepfake probability from first bounding box if any + deepfake_prob = 0.0 + if result.get("bounding_boxes"): + deepfake_prob = result["bounding_boxes"][0].get("is_deepfake", 0.0) + + yield "status", result.get("status", "ERROR") + yield "is_deepfake", deepfake_prob + + if input_data.return_image: + image_data = result.get("image", "") + output_data = f"data:image/jpeg;base64,{image_data}" + yield "image", output_data + else: + yield "image", "" + + except Exception as e: + yield "error", str(e) + yield "status", "ERROR" + yield "is_deepfake", 0.0 + yield "image", "" diff --git a/autogpt_platform/backend/backend/blocks/pinecone.py b/autogpt_platform/backend/backend/blocks/pinecone.py new file mode 100644 index 000000000000..adfbc2e33fcd --- /dev/null +++ b/autogpt_platform/backend/backend/blocks/pinecone.py @@ -0,0 +1,228 @@ +import uuid +from typing import Any, Literal + +from pinecone import Pinecone, ServerlessSpec + +from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema +from backend.data.model import ( + APIKeyCredentials, + CredentialsField, + CredentialsMetaInput, + SchemaField, +) +from backend.integrations.providers import ProviderName + +PineconeCredentials = APIKeyCredentials +PineconeCredentialsInput = CredentialsMetaInput[ + Literal[ProviderName.PINECONE], + Literal["api_key"], +] + + +def PineconeCredentialsField() -> PineconeCredentialsInput: + """Creates a Pinecone credentials input on a block.""" + return CredentialsField( + description="The Pinecone integration can be used with an API Key.", + ) + + +class PineconeInitBlock(Block): + class Input(BlockSchema): + credentials: PineconeCredentialsInput = PineconeCredentialsField() + index_name: str = SchemaField(description="Name of the Pinecone index") + dimension: int = SchemaField( + description="Dimension of the vectors", default=768 + ) + metric: str = SchemaField( + description="Distance metric for the index", default="cosine" + ) + cloud: str = SchemaField( + description="Cloud provider for serverless", default="aws" + ) + region: str = SchemaField( + description="Region for serverless", default="us-east-1" + ) + + class Output(BlockSchema): + index: str = SchemaField(description="Name of the initialized Pinecone index") + message: str = SchemaField(description="Status message") + + def __init__(self): + super().__init__( + id="48d8fdab-8f03-41f3-8407-8107ba11ec9b", + description="Initializes a Pinecone index", + categories={BlockCategory.LOGIC}, + input_schema=PineconeInitBlock.Input, + output_schema=PineconeInitBlock.Output, + ) + + def run( + self, input_data: Input, *, credentials: APIKeyCredentials, **kwargs + ) -> BlockOutput: + pc = Pinecone(api_key=credentials.api_key.get_secret_value()) + + try: + existing_indexes = pc.list_indexes() + if input_data.index_name not in [index.name for index in existing_indexes]: + pc.create_index( + name=input_data.index_name, + dimension=input_data.dimension, + metric=input_data.metric, + spec=ServerlessSpec( + cloud=input_data.cloud, region=input_data.region + ), + ) + message = f"Created new index: {input_data.index_name}" + else: + message = f"Using existing index: {input_data.index_name}" + + yield "index", input_data.index_name + yield "message", message + except Exception as e: + yield "message", f"Error initializing Pinecone index: {str(e)}" + + +class PineconeQueryBlock(Block): + class Input(BlockSchema): + credentials: PineconeCredentialsInput = PineconeCredentialsField() + query_vector: list = SchemaField(description="Query vector") + namespace: str = SchemaField( + description="Namespace to query in Pinecone", default="" + ) + top_k: int = SchemaField( + description="Number of top results to return", default=3 + ) + include_values: bool = SchemaField( + description="Whether to include vector values in the response", + default=False, + ) + include_metadata: bool = SchemaField( + description="Whether to include metadata in the response", default=True + ) + host: str = SchemaField(description="Host for pinecone", default="") + idx_name: str = SchemaField(description="Index name for pinecone") + + class Output(BlockSchema): + results: Any = SchemaField(description="Query results from Pinecone") + combined_results: Any = SchemaField( + description="Combined results from Pinecone" + ) + + def __init__(self): + super().__init__( + id="9ad93d0f-91b4-4c9c-8eb1-82e26b4a01c5", + description="Queries a Pinecone index", + categories={BlockCategory.LOGIC}, + input_schema=PineconeQueryBlock.Input, + output_schema=PineconeQueryBlock.Output, + ) + + def run( + self, + input_data: Input, + *, + credentials: APIKeyCredentials, + **kwargs, + ) -> BlockOutput: + try: + # Create a new client instance + pc = Pinecone(api_key=credentials.api_key.get_secret_value()) + + # Get the index + idx = pc.Index(input_data.idx_name) + + # Ensure query_vector is in correct format + query_vector = input_data.query_vector + if isinstance(query_vector, list) and len(query_vector) > 0: + if isinstance(query_vector[0], list): + query_vector = query_vector[0] + + results = idx.query( + namespace=input_data.namespace, + vector=query_vector, + top_k=input_data.top_k, + include_values=input_data.include_values, + include_metadata=input_data.include_metadata, + ).to_dict() # type: ignore + combined_text = "" + if results["matches"]: + texts = [ + match["metadata"]["text"] + for match in results["matches"] + if match.get("metadata", {}).get("text") + ] + combined_text = "\n\n".join(texts) + + # Return both the raw matches and combined text + yield "results", { + "matches": results["matches"], + "combined_text": combined_text, + } + yield "combined_results", combined_text + + except Exception as e: + error_msg = f"Error querying Pinecone: {str(e)}" + raise RuntimeError(error_msg) from e + + +class PineconeInsertBlock(Block): + class Input(BlockSchema): + credentials: PineconeCredentialsInput = PineconeCredentialsField() + index: str = SchemaField(description="Initialized Pinecone index") + chunks: list = SchemaField(description="List of text chunks to ingest") + embeddings: list = SchemaField( + description="List of embeddings corresponding to the chunks" + ) + namespace: str = SchemaField( + description="Namespace to use in Pinecone", default="" + ) + metadata: dict = SchemaField( + description="Additional metadata to store with each vector", default={} + ) + + class Output(BlockSchema): + upsert_response: str = SchemaField( + description="Response from Pinecone upsert operation" + ) + + def __init__(self): + super().__init__( + id="477f2168-cd91-475a-8146-9499a5982434", + description="Upload data to a Pinecone index", + categories={BlockCategory.LOGIC}, + input_schema=PineconeInsertBlock.Input, + output_schema=PineconeInsertBlock.Output, + ) + + def run( + self, + input_data: Input, + *, + credentials: APIKeyCredentials, + **kwargs, + ) -> BlockOutput: + try: + # Create a new client instance + pc = Pinecone(api_key=credentials.api_key.get_secret_value()) + + # Get the index + idx = pc.Index(input_data.index) + + vectors = [] + for chunk, embedding in zip(input_data.chunks, input_data.embeddings): + vector_metadata = input_data.metadata.copy() + vector_metadata["text"] = chunk + vectors.append( + { + "id": str(uuid.uuid4()), + "values": embedding, + "metadata": vector_metadata, + } + ) + idx.upsert(vectors=vectors, namespace=input_data.namespace) + + yield "upsert_response", "successfully upserted" + + except Exception as e: + error_msg = f"Error uploading to Pinecone: {str(e)}" + raise RuntimeError(error_msg) from e diff --git a/autogpt_platform/backend/backend/blocks/reddit.py b/autogpt_platform/backend/backend/blocks/reddit.py new file mode 100644 index 000000000000..b3dca4ca7477 --- /dev/null +++ b/autogpt_platform/backend/backend/blocks/reddit.py @@ -0,0 +1,213 @@ +from datetime import datetime, timezone +from typing import Iterator, Literal + +import praw +from pydantic import BaseModel, SecretStr + +from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema +from backend.data.model import ( + CredentialsField, + CredentialsMetaInput, + SchemaField, + UserPasswordCredentials, +) +from backend.integrations.providers import ProviderName +from backend.util.mock import MockObject +from backend.util.settings import Settings + +RedditCredentials = UserPasswordCredentials +RedditCredentialsInput = CredentialsMetaInput[ + Literal[ProviderName.REDDIT], + Literal["user_password"], +] + + +def RedditCredentialsField() -> RedditCredentialsInput: + """Creates a Reddit credentials input on a block.""" + return CredentialsField( + description="The Reddit integration requires a username and password.", + ) + + +TEST_CREDENTIALS = UserPasswordCredentials( + id="01234567-89ab-cdef-0123-456789abcdef", + provider="reddit", + username=SecretStr("mock-reddit-username"), + password=SecretStr("mock-reddit-password"), + title="Mock Reddit credentials", +) + +TEST_CREDENTIALS_INPUT = { + "provider": TEST_CREDENTIALS.provider, + "id": TEST_CREDENTIALS.id, + "type": TEST_CREDENTIALS.type, + "title": TEST_CREDENTIALS.title, +} + + +class RedditPost(BaseModel): + id: str + subreddit: str + title: str + body: str + + +class RedditComment(BaseModel): + post_id: str + comment: str + + +settings = Settings() + + +def get_praw(creds: RedditCredentials) -> praw.Reddit: + client = praw.Reddit( + client_id=settings.secrets.reddit_client_id, + client_secret=settings.secrets.reddit_client_secret, + username=creds.username.get_secret_value(), + password=creds.password.get_secret_value(), + user_agent=settings.config.reddit_user_agent, + ) + me = client.user.me() + if not me: + raise ValueError("Invalid Reddit credentials.") + print(f"Logged in as Reddit user: {me.name}") + return client + + +class GetRedditPostsBlock(Block): + class Input(BlockSchema): + subreddit: str = SchemaField( + description="Subreddit name, excluding the /r/ prefix", + default="writingprompts", + ) + credentials: RedditCredentialsInput = RedditCredentialsField() + last_minutes: int | None = SchemaField( + description="Post time to stop minutes ago while fetching posts", + default=None, + ) + last_post: str | None = SchemaField( + description="Post ID to stop when reached while fetching posts", + default=None, + ) + post_limit: int | None = SchemaField( + description="Number of posts to fetch", default=10 + ) + + class Output(BlockSchema): + post: RedditPost = SchemaField(description="Reddit post") + + def __init__(self): + super().__init__( + id="c6731acb-4285-4ee1-bc9b-03d0766c370f", + description="This block fetches Reddit posts from a defined subreddit name.", + categories={BlockCategory.SOCIAL}, + disabled=( + not settings.secrets.reddit_client_id + or not settings.secrets.reddit_client_secret + ), + input_schema=GetRedditPostsBlock.Input, + output_schema=GetRedditPostsBlock.Output, + test_credentials=TEST_CREDENTIALS, + test_input={ + "credentials": TEST_CREDENTIALS_INPUT, + "subreddit": "subreddit", + "last_post": "id3", + "post_limit": 2, + }, + test_output=[ + ( + "post", + RedditPost( + id="id1", subreddit="subreddit", title="title1", body="body1" + ), + ), + ( + "post", + RedditPost( + id="id2", subreddit="subreddit", title="title2", body="body2" + ), + ), + ], + test_mock={ + "get_posts": lambda input_data, credentials: [ + MockObject(id="id1", title="title1", selftext="body1"), + MockObject(id="id2", title="title2", selftext="body2"), + MockObject(id="id3", title="title2", selftext="body2"), + ] + }, + ) + + @staticmethod + def get_posts( + input_data: Input, *, credentials: RedditCredentials + ) -> Iterator[praw.reddit.Submission]: + client = get_praw(credentials) + subreddit = client.subreddit(input_data.subreddit) + return subreddit.new(limit=input_data.post_limit or 10) + + def run( + self, input_data: Input, *, credentials: RedditCredentials, **kwargs + ) -> BlockOutput: + current_time = datetime.now(tz=timezone.utc) + for post in self.get_posts(input_data=input_data, credentials=credentials): + if input_data.last_minutes: + post_datetime = datetime.fromtimestamp( + post.created_utc, tz=timezone.utc + ) + time_difference = current_time - post_datetime + if time_difference.total_seconds() / 60 > input_data.last_minutes: + continue + + if input_data.last_post and post.id == input_data.last_post: + break + + yield "post", RedditPost( + id=post.id, + subreddit=input_data.subreddit, + title=post.title, + body=post.selftext, + ) + + +class PostRedditCommentBlock(Block): + class Input(BlockSchema): + credentials: RedditCredentialsInput = RedditCredentialsField() + data: RedditComment = SchemaField(description="Reddit comment") + + class Output(BlockSchema): + comment_id: str = SchemaField(description="Posted comment ID") + + def __init__(self): + super().__init__( + id="4a92261b-701e-4ffb-8970-675fd28e261f", + description="This block posts a Reddit comment on a specified Reddit post.", + categories={BlockCategory.SOCIAL}, + input_schema=PostRedditCommentBlock.Input, + output_schema=PostRedditCommentBlock.Output, + disabled=( + not settings.secrets.reddit_client_id + or not settings.secrets.reddit_client_secret + ), + test_credentials=TEST_CREDENTIALS, + test_input={ + "credentials": TEST_CREDENTIALS_INPUT, + "data": {"post_id": "id", "comment": "comment"}, + }, + test_output=[("comment_id", "dummy_comment_id")], + test_mock={"reply_post": lambda creds, comment: "dummy_comment_id"}, + ) + + @staticmethod + def reply_post(creds: RedditCredentials, comment: RedditComment) -> str: + client = get_praw(creds) + submission = client.submission(id=comment.post_id) + new_comment = submission.reply(comment.comment) + if not new_comment: + raise ValueError("Failed to post comment.") + return new_comment.id + + def run( + self, input_data: Input, *, credentials: RedditCredentials, **kwargs + ) -> BlockOutput: + yield "comment_id", self.reply_post(credentials, input_data.data) diff --git a/autogpt_platform/backend/backend/blocks/replicate_flux_advanced.py b/autogpt_platform/backend/backend/blocks/replicate_flux_advanced.py new file mode 100644 index 000000000000..88094e9a1dec --- /dev/null +++ b/autogpt_platform/backend/backend/blocks/replicate_flux_advanced.py @@ -0,0 +1,237 @@ +import os +from enum import Enum +from typing import Literal + +import replicate +from pydantic import SecretStr +from replicate.helpers import FileOutput + +from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema +from backend.data.model import ( + APIKeyCredentials, + CredentialsField, + CredentialsMetaInput, + SchemaField, +) +from backend.integrations.providers import ProviderName + +TEST_CREDENTIALS = APIKeyCredentials( + id="01234567-89ab-cdef-0123-456789abcdef", + provider="replicate", + api_key=SecretStr("mock-replicate-api-key"), + title="Mock Replicate API key", + expires_at=None, +) +TEST_CREDENTIALS_INPUT = { + "provider": TEST_CREDENTIALS.provider, + "id": TEST_CREDENTIALS.id, + "type": TEST_CREDENTIALS.type, + "title": TEST_CREDENTIALS.type, +} + + +# Model name enum +class ReplicateFluxModelName(str, Enum): + FLUX_SCHNELL = ("Flux Schnell",) + FLUX_PRO = ("Flux Pro",) + FLUX_PRO1_1 = ("Flux Pro 1.1",) + + @property + def api_name(self): + api_names = { + ReplicateFluxModelName.FLUX_SCHNELL: "black-forest-labs/flux-schnell", + ReplicateFluxModelName.FLUX_PRO: "black-forest-labs/flux-pro", + ReplicateFluxModelName.FLUX_PRO1_1: "black-forest-labs/flux-1.1-pro", + } + return api_names[self] + + +# Image type Enum +class ImageType(str, Enum): + WEBP = "webp" + JPG = "jpg" + PNG = "png" + + +class ReplicateFluxAdvancedModelBlock(Block): + class Input(BlockSchema): + credentials: CredentialsMetaInput[ + Literal[ProviderName.REPLICATE], Literal["api_key"] + ] = CredentialsField( + description="The Replicate integration can be used with " + "any API key with sufficient permissions for the blocks it is used on.", + ) + prompt: str = SchemaField( + description="Text prompt for image generation", + placeholder="e.g., 'A futuristic cityscape at sunset'", + title="Prompt", + ) + replicate_model_name: ReplicateFluxModelName = SchemaField( + description="The name of the Image Generation Model, i.e Flux Schnell", + default=ReplicateFluxModelName.FLUX_SCHNELL, + title="Image Generation Model", + advanced=False, + ) + seed: int | None = SchemaField( + description="Random seed. Set for reproducible generation", + default=None, + title="Seed", + ) + steps: int = SchemaField( + description="Number of diffusion steps", + default=25, + title="Steps", + ) + guidance: float = SchemaField( + description=( + "Controls the balance between adherence to the text prompt and image quality/diversity. " + "Higher values make the output more closely match the prompt but may reduce overall image quality." + ), + default=3, + title="Guidance", + ) + interval: float = SchemaField( + description=( + "Interval is a setting that increases the variance in possible outputs. " + "Setting this value low will ensure strong prompt following with more consistent outputs." + ), + default=2, + title="Interval", + ) + aspect_ratio: str = SchemaField( + description="Aspect ratio for the generated image", + default="1:1", + title="Aspect Ratio", + placeholder="Choose from: 1:1, 16:9, 2:3, 3:2, 4:5, 5:4, 9:16", + ) + output_format: ImageType = SchemaField( + description="File format of the output image", + default=ImageType.WEBP, + title="Output Format", + ) + output_quality: int = SchemaField( + description=( + "Quality when saving the output images, from 0 to 100. " + "Not relevant for .png outputs" + ), + default=80, + title="Output Quality", + ) + safety_tolerance: int = SchemaField( + description="Safety tolerance, 1 is most strict and 5 is most permissive", + default=2, + title="Safety Tolerance", + ) + + class Output(BlockSchema): + result: str = SchemaField(description="Generated output") + error: str = SchemaField(description="Error message if the model run failed") + + def __init__(self): + super().__init__( + id="90f8c45e-e983-4644-aa0b-b4ebe2f531bc", + description="This block runs Flux models on Replicate with advanced settings.", + categories={BlockCategory.AI, BlockCategory.MULTIMEDIA}, + input_schema=ReplicateFluxAdvancedModelBlock.Input, + output_schema=ReplicateFluxAdvancedModelBlock.Output, + test_input={ + "credentials": TEST_CREDENTIALS_INPUT, + "replicate_model_name": ReplicateFluxModelName.FLUX_SCHNELL, + "prompt": "A beautiful landscape painting of a serene lake at sunrise", + "seed": None, + "steps": 25, + "guidance": 3.0, + "interval": 2.0, + "aspect_ratio": "1:1", + "output_format": ImageType.PNG, + "output_quality": 80, + "safety_tolerance": 2, + }, + test_output=[ + ( + "result", + "https://replicate.com/output/generated-image-url.jpg", + ), + ], + test_mock={ + "run_model": lambda api_key, model_name, prompt, seed, steps, guidance, interval, aspect_ratio, output_format, output_quality, safety_tolerance: "https://replicate.com/output/generated-image-url.jpg", + }, + test_credentials=TEST_CREDENTIALS, + ) + + def run( + self, input_data: Input, *, credentials: APIKeyCredentials, **kwargs + ) -> BlockOutput: + # If the seed is not provided, generate a random seed + seed = input_data.seed + if seed is None: + seed = int.from_bytes(os.urandom(4), "big") + + # Run the model using the provided inputs + result = self.run_model( + api_key=credentials.api_key, + model_name=input_data.replicate_model_name.api_name, + prompt=input_data.prompt, + seed=seed, + steps=input_data.steps, + guidance=input_data.guidance, + interval=input_data.interval, + aspect_ratio=input_data.aspect_ratio, + output_format=input_data.output_format, + output_quality=input_data.output_quality, + safety_tolerance=input_data.safety_tolerance, + ) + yield "result", result + + def run_model( + self, + api_key: SecretStr, + model_name, + prompt, + seed, + steps, + guidance, + interval, + aspect_ratio, + output_format, + output_quality, + safety_tolerance, + ): + # Initialize Replicate client with the API key + client = replicate.Client(api_token=api_key.get_secret_value()) + + # Run the model with additional parameters + output: FileOutput | list[FileOutput] = client.run( # type: ignore This is because they changed the return type, and didn't update the type hint! It should be overloaded depending on the value of `use_file_output` to `FileOutput | list[FileOutput]` but it's `Any | Iterator[Any]` + f"{model_name}", + input={ + "prompt": prompt, + "seed": seed, + "steps": steps, + "guidance": guidance, + "interval": interval, + "aspect_ratio": aspect_ratio, + "output_format": output_format, + "output_quality": output_quality, + "safety_tolerance": safety_tolerance, + }, + wait=False, # don't arbitrarily return data:octect/stream or sometimes url depending on the model???? what is this api + ) + + # Check if output is a list or a string and extract accordingly; otherwise, assign a default message + if isinstance(output, list) and len(output) > 0: + if isinstance(output[0], FileOutput): + result_url = output[0].url # If output is a list, get the first element + else: + result_url = output[ + 0 + ] # If output is a list and not a FileOutput, get the first element. Should never happen, but just in case. + elif isinstance(output, FileOutput): + result_url = output.url # If output is a FileOutput, use the url + elif isinstance(output, str): + result_url = output # If output is a string (for some reason due to their janky type hinting), use it directly + else: + result_url = ( + "No output received" # Fallback message if output is not as expected + ) + + return result_url diff --git a/autogpt_platform/backend/backend/blocks/rss.py b/autogpt_platform/backend/backend/blocks/rss.py new file mode 100644 index 000000000000..9a5a17ebeeda --- /dev/null +++ b/autogpt_platform/backend/backend/blocks/rss.py @@ -0,0 +1,116 @@ +import time +from datetime import datetime, timedelta, timezone +from typing import Any + +import feedparser +import pydantic + +from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema +from backend.data.model import SchemaField + + +class RSSEntry(pydantic.BaseModel): + title: str + link: str + description: str + pub_date: datetime + author: str + categories: list[str] + + +class ReadRSSFeedBlock(Block): + class Input(BlockSchema): + rss_url: str = SchemaField( + description="The URL of the RSS feed to read", + placeholder="https://example.com/rss", + ) + time_period: int = SchemaField( + description="The time period to check in minutes relative to the run block runtime, e.g. 60 would check for new entries in the last hour.", + placeholder="1440", + default=1440, + ) + polling_rate: int = SchemaField( + description="The number of seconds to wait between polling attempts.", + placeholder="300", + ) + run_continuously: bool = SchemaField( + description="Whether to run the block continuously or just once.", + default=True, + ) + + class Output(BlockSchema): + entry: RSSEntry = SchemaField(description="The RSS item") + + def __init__(self): + super().__init__( + id="5ebe6768-8e5d-41e3-9134-1c7bd89a8d52", + input_schema=ReadRSSFeedBlock.Input, + output_schema=ReadRSSFeedBlock.Output, + description="Reads RSS feed entries from a given URL.", + categories={BlockCategory.INPUT}, + test_input={ + "rss_url": "https://example.com/rss", + "time_period": 10_000_000, + "polling_rate": 1, + "run_continuously": False, + }, + test_output=[ + ( + "entry", + RSSEntry( + title="Example RSS Item", + link="https://example.com/article", + description="This is an example RSS item description.", + pub_date=datetime(2023, 6, 23, 12, 30, 0, tzinfo=timezone.utc), + author="John Doe", + categories=["Technology", "News"], + ), + ), + ], + test_mock={ + "parse_feed": lambda *args, **kwargs: { + "entries": [ + { + "title": "Example RSS Item", + "link": "https://example.com/article", + "summary": "This is an example RSS item description.", + "published_parsed": (2023, 6, 23, 12, 30, 0, 4, 174, 0), + "author": "John Doe", + "tags": [{"term": "Technology"}, {"term": "News"}], + } + ] + } + }, + ) + + @staticmethod + def parse_feed(url: str) -> dict[str, Any]: + return feedparser.parse(url) # type: ignore + + def run(self, input_data: Input, **kwargs) -> BlockOutput: + keep_going = True + start_time = datetime.now(timezone.utc) - timedelta( + minutes=input_data.time_period + ) + while keep_going: + keep_going = input_data.run_continuously + + feed = self.parse_feed(input_data.rss_url) + + for entry in feed["entries"]: + pub_date = datetime(*entry["published_parsed"][:6], tzinfo=timezone.utc) + + if pub_date > start_time: + yield ( + "entry", + RSSEntry( + title=entry["title"], + link=entry["link"], + description=entry.get("summary", ""), + pub_date=pub_date, + author=entry.get("author", ""), + categories=[tag["term"] for tag in entry.get("tags", [])], + ), + ) + + time.sleep(input_data.polling_rate) diff --git a/autogpt_platform/backend/backend/blocks/sampling.py b/autogpt_platform/backend/backend/blocks/sampling.py new file mode 100644 index 000000000000..d2257db06f68 --- /dev/null +++ b/autogpt_platform/backend/backend/blocks/sampling.py @@ -0,0 +1,264 @@ +import random +from collections import defaultdict +from enum import Enum +from typing import Any, Dict, List, Optional, Union + +from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema +from backend.data.model import SchemaField + + +class SamplingMethod(str, Enum): + RANDOM = "random" + SYSTEMATIC = "systematic" + TOP = "top" + BOTTOM = "bottom" + STRATIFIED = "stratified" + WEIGHTED = "weighted" + RESERVOIR = "reservoir" + CLUSTER = "cluster" + + +class DataSamplingBlock(Block): + class Input(BlockSchema): + data: Union[Dict[str, Any], List[Union[dict, List[Any]]]] = SchemaField( + description="The dataset to sample from. Can be a single dictionary, a list of dictionaries, or a list of lists.", + placeholder="{'id': 1, 'value': 'a'} or [{'id': 1, 'value': 'a'}, {'id': 2, 'value': 'b'}, ...]", + ) + sample_size: int = SchemaField( + description="The number of samples to take from the dataset.", + placeholder="10", + default=10, + ) + sampling_method: SamplingMethod = SchemaField( + description="The method to use for sampling.", + default=SamplingMethod.RANDOM, + ) + accumulate: bool = SchemaField( + description="Whether to accumulate data before sampling.", + default=False, + ) + random_seed: Optional[int] = SchemaField( + description="Seed for random number generator (optional).", + default=None, + ) + stratify_key: Optional[str] = SchemaField( + description="Key to use for stratified sampling (required for stratified sampling).", + default=None, + ) + weight_key: Optional[str] = SchemaField( + description="Key to use for weighted sampling (required for weighted sampling).", + default=None, + ) + cluster_key: Optional[str] = SchemaField( + description="Key to use for cluster sampling (required for cluster sampling).", + default=None, + ) + + class Output(BlockSchema): + sampled_data: List[Union[dict, List[Any]]] = SchemaField( + description="The sampled subset of the input data." + ) + sample_indices: List[int] = SchemaField( + description="The indices of the sampled data in the original dataset." + ) + + def __init__(self): + super().__init__( + id="4a448883-71fa-49cf-91cf-70d793bd7d87", + description="This block samples data from a given dataset using various sampling methods.", + categories={BlockCategory.LOGIC}, + input_schema=DataSamplingBlock.Input, + output_schema=DataSamplingBlock.Output, + test_input={ + "data": [ + {"id": i, "value": chr(97 + i), "group": i % 3} for i in range(10) + ], + "sample_size": 3, + "sampling_method": SamplingMethod.STRATIFIED, + "accumulate": False, + "random_seed": 42, + "stratify_key": "group", + }, + test_output=[ + ( + "sampled_data", + [ + {"id": 0, "value": "a", "group": 0}, + {"id": 1, "value": "b", "group": 1}, + {"id": 8, "value": "i", "group": 2}, + ], + ), + ("sample_indices", [0, 1, 8]), + ], + ) + self.accumulated_data = [] + + def run(self, input_data: Input, **kwargs) -> BlockOutput: + if input_data.accumulate: + if isinstance(input_data.data, dict): + self.accumulated_data.append(input_data.data) + elif isinstance(input_data.data, list): + self.accumulated_data.extend(input_data.data) + else: + raise ValueError(f"Unsupported data type: {type(input_data.data)}") + + # If we don't have enough data yet, return without sampling + if len(self.accumulated_data) < input_data.sample_size: + return + + data_to_sample = self.accumulated_data + else: + # If not accumulating, use the input data directly + data_to_sample = ( + input_data.data + if isinstance(input_data.data, list) + else [input_data.data] + ) + + if input_data.random_seed is not None: + random.seed(input_data.random_seed) + + data_size = len(data_to_sample) + + if input_data.sample_size > data_size: + raise ValueError( + f"Sample size ({input_data.sample_size}) cannot be larger than the dataset size ({data_size})." + ) + + indices = [] + + if input_data.sampling_method == SamplingMethod.RANDOM: + indices = random.sample(range(data_size), input_data.sample_size) + elif input_data.sampling_method == SamplingMethod.SYSTEMATIC: + step = data_size // input_data.sample_size + start = random.randint(0, step - 1) + indices = list(range(start, data_size, step))[: input_data.sample_size] + elif input_data.sampling_method == SamplingMethod.TOP: + indices = list(range(input_data.sample_size)) + elif input_data.sampling_method == SamplingMethod.BOTTOM: + indices = list(range(data_size - input_data.sample_size, data_size)) + elif input_data.sampling_method == SamplingMethod.STRATIFIED: + if not input_data.stratify_key: + raise ValueError( + "Stratify key must be provided for stratified sampling." + ) + strata = defaultdict(list) + for i, item in enumerate(data_to_sample): + if isinstance(item, dict): + strata_value = item.get(input_data.stratify_key) + elif hasattr(item, input_data.stratify_key): + strata_value = getattr(item, input_data.stratify_key) + else: + raise ValueError( + f"Stratify key '{input_data.stratify_key}' not found in item {item}" + ) + + if strata_value is None: + raise ValueError( + f"Stratify value for key '{input_data.stratify_key}' is None" + ) + + strata[str(strata_value)].append(i) + + # Calculate the number of samples to take from each stratum + stratum_sizes = { + k: max(1, int(len(v) / data_size * input_data.sample_size)) + for k, v in strata.items() + } + + # Adjust sizes to ensure we get exactly sample_size samples + while sum(stratum_sizes.values()) != input_data.sample_size: + if sum(stratum_sizes.values()) < input_data.sample_size: + stratum_sizes[ + max(stratum_sizes, key=lambda k: stratum_sizes[k]) + ] += 1 + else: + stratum_sizes[ + max(stratum_sizes, key=lambda k: stratum_sizes[k]) + ] -= 1 + + for stratum, size in stratum_sizes.items(): + indices.extend(random.sample(strata[stratum], size)) + elif input_data.sampling_method == SamplingMethod.WEIGHTED: + if not input_data.weight_key: + raise ValueError("Weight key must be provided for weighted sampling.") + weights = [] + for item in data_to_sample: + if isinstance(item, dict): + weight = item.get(input_data.weight_key) + elif hasattr(item, input_data.weight_key): + weight = getattr(item, input_data.weight_key) + else: + raise ValueError( + f"Weight key '{input_data.weight_key}' not found in item {item}" + ) + + if weight is None: + raise ValueError( + f"Weight value for key '{input_data.weight_key}' is None" + ) + try: + weights.append(float(weight)) + except ValueError: + raise ValueError( + f"Weight value '{weight}' cannot be converted to a number" + ) + + if not weights: + raise ValueError( + f"No valid weights found using key '{input_data.weight_key}'" + ) + + indices = random.choices( + range(data_size), weights=weights, k=input_data.sample_size + ) + elif input_data.sampling_method == SamplingMethod.RESERVOIR: + indices = list(range(input_data.sample_size)) + for i in range(input_data.sample_size, data_size): + j = random.randint(0, i) + if j < input_data.sample_size: + indices[j] = i + elif input_data.sampling_method == SamplingMethod.CLUSTER: + if not input_data.cluster_key: + raise ValueError("Cluster key must be provided for cluster sampling.") + clusters = defaultdict(list) + for i, item in enumerate(data_to_sample): + if isinstance(item, dict): + cluster_value = item.get(input_data.cluster_key) + elif hasattr(item, input_data.cluster_key): + cluster_value = getattr(item, input_data.cluster_key) + else: + raise TypeError( + f"Item {item} does not have the cluster key '{input_data.cluster_key}'" + ) + + clusters[str(cluster_value)].append(i) + + # Randomly select clusters until we have enough samples + selected_clusters = [] + while ( + sum(len(clusters[c]) for c in selected_clusters) + < input_data.sample_size + ): + available_clusters = [c for c in clusters if c not in selected_clusters] + if not available_clusters: + break + selected_clusters.append(random.choice(available_clusters)) + + for cluster in selected_clusters: + indices.extend(clusters[cluster]) + + # If we have more samples than needed, randomly remove some + if len(indices) > input_data.sample_size: + indices = random.sample(indices, input_data.sample_size) + else: + raise ValueError(f"Unknown sampling method: {input_data.sampling_method}") + + sampled_data = [data_to_sample[i] for i in indices] + + # Clear accumulated data after sampling if accumulation is enabled + if input_data.accumulate: + self.accumulated_data = [] + + yield "sampled_data", sampled_data + yield "sample_indices", indices diff --git a/autogpt_platform/backend/backend/blocks/search.py b/autogpt_platform/backend/backend/blocks/search.py new file mode 100644 index 000000000000..633ad3109113 --- /dev/null +++ b/autogpt_platform/backend/backend/blocks/search.py @@ -0,0 +1,130 @@ +from typing import Literal +from urllib.parse import quote + +from pydantic import SecretStr + +from backend.blocks.helpers.http import GetRequest +from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema +from backend.data.model import ( + APIKeyCredentials, + CredentialsField, + CredentialsMetaInput, + SchemaField, +) +from backend.integrations.providers import ProviderName + + +class GetWikipediaSummaryBlock(Block, GetRequest): + class Input(BlockSchema): + topic: str = SchemaField(description="The topic to fetch the summary for") + + class Output(BlockSchema): + summary: str = SchemaField(description="The summary of the given topic") + error: str = SchemaField( + description="Error message if the summary cannot be retrieved" + ) + + def __init__(self): + super().__init__( + id="f5b0f5d0-1862-4d61-94be-3ad0fa772760", + description="This block fetches the summary of a given topic from Wikipedia.", + categories={BlockCategory.SEARCH}, + input_schema=GetWikipediaSummaryBlock.Input, + output_schema=GetWikipediaSummaryBlock.Output, + test_input={"topic": "Artificial Intelligence"}, + test_output=("summary", "summary content"), + test_mock={"get_request": lambda url, json: {"extract": "summary content"}}, + ) + + def run(self, input_data: Input, **kwargs) -> BlockOutput: + topic = input_data.topic + url = f"https://en.wikipedia.org/api/rest_v1/page/summary/{topic}" + response = self.get_request(url, json=True) + if "extract" not in response: + raise RuntimeError(f"Unable to parse Wikipedia response: {response}") + yield "summary", response["extract"] + + +TEST_CREDENTIALS = APIKeyCredentials( + id="01234567-89ab-cdef-0123-456789abcdef", + provider="openweathermap", + api_key=SecretStr("mock-openweathermap-api-key"), + title="Mock OpenWeatherMap API key", + expires_at=None, +) +TEST_CREDENTIALS_INPUT = { + "provider": TEST_CREDENTIALS.provider, + "id": TEST_CREDENTIALS.id, + "type": TEST_CREDENTIALS.type, + "title": TEST_CREDENTIALS.type, +} + + +class GetWeatherInformationBlock(Block, GetRequest): + class Input(BlockSchema): + location: str = SchemaField( + description="Location to get weather information for" + ) + credentials: CredentialsMetaInput[ + Literal[ProviderName.OPENWEATHERMAP], Literal["api_key"] + ] = CredentialsField( + description="The OpenWeatherMap integration can be used with " + "any API key with sufficient permissions for the blocks it is used on.", + ) + use_celsius: bool = SchemaField( + default=True, + description="Whether to use Celsius or Fahrenheit for temperature", + ) + + class Output(BlockSchema): + temperature: str = SchemaField( + description="Temperature in the specified location" + ) + humidity: str = SchemaField(description="Humidity in the specified location") + condition: str = SchemaField( + description="Weather condition in the specified location" + ) + error: str = SchemaField( + description="Error message if the weather information cannot be retrieved" + ) + + def __init__(self): + super().__init__( + id="f7a8b2c3-6d4e-5f8b-9e7f-6d4e5f8b9e7f", + input_schema=GetWeatherInformationBlock.Input, + output_schema=GetWeatherInformationBlock.Output, + description="Retrieves weather information for a specified location using OpenWeatherMap API.", + test_input={ + "location": "New York", + "use_celsius": True, + "credentials": TEST_CREDENTIALS_INPUT, + }, + test_output=[ + ("temperature", "21.66"), + ("humidity", "32"), + ("condition", "overcast clouds"), + ], + test_mock={ + "get_request": lambda url, json: { + "main": {"temp": 21.66, "humidity": 32}, + "weather": [{"description": "overcast clouds"}], + } + }, + test_credentials=TEST_CREDENTIALS, + ) + + def run( + self, input_data: Input, *, credentials: APIKeyCredentials, **kwargs + ) -> BlockOutput: + units = "metric" if input_data.use_celsius else "imperial" + api_key = credentials.api_key + location = input_data.location + url = f"http://api.openweathermap.org/data/2.5/weather?q={quote(location)}&appid={api_key}&units={units}" + weather_data = self.get_request(url, json=True) + + if "main" in weather_data and "weather" in weather_data: + yield "temperature", str(weather_data["main"]["temp"]) + yield "humidity", str(weather_data["main"]["humidity"]) + yield "condition", weather_data["weather"][0]["description"] + else: + raise RuntimeError(f"Expected keys not found in response: {weather_data}") diff --git a/autogpt_platform/backend/backend/blocks/slant3d/_api.py b/autogpt_platform/backend/backend/blocks/slant3d/_api.py new file mode 100644 index 000000000000..d952662e781d --- /dev/null +++ b/autogpt_platform/backend/backend/blocks/slant3d/_api.py @@ -0,0 +1,70 @@ +from enum import Enum +from typing import Literal + +from pydantic import BaseModel, SecretStr + +from backend.data.model import APIKeyCredentials, CredentialsField, CredentialsMetaInput +from backend.integrations.providers import ProviderName + +Slant3DCredentialsInput = CredentialsMetaInput[ + Literal[ProviderName.SLANT3D], Literal["api_key"] +] + + +def Slant3DCredentialsField() -> Slant3DCredentialsInput: + return CredentialsField(description="Slant3D API key for authentication") + + +TEST_CREDENTIALS = APIKeyCredentials( + id="01234567-89ab-cdef-0123-456789abcdef", + provider="slant3d", + api_key=SecretStr("mock-slant3d-api-key"), + title="Mock Slant3D API key", + expires_at=None, +) + +TEST_CREDENTIALS_INPUT = { + "provider": TEST_CREDENTIALS.provider, + "id": TEST_CREDENTIALS.id, + "type": TEST_CREDENTIALS.type, + "title": TEST_CREDENTIALS.title, +} + + +class CustomerDetails(BaseModel): + name: str + email: str + phone: str + address: str + city: str + state: str + zip: str + country_iso: str = "US" + is_residential: bool = True + + +class Color(Enum): + WHITE = "white" + BLACK = "black" + + +class Profile(Enum): + PLA = "PLA" + PETG = "PETG" + + +class OrderItem(BaseModel): + # filename: str + file_url: str + quantity: str # String as per API spec + color: Color = Color.WHITE + profile: Profile = Profile.PLA + # image_url: str = "" + # sku: str = "" + + +class Filament(BaseModel): + filament: str + hexColor: str + colorTag: str + profile: str diff --git a/autogpt_platform/backend/backend/blocks/slant3d/base.py b/autogpt_platform/backend/backend/blocks/slant3d/base.py new file mode 100644 index 000000000000..d5d1681e1d43 --- /dev/null +++ b/autogpt_platform/backend/backend/blocks/slant3d/base.py @@ -0,0 +1,94 @@ +from typing import Any, Dict + +from backend.data.block import Block +from backend.util.request import requests + +from ._api import Color, CustomerDetails, OrderItem, Profile + + +class Slant3DBlockBase(Block): + """Base block class for Slant3D API interactions""" + + BASE_URL = "https://www.slant3dapi.com/api" + + def _get_headers(self, api_key: str) -> Dict[str, str]: + return {"api-key": api_key, "Content-Type": "application/json"} + + def _make_request(self, method: str, endpoint: str, api_key: str, **kwargs) -> Dict: + url = f"{self.BASE_URL}/{endpoint}" + response = requests.request( + method=method, url=url, headers=self._get_headers(api_key), **kwargs + ) + + if not response.ok: + error_msg = response.json().get("error", "Unknown error") + raise RuntimeError(f"API request failed: {error_msg}") + + return response.json() + + def _check_valid_color(self, profile: Profile, color: Color, api_key: str) -> str: + response = self._make_request( + "GET", + "filament", + api_key, + params={"profile": profile.value, "color": color.value}, + ) + if profile == Profile.PLA: + color_tag = color.value + else: + color_tag = f"{profile.value.lower()}{color.value.capitalize()}" + valid_tags = [filament["colorTag"] for filament in response["filaments"]] + + if color_tag not in valid_tags: + raise ValueError( + f"""Invalid color profile combination {color_tag}. +Valid colors for {profile.value} are: +{','.join([filament['colorTag'].replace(profile.value.lower(), '') for filament in response['filaments'] if filament['profile'] == profile.value])} +""" + ) + return color_tag + + def _convert_to_color(self, profile: Profile, color: Color, api_key: str) -> str: + return self._check_valid_color(profile, color, api_key) + + def _format_order_data( + self, + customer: CustomerDetails, + order_number: str, + items: list[OrderItem], + api_key: str, + ) -> list[dict[str, Any]]: + """Helper function to format order data for API requests""" + orders = [] + for item in items: + order_data = { + "email": customer.email, + "phone": customer.phone, + "name": customer.name, + "orderNumber": order_number, + "filename": item.file_url, + "fileURL": item.file_url, + "bill_to_street_1": customer.address, + "bill_to_city": customer.city, + "bill_to_state": customer.state, + "bill_to_zip": customer.zip, + "bill_to_country_as_iso": customer.country_iso, + "bill_to_is_US_residential": str(customer.is_residential).lower(), + "ship_to_name": customer.name, + "ship_to_street_1": customer.address, + "ship_to_city": customer.city, + "ship_to_state": customer.state, + "ship_to_zip": customer.zip, + "ship_to_country_as_iso": customer.country_iso, + "ship_to_is_US_residential": str(customer.is_residential).lower(), + "order_item_name": item.file_url, + "order_quantity": item.quantity, + "order_image_url": "", + "order_sku": "NOT_USED", + "order_item_color": self._convert_to_color( + item.profile, item.color, api_key + ), + "profile": item.profile.value, + } + orders.append(order_data) + return orders diff --git a/autogpt_platform/backend/backend/blocks/slant3d/filament.py b/autogpt_platform/backend/backend/blocks/slant3d/filament.py new file mode 100644 index 000000000000..c232c2ba8da1 --- /dev/null +++ b/autogpt_platform/backend/backend/blocks/slant3d/filament.py @@ -0,0 +1,85 @@ +from typing import List + +from backend.data.block import BlockOutput, BlockSchema +from backend.data.model import APIKeyCredentials, SchemaField + +from ._api import ( + TEST_CREDENTIALS, + TEST_CREDENTIALS_INPUT, + Filament, + Slant3DCredentialsField, + Slant3DCredentialsInput, +) +from .base import Slant3DBlockBase + + +class Slant3DFilamentBlock(Slant3DBlockBase): + """Block for retrieving available filaments""" + + class Input(BlockSchema): + credentials: Slant3DCredentialsInput = Slant3DCredentialsField() + + class Output(BlockSchema): + filaments: List[Filament] = SchemaField( + description="List of available filaments" + ) + error: str = SchemaField(description="Error message if request failed") + + def __init__(self): + super().__init__( + id="7cc416f4-f305-4606-9b3b-452b8a81031c", + description="Get list of available filaments", + input_schema=self.Input, + output_schema=self.Output, + test_input={"credentials": TEST_CREDENTIALS_INPUT}, + test_credentials=TEST_CREDENTIALS, + test_output=[ + ( + "filaments", + [ + { + "filament": "PLA BLACK", + "hexColor": "000000", + "colorTag": "black", + "profile": "PLA", + }, + { + "filament": "PLA WHITE", + "hexColor": "ffffff", + "colorTag": "white", + "profile": "PLA", + }, + ], + ) + ], + test_mock={ + "_make_request": lambda *args, **kwargs: { + "filaments": [ + { + "filament": "PLA BLACK", + "hexColor": "000000", + "colorTag": "black", + "profile": "PLA", + }, + { + "filament": "PLA WHITE", + "hexColor": "ffffff", + "colorTag": "white", + "profile": "PLA", + }, + ] + } + }, + ) + + def run( + self, input_data: Input, *, credentials: APIKeyCredentials, **kwargs + ) -> BlockOutput: + try: + result = self._make_request( + "GET", "filament", credentials.api_key.get_secret_value() + ) + yield "filaments", result["filaments"] + except Exception as e: + yield "error", str(e) + raise diff --git a/autogpt_platform/backend/backend/blocks/slant3d/order.py b/autogpt_platform/backend/backend/blocks/slant3d/order.py new file mode 100644 index 000000000000..a1a342a98e0b --- /dev/null +++ b/autogpt_platform/backend/backend/blocks/slant3d/order.py @@ -0,0 +1,418 @@ +import uuid +from typing import List + +import requests as baserequests + +from backend.data.block import BlockOutput, BlockSchema +from backend.data.model import APIKeyCredentials, SchemaField +from backend.util import settings +from backend.util.settings import BehaveAs + +from ._api import ( + TEST_CREDENTIALS, + TEST_CREDENTIALS_INPUT, + CustomerDetails, + OrderItem, + Slant3DCredentialsField, + Slant3DCredentialsInput, +) +from .base import Slant3DBlockBase + + +class Slant3DCreateOrderBlock(Slant3DBlockBase): + """Block for creating new orders""" + + class Input(BlockSchema): + credentials: Slant3DCredentialsInput = Slant3DCredentialsField() + order_number: str = SchemaField( + description="Your custom order number (or leave blank for a random one)", + default_factory=lambda: str(uuid.uuid4()), + ) + customer: CustomerDetails = SchemaField( + description="Customer details for where to ship the item", + advanced=False, + ) + items: List[OrderItem] = SchemaField( + description="List of items to print", + advanced=False, + ) + + class Output(BlockSchema): + order_id: str = SchemaField(description="Slant3D order ID") + error: str = SchemaField(description="Error message if order failed") + + def __init__(self): + super().__init__( + id="f73007d6-f48f-4aaf-9e6b-6883998a09b4", + description="Create a new print order", + input_schema=self.Input, + output_schema=self.Output, + test_input={ + "credentials": TEST_CREDENTIALS_INPUT, + "order_number": "TEST-001", + "customer": { + "name": "John Doe", + "email": "john@example.com", + "phone": "123-456-7890", + "address": "123 Test St", + "city": "Test City", + "state": "TS", + "zip": "12345", + }, + "items": [ + { + "file_url": "https://example.com/model.stl", + "quantity": "1", + "color": "black", + "profile": "PLA", + } + ], + }, + test_credentials=TEST_CREDENTIALS, + test_output=[("order_id", "314144241")], + test_mock={ + "_make_request": lambda *args, **kwargs: {"orderId": "314144241"}, + "_convert_to_color": lambda *args, **kwargs: "black", + }, + ) + + def run( + self, input_data: Input, *, credentials: APIKeyCredentials, **kwargs + ) -> BlockOutput: + try: + order_data = self._format_order_data( + input_data.customer, + input_data.order_number, + input_data.items, + credentials.api_key.get_secret_value(), + ) + result = self._make_request( + "POST", "order", credentials.api_key.get_secret_value(), json=order_data + ) + yield "order_id", result["orderId"] + except Exception as e: + yield "error", str(e) + raise + + +class Slant3DEstimateOrderBlock(Slant3DBlockBase): + """Block for getting order cost estimates""" + + class Input(BlockSchema): + credentials: Slant3DCredentialsInput = Slant3DCredentialsField() + order_number: str = SchemaField( + description="Your custom order number (or leave blank for a random one)", + default_factory=lambda: str(uuid.uuid4()), + ) + customer: CustomerDetails = SchemaField( + description="Customer details for where to ship the item", + advanced=False, + ) + items: List[OrderItem] = SchemaField( + description="List of items to print", + advanced=False, + ) + + class Output(BlockSchema): + total_price: float = SchemaField(description="Total price in USD") + shipping_cost: float = SchemaField(description="Shipping cost") + printing_cost: float = SchemaField(description="Printing cost") + error: str = SchemaField(description="Error message if estimation failed") + + def __init__(self): + super().__init__( + id="bf8823d6-b42a-48c7-b558-d7c117f2ae85", + description="Get order cost estimate", + input_schema=self.Input, + output_schema=self.Output, + test_input={ + "credentials": TEST_CREDENTIALS_INPUT, + "order_number": "TEST-001", + "customer": { + "name": "John Doe", + "email": "john@example.com", + "phone": "123-456-7890", + "address": "123 Test St", + "city": "Test City", + "state": "TS", + "zip": "12345", + }, + "items": [ + { + "file_url": "https://example.com/model.stl", + "quantity": "1", + "color": "black", + "profile": "PLA", + } + ], + }, + test_credentials=TEST_CREDENTIALS, + test_output=[ + ("total_price", 9.31), + ("shipping_cost", 5.56), + ("printing_cost", 3.75), + ], + test_mock={ + "_make_request": lambda *args, **kwargs: { + "totalPrice": 9.31, + "shippingCost": 5.56, + "printingCost": 3.75, + }, + "_convert_to_color": lambda *args, **kwargs: "black", + }, + ) + + def run( + self, input_data: Input, *, credentials: APIKeyCredentials, **kwargs + ) -> BlockOutput: + order_data = self._format_order_data( + input_data.customer, + input_data.order_number, + input_data.items, + credentials.api_key.get_secret_value(), + ) + try: + result = self._make_request( + "POST", + "order/estimate", + credentials.api_key.get_secret_value(), + json=order_data, + ) + yield "total_price", result["totalPrice"] + yield "shipping_cost", result["shippingCost"] + yield "printing_cost", result["printingCost"] + except baserequests.HTTPError as e: + yield "error", str(f"Error estimating order: {e} {e.response.text}") + raise + + +class Slant3DEstimateShippingBlock(Slant3DBlockBase): + """Block for getting shipping cost estimates""" + + class Input(BlockSchema): + credentials: Slant3DCredentialsInput = Slant3DCredentialsField() + order_number: str = SchemaField( + description="Your custom order number (or leave blank for a random one)", + default_factory=lambda: str(uuid.uuid4()), + ) + customer: CustomerDetails = SchemaField( + description="Customer details for where to ship the item" + ) + items: List[OrderItem] = SchemaField( + description="List of items to print", + advanced=False, + ) + + class Output(BlockSchema): + shipping_cost: float = SchemaField(description="Estimated shipping cost") + currency_code: str = SchemaField(description="Currency code (e.g., 'usd')") + error: str = SchemaField(description="Error message if estimation failed") + + def __init__(self): + super().__init__( + id="00aae2a1-caf6-4a74-8175-39a0615d44e1", + description="Get shipping cost estimate", + input_schema=self.Input, + output_schema=self.Output, + test_input={ + "credentials": TEST_CREDENTIALS_INPUT, + "order_number": "TEST-001", + "customer": { + "name": "John Doe", + "email": "john@example.com", + "phone": "123-456-7890", + "address": "123 Test St", + "city": "Test City", + "state": "TS", + "zip": "12345", + }, + "items": [ + { + "file_url": "https://example.com/model.stl", + "quantity": "1", + "color": "black", + "profile": "PLA", + } + ], + }, + test_credentials=TEST_CREDENTIALS, + test_output=[("shipping_cost", 4.81), ("currency_code", "usd")], + test_mock={ + "_make_request": lambda *args, **kwargs: { + "shippingCost": 4.81, + "currencyCode": "usd", + }, + "_convert_to_color": lambda *args, **kwargs: "black", + }, + ) + + def run( + self, input_data: Input, *, credentials: APIKeyCredentials, **kwargs + ) -> BlockOutput: + try: + order_data = self._format_order_data( + input_data.customer, + input_data.order_number, + input_data.items, + credentials.api_key.get_secret_value(), + ) + result = self._make_request( + "POST", + "order/estimateShipping", + credentials.api_key.get_secret_value(), + json=order_data, + ) + yield "shipping_cost", result["shippingCost"] + yield "currency_code", result["currencyCode"] + except Exception as e: + yield "error", str(e) + raise + + +class Slant3DGetOrdersBlock(Slant3DBlockBase): + """Block for retrieving all orders""" + + class Input(BlockSchema): + credentials: Slant3DCredentialsInput = Slant3DCredentialsField() + + class Output(BlockSchema): + orders: List[str] = SchemaField(description="List of orders with their details") + error: str = SchemaField(description="Error message if request failed") + + def __init__(self): + super().__init__( + id="42283bf5-8a32-4fb4-92a2-60a9ea48e105", + description="Get all orders for the account", + input_schema=self.Input, + output_schema=self.Output, + # This block is disabled for cloud hosted because it allows access to all orders for the account + disabled=settings.Settings().config.behave_as == BehaveAs.CLOUD, + test_input={"credentials": TEST_CREDENTIALS_INPUT}, + test_credentials=TEST_CREDENTIALS, + test_output=[ + ( + "orders", + [ + "1234567890", + ], + ) + ], + test_mock={ + "_make_request": lambda *args, **kwargs: { + "ordersData": [ + { + "orderId": 1234567890, + "orderTimestamp": { + "_seconds": 1719510986, + "_nanoseconds": 710000000, + }, + } + ] + } + }, + ) + + def run( + self, input_data: Input, *, credentials: APIKeyCredentials, **kwargs + ) -> BlockOutput: + try: + result = self._make_request( + "GET", "order", credentials.api_key.get_secret_value() + ) + yield "orders", [str(order["orderId"]) for order in result["ordersData"]] + except Exception as e: + yield "error", str(e) + raise + + +class Slant3DTrackingBlock(Slant3DBlockBase): + """Block for tracking order status and shipping""" + + class Input(BlockSchema): + credentials: Slant3DCredentialsInput = Slant3DCredentialsField() + order_id: str = SchemaField(description="Slant3D order ID to track") + + class Output(BlockSchema): + status: str = SchemaField(description="Order status") + tracking_numbers: List[str] = SchemaField( + description="List of tracking numbers" + ) + error: str = SchemaField(description="Error message if tracking failed") + + def __init__(self): + super().__init__( + id="dd7c0293-c5af-4551-ba3e-fc162fb1fb89", + description="Track order status and shipping", + input_schema=self.Input, + output_schema=self.Output, + test_input={ + "credentials": TEST_CREDENTIALS_INPUT, + "order_id": "314144241", + }, + test_credentials=TEST_CREDENTIALS, + test_output=[("status", "awaiting_shipment"), ("tracking_numbers", [])], + test_mock={ + "_make_request": lambda *args, **kwargs: { + "status": "awaiting_shipment", + "trackingNumbers": [], + } + }, + ) + + def run( + self, input_data: Input, *, credentials: APIKeyCredentials, **kwargs + ) -> BlockOutput: + try: + result = self._make_request( + "GET", + f"order/{input_data.order_id}/get-tracking", + credentials.api_key.get_secret_value(), + ) + yield "status", result["status"] + yield "tracking_numbers", result["trackingNumbers"] + except Exception as e: + yield "error", str(e) + raise + + +class Slant3DCancelOrderBlock(Slant3DBlockBase): + """Block for canceling orders""" + + class Input(BlockSchema): + credentials: Slant3DCredentialsInput = Slant3DCredentialsField() + order_id: str = SchemaField(description="Slant3D order ID to cancel") + + class Output(BlockSchema): + status: str = SchemaField(description="Cancellation status message") + error: str = SchemaField(description="Error message if cancellation failed") + + def __init__(self): + super().__init__( + id="54de35e1-407f-450b-b5fa-3b5e2eba8185", + description="Cancel an existing order", + input_schema=self.Input, + output_schema=self.Output, + test_input={ + "credentials": TEST_CREDENTIALS_INPUT, + "order_id": "314144241", + }, + test_credentials=TEST_CREDENTIALS, + test_output=[("status", "Order cancelled")], + test_mock={ + "_make_request": lambda *args, **kwargs: {"status": "Order cancelled"} + }, + ) + + def run( + self, input_data: Input, *, credentials: APIKeyCredentials, **kwargs + ) -> BlockOutput: + try: + result = self._make_request( + "DELETE", + f"order/{input_data.order_id}", + credentials.api_key.get_secret_value(), + ) + yield "status", result["status"] + except Exception as e: + yield "error", str(e) + raise diff --git a/autogpt_platform/backend/backend/blocks/slant3d/slicing.py b/autogpt_platform/backend/backend/blocks/slant3d/slicing.py new file mode 100644 index 000000000000..1b868efc9edd --- /dev/null +++ b/autogpt_platform/backend/backend/blocks/slant3d/slicing.py @@ -0,0 +1,61 @@ +from backend.data.block import BlockOutput, BlockSchema +from backend.data.model import APIKeyCredentials, SchemaField + +from ._api import ( + TEST_CREDENTIALS, + TEST_CREDENTIALS_INPUT, + Slant3DCredentialsField, + Slant3DCredentialsInput, +) +from .base import Slant3DBlockBase + + +class Slant3DSlicerBlock(Slant3DBlockBase): + """Block for slicing 3D model files""" + + class Input(BlockSchema): + credentials: Slant3DCredentialsInput = Slant3DCredentialsField() + file_url: str = SchemaField( + description="URL of the 3D model file to slice (STL)" + ) + + class Output(BlockSchema): + message: str = SchemaField(description="Response message") + price: float = SchemaField(description="Calculated price for printing") + error: str = SchemaField(description="Error message if slicing failed") + + def __init__(self): + super().__init__( + id="f8a12c8d-3e4b-4d5f-b6a7-8c9d0e1f2g3h", + description="Slice a 3D model file and get pricing information", + input_schema=self.Input, + output_schema=self.Output, + test_input={ + "credentials": TEST_CREDENTIALS_INPUT, + "file_url": "https://example.com/model.stl", + }, + test_credentials=TEST_CREDENTIALS, + test_output=[("message", "Slicing successful"), ("price", 8.23)], + test_mock={ + "_make_request": lambda *args, **kwargs: { + "message": "Slicing successful", + "data": {"price": 8.23}, + } + }, + ) + + def run( + self, input_data: Input, *, credentials: APIKeyCredentials, **kwargs + ) -> BlockOutput: + try: + result = self._make_request( + "POST", + "slicer", + credentials.api_key.get_secret_value(), + json={"fileURL": input_data.file_url}, + ) + yield "message", result["message"] + yield "price", result["data"]["price"] + except Exception as e: + yield "error", str(e) + raise diff --git a/autogpt_platform/backend/backend/blocks/slant3d/webhook.py b/autogpt_platform/backend/backend/blocks/slant3d/webhook.py new file mode 100644 index 000000000000..5726790f99f2 --- /dev/null +++ b/autogpt_platform/backend/backend/blocks/slant3d/webhook.py @@ -0,0 +1,125 @@ +from pydantic import BaseModel + +from backend.data.block import ( + Block, + BlockCategory, + BlockOutput, + BlockSchema, + BlockWebhookConfig, +) +from backend.data.model import SchemaField +from backend.util import settings +from backend.util.settings import AppEnvironment, BehaveAs + +from ._api import ( + TEST_CREDENTIALS, + TEST_CREDENTIALS_INPUT, + Slant3DCredentialsField, + Slant3DCredentialsInput, +) + + +class Slant3DTriggerBase: + """Base class for Slant3D webhook triggers""" + + class Input(BlockSchema): + credentials: Slant3DCredentialsInput = Slant3DCredentialsField() + # Webhook URL is handled by the webhook system + payload: dict = SchemaField(hidden=True, default={}) + + class Output(BlockSchema): + payload: dict = SchemaField( + description="The complete webhook payload received from Slant3D" + ) + order_id: str = SchemaField(description="The ID of the affected order") + error: str = SchemaField( + description="Error message if payload processing failed" + ) + + def run(self, input_data: Input, **kwargs) -> BlockOutput: + yield "payload", input_data.payload + yield "order_id", input_data.payload["orderId"] + + +class Slant3DOrderWebhookBlock(Slant3DTriggerBase, Block): + """Block for handling Slant3D order webhooks""" + + class Input(Slant3DTriggerBase.Input): + class EventsFilter(BaseModel): + """ + Currently Slant3D only supports 'SHIPPED' status updates + Could be expanded in the future with more status types + """ + + shipped: bool = True + + events: EventsFilter = SchemaField( + title="Events", + description="Order status events to subscribe to", + default=EventsFilter(shipped=True), + ) + + class Output(Slant3DTriggerBase.Output): + status: str = SchemaField(description="The new status of the order") + tracking_number: str = SchemaField( + description="The tracking number for the shipment" + ) + carrier_code: str = SchemaField(description="The carrier code (e.g., 'usps')") + + def __init__(self): + super().__init__( + id="8a74c2ad-0104-4640-962f-26c6b69e58cd", + description=( + "This block triggers on Slant3D order status updates and outputs " + "the event details, including tracking information when orders are shipped." + ), + # All webhooks are currently subscribed to for all orders. This works for self hosted, but not for cloud hosted prod + disabled=( + settings.Settings().config.behave_as == BehaveAs.CLOUD + and settings.Settings().config.app_env != AppEnvironment.LOCAL + ), + categories={BlockCategory.DEVELOPER_TOOLS}, + input_schema=self.Input, + output_schema=self.Output, + webhook_config=BlockWebhookConfig( + provider="slant3d", + webhook_type="orders", # Only one type for now + resource_format="", # No resource format needed + event_filter_input="events", + event_format="order.{event}", + ), + test_input={ + "credentials": TEST_CREDENTIALS_INPUT, + "events": {"shipped": True}, + "payload": { + "orderId": "1234567890", + "status": "SHIPPED", + "trackingNumber": "ABCDEF123456", + "carrierCode": "usps", + }, + }, + test_credentials=TEST_CREDENTIALS, + test_output=[ + ( + "payload", + { + "orderId": "1234567890", + "status": "SHIPPED", + "trackingNumber": "ABCDEF123456", + "carrierCode": "usps", + }, + ), + ("order_id", "1234567890"), + ("status", "SHIPPED"), + ("tracking_number", "ABCDEF123456"), + ("carrier_code", "usps"), + ], + ) + + def run(self, input_data: Input, **kwargs) -> BlockOutput: # type: ignore + yield from super().run(input_data, **kwargs) + + # Extract and normalize values from the payload + yield "status", input_data.payload["status"] + yield "tracking_number", input_data.payload["trackingNumber"] + yield "carrier_code", input_data.payload["carrierCode"] diff --git a/autogpt_platform/backend/backend/blocks/talking_head.py b/autogpt_platform/backend/backend/blocks/talking_head.py new file mode 100644 index 000000000000..b57a9b0da6dd --- /dev/null +++ b/autogpt_platform/backend/backend/blocks/talking_head.py @@ -0,0 +1,172 @@ +import time +from typing import Literal + +from pydantic import SecretStr + +from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema +from backend.data.model import ( + APIKeyCredentials, + CredentialsField, + CredentialsMetaInput, + SchemaField, +) +from backend.integrations.providers import ProviderName +from backend.util.request import requests + +TEST_CREDENTIALS = APIKeyCredentials( + id="01234567-89ab-cdef-0123-456789abcdef", + provider="d_id", + api_key=SecretStr("mock-d-id-api-key"), + title="Mock D-ID API key", + expires_at=None, +) +TEST_CREDENTIALS_INPUT = { + "provider": TEST_CREDENTIALS.provider, + "id": TEST_CREDENTIALS.id, + "type": TEST_CREDENTIALS.type, + "title": TEST_CREDENTIALS.type, +} + + +class CreateTalkingAvatarVideoBlock(Block): + class Input(BlockSchema): + credentials: CredentialsMetaInput[ + Literal[ProviderName.D_ID], Literal["api_key"] + ] = CredentialsField( + description="The D-ID integration can be used with " + "any API key with sufficient permissions for the blocks it is used on.", + ) + script_input: str = SchemaField( + description="The text input for the script", + placeholder="Welcome to AutoGPT", + ) + provider: Literal["microsoft", "elevenlabs", "amazon"] = SchemaField( + description="The voice provider to use", default="microsoft" + ) + voice_id: str = SchemaField( + description="The voice ID to use, get list of voices [here](https://docs.agpt.co/server/d_id)", + default="en-US-JennyNeural", + ) + presenter_id: str = SchemaField( + description="The presenter ID to use", default="amy-Aq6OmGZnMt" + ) + driver_id: str = SchemaField( + description="The driver ID to use", default="Vcq0R4a8F0" + ) + result_format: Literal["mp4", "gif", "wav"] = SchemaField( + description="The desired result format", default="mp4" + ) + crop_type: Literal["wide", "square", "vertical"] = SchemaField( + description="The crop type for the presenter", default="wide" + ) + subtitles: bool = SchemaField( + description="Whether to include subtitles", default=False + ) + ssml: bool = SchemaField(description="Whether the input is SSML", default=False) + max_polling_attempts: int = SchemaField( + description="Maximum number of polling attempts", default=30, ge=5 + ) + polling_interval: int = SchemaField( + description="Interval between polling attempts in seconds", default=10, ge=5 + ) + + class Output(BlockSchema): + video_url: str = SchemaField(description="The URL of the created video") + error: str = SchemaField(description="Error message if the request failed") + + def __init__(self): + super().__init__( + id="98c6f503-8c47-4b1c-a96d-351fc7c87dab", + description="This block integrates with D-ID to create video clips and retrieve their URLs.", + categories={BlockCategory.AI, BlockCategory.MULTIMEDIA}, + input_schema=CreateTalkingAvatarVideoBlock.Input, + output_schema=CreateTalkingAvatarVideoBlock.Output, + test_input={ + "credentials": TEST_CREDENTIALS_INPUT, + "script_input": "Welcome to AutoGPT", + "voice_id": "en-US-JennyNeural", + "presenter_id": "amy-Aq6OmGZnMt", + "driver_id": "Vcq0R4a8F0", + "result_format": "mp4", + "crop_type": "wide", + "subtitles": False, + "ssml": False, + "max_polling_attempts": 5, + "polling_interval": 5, + }, + test_output=[ + ( + "video_url", + "https://d-id.com/api/clips/abcd1234-5678-efgh-ijkl-mnopqrstuvwx/video", + ), + ], + test_mock={ + "create_clip": lambda *args, **kwargs: { + "id": "abcd1234-5678-efgh-ijkl-mnopqrstuvwx", + "status": "created", + }, + "get_clip_status": lambda *args, **kwargs: { + "status": "done", + "result_url": "https://d-id.com/api/clips/abcd1234-5678-efgh-ijkl-mnopqrstuvwx/video", + }, + }, + test_credentials=TEST_CREDENTIALS, + ) + + def create_clip(self, api_key: SecretStr, payload: dict) -> dict: + url = "https://api.d-id.com/clips" + headers = { + "accept": "application/json", + "content-type": "application/json", + "authorization": f"Basic {api_key.get_secret_value()}", + } + response = requests.post(url, json=payload, headers=headers) + return response.json() + + def get_clip_status(self, api_key: SecretStr, clip_id: str) -> dict: + url = f"https://api.d-id.com/clips/{clip_id}" + headers = { + "accept": "application/json", + "authorization": f"Basic {api_key.get_secret_value()}", + } + response = requests.get(url, headers=headers) + return response.json() + + def run( + self, input_data: Input, *, credentials: APIKeyCredentials, **kwargs + ) -> BlockOutput: + # Create the clip + payload = { + "script": { + "type": "text", + "subtitles": str(input_data.subtitles).lower(), + "provider": { + "type": input_data.provider, + "voice_id": input_data.voice_id, + }, + "ssml": str(input_data.ssml).lower(), + "input": input_data.script_input, + }, + "config": {"result_format": input_data.result_format}, + "presenter_config": {"crop": {"type": input_data.crop_type}}, + "presenter_id": input_data.presenter_id, + "driver_id": input_data.driver_id, + } + + response = self.create_clip(credentials.api_key, payload) + clip_id = response["id"] + + # Poll for clip status + for _ in range(input_data.max_polling_attempts): + status_response = self.get_clip_status(credentials.api_key, clip_id) + if status_response["status"] == "done": + yield "video_url", status_response["result_url"] + return + elif status_response["status"] == "error": + raise RuntimeError( + f"Clip creation failed: {status_response.get('error', 'Unknown error')}" + ) + + time.sleep(input_data.polling_interval) + + raise TimeoutError("Clip creation timed out") diff --git a/autogpt_platform/backend/backend/blocks/text.py b/autogpt_platform/backend/backend/blocks/text.py new file mode 100644 index 000000000000..be0917abeab4 --- /dev/null +++ b/autogpt_platform/backend/backend/blocks/text.py @@ -0,0 +1,254 @@ +import re +from typing import Any + +from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema +from backend.data.model import SchemaField +from backend.util import json, text + +formatter = text.TextFormatter() + + +class MatchTextPatternBlock(Block): + class Input(BlockSchema): + text: Any = SchemaField(description="Text to match") + match: str = SchemaField(description="Pattern (Regex) to match") + data: Any = SchemaField(description="Data to be forwarded to output") + case_sensitive: bool = SchemaField( + description="Case sensitive match", default=True + ) + dot_all: bool = SchemaField(description="Dot matches all", default=True) + + class Output(BlockSchema): + positive: Any = SchemaField(description="Output data if match is found") + negative: Any = SchemaField(description="Output data if match is not found") + + def __init__(self): + super().__init__( + id="3060088f-6ed9-4928-9ba7-9c92823a7ccd", + description="Matches text against a regex pattern and forwards data to positive or negative output based on the match.", + categories={BlockCategory.TEXT}, + input_schema=MatchTextPatternBlock.Input, + output_schema=MatchTextPatternBlock.Output, + test_input=[ + {"text": "ABC", "match": "ab", "data": "X", "case_sensitive": False}, + {"text": "ABC", "match": "ab", "data": "Y", "case_sensitive": True}, + {"text": "Hello World!", "match": ".orld.+", "data": "Z"}, + {"text": "Hello World!", "match": "World![a-z]+", "data": "Z"}, + ], + test_output=[ + ("positive", "X"), + ("negative", "Y"), + ("positive", "Z"), + ("negative", "Z"), + ], + ) + + def run(self, input_data: Input, **kwargs) -> BlockOutput: + output = input_data.data or input_data.text + flags = 0 + if not input_data.case_sensitive: + flags = flags | re.IGNORECASE + if input_data.dot_all: + flags = flags | re.DOTALL + + if isinstance(input_data.text, str): + text = input_data.text + else: + text = json.dumps(input_data.text) + + if re.search(input_data.match, text, flags=flags): + yield "positive", output + else: + yield "negative", output + + +class ExtractTextInformationBlock(Block): + class Input(BlockSchema): + text: Any = SchemaField(description="Text to parse") + pattern: str = SchemaField(description="Pattern (Regex) to parse") + group: int = SchemaField(description="Group number to extract", default=0) + case_sensitive: bool = SchemaField( + description="Case sensitive match", default=True + ) + dot_all: bool = SchemaField(description="Dot matches all", default=True) + find_all: bool = SchemaField(description="Find all matches", default=False) + + class Output(BlockSchema): + positive: str = SchemaField(description="Extracted text") + negative: str = SchemaField(description="Original text") + + def __init__(self): + super().__init__( + id="3146e4fe-2cdd-4f29-bd12-0c9d5bb4deb0", + description="This block extracts the text from the given text using the pattern (regex).", + categories={BlockCategory.TEXT}, + input_schema=ExtractTextInformationBlock.Input, + output_schema=ExtractTextInformationBlock.Output, + test_input=[ + {"text": "Hello, World!", "pattern": "Hello, (.+)", "group": 1}, + {"text": "Hello, World!", "pattern": "Hello, (.+)", "group": 0}, + {"text": "Hello, World!", "pattern": "Hello, (.+)", "group": 2}, + {"text": "Hello, World!", "pattern": "hello,", "case_sensitive": False}, + { + "text": "Hello, World!! Hello, Earth!!", + "pattern": "Hello, (\\S+)", + "group": 1, + "find_all": False, + }, + { + "text": "Hello, World!! Hello, Earth!!", + "pattern": "Hello, (\\S+)", + "group": 1, + "find_all": True, + }, + ], + test_output=[ + ("positive", "World!"), + ("positive", "Hello, World!"), + ("negative", "Hello, World!"), + ("positive", "Hello,"), + ("positive", "World!!"), + ("positive", "World!!"), + ("positive", "Earth!!"), + ], + ) + + def run(self, input_data: Input, **kwargs) -> BlockOutput: + flags = 0 + if not input_data.case_sensitive: + flags = flags | re.IGNORECASE + if input_data.dot_all: + flags = flags | re.DOTALL + + if isinstance(input_data.text, str): + txt = input_data.text + else: + txt = json.dumps(input_data.text) + + matches = [ + match.group(input_data.group) + for match in re.finditer(input_data.pattern, txt, flags) + if input_data.group <= len(match.groups()) + ] + for match in matches: + yield "positive", match + if not input_data.find_all: + return + if not matches: + yield "negative", input_data.text + + +class FillTextTemplateBlock(Block): + class Input(BlockSchema): + values: dict[str, Any] = SchemaField( + description="Values (dict) to be used in format. These values can be used by putting them in double curly braces in the format template. e.g. {{value_name}}.", + ) + format: str = SchemaField( + description="Template to format the text using `values`. Use Jinja2 syntax." + ) + + class Output(BlockSchema): + output: str = SchemaField(description="Formatted text") + + def __init__(self): + super().__init__( + id="db7d8f02-2f44-4c55-ab7a-eae0941f0c30", + description="This block formats the given texts using the format template.", + categories={BlockCategory.TEXT}, + input_schema=FillTextTemplateBlock.Input, + output_schema=FillTextTemplateBlock.Output, + test_input=[ + { + "values": {"name": "Alice", "hello": "Hello", "world": "World!"}, + "format": "{{hello}}, {{ world }} {{name}}", + }, + { + "values": {"list": ["Hello", " World!"]}, + "format": "{% for item in list %}{{ item }}{% endfor %}", + }, + { + "values": {}, + "format": "{% set name = 'Alice' %}Hello, World! {{ name }}", + }, + ], + test_output=[ + ("output", "Hello, World! Alice"), + ("output", "Hello World!"), + ("output", "Hello, World! Alice"), + ], + ) + + def run(self, input_data: Input, **kwargs) -> BlockOutput: + yield "output", formatter.format_string(input_data.format, input_data.values) + + +class CombineTextsBlock(Block): + class Input(BlockSchema): + input: list[str] = SchemaField(description="text input to combine") + delimiter: str = SchemaField( + description="Delimiter to combine texts", default="" + ) + + class Output(BlockSchema): + output: str = SchemaField(description="Combined text") + + def __init__(self): + super().__init__( + id="e30a4d42-7b7d-4e6a-b36e-1f9b8e3b7d85", + description="This block combines multiple input texts into a single output text.", + categories={BlockCategory.TEXT}, + input_schema=CombineTextsBlock.Input, + output_schema=CombineTextsBlock.Output, + test_input=[ + {"input": ["Hello world I like ", "cake and to go for walks"]}, + {"input": ["This is a test", "Hi!"], "delimiter": "! "}, + ], + test_output=[ + ("output", "Hello world I like cake and to go for walks"), + ("output", "This is a test! Hi!"), + ], + ) + + def run(self, input_data: Input, **kwargs) -> BlockOutput: + combined_text = input_data.delimiter.join(input_data.input) + yield "output", combined_text + + +class TextSplitBlock(Block): + class Input(BlockSchema): + text: str = SchemaField(description="The text to split.") + delimiter: str = SchemaField(description="The delimiter to split the text by.") + strip: bool = SchemaField( + description="Whether to strip the text.", default=True + ) + + class Output(BlockSchema): + texts: list[str] = SchemaField( + description="The text split into a list of strings." + ) + + def __init__(self): + super().__init__( + id="d5ea33c8-a575-477a-b42f-2fe3be5055ec", + description="This block is used to split a text into a list of strings.", + categories={BlockCategory.TEXT}, + input_schema=TextSplitBlock.Input, + output_schema=TextSplitBlock.Output, + test_input=[ + {"text": "Hello, World!", "delimiter": ","}, + {"text": "Hello, World!", "delimiter": ",", "strip": False}, + ], + test_output=[ + ("texts", ["Hello", "World!"]), + ("texts", ["Hello", " World!"]), + ], + ) + + def run(self, input_data: Input, **kwargs) -> BlockOutput: + if len(input_data.text) == 0: + yield "texts", [] + else: + texts = input_data.text.split(input_data.delimiter) + if input_data.strip: + texts = [text.strip() for text in texts] + yield "texts", texts diff --git a/autogpt_platform/backend/backend/blocks/text_to_speech_block.py b/autogpt_platform/backend/backend/blocks/text_to_speech_block.py new file mode 100644 index 000000000000..989dc54e128e --- /dev/null +++ b/autogpt_platform/backend/backend/blocks/text_to_speech_block.py @@ -0,0 +1,102 @@ +from typing import Any, Literal + +from pydantic import SecretStr + +from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema +from backend.data.model import ( + APIKeyCredentials, + CredentialsField, + CredentialsMetaInput, + SchemaField, +) +from backend.integrations.providers import ProviderName +from backend.util.request import requests + +TEST_CREDENTIALS = APIKeyCredentials( + id="01234567-89ab-cdef-0123-456789abcdef", + provider="unreal_speech", + api_key=SecretStr("mock-unreal-speech-api-key"), + title="Mock Unreal Speech API key", + expires_at=None, +) +TEST_CREDENTIALS_INPUT = { + "provider": TEST_CREDENTIALS.provider, + "id": TEST_CREDENTIALS.id, + "type": TEST_CREDENTIALS.type, + "title": TEST_CREDENTIALS.type, +} + + +class UnrealTextToSpeechBlock(Block): + class Input(BlockSchema): + text: str = SchemaField( + description="The text to be converted to speech", + placeholder="Enter the text you want to convert to speech", + ) + voice_id: str = SchemaField( + description="The voice ID to use for text-to-speech conversion", + placeholder="Scarlett", + default="Scarlett", + ) + credentials: CredentialsMetaInput[ + Literal[ProviderName.UNREAL_SPEECH], Literal["api_key"] + ] = CredentialsField( + description="The Unreal Speech integration can be used with " + "any API key with sufficient permissions for the blocks it is used on.", + ) + + class Output(BlockSchema): + mp3_url: str = SchemaField(description="The URL of the generated MP3 file") + error: str = SchemaField(description="Error message if the API call failed") + + def __init__(self): + super().__init__( + id="4ff1ff6d-cc40-4caa-ae69-011daa20c378", + description="Converts text to speech using the Unreal Speech API", + categories={BlockCategory.AI, BlockCategory.TEXT, BlockCategory.MULTIMEDIA}, + input_schema=UnrealTextToSpeechBlock.Input, + output_schema=UnrealTextToSpeechBlock.Output, + test_input={ + "text": "This is a test of the text to speech API.", + "voice_id": "Scarlett", + "credentials": TEST_CREDENTIALS_INPUT, + }, + test_output=[("mp3_url", "https://example.com/test.mp3")], + test_mock={ + "call_unreal_speech_api": lambda *args, **kwargs: { + "OutputUri": "https://example.com/test.mp3" + } + }, + test_credentials=TEST_CREDENTIALS, + ) + + @staticmethod + def call_unreal_speech_api( + api_key: SecretStr, text: str, voice_id: str + ) -> dict[str, Any]: + url = "https://api.v7.unrealspeech.com/speech" + headers = { + "Authorization": f"Bearer {api_key.get_secret_value()}", + "Content-Type": "application/json", + } + data = { + "Text": text, + "VoiceId": voice_id, + "Bitrate": "192k", + "Speed": "0", + "Pitch": "1", + "TimestampType": "sentence", + } + + response = requests.post(url, headers=headers, json=data) + return response.json() + + def run( + self, input_data: Input, *, credentials: APIKeyCredentials, **kwargs + ) -> BlockOutput: + api_response = self.call_unreal_speech_api( + credentials.api_key, + input_data.text, + input_data.voice_id, + ) + yield "mp3_url", api_response["OutputUri"] diff --git a/autogpt_platform/backend/backend/blocks/time_blocks.py b/autogpt_platform/backend/backend/blocks/time_blocks.py new file mode 100644 index 000000000000..4b060aea5cfc --- /dev/null +++ b/autogpt_platform/backend/backend/blocks/time_blocks.py @@ -0,0 +1,191 @@ +import time +from datetime import datetime, timedelta +from typing import Any, Union + +from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema +from backend.data.model import SchemaField + + +class GetCurrentTimeBlock(Block): + class Input(BlockSchema): + trigger: str = SchemaField( + description="Trigger any data to output the current time" + ) + format: str = SchemaField( + description="Format of the time to output", default="%H:%M:%S" + ) + + class Output(BlockSchema): + time: str = SchemaField( + description="Current time in the specified format (default: %H:%M:%S)" + ) + + def __init__(self): + super().__init__( + id="a892b8d9-3e4e-4e9c-9c1e-75f8efcf1bfa", + description="This block outputs the current time.", + categories={BlockCategory.TEXT}, + input_schema=GetCurrentTimeBlock.Input, + output_schema=GetCurrentTimeBlock.Output, + test_input=[ + {"trigger": "Hello"}, + {"trigger": "Hello", "format": "%H:%M"}, + ], + test_output=[ + ("time", lambda _: time.strftime("%H:%M:%S")), + ("time", lambda _: time.strftime("%H:%M")), + ], + ) + + def run(self, input_data: Input, **kwargs) -> BlockOutput: + current_time = time.strftime(input_data.format) + yield "time", current_time + + +class GetCurrentDateBlock(Block): + class Input(BlockSchema): + trigger: str = SchemaField( + description="Trigger any data to output the current date" + ) + offset: Union[int, str] = SchemaField( + title="Days Offset", + description="Offset in days from the current date", + default=0, + ) + format: str = SchemaField( + description="Format of the date to output", default="%Y-%m-%d" + ) + + class Output(BlockSchema): + date: str = SchemaField( + description="Current date in the specified format (default: YYYY-MM-DD)" + ) + + def __init__(self): + super().__init__( + id="b29c1b50-5d0e-4d9f-8f9d-1b0e6fcbf0b1", + description="This block outputs the current date with an optional offset.", + categories={BlockCategory.TEXT}, + input_schema=GetCurrentDateBlock.Input, + output_schema=GetCurrentDateBlock.Output, + test_input=[ + {"trigger": "Hello", "offset": "7"}, + {"trigger": "Hello", "offset": "7", "format": "%m/%d/%Y"}, + ], + test_output=[ + ( + "date", + lambda t: abs(datetime.now() - datetime.strptime(t, "%Y-%m-%d")) + < timedelta(days=8), # 7 days difference + 1 day error margin. + ), + ( + "date", + lambda t: abs(datetime.now() - datetime.strptime(t, "%m/%d/%Y")) + < timedelta(days=8), + # 7 days difference + 1 day error margin. + ), + ], + ) + + def run(self, input_data: Input, **kwargs) -> BlockOutput: + try: + offset = int(input_data.offset) + except ValueError: + offset = 0 + current_date = datetime.now() - timedelta(days=offset) + yield "date", current_date.strftime(input_data.format) + + +class GetCurrentDateAndTimeBlock(Block): + class Input(BlockSchema): + trigger: str = SchemaField( + description="Trigger any data to output the current date and time" + ) + format: str = SchemaField( + description="Format of the date and time to output", + default="%Y-%m-%d %H:%M:%S", + ) + + class Output(BlockSchema): + date_time: str = SchemaField( + description="Current date and time in the specified format (default: YYYY-MM-DD HH:MM:SS)" + ) + + def __init__(self): + super().__init__( + id="716a67b3-6760-42e7-86dc-18645c6e00fc", + description="This block outputs the current date and time.", + categories={BlockCategory.TEXT}, + input_schema=GetCurrentDateAndTimeBlock.Input, + output_schema=GetCurrentDateAndTimeBlock.Output, + test_input=[ + {"trigger": "Hello"}, + ], + test_output=[ + ( + "date_time", + lambda t: abs( + datetime.now() - datetime.strptime(t, "%Y-%m-%d %H:%M:%S") + ) + < timedelta(seconds=10), # 10 seconds error margin. + ), + ], + ) + + def run(self, input_data: Input, **kwargs) -> BlockOutput: + current_date_time = time.strftime(input_data.format) + yield "date_time", current_date_time + + +class CountdownTimerBlock(Block): + class Input(BlockSchema): + input_message: Any = SchemaField( + advanced=False, + description="Message to output after the timer finishes", + default="timer finished", + ) + seconds: Union[int, str] = SchemaField( + advanced=False, description="Duration in seconds", default=0 + ) + minutes: Union[int, str] = SchemaField( + advanced=False, description="Duration in minutes", default=0 + ) + hours: Union[int, str] = SchemaField( + advanced=False, description="Duration in hours", default=0 + ) + days: Union[int, str] = SchemaField( + advanced=False, description="Duration in days", default=0 + ) + + class Output(BlockSchema): + output_message: Any = SchemaField( + description="Message after the timer finishes" + ) + + def __init__(self): + super().__init__( + id="d67a9c52-5e4e-11e2-bcfd-0800200c9a71", + description="This block triggers after a specified duration.", + categories={BlockCategory.TEXT}, + input_schema=CountdownTimerBlock.Input, + output_schema=CountdownTimerBlock.Output, + test_input=[ + {"seconds": 1}, + {"input_message": "Custom message"}, + ], + test_output=[ + ("output_message", "timer finished"), + ("output_message", "Custom message"), + ], + ) + + def run(self, input_data: Input, **kwargs) -> BlockOutput: + seconds = int(input_data.seconds) + minutes = int(input_data.minutes) + hours = int(input_data.hours) + days = int(input_data.days) + + total_seconds = seconds + minutes * 60 + hours * 3600 + days * 86400 + + time.sleep(total_seconds) + yield "output_message", input_data.input_message diff --git a/autogpt_platform/backend/backend/blocks/twitter/_auth.py b/autogpt_platform/backend/backend/blocks/twitter/_auth.py new file mode 100644 index 000000000000..0bff03fa370a --- /dev/null +++ b/autogpt_platform/backend/backend/blocks/twitter/_auth.py @@ -0,0 +1,60 @@ +from typing import Literal + +from pydantic import SecretStr + +from backend.data.model import ( + CredentialsField, + CredentialsMetaInput, + OAuth2Credentials, + ProviderName, +) +from backend.integrations.oauth.twitter import TwitterOAuthHandler +from backend.util.settings import Secrets + +# --8<-- [start:TwitterOAuthIsConfigured] +secrets = Secrets() +TWITTER_OAUTH_IS_CONFIGURED = bool( + secrets.twitter_client_id and secrets.twitter_client_secret +) +# --8<-- [end:TwitterOAuthIsConfigured] + +TwitterCredentials = OAuth2Credentials +TwitterCredentialsInput = CredentialsMetaInput[ + Literal[ProviderName.TWITTER], Literal["oauth2"] +] + + +# Currently, We are getting all the permission from the Twitter API initally +# In future, If we need to add incremental permission, we can use these requested_scopes +def TwitterCredentialsField(scopes: list[str]) -> TwitterCredentialsInput: + """ + Creates a Twitter credentials input on a block. + + Params: + scopes: The authorization scopes needed for the block to work. + """ + return CredentialsField( + # required_scopes=set(scopes), + required_scopes=set(TwitterOAuthHandler.DEFAULT_SCOPES + scopes), + description="The Twitter integration requires OAuth2 authentication.", + ) + + +TEST_CREDENTIALS = OAuth2Credentials( + id="01234567-89ab-cdef-0123-456789abcdef", + provider="twitter", + access_token=SecretStr("mock-twitter-access-token"), + refresh_token=SecretStr("mock-twitter-refresh-token"), + access_token_expires_at=1234567890, + scopes=["tweet.read", "tweet.write", "users.read", "offline.access"], + title="Mock Twitter OAuth2 Credentials", + username="mock-twitter-username", + refresh_token_expires_at=1234567890, +) + +TEST_CREDENTIALS_INPUT = { + "provider": TEST_CREDENTIALS.provider, + "id": TEST_CREDENTIALS.id, + "type": TEST_CREDENTIALS.type, + "title": TEST_CREDENTIALS.title, +} diff --git a/autogpt_platform/backend/backend/blocks/twitter/_builders.py b/autogpt_platform/backend/backend/blocks/twitter/_builders.py new file mode 100644 index 000000000000..6dc450c2474f --- /dev/null +++ b/autogpt_platform/backend/backend/blocks/twitter/_builders.py @@ -0,0 +1,418 @@ +from datetime import datetime +from typing import Any, Dict + +from backend.blocks.twitter._mappers import ( + get_backend_expansion, + get_backend_field, + get_backend_list_expansion, + get_backend_list_field, + get_backend_media_field, + get_backend_place_field, + get_backend_poll_field, + get_backend_space_expansion, + get_backend_space_field, + get_backend_user_field, +) +from backend.blocks.twitter._types import ( # DMEventFieldFilter, + DMEventExpansionFilter, + DMEventTypeFilter, + DMMediaFieldFilter, + DMTweetFieldFilter, + ExpansionFilter, + ListExpansionsFilter, + ListFieldsFilter, + SpaceExpansionsFilter, + SpaceFieldsFilter, + TweetFieldsFilter, + TweetMediaFieldsFilter, + TweetPlaceFieldsFilter, + TweetPollFieldsFilter, + TweetReplySettingsFilter, + TweetUserFieldsFilter, + UserExpansionsFilter, +) + + +# Common Builder +class TweetExpansionsBuilder: + def __init__(self, param: Dict[str, Any]): + self.params: Dict[str, Any] = param + + def add_expansions(self, expansions: ExpansionFilter | None): + if expansions: + filtered_expansions = [ + name for name, value in expansions.dict().items() if value is True + ] + + if filtered_expansions: + self.params["expansions"] = ",".join( + [get_backend_expansion(exp) for exp in filtered_expansions] + ) + + return self + + def add_media_fields(self, media_fields: TweetMediaFieldsFilter | None): + if media_fields: + filtered_fields = [ + name for name, value in media_fields.dict().items() if value is True + ] + if filtered_fields: + self.params["media.fields"] = ",".join( + [get_backend_media_field(field) for field in filtered_fields] + ) + return self + + def add_place_fields(self, place_fields: TweetPlaceFieldsFilter | None): + if place_fields: + filtered_fields = [ + name for name, value in place_fields.dict().items() if value is True + ] + if filtered_fields: + self.params["place.fields"] = ",".join( + [get_backend_place_field(field) for field in filtered_fields] + ) + return self + + def add_poll_fields(self, poll_fields: TweetPollFieldsFilter | None): + if poll_fields: + filtered_fields = [ + name for name, value in poll_fields.dict().items() if value is True + ] + if filtered_fields: + self.params["poll.fields"] = ",".join( + [get_backend_poll_field(field) for field in filtered_fields] + ) + return self + + def add_tweet_fields(self, tweet_fields: TweetFieldsFilter | None): + if tweet_fields: + filtered_fields = [ + name for name, value in tweet_fields.dict().items() if value is True + ] + if filtered_fields: + self.params["tweet.fields"] = ",".join( + [get_backend_field(field) for field in filtered_fields] + ) + return self + + def add_user_fields(self, user_fields: TweetUserFieldsFilter | None): + if user_fields: + filtered_fields = [ + name for name, value in user_fields.dict().items() if value is True + ] + if filtered_fields: + self.params["user.fields"] = ",".join( + [get_backend_user_field(field) for field in filtered_fields] + ) + return self + + def build(self): + return self.params + + +class UserExpansionsBuilder: + def __init__(self, param: Dict[str, Any]): + self.params: Dict[str, Any] = param + + def add_expansions(self, expansions: UserExpansionsFilter | None): + if expansions: + filtered_expansions = [ + name for name, value in expansions.dict().items() if value is True + ] + if filtered_expansions: + self.params["expansions"] = ",".join(filtered_expansions) + return self + + def add_tweet_fields(self, tweet_fields: TweetFieldsFilter | None): + if tweet_fields: + filtered_fields = [ + name for name, value in tweet_fields.dict().items() if value is True + ] + if filtered_fields: + self.params["tweet.fields"] = ",".join( + [get_backend_field(field) for field in filtered_fields] + ) + return self + + def add_user_fields(self, user_fields: TweetUserFieldsFilter | None): + if user_fields: + filtered_fields = [ + name for name, value in user_fields.dict().items() if value is True + ] + if filtered_fields: + self.params["user.fields"] = ",".join( + [get_backend_user_field(field) for field in filtered_fields] + ) + return self + + def build(self): + return self.params + + +class ListExpansionsBuilder: + def __init__(self, param: Dict[str, Any]): + self.params: Dict[str, Any] = param + + def add_expansions(self, expansions: ListExpansionsFilter | None): + if expansions: + filtered_expansions = [ + name for name, value in expansions.dict().items() if value is True + ] + if filtered_expansions: + self.params["expansions"] = ",".join( + [get_backend_list_expansion(exp) for exp in filtered_expansions] + ) + return self + + def add_list_fields(self, list_fields: ListFieldsFilter | None): + if list_fields: + filtered_fields = [ + name for name, value in list_fields.dict().items() if value is True + ] + if filtered_fields: + self.params["list.fields"] = ",".join( + [get_backend_list_field(field) for field in filtered_fields] + ) + return self + + def add_user_fields(self, user_fields: TweetUserFieldsFilter | None): + if user_fields: + filtered_fields = [ + name for name, value in user_fields.dict().items() if value is True + ] + if filtered_fields: + self.params["user.fields"] = ",".join( + [get_backend_user_field(field) for field in filtered_fields] + ) + return self + + def build(self): + return self.params + + +class SpaceExpansionsBuilder: + def __init__(self, param: Dict[str, Any]): + self.params: Dict[str, Any] = param + + def add_expansions(self, expansions: SpaceExpansionsFilter | None): + if expansions: + filtered_expansions = [ + name for name, value in expansions.dict().items() if value is True + ] + if filtered_expansions: + self.params["expansions"] = ",".join( + [get_backend_space_expansion(exp) for exp in filtered_expansions] + ) + return self + + def add_space_fields(self, space_fields: SpaceFieldsFilter | None): + if space_fields: + filtered_fields = [ + name for name, value in space_fields.dict().items() if value is True + ] + if filtered_fields: + self.params["space.fields"] = ",".join( + [get_backend_space_field(field) for field in filtered_fields] + ) + return self + + def add_user_fields(self, user_fields: TweetUserFieldsFilter | None): + if user_fields: + filtered_fields = [ + name for name, value in user_fields.dict().items() if value is True + ] + if filtered_fields: + self.params["user.fields"] = ",".join( + [get_backend_user_field(field) for field in filtered_fields] + ) + return self + + def build(self): + return self.params + + +class TweetDurationBuilder: + def __init__(self, param: Dict[str, Any]): + self.params: Dict[str, Any] = param + + def add_start_time(self, start_time: datetime | None): + if start_time: + self.params["start_time"] = start_time + return self + + def add_end_time(self, end_time: datetime | None): + if end_time: + self.params["end_time"] = end_time + return self + + def add_since_id(self, since_id: str | None): + if since_id: + self.params["since_id"] = since_id + return self + + def add_until_id(self, until_id: str | None): + if until_id: + self.params["until_id"] = until_id + return self + + def add_sort_order(self, sort_order: str | None): + if sort_order: + self.params["sort_order"] = sort_order + return self + + def build(self): + return self.params + + +class DMExpansionsBuilder: + def __init__(self, param: Dict[str, Any]): + self.params: Dict[str, Any] = param + + def add_expansions(self, expansions: DMEventExpansionFilter): + if expansions: + filtered_expansions = [ + name for name, value in expansions.dict().items() if value is True + ] + if filtered_expansions: + self.params["expansions"] = ",".join(filtered_expansions) + return self + + def add_event_types(self, event_types: DMEventTypeFilter): + if event_types: + filtered_types = [ + name for name, value in event_types.dict().items() if value is True + ] + if filtered_types: + self.params["event_types"] = ",".join(filtered_types) + return self + + def add_media_fields(self, media_fields: DMMediaFieldFilter): + if media_fields: + filtered_fields = [ + name for name, value in media_fields.dict().items() if value is True + ] + if filtered_fields: + self.params["media.fields"] = ",".join(filtered_fields) + return self + + def add_tweet_fields(self, tweet_fields: DMTweetFieldFilter): + if tweet_fields: + filtered_fields = [ + name for name, value in tweet_fields.dict().items() if value is True + ] + if filtered_fields: + self.params["tweet.fields"] = ",".join(filtered_fields) + return self + + def add_user_fields(self, user_fields: TweetUserFieldsFilter): + if user_fields: + filtered_fields = [ + name for name, value in user_fields.dict().items() if value is True + ] + if filtered_fields: + self.params["user.fields"] = ",".join(filtered_fields) + return self + + def build(self): + return self.params + + +# Specific Builders +class TweetSearchBuilder: + def __init__(self): + self.params: Dict[str, Any] = {"user_auth": False} + + def add_query(self, query: str): + if query: + self.params["query"] = query + return self + + def add_pagination(self, max_results: int, pagination: str | None): + if max_results: + self.params["max_results"] = max_results + if pagination: + self.params["pagination_token"] = pagination + return self + + def build(self): + return self.params + + +class TweetPostBuilder: + def __init__(self): + self.params: Dict[str, Any] = {"user_auth": False} + + def add_text(self, text: str | None): + if text: + self.params["text"] = text + return self + + def add_media(self, media_ids: list, tagged_user_ids: list): + if media_ids: + self.params["media_ids"] = media_ids + if tagged_user_ids: + self.params["media_tagged_user_ids"] = tagged_user_ids + return self + + def add_deep_link(self, link: str): + if link: + self.params["direct_message_deep_link"] = link + return self + + def add_super_followers(self, for_super_followers: bool): + if for_super_followers: + self.params["for_super_followers_only"] = for_super_followers + return self + + def add_place(self, place_id: str): + if place_id: + self.params["place_id"] = place_id + return self + + def add_poll_options(self, poll_options: list): + if poll_options: + self.params["poll_options"] = poll_options + return self + + def add_poll_duration(self, poll_duration_minutes: int): + if poll_duration_minutes: + self.params["poll_duration_minutes"] = poll_duration_minutes + return self + + def add_quote(self, quote_id: str): + if quote_id: + self.params["quote_tweet_id"] = quote_id + return self + + def add_reply_settings( + self, + exclude_user_ids: list, + reply_to_id: str, + settings: TweetReplySettingsFilter, + ): + if exclude_user_ids: + self.params["exclude_reply_user_ids"] = exclude_user_ids + if reply_to_id: + self.params["in_reply_to_tweet_id"] = reply_to_id + if settings.All_Users: + self.params["reply_settings"] = None + elif settings.Following_Users_Only: + self.params["reply_settings"] = "following" + elif settings.Mentioned_Users_Only: + self.params["reply_settings"] = "mentionedUsers" + return self + + def build(self): + return self.params + + +class TweetGetsBuilder: + def __init__(self): + self.params: Dict[str, Any] = {"user_auth": False} + + def add_id(self, tweet_id: list[str]): + self.params["id"] = tweet_id + return self + + def build(self): + return self.params diff --git a/autogpt_platform/backend/backend/blocks/twitter/_mappers.py b/autogpt_platform/backend/backend/blocks/twitter/_mappers.py new file mode 100644 index 000000000000..a564174ed0f2 --- /dev/null +++ b/autogpt_platform/backend/backend/blocks/twitter/_mappers.py @@ -0,0 +1,234 @@ +# -------------- Tweets ----------------- + +# Tweet Expansions +EXPANSION_FRONTEND_TO_BACKEND_MAPPING = { + "Poll_IDs": "attachments.poll_ids", + "Media_Keys": "attachments.media_keys", + "Author_User_ID": "author_id", + "Edit_History_Tweet_IDs": "edit_history_tweet_ids", + "Mentioned_Usernames": "entities.mentions.username", + "Place_ID": "geo.place_id", + "Reply_To_User_ID": "in_reply_to_user_id", + "Referenced_Tweet_ID": "referenced_tweets.id", + "Referenced_Tweet_Author_ID": "referenced_tweets.id.author_id", +} + + +def get_backend_expansion(frontend_key: str) -> str: + result = EXPANSION_FRONTEND_TO_BACKEND_MAPPING.get(frontend_key) + if result is None: + raise KeyError(f"Invalid expansion key: {frontend_key}") + return result + + +# TweetReplySettings +REPLY_SETTINGS_FRONTEND_TO_BACKEND_MAPPING = { + "Mentioned_Users_Only": "mentionedUsers", + "Following_Users_Only": "following", + "All_Users": "all", +} + + +# TweetUserFields +def get_backend_reply_setting(frontend_key: str) -> str: + result = REPLY_SETTINGS_FRONTEND_TO_BACKEND_MAPPING.get(frontend_key) + if result is None: + raise KeyError(f"Invalid reply setting key: {frontend_key}") + return result + + +USER_FIELDS_FRONTEND_TO_BACKEND_MAPPING = { + "Account_Creation_Date": "created_at", + "User_Bio": "description", + "User_Entities": "entities", + "User_ID": "id", + "User_Location": "location", + "Latest_Tweet_ID": "most_recent_tweet_id", + "Display_Name": "name", + "Pinned_Tweet_ID": "pinned_tweet_id", + "Profile_Picture_URL": "profile_image_url", + "Is_Protected_Account": "protected", + "Account_Statistics": "public_metrics", + "Profile_URL": "url", + "Username": "username", + "Is_Verified": "verified", + "Verification_Type": "verified_type", + "Content_Withholding_Info": "withheld", +} + + +def get_backend_user_field(frontend_key: str) -> str: + result = USER_FIELDS_FRONTEND_TO_BACKEND_MAPPING.get(frontend_key) + if result is None: + raise KeyError(f"Invalid user field key: {frontend_key}") + return result + + +# TweetFields +FIELDS_FRONTEND_TO_BACKEND_MAPPING = { + "Tweet_Attachments": "attachments", + "Author_ID": "author_id", + "Context_Annotations": "context_annotations", + "Conversation_ID": "conversation_id", + "Creation_Time": "created_at", + "Edit_Controls": "edit_controls", + "Tweet_Entities": "entities", + "Geographic_Location": "geo", + "Tweet_ID": "id", + "Reply_To_User_ID": "in_reply_to_user_id", + "Language": "lang", + "Public_Metrics": "public_metrics", + "Sensitive_Content_Flag": "possibly_sensitive", + "Referenced_Tweets": "referenced_tweets", + "Reply_Settings": "reply_settings", + "Tweet_Source": "source", + "Tweet_Text": "text", + "Withheld_Content": "withheld", +} + + +def get_backend_field(frontend_key: str) -> str: + result = FIELDS_FRONTEND_TO_BACKEND_MAPPING.get(frontend_key) + if result is None: + raise KeyError(f"Invalid field key: {frontend_key}") + return result + + +# TweetPollFields +POLL_FIELDS_FRONTEND_TO_BACKEND_MAPPING = { + "Duration_Minutes": "duration_minutes", + "End_DateTime": "end_datetime", + "Poll_ID": "id", + "Poll_Options": "options", + "Voting_Status": "voting_status", +} + + +def get_backend_poll_field(frontend_key: str) -> str: + result = POLL_FIELDS_FRONTEND_TO_BACKEND_MAPPING.get(frontend_key) + if result is None: + raise KeyError(f"Invalid poll field key: {frontend_key}") + return result + + +PLACE_FIELDS_FRONTEND_TO_BACKEND_MAPPING = { + "Contained_Within_Places": "contained_within", + "Country": "country", + "Country_Code": "country_code", + "Full_Location_Name": "full_name", + "Geographic_Coordinates": "geo", + "Place_ID": "id", + "Place_Name": "name", + "Place_Type": "place_type", +} + + +def get_backend_place_field(frontend_key: str) -> str: + result = PLACE_FIELDS_FRONTEND_TO_BACKEND_MAPPING.get(frontend_key) + if result is None: + raise KeyError(f"Invalid place field key: {frontend_key}") + return result + + +# TweetMediaFields +MEDIA_FIELDS_FRONTEND_TO_BACKEND_MAPPING = { + "Duration_in_Milliseconds": "duration_ms", + "Height": "height", + "Media_Key": "media_key", + "Preview_Image_URL": "preview_image_url", + "Media_Type": "type", + "Media_URL": "url", + "Width": "width", + "Public_Metrics": "public_metrics", + "Non_Public_Metrics": "non_public_metrics", + "Organic_Metrics": "organic_metrics", + "Promoted_Metrics": "promoted_metrics", + "Alternative_Text": "alt_text", + "Media_Variants": "variants", +} + + +def get_backend_media_field(frontend_key: str) -> str: + result = MEDIA_FIELDS_FRONTEND_TO_BACKEND_MAPPING.get(frontend_key) + if result is None: + raise KeyError(f"Invalid media field key: {frontend_key}") + return result + + +# -------------- Spaces ----------------- + +# SpaceExpansions +EXPANSION_FRONTEND_TO_BACKEND_MAPPING_SPACE = { + "Invited_Users": "invited_user_ids", + "Speakers": "speaker_ids", + "Creator": "creator_id", + "Hosts": "host_ids", + "Topics": "topic_ids", +} + + +def get_backend_space_expansion(frontend_key: str) -> str: + result = EXPANSION_FRONTEND_TO_BACKEND_MAPPING_SPACE.get(frontend_key) + if result is None: + raise KeyError(f"Invalid expansion key: {frontend_key}") + return result + + +# SpaceFields +SPACE_FIELDS_FRONTEND_TO_BACKEND_MAPPING = { + "Space_ID": "id", + "Space_State": "state", + "Creation_Time": "created_at", + "End_Time": "ended_at", + "Host_User_IDs": "host_ids", + "Language": "lang", + "Is_Ticketed": "is_ticketed", + "Invited_User_IDs": "invited_user_ids", + "Participant_Count": "participant_count", + "Subscriber_Count": "subscriber_count", + "Scheduled_Start_Time": "scheduled_start", + "Speaker_User_IDs": "speaker_ids", + "Start_Time": "started_at", + "Space_Title": "title", + "Topic_IDs": "topic_ids", + "Last_Updated_Time": "updated_at", +} + + +def get_backend_space_field(frontend_key: str) -> str: + result = SPACE_FIELDS_FRONTEND_TO_BACKEND_MAPPING.get(frontend_key) + if result is None: + raise KeyError(f"Invalid space field key: {frontend_key}") + return result + + +# -------------- List Expansions ----------------- + +# ListExpansions +LIST_EXPANSION_FRONTEND_TO_BACKEND_MAPPING = {"List_Owner_ID": "owner_id"} + + +def get_backend_list_expansion(frontend_key: str) -> str: + result = LIST_EXPANSION_FRONTEND_TO_BACKEND_MAPPING.get(frontend_key) + if result is None: + raise KeyError(f"Invalid list expansion key: {frontend_key}") + return result + + +LIST_FIELDS_FRONTEND_TO_BACKEND_MAPPING = { + "List_ID": "id", + "List_Name": "name", + "Creation_Date": "created_at", + "Description": "description", + "Follower_Count": "follower_count", + "Member_Count": "member_count", + "Is_Private": "private", + "Owner_ID": "owner_id", +} + + +def get_backend_list_field(frontend_key: str) -> str: + result = LIST_FIELDS_FRONTEND_TO_BACKEND_MAPPING.get(frontend_key) + if result is None: + raise KeyError(f"Invalid list field key: {frontend_key}") + return result diff --git a/autogpt_platform/backend/backend/blocks/twitter/_serializer.py b/autogpt_platform/backend/backend/blocks/twitter/_serializer.py new file mode 100644 index 000000000000..906c52445686 --- /dev/null +++ b/autogpt_platform/backend/backend/blocks/twitter/_serializer.py @@ -0,0 +1,76 @@ +from typing import Any, Dict, List + + +class BaseSerializer: + @staticmethod + def _serialize_value(value: Any) -> Any: + """Helper method to serialize individual values""" + if hasattr(value, "data"): + return value.data + return value + + +class IncludesSerializer(BaseSerializer): + @classmethod + def serialize(cls, includes: Dict[str, Any]) -> Dict[str, Any]: + """Serializes the includes dictionary""" + if not includes: + return {} + + serialized_includes = {} + for key, value in includes.items(): + if isinstance(value, list): + serialized_includes[key] = [ + cls._serialize_value(item) for item in value + ] + else: + serialized_includes[key] = cls._serialize_value(value) + + return serialized_includes + + +class ResponseDataSerializer(BaseSerializer): + @classmethod + def serialize_dict(cls, item: Dict[str, Any]) -> Dict[str, Any]: + """Serializes a single dictionary item""" + serialized_item = {} + + if hasattr(item, "__dict__"): + items = item.__dict__.items() + else: + items = item.items() + + for key, value in items: + if isinstance(value, list): + serialized_item[key] = [ + cls._serialize_value(sub_item) for sub_item in value + ] + else: + serialized_item[key] = cls._serialize_value(value) + + return serialized_item + + @classmethod + def serialize_list(cls, data: List[Dict[str, Any]]) -> List[Dict[str, Any]]: + """Serializes a list of dictionary items""" + return [cls.serialize_dict(item) for item in data] + + +class ResponseSerializer: + @classmethod + def serialize(cls, response) -> Dict[str, Any]: + """Main serializer that handles both data and includes""" + result = {"data": None, "included": {}} + + # Handle response.data + if response.data: + if isinstance(response.data, list): + result["data"] = ResponseDataSerializer.serialize_list(response.data) + else: + result["data"] = ResponseDataSerializer.serialize_dict(response.data) + + # Handle includes + if hasattr(response, "includes") and response.includes: + result["included"] = IncludesSerializer.serialize(response.includes) + + return result diff --git a/autogpt_platform/backend/backend/blocks/twitter/_types.py b/autogpt_platform/backend/backend/blocks/twitter/_types.py new file mode 100644 index 000000000000..2b404e4f560e --- /dev/null +++ b/autogpt_platform/backend/backend/blocks/twitter/_types.py @@ -0,0 +1,443 @@ +from datetime import datetime +from enum import Enum + +from pydantic import BaseModel + +from backend.data.block import BlockSchema +from backend.data.model import SchemaField + +# -------------- Tweets ----------------- + + +class TweetReplySettingsFilter(BaseModel): + Mentioned_Users_Only: bool = False + Following_Users_Only: bool = False + All_Users: bool = False + + +class TweetUserFieldsFilter(BaseModel): + Account_Creation_Date: bool = False + User_Bio: bool = False + User_Entities: bool = False + User_ID: bool = False + User_Location: bool = False + Latest_Tweet_ID: bool = False + Display_Name: bool = False + Pinned_Tweet_ID: bool = False + Profile_Picture_URL: bool = False + Is_Protected_Account: bool = False + Account_Statistics: bool = False + Profile_URL: bool = False + Username: bool = False + Is_Verified: bool = False + Verification_Type: bool = False + Content_Withholding_Info: bool = False + + +class TweetFieldsFilter(BaseModel): + Tweet_Attachments: bool = False + Author_ID: bool = False + Context_Annotations: bool = False + Conversation_ID: bool = False + Creation_Time: bool = False + Edit_Controls: bool = False + Tweet_Entities: bool = False + Geographic_Location: bool = False + Tweet_ID: bool = False + Reply_To_User_ID: bool = False + Language: bool = False + Public_Metrics: bool = False + Sensitive_Content_Flag: bool = False + Referenced_Tweets: bool = False + Reply_Settings: bool = False + Tweet_Source: bool = False + Tweet_Text: bool = False + Withheld_Content: bool = False + + +class PersonalTweetFieldsFilter(BaseModel): + attachments: bool = False + author_id: bool = False + context_annotations: bool = False + conversation_id: bool = False + created_at: bool = False + edit_controls: bool = False + entities: bool = False + geo: bool = False + id: bool = False + in_reply_to_user_id: bool = False + lang: bool = False + non_public_metrics: bool = False + public_metrics: bool = False + organic_metrics: bool = False + promoted_metrics: bool = False + possibly_sensitive: bool = False + referenced_tweets: bool = False + reply_settings: bool = False + source: bool = False + text: bool = False + withheld: bool = False + + +class TweetPollFieldsFilter(BaseModel): + Duration_Minutes: bool = False + End_DateTime: bool = False + Poll_ID: bool = False + Poll_Options: bool = False + Voting_Status: bool = False + + +class TweetPlaceFieldsFilter(BaseModel): + Contained_Within_Places: bool = False + Country: bool = False + Country_Code: bool = False + Full_Location_Name: bool = False + Geographic_Coordinates: bool = False + Place_ID: bool = False + Place_Name: bool = False + Place_Type: bool = False + + +class TweetMediaFieldsFilter(BaseModel): + Duration_in_Milliseconds: bool = False + Height: bool = False + Media_Key: bool = False + Preview_Image_URL: bool = False + Media_Type: bool = False + Media_URL: bool = False + Width: bool = False + Public_Metrics: bool = False + Non_Public_Metrics: bool = False + Organic_Metrics: bool = False + Promoted_Metrics: bool = False + Alternative_Text: bool = False + Media_Variants: bool = False + + +class ExpansionFilter(BaseModel): + Poll_IDs: bool = False + Media_Keys: bool = False + Author_User_ID: bool = False + Edit_History_Tweet_IDs: bool = False + Mentioned_Usernames: bool = False + Place_ID: bool = False + Reply_To_User_ID: bool = False + Referenced_Tweet_ID: bool = False + Referenced_Tweet_Author_ID: bool = False + + +class TweetExcludesFilter(BaseModel): + retweets: bool = False + replies: bool = False + + +# -------------- Users ----------------- + + +class UserExpansionsFilter(BaseModel): + pinned_tweet_id: bool = False + + +# -------------- DM's' ----------------- + + +class DMEventFieldFilter(BaseModel): + id: bool = False + text: bool = False + event_type: bool = False + created_at: bool = False + dm_conversation_id: bool = False + sender_id: bool = False + participant_ids: bool = False + referenced_tweets: bool = False + attachments: bool = False + + +class DMEventTypeFilter(BaseModel): + MessageCreate: bool = False + ParticipantsJoin: bool = False + ParticipantsLeave: bool = False + + +class DMEventExpansionFilter(BaseModel): + attachments_media_keys: bool = False + referenced_tweets_id: bool = False + sender_id: bool = False + participant_ids: bool = False + + +class DMMediaFieldFilter(BaseModel): + duration_ms: bool = False + height: bool = False + media_key: bool = False + preview_image_url: bool = False + type: bool = False + url: bool = False + width: bool = False + public_metrics: bool = False + alt_text: bool = False + variants: bool = False + + +class DMTweetFieldFilter(BaseModel): + attachments: bool = False + author_id: bool = False + context_annotations: bool = False + conversation_id: bool = False + created_at: bool = False + edit_controls: bool = False + entities: bool = False + geo: bool = False + id: bool = False + in_reply_to_user_id: bool = False + lang: bool = False + public_metrics: bool = False + possibly_sensitive: bool = False + referenced_tweets: bool = False + reply_settings: bool = False + source: bool = False + text: bool = False + withheld: bool = False + + +# -------------- Spaces ----------------- + + +class SpaceExpansionsFilter(BaseModel): + Invited_Users: bool = False + Speakers: bool = False + Creator: bool = False + Hosts: bool = False + Topics: bool = False + + +class SpaceFieldsFilter(BaseModel): + Space_ID: bool = False + Space_State: bool = False + Creation_Time: bool = False + End_Time: bool = False + Host_User_IDs: bool = False + Language: bool = False + Is_Ticketed: bool = False + Invited_User_IDs: bool = False + Participant_Count: bool = False + Subscriber_Count: bool = False + Scheduled_Start_Time: bool = False + Speaker_User_IDs: bool = False + Start_Time: bool = False + Space_Title: bool = False + Topic_IDs: bool = False + Last_Updated_Time: bool = False + + +class SpaceStatesFilter(str, Enum): + live = "live" + scheduled = "scheduled" + all = "all" + + +# -------------- List Expansions ----------------- + + +class ListExpansionsFilter(BaseModel): + List_Owner_ID: bool = False + + +class ListFieldsFilter(BaseModel): + List_ID: bool = False + List_Name: bool = False + Creation_Date: bool = False + Description: bool = False + Follower_Count: bool = False + Member_Count: bool = False + Is_Private: bool = False + Owner_ID: bool = False + + +# --------- [Input Types] ------------- +class TweetExpansionInputs(BlockSchema): + + expansions: ExpansionFilter | None = SchemaField( + description="Choose what extra information you want to get with your tweets. For example:\n- Select 'Media_Keys' to get media details\n- Select 'Author_User_ID' to get user information\n- Select 'Place_ID' to get location details", + placeholder="Pick the extra information you want to see", + default=None, + advanced=True, + ) + + media_fields: TweetMediaFieldsFilter | None = SchemaField( + description="Select what media information you want to see (images, videos, etc). To use this, you must first select 'Media_Keys' in the expansions above.", + placeholder="Choose what media details you want to see", + default=None, + advanced=True, + ) + + place_fields: TweetPlaceFieldsFilter | None = SchemaField( + description="Select what location information you want to see (country, coordinates, etc). To use this, you must first select 'Place_ID' in the expansions above.", + placeholder="Choose what location details you want to see", + default=None, + advanced=True, + ) + + poll_fields: TweetPollFieldsFilter | None = SchemaField( + description="Select what poll information you want to see (options, voting status, etc). To use this, you must first select 'Poll_IDs' in the expansions above.", + placeholder="Choose what poll details you want to see", + default=None, + advanced=True, + ) + + tweet_fields: TweetFieldsFilter | None = SchemaField( + description="Select what tweet information you want to see. For referenced tweets (like retweets), select 'Referenced_Tweet_ID' in the expansions above.", + placeholder="Choose what tweet details you want to see", + default=None, + advanced=True, + ) + + user_fields: TweetUserFieldsFilter | None = SchemaField( + description="Select what user information you want to see. To use this, you must first select one of these in expansions above:\n- 'Author_User_ID' for tweet authors\n- 'Mentioned_Usernames' for mentioned users\n- 'Reply_To_User_ID' for users being replied to\n- 'Referenced_Tweet_Author_ID' for authors of referenced tweets", + placeholder="Choose what user details you want to see", + default=None, + advanced=True, + ) + + +class DMEventExpansionInputs(BlockSchema): + expansions: DMEventExpansionFilter | None = SchemaField( + description="Select expansions to include related data objects in the 'includes' section.", + placeholder="Enter expansions", + default=None, + advanced=True, + ) + + event_types: DMEventTypeFilter | None = SchemaField( + description="Select DM event types to include in the response.", + placeholder="Enter event types", + default=None, + advanced=True, + ) + + media_fields: DMMediaFieldFilter | None = SchemaField( + description="Select media fields to include in the response (requires expansions=attachments.media_keys).", + placeholder="Enter media fields", + default=None, + advanced=True, + ) + + tweet_fields: DMTweetFieldFilter | None = SchemaField( + description="Select tweet fields to include in the response (requires expansions=referenced_tweets.id).", + placeholder="Enter tweet fields", + default=None, + advanced=True, + ) + + user_fields: TweetUserFieldsFilter | None = SchemaField( + description="Select user fields to include in the response (requires expansions=sender_id or participant_ids).", + placeholder="Enter user fields", + default=None, + advanced=True, + ) + + +class UserExpansionInputs(BlockSchema): + expansions: UserExpansionsFilter | None = SchemaField( + description="Choose what extra information you want to get with user data. Currently only 'pinned_tweet_id' is available to see a user's pinned tweet.", + placeholder="Select extra user information to include", + default=None, + advanced=True, + ) + + tweet_fields: TweetFieldsFilter | None = SchemaField( + description="Select what tweet information you want to see in pinned tweets. This only works if you select 'pinned_tweet_id' in expansions above.", + placeholder="Choose what details to see in pinned tweets", + default=None, + advanced=True, + ) + + user_fields: TweetUserFieldsFilter | None = SchemaField( + description="Select what user information you want to see, like username, bio, profile picture, etc.", + placeholder="Choose what user details you want to see", + default=None, + advanced=True, + ) + + +class SpaceExpansionInputs(BlockSchema): + expansions: SpaceExpansionsFilter | None = SchemaField( + description="Choose additional information you want to get with your Twitter Spaces:\n- Select 'Invited_Users' to see who was invited\n- Select 'Speakers' to see who can speak\n- Select 'Creator' to get details about who made the Space\n- Select 'Hosts' to see who's hosting\n- Select 'Topics' to see Space topics", + placeholder="Pick what extra information you want to see about the Space", + default=None, + advanced=True, + ) + + space_fields: SpaceFieldsFilter | None = SchemaField( + description="Choose what Space details you want to see, such as:\n- Title\n- Start/End times\n- Number of participants\n- Language\n- State (live/scheduled)\n- And more", + placeholder="Choose what Space information you want to get", + default=SpaceFieldsFilter(Space_Title=True, Host_User_IDs=True), + advanced=True, + ) + + user_fields: TweetUserFieldsFilter | None = SchemaField( + description="Choose what user information you want to see. This works when you select any of these in expansions above:\n- 'Creator' for Space creator details\n- 'Hosts' for host information\n- 'Speakers' for speaker details\n- 'Invited_Users' for invited user information", + placeholder="Pick what details you want to see about the users", + default=None, + advanced=True, + ) + + +class ListExpansionInputs(BlockSchema): + expansions: ListExpansionsFilter | None = SchemaField( + description="Choose what extra information you want to get with your Twitter Lists:\n- Select 'List_Owner_ID' to get details about who owns the list\n\nThis will let you see more details about the list owner when you also select user fields below.", + placeholder="Pick what extra list information you want to see", + default=ListExpansionsFilter(List_Owner_ID=True), + advanced=True, + ) + + user_fields: TweetUserFieldsFilter | None = SchemaField( + description="Choose what information you want to see about list owners. This only works when you select 'List_Owner_ID' in expansions above.\n\nYou can see things like:\n- Their username\n- Profile picture\n- Account details\n- And more", + placeholder="Select what details you want to see about list owners", + default=TweetUserFieldsFilter(User_ID=True, Username=True), + advanced=True, + ) + + list_fields: ListFieldsFilter | None = SchemaField( + description="Choose what information you want to see about the Twitter Lists themselves, such as:\n- List name\n- Description\n- Number of followers\n- Number of members\n- Whether it's private\n- Creation date\n- And more", + placeholder="Pick what list details you want to see", + default=ListFieldsFilter(Owner_ID=True), + advanced=True, + ) + + +class TweetTimeWindowInputs(BlockSchema): + start_time: datetime | None = SchemaField( + description="Start time in YYYY-MM-DDTHH:mm:ssZ format", + placeholder="Enter start time", + default=None, + advanced=False, + ) + + end_time: datetime | None = SchemaField( + description="End time in YYYY-MM-DDTHH:mm:ssZ format", + placeholder="Enter end time", + default=None, + advanced=False, + ) + + since_id: str | None = SchemaField( + description="Returns results with Tweet ID greater than this (more recent than), we give priority to since_id over start_time", + placeholder="Enter since ID", + default=None, + advanced=True, + ) + + until_id: str | None = SchemaField( + description="Returns results with Tweet ID less than this (that is, older than), and used with since_id", + placeholder="Enter until ID", + default=None, + advanced=True, + ) + + sort_order: str | None = SchemaField( + description="Order of returned tweets (recency or relevancy)", + placeholder="Enter sort order", + default=None, + advanced=True, + ) diff --git a/autogpt_platform/backend/backend/blocks/twitter/direct_message/direct_message_lookup.py b/autogpt_platform/backend/backend/blocks/twitter/direct_message/direct_message_lookup.py new file mode 100644 index 000000000000..56a62d166eaf --- /dev/null +++ b/autogpt_platform/backend/backend/blocks/twitter/direct_message/direct_message_lookup.py @@ -0,0 +1,201 @@ +# Todo : Add new Type support + +# from typing import cast +# import tweepy +# from tweepy.client import Response + +# from backend.blocks.twitter._serializer import IncludesSerializer, ResponseDataSerializer +# from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema +# from backend.data.model import SchemaField +# from backend.blocks.twitter._builders import DMExpansionsBuilder +# from backend.blocks.twitter._types import DMEventExpansion, DMEventExpansionInputs, DMEventType, DMMediaField, DMTweetField, TweetUserFields +# from backend.blocks.twitter.tweepy_exceptions import handle_tweepy_exception +# from backend.blocks.twitter._auth import ( +# TEST_CREDENTIALS, +# TEST_CREDENTIALS_INPUT, +# TwitterCredentials, +# TwitterCredentialsField, +# TwitterCredentialsInput, +# ) + +# Require Pro or Enterprise plan [Manual Testing Required] +# class TwitterGetDMEventsBlock(Block): +# """ +# Gets a list of Direct Message events for the authenticated user +# """ + +# class Input(DMEventExpansionInputs): +# credentials: TwitterCredentialsInput = TwitterCredentialsField( +# ["dm.read", "offline.access", "user.read", "tweet.read"] +# ) + +# dm_conversation_id: str = SchemaField( +# description="The ID of the Direct Message conversation", +# placeholder="Enter conversation ID", +# required=True +# ) + +# max_results: int = SchemaField( +# description="Maximum number of results to return (1-100)", +# placeholder="Enter max results", +# advanced=True, +# default=10, +# ) + +# pagination_token: str = SchemaField( +# description="Token for pagination", +# placeholder="Enter pagination token", +# advanced=True, +# default="" +# ) + +# class Output(BlockSchema): +# # Common outputs +# event_ids: list[str] = SchemaField(description="DM Event IDs") +# event_texts: list[str] = SchemaField(description="DM Event text contents") +# event_types: list[str] = SchemaField(description="Types of DM events") +# next_token: str = SchemaField(description="Token for next page of results") + +# # Complete outputs +# data: list[dict] = SchemaField(description="Complete DM events data") +# included: dict = SchemaField(description="Additional data requested via expansions") +# meta: dict = SchemaField(description="Metadata about the response") +# error: str = SchemaField(description="Error message if request failed") + +# def __init__(self): +# super().__init__( +# id="dc37a6d4-a62e-11ef-a3a5-03061375737b", +# description="This block retrieves Direct Message events for the authenticated user.", +# categories={BlockCategory.SOCIAL}, +# input_schema=TwitterGetDMEventsBlock.Input, +# output_schema=TwitterGetDMEventsBlock.Output, +# test_input={ +# "dm_conversation_id": "1234567890", +# "max_results": 10, +# "credentials": TEST_CREDENTIALS_INPUT, +# "expansions": [], +# "event_types": [], +# "media_fields": [], +# "tweet_fields": [], +# "user_fields": [] +# }, +# test_credentials=TEST_CREDENTIALS, +# test_output=[ +# ("event_ids", ["1346889436626259968"]), +# ("event_texts", ["Hello just you..."]), +# ("event_types", ["MessageCreate"]), +# ("next_token", None), +# ("data", [{"id": "1346889436626259968", "text": "Hello just you...", "event_type": "MessageCreate"}]), +# ("included", {}), +# ("meta", {}), +# ("error", "") +# ], +# test_mock={ +# "get_dm_events": lambda *args, **kwargs: ( +# [{"id": "1346889436626259968", "text": "Hello just you...", "event_type": "MessageCreate"}], +# {}, +# {}, +# ["1346889436626259968"], +# ["Hello just you..."], +# ["MessageCreate"], +# None +# ) +# } +# ) + +# @staticmethod +# def get_dm_events( +# credentials: TwitterCredentials, +# dm_conversation_id: str, +# max_results: int, +# pagination_token: str, +# expansions: list[DMEventExpansion], +# event_types: list[DMEventType], +# media_fields: list[DMMediaField], +# tweet_fields: list[DMTweetField], +# user_fields: list[TweetUserFields] +# ): +# try: +# client = tweepy.Client( +# bearer_token=credentials.access_token.get_secret_value() +# ) + +# params = { +# "dm_conversation_id": dm_conversation_id, +# "max_results": max_results, +# "pagination_token": None if pagination_token == "" else pagination_token, +# "user_auth": False +# } + +# params = (DMExpansionsBuilder(params) +# .add_expansions(expansions) +# .add_event_types(event_types) +# .add_media_fields(media_fields) +# .add_tweet_fields(tweet_fields) +# .add_user_fields(user_fields) +# .build()) + +# response = cast(Response, client.get_direct_message_events(**params)) + +# meta = {} +# event_ids = [] +# event_texts = [] +# event_types = [] +# next_token = None + +# if response.meta: +# meta = response.meta +# next_token = meta.get("next_token") + +# included = IncludesSerializer.serialize(response.includes) +# data = ResponseDataSerializer.serialize_list(response.data) + +# if response.data: +# event_ids = [str(item.id) for item in response.data] +# event_texts = [item.text if hasattr(item, "text") else None for item in response.data] +# event_types = [item.event_type for item in response.data] + +# return data, included, meta, event_ids, event_texts, event_types, next_token + +# raise Exception("No DM events found") + +# except tweepy.TweepyException: +# raise + +# def run( +# self, +# input_data: Input, +# *, +# credentials: TwitterCredentials, +# **kwargs, +# ) -> BlockOutput: +# try: +# event_data, included, meta, event_ids, event_texts, event_types, next_token = self.get_dm_events( +# credentials, +# input_data.dm_conversation_id, +# input_data.max_results, +# input_data.pagination_token, +# input_data.expansions, +# input_data.event_types, +# input_data.media_fields, +# input_data.tweet_fields, +# input_data.user_fields +# ) + +# if event_ids: +# yield "event_ids", event_ids +# if event_texts: +# yield "event_texts", event_texts +# if event_types: +# yield "event_types", event_types +# if next_token: +# yield "next_token", next_token +# if event_data: +# yield "data", event_data +# if included: +# yield "included", included +# if meta: +# yield "meta", meta + +# except Exception as e: +# yield "error", handle_tweepy_exception(e) diff --git a/autogpt_platform/backend/backend/blocks/twitter/direct_message/manage_direct_message.py b/autogpt_platform/backend/backend/blocks/twitter/direct_message/manage_direct_message.py new file mode 100644 index 000000000000..f25331db9748 --- /dev/null +++ b/autogpt_platform/backend/backend/blocks/twitter/direct_message/manage_direct_message.py @@ -0,0 +1,260 @@ +# Todo : Add new Type support + +# from typing import cast + +# import tweepy +# from tweepy.client import Response + +# from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema +# from backend.data.model import SchemaField +# from backend.blocks.twitter.tweepy_exceptions import handle_tweepy_exception +# from backend.blocks.twitter._auth import ( +# TEST_CREDENTIALS, +# TEST_CREDENTIALS_INPUT, +# TwitterCredentials, +# TwitterCredentialsField, +# TwitterCredentialsInput, +# ) + +# Pro and Enterprise plan [Manual Testing Required] +# class TwitterSendDirectMessageBlock(Block): +# """ +# Sends a direct message to a Twitter user +# """ + +# class Input(BlockSchema): +# credentials: TwitterCredentialsInput = TwitterCredentialsField( +# ["offline.access", "direct_messages.write"] +# ) + +# participant_id: str = SchemaField( +# description="The User ID of the account to send DM to", +# placeholder="Enter recipient user ID", +# default="", +# advanced=False +# ) + +# dm_conversation_id: str = SchemaField( +# description="The conversation ID to send message to", +# placeholder="Enter conversation ID", +# default="", +# advanced=False +# ) + +# text: str = SchemaField( +# description="Text of the Direct Message (up to 10,000 characters)", +# placeholder="Enter message text", +# default="", +# advanced=False +# ) + +# media_id: str = SchemaField( +# description="Media ID to attach to the message", +# placeholder="Enter media ID", +# default="" +# ) + +# class Output(BlockSchema): +# dm_event_id: str = SchemaField(description="ID of the sent direct message") +# dm_conversation_id_: str = SchemaField(description="ID of the conversation") +# error: str = SchemaField(description="Error message if sending failed") + +# def __init__(self): +# super().__init__( +# id="f32f2786-a62e-11ef-a93d-a3ef199dde7f", +# description="This block sends a direct message to a specified Twitter user.", +# categories={BlockCategory.SOCIAL}, +# input_schema=TwitterSendDirectMessageBlock.Input, +# output_schema=TwitterSendDirectMessageBlock.Output, +# test_input={ +# "participant_id": "783214", +# "dm_conversation_id": "", +# "text": "Hello from Twitter API", +# "media_id": "", +# "credentials": TEST_CREDENTIALS_INPUT +# }, +# test_credentials=TEST_CREDENTIALS, +# test_output=[ +# ("dm_event_id", "0987654321"), +# ("dm_conversation_id_", "1234567890"), +# ("error", "") +# ], +# test_mock={ +# "send_direct_message": lambda *args, **kwargs: ( +# "0987654321", +# "1234567890" +# ) +# }, +# ) + +# @staticmethod +# def send_direct_message( +# credentials: TwitterCredentials, +# participant_id: str, +# dm_conversation_id: str, +# text: str, +# media_id: str +# ): +# try: +# client = tweepy.Client( +# bearer_token=credentials.access_token.get_secret_value() +# ) + +# response = cast( +# Response, +# client.create_direct_message( +# participant_id=None if participant_id == "" else participant_id, +# dm_conversation_id=None if dm_conversation_id == "" else dm_conversation_id, +# text=None if text == "" else text, +# media_id=None if media_id == "" else media_id, +# user_auth=False +# ) +# ) + +# if not response.data: +# raise Exception("Failed to send direct message") + +# return response.data["dm_event_id"], response.data["dm_conversation_id"] + +# except tweepy.TweepyException: +# raise +# except Exception as e: +# print(f"Unexpected error: {str(e)}") +# raise + +# def run( +# self, +# input_data: Input, +# *, +# credentials: TwitterCredentials, +# **kwargs, +# ) -> BlockOutput: +# try: +# dm_event_id, dm_conversation_id = self.send_direct_message( +# credentials, +# input_data.participant_id, +# input_data.dm_conversation_id, +# input_data.text, +# input_data.media_id +# ) +# yield "dm_event_id", dm_event_id +# yield "dm_conversation_id", dm_conversation_id + +# except Exception as e: +# yield "error", handle_tweepy_exception(e) + +# class TwitterCreateDMConversationBlock(Block): +# """ +# Creates a new group direct message conversation on Twitter +# """ + +# class Input(BlockSchema): +# credentials: TwitterCredentialsInput = TwitterCredentialsField( +# ["offline.access", "dm.write","dm.read","tweet.read","user.read"] +# ) + +# participant_ids: list[str] = SchemaField( +# description="Array of User IDs to create conversation with (max 50)", +# placeholder="Enter participant user IDs", +# default=[], +# advanced=False +# ) + +# text: str = SchemaField( +# description="Text of the Direct Message (up to 10,000 characters)", +# placeholder="Enter message text", +# default="", +# advanced=False +# ) + +# media_id: str = SchemaField( +# description="Media ID to attach to the message", +# placeholder="Enter media ID", +# default="", +# advanced=False +# ) + +# class Output(BlockSchema): +# dm_event_id: str = SchemaField(description="ID of the sent direct message") +# dm_conversation_id: str = SchemaField(description="ID of the conversation") +# error: str = SchemaField(description="Error message if sending failed") + +# def __init__(self): +# super().__init__( +# id="ec11cabc-a62e-11ef-8c0e-3fe37ba2ec92", +# description="This block creates a new group DM conversation with specified Twitter users.", +# categories={BlockCategory.SOCIAL}, +# input_schema=TwitterCreateDMConversationBlock.Input, +# output_schema=TwitterCreateDMConversationBlock.Output, +# test_input={ +# "participant_ids": ["783214", "2244994945"], +# "text": "Hello from Twitter API", +# "media_id": "", +# "credentials": TEST_CREDENTIALS_INPUT +# }, +# test_credentials=TEST_CREDENTIALS, +# test_output=[ +# ("dm_event_id", "0987654321"), +# ("dm_conversation_id", "1234567890"), +# ("error", "") +# ], +# test_mock={ +# "create_dm_conversation": lambda *args, **kwargs: ( +# "0987654321", +# "1234567890" +# ) +# }, +# ) + +# @staticmethod +# def create_dm_conversation( +# credentials: TwitterCredentials, +# participant_ids: list[str], +# text: str, +# media_id: str +# ): +# try: +# client = tweepy.Client( +# bearer_token=credentials.access_token.get_secret_value() +# ) + +# response = cast( +# Response, +# client.create_direct_message_conversation( +# participant_ids=participant_ids, +# text=None if text == "" else text, +# media_id=None if media_id == "" else media_id, +# user_auth=False +# ) +# ) + +# if not response.data: +# raise Exception("Failed to create DM conversation") + +# return response.data["dm_event_id"], response.data["dm_conversation_id"] + +# except tweepy.TweepyException: +# raise +# except Exception as e: +# print(f"Unexpected error: {str(e)}") +# raise + +# def run( +# self, +# input_data: Input, +# *, +# credentials: TwitterCredentials, +# **kwargs, +# ) -> BlockOutput: +# try: +# dm_event_id, dm_conversation_id = self.create_dm_conversation( +# credentials, +# input_data.participant_ids, +# input_data.text, +# input_data.media_id +# ) +# yield "dm_event_id", dm_event_id +# yield "dm_conversation_id", dm_conversation_id + +# except Exception as e: +# yield "error", handle_tweepy_exception(e) diff --git a/autogpt_platform/backend/backend/blocks/twitter/lists/list_follows.py b/autogpt_platform/backend/backend/blocks/twitter/lists/list_follows.py new file mode 100644 index 000000000000..99a0108296ae --- /dev/null +++ b/autogpt_platform/backend/backend/blocks/twitter/lists/list_follows.py @@ -0,0 +1,470 @@ +# from typing import cast +import tweepy + +from backend.blocks.twitter._auth import ( + TEST_CREDENTIALS, + TEST_CREDENTIALS_INPUT, + TwitterCredentials, + TwitterCredentialsField, + TwitterCredentialsInput, +) + +# from backend.blocks.twitter._builders import UserExpansionsBuilder +# from backend.blocks.twitter._types import TweetFields, TweetUserFields, UserExpansionInputs, UserExpansions +from backend.blocks.twitter.tweepy_exceptions import handle_tweepy_exception +from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema +from backend.data.model import SchemaField + +# from tweepy.client import Response + + +class TwitterUnfollowListBlock(Block): + """ + Unfollows a Twitter list for the authenticated user + """ + + class Input(BlockSchema): + credentials: TwitterCredentialsInput = TwitterCredentialsField( + ["follows.write", "offline.access"] + ) + + list_id: str = SchemaField( + description="The ID of the List to unfollow", + placeholder="Enter list ID", + ) + + class Output(BlockSchema): + success: bool = SchemaField(description="Whether the unfollow was successful") + error: str = SchemaField(description="Error message if the request failed") + + def __init__(self): + super().__init__( + id="1f43310a-a62f-11ef-8276-2b06a1bbae1a", + description="This block unfollows a specified Twitter list for the authenticated user.", + categories={BlockCategory.SOCIAL}, + input_schema=TwitterUnfollowListBlock.Input, + output_schema=TwitterUnfollowListBlock.Output, + test_input={"list_id": "123456789", "credentials": TEST_CREDENTIALS_INPUT}, + test_credentials=TEST_CREDENTIALS, + test_output=[ + ("success", True), + ], + test_mock={"unfollow_list": lambda *args, **kwargs: True}, + ) + + @staticmethod + def unfollow_list(credentials: TwitterCredentials, list_id: str): + try: + client = tweepy.Client( + bearer_token=credentials.access_token.get_secret_value() + ) + + client.unfollow_list(list_id=list_id, user_auth=False) + + return True + + except tweepy.TweepyException: + raise + + def run( + self, + input_data: Input, + *, + credentials: TwitterCredentials, + **kwargs, + ) -> BlockOutput: + try: + success = self.unfollow_list(credentials, input_data.list_id) + yield "success", success + except Exception as e: + yield "error", handle_tweepy_exception(e) + + +class TwitterFollowListBlock(Block): + """ + Follows a Twitter list for the authenticated user + """ + + class Input(BlockSchema): + credentials: TwitterCredentialsInput = TwitterCredentialsField( + ["tweet.read", "users.read", "list.write", "offline.access"] + ) + + list_id: str = SchemaField( + description="The ID of the List to follow", + placeholder="Enter list ID", + ) + + class Output(BlockSchema): + success: bool = SchemaField(description="Whether the follow was successful") + error: str = SchemaField(description="Error message if the request failed") + + def __init__(self): + super().__init__( + id="03d8acf6-a62f-11ef-b17f-b72b04a09e79", + description="This block follows a specified Twitter list for the authenticated user.", + categories={BlockCategory.SOCIAL}, + input_schema=TwitterFollowListBlock.Input, + output_schema=TwitterFollowListBlock.Output, + test_input={"list_id": "123456789", "credentials": TEST_CREDENTIALS_INPUT}, + test_credentials=TEST_CREDENTIALS, + test_output=[ + ("success", True), + ], + test_mock={"follow_list": lambda *args, **kwargs: True}, + ) + + @staticmethod + def follow_list(credentials: TwitterCredentials, list_id: str): + try: + client = tweepy.Client( + bearer_token=credentials.access_token.get_secret_value() + ) + + client.follow_list(list_id=list_id, user_auth=False) + + return True + + except tweepy.TweepyException: + raise + + def run( + self, + input_data: Input, + *, + credentials: TwitterCredentials, + **kwargs, + ) -> BlockOutput: + try: + success = self.follow_list(credentials, input_data.list_id) + yield "success", success + except Exception as e: + yield "error", handle_tweepy_exception(e) + + +# Enterprise Level [Need to do Manual testing], There is a high possibility that we might get error in this +# Needs Type Input in this + +# class TwitterListGetFollowersBlock(Block): +# """ +# Gets followers of a specified Twitter list +# """ + +# class Input(UserExpansionInputs): +# credentials: TwitterCredentialsInput = TwitterCredentialsField( +# ["tweet.read","users.read", "list.read", "offline.access"] +# ) + +# list_id: str = SchemaField( +# description="The ID of the List to get followers for", +# placeholder="Enter list ID", +# required=True +# ) + +# max_results: int = SchemaField( +# description="Max number of results per page (1-100)", +# placeholder="Enter max results", +# default=10, +# advanced=True, +# ) + +# pagination_token: str = SchemaField( +# description="Token for pagination", +# placeholder="Enter pagination token", +# default="", +# advanced=True, +# ) + +# class Output(BlockSchema): +# user_ids: list[str] = SchemaField(description="List of user IDs of followers") +# usernames: list[str] = SchemaField(description="List of usernames of followers") +# next_token: str = SchemaField(description="Token for next page of results") +# data: list[dict] = SchemaField(description="Complete follower data") +# included: dict = SchemaField(description="Additional data requested via expansions") +# meta: dict = SchemaField(description="Metadata about the response") +# error: str = SchemaField(description="Error message if the request failed") + +# def __init__(self): +# super().__init__( +# id="16b289b4-a62f-11ef-95d4-bb29b849eb99", +# description="This block retrieves followers of a specified Twitter list.", +# categories={BlockCategory.SOCIAL}, +# input_schema=TwitterListGetFollowersBlock.Input, +# output_schema=TwitterListGetFollowersBlock.Output, +# test_input={ +# "list_id": "123456789", +# "max_results": 10, +# "pagination_token": None, +# "credentials": TEST_CREDENTIALS_INPUT, +# "expansions": [], +# "tweet_fields": [], +# "user_fields": [] +# }, +# test_credentials=TEST_CREDENTIALS, +# test_output=[ +# ("user_ids", ["2244994945"]), +# ("usernames", ["testuser"]), +# ("next_token", None), +# ("data", {"followers": [{"id": "2244994945", "username": "testuser"}]}), +# ("included", {}), +# ("meta", {}), +# ("error", "") +# ], +# test_mock={ +# "get_list_followers": lambda *args, **kwargs: ({ +# "followers": [{"id": "2244994945", "username": "testuser"}] +# }, {}, {}, ["2244994945"], ["testuser"], None) +# } +# ) + +# @staticmethod +# def get_list_followers( +# credentials: TwitterCredentials, +# list_id: str, +# max_results: int, +# pagination_token: str, +# expansions: list[UserExpansions], +# tweet_fields: list[TweetFields], +# user_fields: list[TweetUserFields] +# ): +# try: +# client = tweepy.Client( +# bearer_token=credentials.access_token.get_secret_value(), +# ) + +# params = { +# "id": list_id, +# "max_results": max_results, +# "pagination_token": None if pagination_token == "" else pagination_token, +# "user_auth": False +# } + +# params = (UserExpansionsBuilder(params) +# .add_expansions(expansions) +# .add_tweet_fields(tweet_fields) +# .add_user_fields(user_fields) +# .build()) + +# response = cast( +# Response, +# client.get_list_followers(**params) +# ) + +# meta = {} +# user_ids = [] +# usernames = [] +# next_token = None + +# if response.meta: +# meta = response.meta +# next_token = meta.get("next_token") + +# included = IncludesSerializer.serialize(response.includes) +# data = ResponseDataSerializer.serialize_list(response.data) + +# if response.data: +# user_ids = [str(item.id) for item in response.data] +# usernames = [item.username for item in response.data] + +# return data, included, meta, user_ids, usernames, next_token + +# raise Exception("No followers found") + +# except tweepy.TweepyException: +# raise + +# def run( +# self, +# input_data: Input, +# *, +# credentials: TwitterCredentials, +# **kwargs, +# ) -> BlockOutput: +# try: +# followers_data, included, meta, user_ids, usernames, next_token = self.get_list_followers( +# credentials, +# input_data.list_id, +# input_data.max_results, +# input_data.pagination_token, +# input_data.expansions, +# input_data.tweet_fields, +# input_data.user_fields +# ) + +# if user_ids: +# yield "user_ids", user_ids +# if usernames: +# yield "usernames", usernames +# if next_token: +# yield "next_token", next_token +# if followers_data: +# yield "data", followers_data +# if included: +# yield "included", included +# if meta: +# yield "meta", meta + +# except Exception as e: +# yield "error", handle_tweepy_exception(e) + +# class TwitterGetFollowedListsBlock(Block): +# """ +# Gets lists followed by a specified Twitter user +# """ + +# class Input(UserExpansionInputs): +# credentials: TwitterCredentialsInput = TwitterCredentialsField( +# ["follows.read", "users.read", "list.read", "offline.access"] +# ) + +# user_id: str = SchemaField( +# description="The user ID whose followed Lists to retrieve", +# placeholder="Enter user ID", +# required=True +# ) + +# max_results: int = SchemaField( +# description="Max number of results per page (1-100)", +# placeholder="Enter max results", +# default=10, +# advanced=True, +# ) + +# pagination_token: str = SchemaField( +# description="Token for pagination", +# placeholder="Enter pagination token", +# default="", +# advanced=True, +# ) + +# class Output(BlockSchema): +# list_ids: list[str] = SchemaField(description="List of list IDs") +# list_names: list[str] = SchemaField(description="List of list names") +# data: list[dict] = SchemaField(description="Complete list data") +# includes: dict = SchemaField(description="Additional data requested via expansions") +# meta: dict = SchemaField(description="Metadata about the response") +# next_token: str = SchemaField(description="Token for next page of results") +# error: str = SchemaField(description="Error message if the request failed") + +# def __init__(self): +# super().__init__( +# id="0e18bbfc-a62f-11ef-94fa-1f1e174b809e", +# description="This block retrieves all Lists a specified user follows.", +# categories={BlockCategory.SOCIAL}, +# input_schema=TwitterGetFollowedListsBlock.Input, +# output_schema=TwitterGetFollowedListsBlock.Output, +# test_input={ +# "user_id": "123456789", +# "max_results": 10, +# "pagination_token": None, +# "credentials": TEST_CREDENTIALS_INPUT, +# "expansions": [], +# "tweet_fields": [], +# "user_fields": [] +# }, +# test_credentials=TEST_CREDENTIALS, +# test_output=[ +# ("list_ids", ["12345"]), +# ("list_names", ["Test List"]), +# ("data", {"followed_lists": [{"id": "12345", "name": "Test List"}]}), +# ("includes", {}), +# ("meta", {}), +# ("next_token", None), +# ("error", "") +# ], +# test_mock={ +# "get_followed_lists": lambda *args, **kwargs: ({ +# "followed_lists": [{"id": "12345", "name": "Test List"}] +# }, {}, {}, ["12345"], ["Test List"], None) +# } +# ) + +# @staticmethod +# def get_followed_lists( +# credentials: TwitterCredentials, +# user_id: str, +# max_results: int, +# pagination_token: str, +# expansions: list[UserExpansions], +# tweet_fields: list[TweetFields], +# user_fields: list[TweetUserFields] +# ): +# try: +# client = tweepy.Client( +# bearer_token=credentials.access_token.get_secret_value(), +# ) + +# params = { +# "id": user_id, +# "max_results": max_results, +# "pagination_token": None if pagination_token == "" else pagination_token, +# "user_auth": False +# } + +# params = (UserExpansionsBuilder(params) +# .add_expansions(expansions) +# .add_tweet_fields(tweet_fields) +# .add_user_fields(user_fields) +# .build()) + +# response = cast( +# Response, +# client.get_followed_lists(**params) +# ) + +# meta = {} +# list_ids = [] +# list_names = [] +# next_token = None + +# if response.meta: +# meta = response.meta +# next_token = meta.get("next_token") + +# included = IncludesSerializer.serialize(response.includes) +# data = ResponseDataSerializer.serialize_list(response.data) + +# if response.data: +# list_ids = [str(item.id) for item in response.data] +# list_names = [item.name for item in response.data] + +# return data, included, meta, list_ids, list_names, next_token + +# raise Exception("No followed lists found") + +# except tweepy.TweepyException: +# raise + +# def run( +# self, +# input_data: Input, +# *, +# credentials: TwitterCredentials, +# **kwargs, +# ) -> BlockOutput: +# try: +# lists_data, included, meta, list_ids, list_names, next_token = self.get_followed_lists( +# credentials, +# input_data.user_id, +# input_data.max_results, +# input_data.pagination_token, +# input_data.expansions, +# input_data.tweet_fields, +# input_data.user_fields +# ) + +# if list_ids: +# yield "list_ids", list_ids +# if list_names: +# yield "list_names", list_names +# if next_token: +# yield "next_token", next_token +# if lists_data: +# yield "data", lists_data +# if included: +# yield "includes", included +# if meta: +# yield "meta", meta + +# except Exception as e: +# yield "error", handle_tweepy_exception(e) diff --git a/autogpt_platform/backend/backend/blocks/twitter/lists/list_lookup.py b/autogpt_platform/backend/backend/blocks/twitter/lists/list_lookup.py new file mode 100644 index 000000000000..5d5d3da6a40b --- /dev/null +++ b/autogpt_platform/backend/backend/blocks/twitter/lists/list_lookup.py @@ -0,0 +1,348 @@ +from typing import cast + +import tweepy +from tweepy.client import Response + +from backend.blocks.twitter._auth import ( + TEST_CREDENTIALS, + TEST_CREDENTIALS_INPUT, + TwitterCredentials, + TwitterCredentialsField, + TwitterCredentialsInput, +) +from backend.blocks.twitter._builders import ListExpansionsBuilder +from backend.blocks.twitter._serializer import ( + IncludesSerializer, + ResponseDataSerializer, +) +from backend.blocks.twitter._types import ( + ListExpansionInputs, + ListExpansionsFilter, + ListFieldsFilter, + TweetUserFieldsFilter, +) +from backend.blocks.twitter.tweepy_exceptions import handle_tweepy_exception +from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema +from backend.data.model import SchemaField + + +class TwitterGetListBlock(Block): + """ + Gets information about a Twitter List specified by ID + """ + + class Input(ListExpansionInputs): + credentials: TwitterCredentialsInput = TwitterCredentialsField( + ["tweet.read", "users.read", "offline.access"] + ) + + list_id: str = SchemaField( + description="The ID of the List to lookup", + placeholder="Enter list ID", + required=True, + ) + + class Output(BlockSchema): + # Common outputs + id: str = SchemaField(description="ID of the Twitter List") + name: str = SchemaField(description="Name of the Twitter List") + owner_id: str = SchemaField(description="ID of the List owner") + owner_username: str = SchemaField(description="Username of the List owner") + + # Complete outputs + data: dict = SchemaField(description="Complete list data") + included: dict = SchemaField( + description="Additional data requested via expansions" + ) + meta: dict = SchemaField(description="Metadata about the response") + error: str = SchemaField(description="Error message if the request failed") + + def __init__(self): + super().__init__( + id="34ebc80a-a62f-11ef-9c2a-3fcab6c07079", + description="This block retrieves information about a specified Twitter List.", + categories={BlockCategory.SOCIAL}, + input_schema=TwitterGetListBlock.Input, + output_schema=TwitterGetListBlock.Output, + test_input={ + "list_id": "84839422", + "credentials": TEST_CREDENTIALS_INPUT, + "expansions": None, + "list_fields": None, + "user_fields": None, + }, + test_credentials=TEST_CREDENTIALS, + test_output=[ + ("id", "84839422"), + ("name", "Official Twitter Accounts"), + ("owner_id", "2244994945"), + ("owner_username", "TwitterAPI"), + ("data", {"id": "84839422", "name": "Official Twitter Accounts"}), + ], + test_mock={ + "get_list": lambda *args, **kwargs: ( + {"id": "84839422", "name": "Official Twitter Accounts"}, + {}, + {}, + "2244994945", + "TwitterAPI", + ) + }, + ) + + @staticmethod + def get_list( + credentials: TwitterCredentials, + list_id: str, + expansions: ListExpansionsFilter | None, + user_fields: TweetUserFieldsFilter | None, + list_fields: ListFieldsFilter | None, + ): + try: + client = tweepy.Client( + bearer_token=credentials.access_token.get_secret_value() + ) + + params = {"id": list_id, "user_auth": False} + + params = ( + ListExpansionsBuilder(params) + .add_expansions(expansions) + .add_user_fields(user_fields) + .add_list_fields(list_fields) + .build() + ) + + response = cast(Response, client.get_list(**params)) + + meta = {} + owner_id = "" + owner_username = "" + included = {} + + if response.includes: + included = IncludesSerializer.serialize(response.includes) + + if "users" in included: + owner_id = str(included["users"][0]["id"]) + owner_username = included["users"][0]["username"] + + if response.meta: + meta = response.meta + + if response.data: + data_dict = ResponseDataSerializer.serialize_dict(response.data) + return data_dict, included, meta, owner_id, owner_username + + raise Exception("List not found") + + except tweepy.TweepyException: + raise + + def run( + self, + input_data: Input, + *, + credentials: TwitterCredentials, + **kwargs, + ) -> BlockOutput: + try: + list_data, included, meta, owner_id, owner_username = self.get_list( + credentials, + input_data.list_id, + input_data.expansions, + input_data.user_fields, + input_data.list_fields, + ) + + yield "id", str(list_data["id"]) + yield "name", list_data["name"] + if owner_id: + yield "owner_id", owner_id + if owner_username: + yield "owner_username", owner_username + yield "data", {"id": list_data["id"], "name": list_data["name"]} + if included: + yield "included", included + if meta: + yield "meta", meta + + except Exception as e: + yield "error", handle_tweepy_exception(e) + + +class TwitterGetOwnedListsBlock(Block): + """ + Gets all Lists owned by the specified user + """ + + class Input(ListExpansionInputs): + credentials: TwitterCredentialsInput = TwitterCredentialsField( + ["tweet.read", "users.read", "list.read", "offline.access"] + ) + + user_id: str = SchemaField( + description="The user ID whose owned Lists to retrieve", + placeholder="Enter user ID", + required=True, + ) + + max_results: int | None = SchemaField( + description="Maximum number of results per page (1-100)", + placeholder="Enter max results (default 100)", + advanced=True, + default=10, + ) + + pagination_token: str | None = SchemaField( + description="Token for pagination", + placeholder="Enter pagination token", + advanced=True, + default="", + ) + + class Output(BlockSchema): + # Common outputs + list_ids: list[str] = SchemaField(description="List ids of the owned lists") + list_names: list[str] = SchemaField(description="List names of the owned lists") + next_token: str = SchemaField(description="Token for next page of results") + + # Complete outputs + data: list[dict] = SchemaField(description="Complete owned lists data") + included: dict = SchemaField( + description="Additional data requested via expansions" + ) + meta: dict = SchemaField(description="Metadata about the response") + error: str = SchemaField(description="Error message if the request failed") + + def __init__(self): + super().__init__( + id="2b6bdb26-a62f-11ef-a9ce-ff89c2568726", + description="This block retrieves all Lists owned by a specified Twitter user.", + categories={BlockCategory.SOCIAL}, + input_schema=TwitterGetOwnedListsBlock.Input, + output_schema=TwitterGetOwnedListsBlock.Output, + test_input={ + "user_id": "2244994945", + "max_results": 10, + "credentials": TEST_CREDENTIALS_INPUT, + "expansions": None, + "list_fields": None, + "user_fields": None, + }, + test_credentials=TEST_CREDENTIALS, + test_output=[ + ("list_ids", ["84839422"]), + ("list_names", ["Official Twitter Accounts"]), + ("data", [{"id": "84839422", "name": "Official Twitter Accounts"}]), + ], + test_mock={ + "get_owned_lists": lambda *args, **kwargs: ( + [{"id": "84839422", "name": "Official Twitter Accounts"}], + {}, + {}, + ["84839422"], + ["Official Twitter Accounts"], + None, + ) + }, + ) + + @staticmethod + def get_owned_lists( + credentials: TwitterCredentials, + user_id: str, + max_results: int | None, + pagination_token: str | None, + expansions: ListExpansionsFilter | None, + user_fields: TweetUserFieldsFilter | None, + list_fields: ListFieldsFilter | None, + ): + try: + client = tweepy.Client( + bearer_token=credentials.access_token.get_secret_value() + ) + + params = { + "id": user_id, + "max_results": max_results, + "pagination_token": ( + None if pagination_token == "" else pagination_token + ), + "user_auth": False, + } + + params = ( + ListExpansionsBuilder(params) + .add_expansions(expansions) + .add_user_fields(user_fields) + .add_list_fields(list_fields) + .build() + ) + + response = cast(Response, client.get_owned_lists(**params)) + + meta = {} + included = {} + list_ids = [] + list_names = [] + next_token = None + + if response.meta: + meta = response.meta + next_token = meta.get("next_token") + + if response.includes: + included = IncludesSerializer.serialize(response.includes) + + if response.data: + data = ResponseDataSerializer.serialize_list(response.data) + list_ids = [ + str(item.id) for item in response.data if hasattr(item, "id") + ] + list_names = [ + item.name for item in response.data if hasattr(item, "name") + ] + + return data, included, meta, list_ids, list_names, next_token + + raise Exception("User have no owned list") + + except tweepy.TweepyException: + raise + + def run( + self, + input_data: Input, + *, + credentials: TwitterCredentials, + **kwargs, + ) -> BlockOutput: + try: + list_data, included, meta, list_ids, list_names, next_token = ( + self.get_owned_lists( + credentials, + input_data.user_id, + input_data.max_results, + input_data.pagination_token, + input_data.expansions, + input_data.user_fields, + input_data.list_fields, + ) + ) + + if list_ids: + yield "list_ids", list_ids + if list_names: + yield "list_names", list_names + if next_token: + yield "next_token", next_token + if list_data: + yield "data", list_data + if included: + yield "included", included + if meta: + yield "meta", meta + + except Exception as e: + yield "error", handle_tweepy_exception(e) diff --git a/autogpt_platform/backend/backend/blocks/twitter/lists/list_members.py b/autogpt_platform/backend/backend/blocks/twitter/lists/list_members.py new file mode 100644 index 000000000000..8e0bfd740521 --- /dev/null +++ b/autogpt_platform/backend/backend/blocks/twitter/lists/list_members.py @@ -0,0 +1,527 @@ +from typing import cast + +import tweepy +from tweepy.client import Response + +from backend.blocks.twitter._auth import ( + TEST_CREDENTIALS, + TEST_CREDENTIALS_INPUT, + TwitterCredentials, + TwitterCredentialsField, + TwitterCredentialsInput, +) +from backend.blocks.twitter._builders import ( + ListExpansionsBuilder, + UserExpansionsBuilder, +) +from backend.blocks.twitter._serializer import ( + IncludesSerializer, + ResponseDataSerializer, +) +from backend.blocks.twitter._types import ( + ListExpansionInputs, + ListExpansionsFilter, + ListFieldsFilter, + TweetFieldsFilter, + TweetUserFieldsFilter, + UserExpansionInputs, + UserExpansionsFilter, +) +from backend.blocks.twitter.tweepy_exceptions import handle_tweepy_exception +from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema +from backend.data.model import SchemaField + + +class TwitterRemoveListMemberBlock(Block): + """ + Removes a member from a Twitter List that the authenticated user owns + """ + + class Input(BlockSchema): + credentials: TwitterCredentialsInput = TwitterCredentialsField( + ["list.write", "users.read", "tweet.read", "offline.access"] + ) + + list_id: str = SchemaField( + description="The ID of the List to remove the member from", + placeholder="Enter list ID", + required=True, + ) + + user_id: str = SchemaField( + description="The ID of the user to remove from the List", + placeholder="Enter user ID to remove", + required=True, + ) + + class Output(BlockSchema): + success: bool = SchemaField( + description="Whether the member was successfully removed" + ) + error: str = SchemaField(description="Error message if the removal failed") + + def __init__(self): + super().__init__( + id="5a3d1320-a62f-11ef-b7ce-a79e7656bcb0", + description="This block removes a specified user from a Twitter List owned by the authenticated user.", + categories={BlockCategory.SOCIAL}, + input_schema=TwitterRemoveListMemberBlock.Input, + output_schema=TwitterRemoveListMemberBlock.Output, + test_input={ + "list_id": "123456789", + "user_id": "987654321", + "credentials": TEST_CREDENTIALS_INPUT, + }, + test_credentials=TEST_CREDENTIALS, + test_output=[("success", True)], + test_mock={"remove_list_member": lambda *args, **kwargs: True}, + ) + + @staticmethod + def remove_list_member(credentials: TwitterCredentials, list_id: str, user_id: str): + try: + client = tweepy.Client( + bearer_token=credentials.access_token.get_secret_value() + ) + client.remove_list_member(id=list_id, user_id=user_id, user_auth=False) + return True + except tweepy.TweepyException: + raise + except Exception: + raise + + def run( + self, + input_data: Input, + *, + credentials: TwitterCredentials, + **kwargs, + ) -> BlockOutput: + try: + success = self.remove_list_member( + credentials, input_data.list_id, input_data.user_id + ) + yield "success", success + + except Exception as e: + yield "error", handle_tweepy_exception(e) + + +class TwitterAddListMemberBlock(Block): + """ + Adds a member to a Twitter List that the authenticated user owns + """ + + class Input(BlockSchema): + credentials: TwitterCredentialsInput = TwitterCredentialsField( + ["list.write", "users.read", "tweet.read", "offline.access"] + ) + + list_id: str = SchemaField( + description="The ID of the List to add the member to", + placeholder="Enter list ID", + required=True, + ) + + user_id: str = SchemaField( + description="The ID of the user to add to the List", + placeholder="Enter user ID to add", + required=True, + ) + + class Output(BlockSchema): + success: bool = SchemaField( + description="Whether the member was successfully added" + ) + error: str = SchemaField(description="Error message if the addition failed") + + def __init__(self): + super().__init__( + id="3ee8284e-a62f-11ef-84e4-8f6e2cbf0ddb", + description="This block adds a specified user to a Twitter List owned by the authenticated user.", + categories={BlockCategory.SOCIAL}, + input_schema=TwitterAddListMemberBlock.Input, + output_schema=TwitterAddListMemberBlock.Output, + test_input={ + "list_id": "123456789", + "user_id": "987654321", + "credentials": TEST_CREDENTIALS_INPUT, + }, + test_credentials=TEST_CREDENTIALS, + test_output=[("success", True)], + test_mock={"add_list_member": lambda *args, **kwargs: True}, + ) + + @staticmethod + def add_list_member(credentials: TwitterCredentials, list_id: str, user_id: str): + try: + client = tweepy.Client( + bearer_token=credentials.access_token.get_secret_value() + ) + client.add_list_member(id=list_id, user_id=user_id, user_auth=False) + return True + except tweepy.TweepyException: + raise + except Exception: + raise + + def run( + self, + input_data: Input, + *, + credentials: TwitterCredentials, + **kwargs, + ) -> BlockOutput: + try: + success = self.add_list_member( + credentials, input_data.list_id, input_data.user_id + ) + yield "success", success + + except Exception as e: + yield "error", handle_tweepy_exception(e) + + +class TwitterGetListMembersBlock(Block): + """ + Gets the members of a specified Twitter List + """ + + class Input(UserExpansionInputs): + credentials: TwitterCredentialsInput = TwitterCredentialsField( + ["list.read", "offline.access"] + ) + + list_id: str = SchemaField( + description="The ID of the List to get members from", + placeholder="Enter list ID", + required=True, + ) + + max_results: int | None = SchemaField( + description="Maximum number of results per page (1-100)", + placeholder="Enter max results", + default=10, + advanced=True, + ) + + pagination_token: str | None = SchemaField( + description="Token for pagination of results", + placeholder="Enter pagination token", + default="", + advanced=True, + ) + + class Output(BlockSchema): + ids: list[str] = SchemaField(description="List of member user IDs") + usernames: list[str] = SchemaField(description="List of member usernames") + next_token: str = SchemaField(description="Next token for pagination") + + data: list[dict] = SchemaField( + description="Complete user data for list members" + ) + included: dict = SchemaField( + description="Additional data requested via expansions" + ) + meta: dict = SchemaField(description="Metadata including pagination info") + + error: str = SchemaField(description="Error message if the request failed") + + def __init__(self): + super().__init__( + id="4dba046e-a62f-11ef-b69a-87240c84b4c7", + description="This block retrieves the members of a specified Twitter List.", + categories={BlockCategory.SOCIAL}, + input_schema=TwitterGetListMembersBlock.Input, + output_schema=TwitterGetListMembersBlock.Output, + test_input={ + "list_id": "123456789", + "max_results": 2, + "pagination_token": None, + "credentials": TEST_CREDENTIALS_INPUT, + "expansions": None, + "tweet_fields": None, + "user_fields": None, + }, + test_credentials=TEST_CREDENTIALS, + test_output=[ + ("ids", ["12345", "67890"]), + ("usernames", ["testuser1", "testuser2"]), + ( + "data", + [ + {"id": "12345", "username": "testuser1"}, + {"id": "67890", "username": "testuser2"}, + ], + ), + ], + test_mock={ + "get_list_members": lambda *args, **kwargs: ( + ["12345", "67890"], + ["testuser1", "testuser2"], + [ + {"id": "12345", "username": "testuser1"}, + {"id": "67890", "username": "testuser2"}, + ], + {}, + {}, + None, + ) + }, + ) + + @staticmethod + def get_list_members( + credentials: TwitterCredentials, + list_id: str, + max_results: int | None, + pagination_token: str | None, + expansions: UserExpansionsFilter | None, + tweet_fields: TweetFieldsFilter | None, + user_fields: TweetUserFieldsFilter | None, + ): + try: + client = tweepy.Client( + bearer_token=credentials.access_token.get_secret_value() + ) + + params = { + "id": list_id, + "max_results": max_results, + "pagination_token": ( + None if pagination_token == "" else pagination_token + ), + "user_auth": False, + } + + params = ( + UserExpansionsBuilder(params) + .add_expansions(expansions) + .add_tweet_fields(tweet_fields) + .add_user_fields(user_fields) + .build() + ) + + response = cast(Response, client.get_list_members(**params)) + + meta = {} + included = {} + next_token = None + user_ids = [] + usernames = [] + + if response.meta: + meta = response.meta + next_token = meta.get("next_token") + + if response.includes: + included = IncludesSerializer.serialize(response.includes) + + if response.data: + data = ResponseDataSerializer.serialize_list(response.data) + user_ids = [str(user.id) for user in response.data] + usernames = [user.username for user in response.data] + return user_ids, usernames, data, included, meta, next_token + + raise Exception("List members not found") + + except tweepy.TweepyException: + raise + + def run( + self, + input_data: Input, + *, + credentials: TwitterCredentials, + **kwargs, + ) -> BlockOutput: + try: + ids, usernames, data, included, meta, next_token = self.get_list_members( + credentials, + input_data.list_id, + input_data.max_results, + input_data.pagination_token, + input_data.expansions, + input_data.tweet_fields, + input_data.user_fields, + ) + + if ids: + yield "ids", ids + if usernames: + yield "usernames", usernames + if next_token: + yield "next_token", next_token + if data: + yield "data", data + if included: + yield "included", included + if meta: + yield "meta", meta + + except Exception as e: + yield "error", handle_tweepy_exception(e) + + +class TwitterGetListMembershipsBlock(Block): + """ + Gets all Lists that a specified user is a member of + """ + + class Input(ListExpansionInputs): + credentials: TwitterCredentialsInput = TwitterCredentialsField( + ["list.read", "offline.access"] + ) + + user_id: str = SchemaField( + description="The ID of the user whose List memberships to retrieve", + placeholder="Enter user ID", + required=True, + ) + + max_results: int | None = SchemaField( + description="Maximum number of results per page (1-100)", + placeholder="Enter max results", + advanced=True, + default=10, + ) + + pagination_token: str | None = SchemaField( + description="Token for pagination of results", + placeholder="Enter pagination token", + advanced=True, + default="", + ) + + class Output(BlockSchema): + list_ids: list[str] = SchemaField(description="List of list IDs") + next_token: str = SchemaField(description="Next token for pagination") + + data: list[dict] = SchemaField(description="List membership data") + included: dict = SchemaField( + description="Additional data requested via expansions" + ) + meta: dict = SchemaField(description="Metadata about pagination") + error: str = SchemaField(description="Error message if the request failed") + + def __init__(self): + super().__init__( + id="46e6429c-a62f-11ef-81c0-2b55bc7823ba", + description="This block retrieves all Lists that a specified user is a member of.", + categories={BlockCategory.SOCIAL}, + input_schema=TwitterGetListMembershipsBlock.Input, + output_schema=TwitterGetListMembershipsBlock.Output, + test_input={ + "user_id": "123456789", + "max_results": 1, + "pagination_token": None, + "credentials": TEST_CREDENTIALS_INPUT, + "expansions": None, + "list_fields": None, + "user_fields": None, + }, + test_credentials=TEST_CREDENTIALS, + test_output=[ + ("list_ids", ["84839422"]), + ("data", [{"id": "84839422"}]), + ], + test_mock={ + "get_list_memberships": lambda *args, **kwargs: ( + [{"id": "84839422"}], + {}, + {}, + ["84839422"], + None, + ) + }, + ) + + @staticmethod + def get_list_memberships( + credentials: TwitterCredentials, + user_id: str, + max_results: int | None, + pagination_token: str | None, + expansions: ListExpansionsFilter | None, + user_fields: TweetUserFieldsFilter | None, + list_fields: ListFieldsFilter | None, + ): + try: + client = tweepy.Client( + bearer_token=credentials.access_token.get_secret_value() + ) + + params = { + "id": user_id, + "max_results": max_results, + "pagination_token": ( + None if pagination_token == "" else pagination_token + ), + "user_auth": False, + } + + params = ( + ListExpansionsBuilder(params) + .add_expansions(expansions) + .add_user_fields(user_fields) + .add_list_fields(list_fields) + .build() + ) + + response = cast(Response, client.get_list_memberships(**params)) + + meta = {} + included = {} + next_token = None + list_ids = [] + + if response.meta: + meta = response.meta + next_token = meta.get("next_token") + + if response.includes: + included = IncludesSerializer.serialize(response.includes) + + if response.data: + data = ResponseDataSerializer.serialize_list(response.data) + list_ids = [str(lst.id) for lst in response.data] + return data, included, meta, list_ids, next_token + + raise Exception("List memberships not found") + + except tweepy.TweepyException: + raise + except Exception: + raise + + def run( + self, + input_data: Input, + *, + credentials: TwitterCredentials, + **kwargs, + ) -> BlockOutput: + try: + data, included, meta, list_ids, next_token = self.get_list_memberships( + credentials, + input_data.user_id, + input_data.max_results, + input_data.pagination_token, + input_data.expansions, + input_data.user_fields, + input_data.list_fields, + ) + + if list_ids: + yield "list_ids", list_ids + if next_token: + yield "next_token", next_token + if data: + yield "data", data + if included: + yield "included", included + if meta: + yield "meta", meta + + except Exception as e: + yield "error", handle_tweepy_exception(e) diff --git a/autogpt_platform/backend/backend/blocks/twitter/lists/list_tweets_lookup.py b/autogpt_platform/backend/backend/blocks/twitter/lists/list_tweets_lookup.py new file mode 100644 index 000000000000..99de955cb3aa --- /dev/null +++ b/autogpt_platform/backend/backend/blocks/twitter/lists/list_tweets_lookup.py @@ -0,0 +1,217 @@ +from typing import cast + +import tweepy +from tweepy.client import Response + +from backend.blocks.twitter._auth import ( + TEST_CREDENTIALS, + TEST_CREDENTIALS_INPUT, + TwitterCredentials, + TwitterCredentialsField, + TwitterCredentialsInput, +) +from backend.blocks.twitter._builders import TweetExpansionsBuilder +from backend.blocks.twitter._serializer import ( + IncludesSerializer, + ResponseDataSerializer, +) +from backend.blocks.twitter._types import ( + ExpansionFilter, + TweetExpansionInputs, + TweetFieldsFilter, + TweetMediaFieldsFilter, + TweetPlaceFieldsFilter, + TweetPollFieldsFilter, + TweetUserFieldsFilter, +) +from backend.blocks.twitter.tweepy_exceptions import handle_tweepy_exception +from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema +from backend.data.model import SchemaField + + +class TwitterGetListTweetsBlock(Block): + """ + Gets tweets from a specified Twitter list + """ + + class Input(TweetExpansionInputs): + credentials: TwitterCredentialsInput = TwitterCredentialsField( + ["tweet.read", "offline.access"] + ) + + list_id: str = SchemaField( + description="The ID of the List whose Tweets you would like to retrieve", + placeholder="Enter list ID", + required=True, + ) + + max_results: int | None = SchemaField( + description="Maximum number of results per page (1-100)", + placeholder="Enter max results", + default=10, + advanced=True, + ) + + pagination_token: str | None = SchemaField( + description="Token for paginating through results", + placeholder="Enter pagination token", + default="", + advanced=True, + ) + + class Output(BlockSchema): + # Common outputs + tweet_ids: list[str] = SchemaField(description="List of tweet IDs") + texts: list[str] = SchemaField(description="List of tweet texts") + next_token: str = SchemaField(description="Token for next page of results") + + # Complete outputs + data: list[dict] = SchemaField(description="Complete list tweets data") + included: dict = SchemaField( + description="Additional data requested via expansions" + ) + meta: dict = SchemaField( + description="Response metadata including pagination tokens" + ) + error: str = SchemaField(description="Error message if the request failed") + + def __init__(self): + super().__init__( + id="6657edb0-a62f-11ef-8c10-0326d832467d", + description="This block retrieves tweets from a specified Twitter list.", + categories={BlockCategory.SOCIAL}, + input_schema=TwitterGetListTweetsBlock.Input, + output_schema=TwitterGetListTweetsBlock.Output, + test_input={ + "list_id": "84839422", + "max_results": 1, + "pagination_token": None, + "credentials": TEST_CREDENTIALS_INPUT, + "expansions": None, + "media_fields": None, + "place_fields": None, + "poll_fields": None, + "tweet_fields": None, + "user_fields": None, + }, + test_credentials=TEST_CREDENTIALS, + test_output=[ + ("tweet_ids", ["1234567890"]), + ("texts", ["Test tweet"]), + ("data", [{"id": "1234567890", "text": "Test tweet"}]), + ], + test_mock={ + "get_list_tweets": lambda *args, **kwargs: ( + [{"id": "1234567890", "text": "Test tweet"}], + {}, + {}, + ["1234567890"], + ["Test tweet"], + None, + ) + }, + ) + + @staticmethod + def get_list_tweets( + credentials: TwitterCredentials, + list_id: str, + max_results: int | None, + pagination_token: str | None, + expansions: ExpansionFilter | None, + media_fields: TweetMediaFieldsFilter | None, + place_fields: TweetPlaceFieldsFilter | None, + poll_fields: TweetPollFieldsFilter | None, + tweet_fields: TweetFieldsFilter | None, + user_fields: TweetUserFieldsFilter | None, + ): + try: + client = tweepy.Client( + bearer_token=credentials.access_token.get_secret_value() + ) + + params = { + "id": list_id, + "max_results": max_results, + "pagination_token": ( + None if pagination_token == "" else pagination_token + ), + "user_auth": False, + } + + params = ( + TweetExpansionsBuilder(params) + .add_expansions(expansions) + .add_media_fields(media_fields) + .add_place_fields(place_fields) + .add_poll_fields(poll_fields) + .add_tweet_fields(tweet_fields) + .add_user_fields(user_fields) + .build() + ) + + response = cast(Response, client.get_list_tweets(**params)) + + meta = {} + included = {} + tweet_ids = [] + texts = [] + next_token = None + + if response.meta: + meta = response.meta + next_token = meta.get("next_token") + + if response.includes: + included = IncludesSerializer.serialize(response.includes) + + if response.data: + data = ResponseDataSerializer.serialize_list(response.data) + tweet_ids = [str(item.id) for item in response.data] + texts = [item.text for item in response.data] + + return data, included, meta, tweet_ids, texts, next_token + + raise Exception("No tweets found in this list") + + except tweepy.TweepyException: + raise + + def run( + self, + input_data: Input, + *, + credentials: TwitterCredentials, + **kwargs, + ) -> BlockOutput: + try: + list_data, included, meta, tweet_ids, texts, next_token = ( + self.get_list_tweets( + credentials, + input_data.list_id, + input_data.max_results, + input_data.pagination_token, + input_data.expansions, + input_data.media_fields, + input_data.place_fields, + input_data.poll_fields, + input_data.tweet_fields, + input_data.user_fields, + ) + ) + + if tweet_ids: + yield "tweet_ids", tweet_ids + if texts: + yield "texts", texts + if next_token: + yield "next_token", next_token + if list_data: + yield "data", list_data + if included: + yield "included", included + if meta: + yield "meta", meta + + except Exception as e: + yield "error", handle_tweepy_exception(e) diff --git a/autogpt_platform/backend/backend/blocks/twitter/lists/manage_lists.py b/autogpt_platform/backend/backend/blocks/twitter/lists/manage_lists.py new file mode 100644 index 000000000000..490a841e4aa8 --- /dev/null +++ b/autogpt_platform/backend/backend/blocks/twitter/lists/manage_lists.py @@ -0,0 +1,278 @@ +from typing import cast + +import tweepy +from tweepy.client import Response + +from backend.blocks.twitter._auth import ( + TEST_CREDENTIALS, + TEST_CREDENTIALS_INPUT, + TwitterCredentials, + TwitterCredentialsField, + TwitterCredentialsInput, +) +from backend.blocks.twitter.tweepy_exceptions import handle_tweepy_exception +from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema +from backend.data.model import SchemaField + + +class TwitterDeleteListBlock(Block): + """ + Deletes a Twitter List owned by the authenticated user + """ + + class Input(BlockSchema): + credentials: TwitterCredentialsInput = TwitterCredentialsField( + ["list.write", "offline.access"] + ) + + list_id: str = SchemaField( + description="The ID of the List to be deleted", + placeholder="Enter list ID", + required=True, + ) + + class Output(BlockSchema): + success: bool = SchemaField(description="Whether the deletion was successful") + error: str = SchemaField(description="Error message if the request failed") + + def __init__(self): + super().__init__( + id="843c6892-a62f-11ef-a5c8-b71239a78d3b", + description="This block deletes a specified Twitter List owned by the authenticated user.", + categories={BlockCategory.SOCIAL}, + input_schema=TwitterDeleteListBlock.Input, + output_schema=TwitterDeleteListBlock.Output, + test_input={"list_id": "1234567890", "credentials": TEST_CREDENTIALS_INPUT}, + test_credentials=TEST_CREDENTIALS, + test_output=[("success", True)], + test_mock={"delete_list": lambda *args, **kwargs: True}, + ) + + @staticmethod + def delete_list(credentials: TwitterCredentials, list_id: str): + try: + client = tweepy.Client( + bearer_token=credentials.access_token.get_secret_value() + ) + + client.delete_list(id=list_id, user_auth=False) + return True + + except tweepy.TweepyException: + raise + except Exception: + raise + + def run( + self, + input_data: Input, + *, + credentials: TwitterCredentials, + **kwargs, + ) -> BlockOutput: + try: + success = self.delete_list(credentials, input_data.list_id) + yield "success", success + + except Exception as e: + yield "error", handle_tweepy_exception(e) + + +class TwitterUpdateListBlock(Block): + """ + Updates a Twitter List owned by the authenticated user + """ + + class Input(BlockSchema): + credentials: TwitterCredentialsInput = TwitterCredentialsField( + ["list.write", "offline.access"] + ) + + list_id: str = SchemaField( + description="The ID of the List to be updated", + placeholder="Enter list ID", + advanced=False, + ) + + name: str | None = SchemaField( + description="New name for the List", + placeholder="Enter list name", + default="", + advanced=False, + ) + + description: str | None = SchemaField( + description="New description for the List", + placeholder="Enter list description", + default="", + advanced=False, + ) + + class Output(BlockSchema): + success: bool = SchemaField(description="Whether the update was successful") + error: str = SchemaField(description="Error message if the request failed") + + def __init__(self): + super().__init__( + id="7d12630a-a62f-11ef-90c9-8f5a996612c3", + description="This block updates a specified Twitter List owned by the authenticated user.", + categories={BlockCategory.SOCIAL}, + input_schema=TwitterUpdateListBlock.Input, + output_schema=TwitterUpdateListBlock.Output, + test_input={ + "list_id": "1234567890", + "name": "Updated List Name", + "description": "Updated List Description", + "private": True, + "credentials": TEST_CREDENTIALS_INPUT, + }, + test_credentials=TEST_CREDENTIALS, + test_output=[("success", True)], + test_mock={"update_list": lambda *args, **kwargs: True}, + ) + + @staticmethod + def update_list( + credentials: TwitterCredentials, + list_id: str, + name: str | None, + description: str | None, + ): + try: + client = tweepy.Client( + bearer_token=credentials.access_token.get_secret_value() + ) + + client.update_list( + id=list_id, + name=None if name == "" else name, + description=None if description == "" else description, + user_auth=False, + ) + return True + + except tweepy.TweepyException: + raise + except Exception: + raise + + def run( + self, + input_data: Input, + *, + credentials: TwitterCredentials, + **kwargs, + ) -> BlockOutput: + try: + success = self.update_list( + credentials, input_data.list_id, input_data.name, input_data.description + ) + yield "success", success + + except Exception as e: + yield "error", handle_tweepy_exception(e) + + +class TwitterCreateListBlock(Block): + """ + Creates a Twitter List owned by the authenticated user + """ + + class Input(BlockSchema): + credentials: TwitterCredentialsInput = TwitterCredentialsField( + ["list.write", "offline.access"] + ) + + name: str = SchemaField( + description="The name of the List to be created", + placeholder="Enter list name", + advanced=False, + default="", + ) + + description: str | None = SchemaField( + description="Description of the List", + placeholder="Enter list description", + advanced=False, + default="", + ) + + private: bool = SchemaField( + description="Whether the List should be private", + advanced=False, + default=False, + ) + + class Output(BlockSchema): + url: str = SchemaField(description="URL of the created list") + list_id: str = SchemaField(description="ID of the created list") + error: str = SchemaField(description="Error message if the request failed") + + def __init__(self): + super().__init__( + id="724148ba-a62f-11ef-89ba-5349b813ef5f", + description="This block creates a new Twitter List for the authenticated user.", + categories={BlockCategory.SOCIAL}, + input_schema=TwitterCreateListBlock.Input, + output_schema=TwitterCreateListBlock.Output, + test_input={ + "name": "New List Name", + "description": "New List Description", + "private": True, + "credentials": TEST_CREDENTIALS_INPUT, + }, + test_credentials=TEST_CREDENTIALS, + test_output=[ + ("list_id", "1234567890"), + ("url", "https://twitter.com/i/lists/1234567890"), + ], + test_mock={"create_list": lambda *args, **kwargs: ("1234567890")}, + ) + + @staticmethod + def create_list( + credentials: TwitterCredentials, + name: str, + description: str | None, + private: bool, + ): + try: + client = tweepy.Client( + bearer_token=credentials.access_token.get_secret_value() + ) + + response = cast( + Response, + client.create_list( + name=None if name == "" else name, + description=None if description == "" else description, + private=private, + user_auth=False, + ), + ) + + list_id = str(response.data["id"]) + + return list_id + + except tweepy.TweepyException: + raise + except Exception: + raise + + def run( + self, + input_data: Input, + *, + credentials: TwitterCredentials, + **kwargs, + ) -> BlockOutput: + try: + list_id = self.create_list( + credentials, input_data.name, input_data.description, input_data.private + ) + yield "list_id", list_id + yield "url", f"https://twitter.com/i/lists/{list_id}" + + except Exception as e: + yield "error", handle_tweepy_exception(e) diff --git a/autogpt_platform/backend/backend/blocks/twitter/lists/pinned_lists.py b/autogpt_platform/backend/backend/blocks/twitter/lists/pinned_lists.py new file mode 100644 index 000000000000..f9b54cfdaca2 --- /dev/null +++ b/autogpt_platform/backend/backend/blocks/twitter/lists/pinned_lists.py @@ -0,0 +1,285 @@ +from typing import cast + +import tweepy +from tweepy.client import Response + +from backend.blocks.twitter._auth import ( + TEST_CREDENTIALS, + TEST_CREDENTIALS_INPUT, + TwitterCredentials, + TwitterCredentialsField, + TwitterCredentialsInput, +) +from backend.blocks.twitter._builders import ListExpansionsBuilder +from backend.blocks.twitter._serializer import ( + IncludesSerializer, + ResponseDataSerializer, +) +from backend.blocks.twitter._types import ( + ListExpansionInputs, + ListExpansionsFilter, + ListFieldsFilter, + TweetUserFieldsFilter, +) +from backend.blocks.twitter.tweepy_exceptions import handle_tweepy_exception +from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema +from backend.data.model import SchemaField + + +class TwitterUnpinListBlock(Block): + """ + Enables the authenticated user to unpin a List. + """ + + class Input(BlockSchema): + credentials: TwitterCredentialsInput = TwitterCredentialsField( + ["list.write", "users.read", "tweet.read", "offline.access"] + ) + + list_id: str = SchemaField( + description="The ID of the List to unpin", + placeholder="Enter list ID", + required=True, + ) + + class Output(BlockSchema): + success: bool = SchemaField(description="Whether the unpin was successful") + error: str = SchemaField(description="Error message if the request failed") + + def __init__(self): + super().__init__( + id="a099c034-a62f-11ef-9622-47d0ceb73555", + description="This block allows the authenticated user to unpin a specified List.", + categories={BlockCategory.SOCIAL}, + input_schema=TwitterUnpinListBlock.Input, + output_schema=TwitterUnpinListBlock.Output, + test_input={"list_id": "123456789", "credentials": TEST_CREDENTIALS_INPUT}, + test_credentials=TEST_CREDENTIALS, + test_output=[("success", True)], + test_mock={"unpin_list": lambda *args, **kwargs: True}, + ) + + @staticmethod + def unpin_list(credentials: TwitterCredentials, list_id: str): + try: + client = tweepy.Client( + bearer_token=credentials.access_token.get_secret_value() + ) + + client.unpin_list(list_id=list_id, user_auth=False) + + return True + + except tweepy.TweepyException: + raise + except Exception: + raise + + def run( + self, + input_data: Input, + *, + credentials: TwitterCredentials, + **kwargs, + ) -> BlockOutput: + try: + success = self.unpin_list(credentials, input_data.list_id) + yield "success", success + + except Exception as e: + yield "error", handle_tweepy_exception(e) + + +class TwitterPinListBlock(Block): + """ + Enables the authenticated user to pin a List. + """ + + class Input(BlockSchema): + credentials: TwitterCredentialsInput = TwitterCredentialsField( + ["list.write", "users.read", "tweet.read", "offline.access"] + ) + + list_id: str = SchemaField( + description="The ID of the List to pin", + placeholder="Enter list ID", + required=True, + ) + + class Output(BlockSchema): + success: bool = SchemaField(description="Whether the pin was successful") + error: str = SchemaField(description="Error message if the request failed") + + def __init__(self): + super().__init__( + id="8ec16e48-a62f-11ef-9f35-f3d6de43a802", + description="This block allows the authenticated user to pin a specified List.", + categories={BlockCategory.SOCIAL}, + input_schema=TwitterPinListBlock.Input, + output_schema=TwitterPinListBlock.Output, + test_input={"list_id": "123456789", "credentials": TEST_CREDENTIALS_INPUT}, + test_credentials=TEST_CREDENTIALS, + test_output=[("success", True)], + test_mock={"pin_list": lambda *args, **kwargs: True}, + ) + + @staticmethod + def pin_list(credentials: TwitterCredentials, list_id: str): + try: + client = tweepy.Client( + bearer_token=credentials.access_token.get_secret_value() + ) + + client.pin_list(list_id=list_id, user_auth=False) + + return True + + except tweepy.TweepyException: + raise + except Exception: + raise + + def run( + self, + input_data: Input, + *, + credentials: TwitterCredentials, + **kwargs, + ) -> BlockOutput: + try: + success = self.pin_list(credentials, input_data.list_id) + yield "success", success + + except Exception as e: + yield "error", handle_tweepy_exception(e) + + +class TwitterGetPinnedListsBlock(Block): + """ + Returns the Lists pinned by the authenticated user. + """ + + class Input(ListExpansionInputs): + credentials: TwitterCredentialsInput = TwitterCredentialsField( + ["lists.read", "users.read", "offline.access"] + ) + + class Output(BlockSchema): + list_ids: list[str] = SchemaField(description="List IDs of the pinned lists") + list_names: list[str] = SchemaField( + description="List names of the pinned lists" + ) + + data: list[dict] = SchemaField( + description="Response data containing pinned lists" + ) + included: dict = SchemaField( + description="Additional data requested via expansions" + ) + meta: dict = SchemaField(description="Metadata about the response") + error: str = SchemaField(description="Error message if the request failed") + + def __init__(self): + super().__init__( + id="97e03aae-a62f-11ef-bc53-5b89cb02888f", + description="This block returns the Lists pinned by the authenticated user.", + categories={BlockCategory.SOCIAL}, + input_schema=TwitterGetPinnedListsBlock.Input, + output_schema=TwitterGetPinnedListsBlock.Output, + test_input={ + "expansions": None, + "list_fields": None, + "user_fields": None, + "credentials": TEST_CREDENTIALS_INPUT, + }, + test_credentials=TEST_CREDENTIALS, + test_output=[ + ("list_ids", ["84839422"]), + ("list_names", ["Twitter List"]), + ("data", [{"id": "84839422", "name": "Twitter List"}]), + ], + test_mock={ + "get_pinned_lists": lambda *args, **kwargs: ( + [{"id": "84839422", "name": "Twitter List"}], + {}, + {}, + ["84839422"], + ["Twitter List"], + ) + }, + ) + + @staticmethod + def get_pinned_lists( + credentials: TwitterCredentials, + expansions: ListExpansionsFilter | None, + user_fields: TweetUserFieldsFilter | None, + list_fields: ListFieldsFilter | None, + ): + try: + client = tweepy.Client( + bearer_token=credentials.access_token.get_secret_value() + ) + + params = {"user_auth": False} + + params = ( + ListExpansionsBuilder(params) + .add_expansions(expansions) + .add_user_fields(user_fields) + .add_list_fields(list_fields) + .build() + ) + + response = cast(Response, client.get_pinned_lists(**params)) + + meta = {} + included = {} + list_ids = [] + list_names = [] + + if response.meta: + meta = response.meta + + if response.includes: + included = IncludesSerializer.serialize(response.includes) + + if response.data: + data = ResponseDataSerializer.serialize_list(response.data) + list_ids = [str(item.id) for item in response.data] + list_names = [item.name for item in response.data] + return data, included, meta, list_ids, list_names + + raise Exception("Lists not found") + + except tweepy.TweepyException: + raise + + def run( + self, + input_data: Input, + *, + credentials: TwitterCredentials, + **kwargs, + ) -> BlockOutput: + try: + list_data, included, meta, list_ids, list_names = self.get_pinned_lists( + credentials, + input_data.expansions, + input_data.user_fields, + input_data.list_fields, + ) + + if list_ids: + yield "list_ids", list_ids + if list_names: + yield "list_names", list_names + if list_data: + yield "data", list_data + if included: + yield "included", included + if meta: + yield "meta", meta + + except Exception as e: + yield "error", handle_tweepy_exception(e) diff --git a/autogpt_platform/backend/backend/blocks/twitter/spaces/search_spaces.py b/autogpt_platform/backend/backend/blocks/twitter/spaces/search_spaces.py new file mode 100644 index 000000000000..ad3399c3b119 --- /dev/null +++ b/autogpt_platform/backend/backend/blocks/twitter/spaces/search_spaces.py @@ -0,0 +1,195 @@ +from typing import cast + +import tweepy +from tweepy.client import Response + +from backend.blocks.twitter._auth import ( + TEST_CREDENTIALS, + TEST_CREDENTIALS_INPUT, + TwitterCredentials, + TwitterCredentialsField, + TwitterCredentialsInput, +) +from backend.blocks.twitter._builders import SpaceExpansionsBuilder +from backend.blocks.twitter._serializer import ( + IncludesSerializer, + ResponseDataSerializer, +) +from backend.blocks.twitter._types import ( + SpaceExpansionInputs, + SpaceExpansionsFilter, + SpaceFieldsFilter, + SpaceStatesFilter, + TweetUserFieldsFilter, +) +from backend.blocks.twitter.tweepy_exceptions import handle_tweepy_exception +from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema +from backend.data.model import SchemaField + + +class TwitterSearchSpacesBlock(Block): + """ + Returns live or scheduled Spaces matching specified search terms [for a week only] + """ + + class Input(SpaceExpansionInputs): + credentials: TwitterCredentialsInput = TwitterCredentialsField( + ["spaces.read", "users.read", "tweet.read", "offline.access"] + ) + + query: str = SchemaField( + description="Search term to find in Space titles", + placeholder="Enter search query", + ) + + max_results: int | None = SchemaField( + description="Maximum number of results to return (1-100)", + placeholder="Enter max results", + default=10, + advanced=True, + ) + + state: SpaceStatesFilter = SchemaField( + description="Type of Spaces to return (live, scheduled, or all)", + placeholder="Enter state filter", + default=SpaceStatesFilter.all, + ) + + class Output(BlockSchema): + # Common outputs that user commonly uses + ids: list[str] = SchemaField(description="List of space IDs") + titles: list[str] = SchemaField(description="List of space titles") + host_ids: list = SchemaField(description="List of host IDs") + next_token: str = SchemaField(description="Next token for pagination") + + # Complete outputs for advanced use + data: list[dict] = SchemaField(description="Complete space data") + includes: dict = SchemaField( + description="Additional data requested via expansions" + ) + meta: dict = SchemaField(description="Metadata including pagination info") + + error: str = SchemaField(description="Error message if the request failed") + + def __init__(self): + super().__init__( + id="aaefdd48-a62f-11ef-a73c-3f44df63e276", + description="This block searches for Twitter Spaces based on specified terms.", + categories={BlockCategory.SOCIAL}, + input_schema=TwitterSearchSpacesBlock.Input, + output_schema=TwitterSearchSpacesBlock.Output, + test_input={ + "query": "tech", + "max_results": 1, + "state": "live", + "credentials": TEST_CREDENTIALS_INPUT, + "expansions": None, + "space_fields": None, + "user_fields": None, + }, + test_credentials=TEST_CREDENTIALS, + test_output=[ + ("ids", ["1234"]), + ("titles", ["Tech Talk"]), + ("host_ids", ["5678"]), + ("data", [{"id": "1234", "title": "Tech Talk", "host_ids": ["5678"]}]), + ], + test_mock={ + "search_spaces": lambda *args, **kwargs: ( + [{"id": "1234", "title": "Tech Talk", "host_ids": ["5678"]}], + {}, + {}, + ["1234"], + ["Tech Talk"], + ["5678"], + None, + ) + }, + ) + + @staticmethod + def search_spaces( + credentials: TwitterCredentials, + query: str, + max_results: int | None, + state: SpaceStatesFilter, + expansions: SpaceExpansionsFilter | None, + space_fields: SpaceFieldsFilter | None, + user_fields: TweetUserFieldsFilter | None, + ): + try: + client = tweepy.Client( + bearer_token=credentials.access_token.get_secret_value() + ) + + params = {"query": query, "max_results": max_results, "state": state.value} + + params = ( + SpaceExpansionsBuilder(params) + .add_expansions(expansions) + .add_space_fields(space_fields) + .add_user_fields(user_fields) + .build() + ) + + response = cast(Response, client.search_spaces(**params)) + + meta = {} + next_token = "" + if response.meta: + meta = response.meta + if "next_token" in meta: + next_token = meta["next_token"] + + included = IncludesSerializer.serialize(response.includes) + data = ResponseDataSerializer.serialize_list(response.data) + + if response.data: + ids = [str(space["id"]) for space in response.data if "id" in space] + titles = [space["title"] for space in data if "title" in space] + host_ids = [space["host_ids"] for space in data if "host_ids" in space] + + return data, included, meta, ids, titles, host_ids, next_token + + raise Exception("Spaces not found") + + except tweepy.TweepyException: + raise + + def run( + self, + input_data: Input, + *, + credentials: TwitterCredentials, + **kwargs, + ) -> BlockOutput: + try: + data, included, meta, ids, titles, host_ids, next_token = ( + self.search_spaces( + credentials, + input_data.query, + input_data.max_results, + input_data.state, + input_data.expansions, + input_data.space_fields, + input_data.user_fields, + ) + ) + + if ids: + yield "ids", ids + if titles: + yield "titles", titles + if host_ids: + yield "host_ids", host_ids + if next_token: + yield "next_token", next_token + if data: + yield "data", data + if included: + yield "includes", included + if meta: + yield "meta", meta + + except Exception as e: + yield "error", handle_tweepy_exception(e) diff --git a/autogpt_platform/backend/backend/blocks/twitter/spaces/spaces_lookup.py b/autogpt_platform/backend/backend/blocks/twitter/spaces/spaces_lookup.py new file mode 100644 index 000000000000..d7365e80d8ad --- /dev/null +++ b/autogpt_platform/backend/backend/blocks/twitter/spaces/spaces_lookup.py @@ -0,0 +1,651 @@ +from typing import Literal, Union, cast + +import tweepy +from pydantic import BaseModel +from tweepy.client import Response + +from backend.blocks.twitter._auth import ( + TEST_CREDENTIALS, + TEST_CREDENTIALS_INPUT, + TwitterCredentials, + TwitterCredentialsField, + TwitterCredentialsInput, +) +from backend.blocks.twitter._builders import ( + SpaceExpansionsBuilder, + TweetExpansionsBuilder, + UserExpansionsBuilder, +) +from backend.blocks.twitter._serializer import ( + IncludesSerializer, + ResponseDataSerializer, +) +from backend.blocks.twitter._types import ( + ExpansionFilter, + SpaceExpansionInputs, + SpaceExpansionsFilter, + SpaceFieldsFilter, + TweetExpansionInputs, + TweetFieldsFilter, + TweetMediaFieldsFilter, + TweetPlaceFieldsFilter, + TweetPollFieldsFilter, + TweetUserFieldsFilter, + UserExpansionInputs, + UserExpansionsFilter, +) +from backend.blocks.twitter.tweepy_exceptions import handle_tweepy_exception +from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema +from backend.data.model import SchemaField + + +class SpaceList(BaseModel): + discriminator: Literal["space_list"] + space_ids: list[str] = SchemaField( + description="List of Space IDs to lookup (up to 100)", + placeholder="Enter Space IDs", + default=[], + advanced=False, + ) + + +class UserList(BaseModel): + discriminator: Literal["user_list"] + user_ids: list[str] = SchemaField( + description="List of user IDs to lookup their Spaces (up to 100)", + placeholder="Enter user IDs", + default=[], + advanced=False, + ) + + +class TwitterGetSpacesBlock(Block): + """ + Gets information about multiple Twitter Spaces specified by Space IDs or creator user IDs + """ + + class Input(SpaceExpansionInputs): + credentials: TwitterCredentialsInput = TwitterCredentialsField( + ["spaces.read", "users.read", "offline.access"] + ) + + identifier: Union[SpaceList, UserList] = SchemaField( + discriminator="discriminator", + description="Choose whether to lookup spaces by their IDs or by creator user IDs", + advanced=False, + ) + + class Output(BlockSchema): + # Common outputs + ids: list[str] = SchemaField(description="List of space IDs") + titles: list[str] = SchemaField(description="List of space titles") + + # Complete outputs for advanced use + data: list[dict] = SchemaField(description="Complete space data") + includes: dict = SchemaField( + description="Additional data requested via expansions" + ) + error: str = SchemaField(description="Error message if the request failed") + + def __init__(self): + super().__init__( + id="d75bd7d8-a62f-11ef-b0d8-c7a9496f617f", + description="This block retrieves information about multiple Twitter Spaces.", + categories={BlockCategory.SOCIAL}, + input_schema=TwitterGetSpacesBlock.Input, + output_schema=TwitterGetSpacesBlock.Output, + test_input={ + "identifier": { + "discriminator": "space_list", + "space_ids": ["1DXxyRYNejbKM"], + }, + "credentials": TEST_CREDENTIALS_INPUT, + "expansions": None, + "space_fields": None, + "user_fields": None, + }, + test_credentials=TEST_CREDENTIALS, + test_output=[ + ("ids", ["1DXxyRYNejbKM"]), + ("titles", ["Test Space"]), + ( + "data", + [ + { + "id": "1DXxyRYNejbKM", + "title": "Test Space", + "host_id": "1234567", + } + ], + ), + ], + test_mock={ + "get_spaces": lambda *args, **kwargs: ( + [ + { + "id": "1DXxyRYNejbKM", + "title": "Test Space", + "host_id": "1234567", + } + ], + {}, + ["1DXxyRYNejbKM"], + ["Test Space"], + ) + }, + ) + + @staticmethod + def get_spaces( + credentials: TwitterCredentials, + identifier: Union[SpaceList, UserList], + expansions: SpaceExpansionsFilter | None, + space_fields: SpaceFieldsFilter | None, + user_fields: TweetUserFieldsFilter | None, + ): + try: + client = tweepy.Client( + bearer_token=credentials.access_token.get_secret_value() + ) + + params = { + "ids": ( + identifier.space_ids if isinstance(identifier, SpaceList) else None + ), + "user_ids": ( + identifier.user_ids if isinstance(identifier, UserList) else None + ), + } + + params = ( + SpaceExpansionsBuilder(params) + .add_expansions(expansions) + .add_space_fields(space_fields) + .add_user_fields(user_fields) + .build() + ) + + response = cast(Response, client.get_spaces(**params)) + + ids = [] + titles = [] + + included = IncludesSerializer.serialize(response.includes) + + if response.data: + data = ResponseDataSerializer.serialize_list(response.data) + ids = [space["id"] for space in data if "id" in space] + titles = [space["title"] for space in data if "title" in space] + + return data, included, ids, titles + + raise Exception("No spaces found") + + except tweepy.TweepyException: + raise + + def run( + self, + input_data: Input, + *, + credentials: TwitterCredentials, + **kwargs, + ) -> BlockOutput: + try: + data, included, ids, titles = self.get_spaces( + credentials, + input_data.identifier, + input_data.expansions, + input_data.space_fields, + input_data.user_fields, + ) + + if ids: + yield "ids", ids + if titles: + yield "titles", titles + + if data: + yield "data", data + if included: + yield "includes", included + + except Exception as e: + yield "error", handle_tweepy_exception(e) + + +class TwitterGetSpaceByIdBlock(Block): + """ + Gets information about a single Twitter Space specified by Space ID + """ + + class Input(SpaceExpansionInputs): + credentials: TwitterCredentialsInput = TwitterCredentialsField( + ["spaces.read", "users.read", "offline.access"] + ) + + space_id: str = SchemaField( + description="Space ID to lookup", + placeholder="Enter Space ID", + required=True, + ) + + class Output(BlockSchema): + # Common outputs + id: str = SchemaField(description="Space ID") + title: str = SchemaField(description="Space title") + host_ids: list[str] = SchemaField(description="Host ID") + + # Complete outputs for advanced use + data: dict = SchemaField(description="Complete space data") + includes: dict = SchemaField( + description="Additional data requested via expansions" + ) + error: str = SchemaField(description="Error message if the request failed") + + def __init__(self): + super().__init__( + id="c79700de-a62f-11ef-ab20-fb32bf9d5a9d", + description="This block retrieves information about a single Twitter Space.", + categories={BlockCategory.SOCIAL}, + input_schema=TwitterGetSpaceByIdBlock.Input, + output_schema=TwitterGetSpaceByIdBlock.Output, + test_input={ + "space_id": "1DXxyRYNejbKM", + "credentials": TEST_CREDENTIALS_INPUT, + "expansions": None, + "space_fields": None, + "user_fields": None, + }, + test_credentials=TEST_CREDENTIALS, + test_output=[ + ("id", "1DXxyRYNejbKM"), + ("title", "Test Space"), + ("host_ids", ["1234567"]), + ( + "data", + { + "id": "1DXxyRYNejbKM", + "title": "Test Space", + "host_ids": ["1234567"], + }, + ), + ], + test_mock={ + "get_space": lambda *args, **kwargs: ( + { + "id": "1DXxyRYNejbKM", + "title": "Test Space", + "host_ids": ["1234567"], + }, + {}, + ) + }, + ) + + @staticmethod + def get_space( + credentials: TwitterCredentials, + space_id: str, + expansions: SpaceExpansionsFilter | None, + space_fields: SpaceFieldsFilter | None, + user_fields: TweetUserFieldsFilter | None, + ): + try: + client = tweepy.Client( + bearer_token=credentials.access_token.get_secret_value() + ) + + params = { + "id": space_id, + } + + params = ( + SpaceExpansionsBuilder(params) + .add_expansions(expansions) + .add_space_fields(space_fields) + .add_user_fields(user_fields) + .build() + ) + + response = cast(Response, client.get_space(**params)) + + includes = {} + if response.includes: + for key, value in response.includes.items(): + if isinstance(value, list): + includes[key] = [ + item.data if hasattr(item, "data") else item + for item in value + ] + else: + includes[key] = value.data if hasattr(value, "data") else value + + data = {} + if response.data: + for key, value in response.data.items(): + if isinstance(value, list): + data[key] = [ + item.data if hasattr(item, "data") else item + for item in value + ] + else: + data[key] = value.data if hasattr(value, "data") else value + + return data, includes + + raise Exception("Space not found") + + except tweepy.TweepyException: + raise + + def run( + self, + input_data: Input, + *, + credentials: TwitterCredentials, + **kwargs, + ) -> BlockOutput: + try: + space_data, includes = self.get_space( + credentials, + input_data.space_id, + input_data.expansions, + input_data.space_fields, + input_data.user_fields, + ) + + # Common outputs + if space_data: + if "id" in space_data: + yield "id", space_data.get("id") + + if "title" in space_data: + yield "title", space_data.get("title") + + if "host_ids" in space_data: + yield "host_ids", space_data.get("host_ids") + + if space_data: + yield "data", space_data + if includes: + yield "includes", includes + + except Exception as e: + yield "error", handle_tweepy_exception(e) + + +# Not tested yet, might have some problem +class TwitterGetSpaceBuyersBlock(Block): + """ + Gets list of users who purchased a ticket to the requested Space + """ + + class Input(UserExpansionInputs): + credentials: TwitterCredentialsInput = TwitterCredentialsField( + ["spaces.read", "users.read", "offline.access"] + ) + + space_id: str = SchemaField( + description="Space ID to lookup buyers for", + placeholder="Enter Space ID", + required=True, + ) + + class Output(BlockSchema): + # Common outputs + buyer_ids: list[str] = SchemaField(description="List of buyer IDs") + usernames: list[str] = SchemaField(description="List of buyer usernames") + + # Complete outputs for advanced use + data: list[dict] = SchemaField(description="Complete space buyers data") + includes: dict = SchemaField( + description="Additional data requested via expansions" + ) + error: str = SchemaField(description="Error message if the request failed") + + def __init__(self): + super().__init__( + id="c1c121a8-a62f-11ef-8b0e-d7b85f96a46f", + description="This block retrieves a list of users who purchased tickets to a Twitter Space.", + categories={BlockCategory.SOCIAL}, + input_schema=TwitterGetSpaceBuyersBlock.Input, + output_schema=TwitterGetSpaceBuyersBlock.Output, + test_input={ + "space_id": "1DXxyRYNejbKM", + "credentials": TEST_CREDENTIALS_INPUT, + "expansions": None, + "user_fields": None, + }, + test_credentials=TEST_CREDENTIALS, + test_output=[ + ("buyer_ids", ["2244994945"]), + ("usernames", ["testuser"]), + ( + "data", + [{"id": "2244994945", "username": "testuser", "name": "Test User"}], + ), + ], + test_mock={ + "get_space_buyers": lambda *args, **kwargs: ( + [{"id": "2244994945", "username": "testuser", "name": "Test User"}], + {}, + ["2244994945"], + ["testuser"], + ) + }, + ) + + @staticmethod + def get_space_buyers( + credentials: TwitterCredentials, + space_id: str, + expansions: UserExpansionsFilter | None, + user_fields: TweetUserFieldsFilter | None, + ): + try: + client = tweepy.Client( + bearer_token=credentials.access_token.get_secret_value() + ) + + params = { + "id": space_id, + } + + params = ( + UserExpansionsBuilder(params) + .add_expansions(expansions) + .add_user_fields(user_fields) + .build() + ) + + response = cast(Response, client.get_space_buyers(**params)) + + included = IncludesSerializer.serialize(response.includes) + + if response.data: + data = ResponseDataSerializer.serialize_list(response.data) + buyer_ids = [buyer["id"] for buyer in data] + usernames = [buyer["username"] for buyer in data] + + return data, included, buyer_ids, usernames + + raise Exception("No buyers found for this Space") + + except tweepy.TweepyException: + raise + + def run( + self, + input_data: Input, + *, + credentials: TwitterCredentials, + **kwargs, + ) -> BlockOutput: + try: + buyers_data, included, buyer_ids, usernames = self.get_space_buyers( + credentials, + input_data.space_id, + input_data.expansions, + input_data.user_fields, + ) + + if buyer_ids: + yield "buyer_ids", buyer_ids + if usernames: + yield "usernames", usernames + + if buyers_data: + yield "data", buyers_data + if included: + yield "includes", included + + except Exception as e: + yield "error", handle_tweepy_exception(e) + + +class TwitterGetSpaceTweetsBlock(Block): + """ + Gets list of Tweets shared in the requested Space + """ + + class Input(TweetExpansionInputs): + credentials: TwitterCredentialsInput = TwitterCredentialsField( + ["spaces.read", "users.read", "offline.access"] + ) + + space_id: str = SchemaField( + description="Space ID to lookup tweets for", + placeholder="Enter Space ID", + required=True, + ) + + class Output(BlockSchema): + # Common outputs + tweet_ids: list[str] = SchemaField(description="List of tweet IDs") + texts: list[str] = SchemaField(description="List of tweet texts") + + # Complete outputs for advanced use + data: list[dict] = SchemaField(description="Complete space tweets data") + includes: dict = SchemaField( + description="Additional data requested via expansions" + ) + meta: dict = SchemaField(description="Response metadata") + error: str = SchemaField(description="Error message if the request failed") + + def __init__(self): + super().__init__( + id="b69731e6-a62f-11ef-b2d4-1bf14dd6aee4", + description="This block retrieves tweets shared in a Twitter Space.", + categories={BlockCategory.SOCIAL}, + input_schema=TwitterGetSpaceTweetsBlock.Input, + output_schema=TwitterGetSpaceTweetsBlock.Output, + test_input={ + "space_id": "1DXxyRYNejbKM", + "credentials": TEST_CREDENTIALS_INPUT, + "expansions": None, + "media_fields": None, + "place_fields": None, + "poll_fields": None, + "tweet_fields": None, + "user_fields": None, + }, + test_credentials=TEST_CREDENTIALS, + test_output=[ + ("tweet_ids", ["1234567890"]), + ("texts", ["Test tweet"]), + ("data", [{"id": "1234567890", "text": "Test tweet"}]), + ], + test_mock={ + "get_space_tweets": lambda *args, **kwargs: ( + [{"id": "1234567890", "text": "Test tweet"}], # data + {}, + ["1234567890"], + ["Test tweet"], + {}, + ) + }, + ) + + @staticmethod + def get_space_tweets( + credentials: TwitterCredentials, + space_id: str, + expansions: ExpansionFilter | None, + media_fields: TweetMediaFieldsFilter | None, + place_fields: TweetPlaceFieldsFilter | None, + poll_fields: TweetPollFieldsFilter | None, + tweet_fields: TweetFieldsFilter | None, + user_fields: TweetUserFieldsFilter | None, + ): + try: + client = tweepy.Client( + bearer_token=credentials.access_token.get_secret_value() + ) + + params = { + "id": space_id, + } + + params = ( + TweetExpansionsBuilder(params) + .add_expansions(expansions) + .add_media_fields(media_fields) + .add_place_fields(place_fields) + .add_poll_fields(poll_fields) + .add_tweet_fields(tweet_fields) + .add_user_fields(user_fields) + .build() + ) + + response = cast(Response, client.get_space_tweets(**params)) + + included = IncludesSerializer.serialize(response.includes) + + if response.data: + data = ResponseDataSerializer.serialize_list(response.data) + tweet_ids = [str(tweet["id"]) for tweet in data] + texts = [tweet["text"] for tweet in data] + + meta = response.meta or {} + + return data, included, tweet_ids, texts, meta + + raise Exception("No tweets found for this Space") + + except tweepy.TweepyException: + raise + + def run( + self, + input_data: Input, + *, + credentials: TwitterCredentials, + **kwargs, + ) -> BlockOutput: + try: + tweets_data, included, tweet_ids, texts, meta = self.get_space_tweets( + credentials, + input_data.space_id, + input_data.expansions, + input_data.media_fields, + input_data.place_fields, + input_data.poll_fields, + input_data.tweet_fields, + input_data.user_fields, + ) + + if tweet_ids: + yield "tweet_ids", tweet_ids + if texts: + yield "texts", texts + + if tweets_data: + yield "data", tweets_data + if included: + yield "includes", included + if meta: + yield "meta", meta + + except Exception as e: + yield "error", handle_tweepy_exception(e) diff --git a/autogpt_platform/backend/backend/blocks/twitter/tweepy_exceptions.py b/autogpt_platform/backend/backend/blocks/twitter/tweepy_exceptions.py new file mode 100644 index 000000000000..c1900269982f --- /dev/null +++ b/autogpt_platform/backend/backend/blocks/twitter/tweepy_exceptions.py @@ -0,0 +1,20 @@ +import tweepy + + +def handle_tweepy_exception(e: Exception) -> str: + if isinstance(e, tweepy.BadRequest): + return f"Bad Request (400): {str(e)}" + elif isinstance(e, tweepy.Unauthorized): + return f"Unauthorized (401): {str(e)}" + elif isinstance(e, tweepy.Forbidden): + return f"Forbidden (403): {str(e)}" + elif isinstance(e, tweepy.NotFound): + return f"Not Found (404): {str(e)}" + elif isinstance(e, tweepy.TooManyRequests): + return f"Too Many Requests (429): {str(e)}" + elif isinstance(e, tweepy.TwitterServerError): + return f"Twitter Server Error (5xx): {str(e)}" + elif isinstance(e, tweepy.TweepyException): + return f"Tweepy Error: {str(e)}" + else: + return f"Unexpected error: {str(e)}" diff --git a/autogpt_platform/backend/backend/blocks/twitter/tweets/bookmark.py b/autogpt_platform/backend/backend/blocks/twitter/tweets/bookmark.py new file mode 100644 index 000000000000..9a3147903c10 --- /dev/null +++ b/autogpt_platform/backend/backend/blocks/twitter/tweets/bookmark.py @@ -0,0 +1,372 @@ +from typing import cast + +import tweepy +from tweepy.client import Response + +from backend.blocks.twitter._auth import ( + TEST_CREDENTIALS, + TEST_CREDENTIALS_INPUT, + TwitterCredentials, + TwitterCredentialsField, + TwitterCredentialsInput, +) +from backend.blocks.twitter._builders import TweetExpansionsBuilder +from backend.blocks.twitter._serializer import ( + IncludesSerializer, + ResponseDataSerializer, +) +from backend.blocks.twitter._types import ( + ExpansionFilter, + TweetExpansionInputs, + TweetFieldsFilter, + TweetMediaFieldsFilter, + TweetPlaceFieldsFilter, + TweetPollFieldsFilter, + TweetUserFieldsFilter, +) +from backend.blocks.twitter.tweepy_exceptions import handle_tweepy_exception +from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema +from backend.data.model import SchemaField + + +class TwitterBookmarkTweetBlock(Block): + """ + Bookmark a tweet on Twitter + """ + + class Input(BlockSchema): + credentials: TwitterCredentialsInput = TwitterCredentialsField( + ["tweet.read", "bookmark.write", "users.read", "offline.access"] + ) + + tweet_id: str = SchemaField( + description="ID of the tweet to bookmark", + placeholder="Enter tweet ID", + ) + + class Output(BlockSchema): + success: bool = SchemaField(description="Whether the bookmark was successful") + error: str = SchemaField(description="Error message if the bookmark failed") + + def __init__(self): + super().__init__( + id="f33d67be-a62f-11ef-a797-ff83ec29ee8e", + description="This block bookmarks a tweet on Twitter.", + categories={BlockCategory.SOCIAL}, + input_schema=TwitterBookmarkTweetBlock.Input, + output_schema=TwitterBookmarkTweetBlock.Output, + test_input={ + "tweet_id": "1234567890", + "credentials": TEST_CREDENTIALS_INPUT, + }, + test_credentials=TEST_CREDENTIALS, + test_output=[ + ("success", True), + ], + test_mock={"bookmark_tweet": lambda *args, **kwargs: True}, + ) + + @staticmethod + def bookmark_tweet( + credentials: TwitterCredentials, + tweet_id: str, + ): + try: + client = tweepy.Client( + bearer_token=credentials.access_token.get_secret_value() + ) + + client.bookmark(tweet_id) + + return True + + except tweepy.TweepyException: + raise + + def run( + self, + input_data: Input, + *, + credentials: TwitterCredentials, + **kwargs, + ) -> BlockOutput: + try: + success = self.bookmark_tweet(credentials, input_data.tweet_id) + yield "success", success + except Exception as e: + yield "error", handle_tweepy_exception(e) + + +class TwitterGetBookmarkedTweetsBlock(Block): + """ + Get All your bookmarked tweets from Twitter + """ + + class Input(TweetExpansionInputs): + credentials: TwitterCredentialsInput = TwitterCredentialsField( + ["tweet.read", "bookmark.read", "users.read", "offline.access"] + ) + + max_results: int | None = SchemaField( + description="Maximum number of results to return (1-100)", + placeholder="Enter max results", + default=10, + advanced=True, + ) + + pagination_token: str | None = SchemaField( + description="Token for pagination", + placeholder="Enter pagination token", + default="", + advanced=True, + ) + + class Output(BlockSchema): + # Common Outputs that user commonly uses + id: list[str] = SchemaField(description="All Tweet IDs") + text: list[str] = SchemaField(description="All Tweet texts") + userId: list[str] = SchemaField(description="IDs of the tweet authors") + userName: list[str] = SchemaField(description="Usernames of the tweet authors") + + # Complete Outputs for advanced use + data: list[dict] = SchemaField(description="Complete Tweet data") + included: dict = SchemaField( + description="Additional data that you have requested (Optional) via Expansions field" + ) + meta: dict = SchemaField( + description="Provides metadata such as pagination info (next_token) or result counts" + ) + next_token: str = SchemaField(description="Next token for pagination") + + error: str = SchemaField(description="Error message if the request failed") + + def __init__(self): + super().__init__( + id="ed26783e-a62f-11ef-9a21-c77c57dd8a1f", + description="This block retrieves bookmarked tweets from Twitter.", + categories={BlockCategory.SOCIAL}, + input_schema=TwitterGetBookmarkedTweetsBlock.Input, + output_schema=TwitterGetBookmarkedTweetsBlock.Output, + test_input={ + "max_results": 2, + "pagination_token": None, + "expansions": None, + "media_fields": None, + "place_fields": None, + "poll_fields": None, + "tweet_fields": None, + "user_fields": None, + "credentials": TEST_CREDENTIALS_INPUT, + }, + test_credentials=TEST_CREDENTIALS, + test_output=[ + ("id", ["1234567890"]), + ("text", ["Test tweet"]), + ("userId", ["12345"]), + ("userName", ["testuser"]), + ("data", [{"id": "1234567890", "text": "Test tweet"}]), + ], + test_mock={ + "get_bookmarked_tweets": lambda *args, **kwargs: ( + ["1234567890"], + ["Test tweet"], + ["12345"], + ["testuser"], + [{"id": "1234567890", "text": "Test tweet"}], + {}, + {}, + None, + ) + }, + ) + + @staticmethod + def get_bookmarked_tweets( + credentials: TwitterCredentials, + max_results: int | None, + pagination_token: str | None, + expansions: ExpansionFilter | None, + media_fields: TweetMediaFieldsFilter | None, + place_fields: TweetPlaceFieldsFilter | None, + poll_fields: TweetPollFieldsFilter | None, + tweet_fields: TweetFieldsFilter | None, + user_fields: TweetUserFieldsFilter | None, + ): + try: + client = tweepy.Client( + bearer_token=credentials.access_token.get_secret_value() + ) + + params = { + "max_results": max_results, + "pagination_token": ( + None if pagination_token == "" else pagination_token + ), + } + + params = ( + TweetExpansionsBuilder(params) + .add_expansions(expansions) + .add_media_fields(media_fields) + .add_place_fields(place_fields) + .add_poll_fields(poll_fields) + .add_tweet_fields(tweet_fields) + .add_user_fields(user_fields) + .build() + ) + + response = cast( + Response, + client.get_bookmarks(**params), + ) + + meta = {} + tweet_ids = [] + tweet_texts = [] + user_ids = [] + user_names = [] + next_token = None + + if response.meta: + meta = response.meta + next_token = meta.get("next_token") + + included = IncludesSerializer.serialize(response.includes) + data = ResponseDataSerializer.serialize_list(response.data) + + if response.data: + tweet_ids = [str(tweet.id) for tweet in response.data] + tweet_texts = [tweet.text for tweet in response.data] + + if "users" in included: + for user in included["users"]: + user_ids.append(str(user["id"])) + user_names.append(user["username"]) + + return ( + tweet_ids, + tweet_texts, + user_ids, + user_names, + data, + included, + meta, + next_token, + ) + + raise Exception("No bookmarked tweets found") + + except tweepy.TweepyException: + raise + + def run( + self, + input_data: Input, + *, + credentials: TwitterCredentials, + **kwargs, + ) -> BlockOutput: + try: + ids, texts, user_ids, user_names, data, included, meta, next_token = ( + self.get_bookmarked_tweets( + credentials, + input_data.max_results, + input_data.pagination_token, + input_data.expansions, + input_data.media_fields, + input_data.place_fields, + input_data.poll_fields, + input_data.tweet_fields, + input_data.user_fields, + ) + ) + if ids: + yield "id", ids + if texts: + yield "text", texts + if user_ids: + yield "userId", user_ids + if user_names: + yield "userName", user_names + if data: + yield "data", data + if included: + yield "included", included + if meta: + yield "meta", meta + if next_token: + yield "next_token", next_token + except Exception as e: + yield "error", handle_tweepy_exception(e) + + +class TwitterRemoveBookmarkTweetBlock(Block): + """ + Remove a bookmark for a tweet on Twitter + """ + + class Input(BlockSchema): + credentials: TwitterCredentialsInput = TwitterCredentialsField( + ["tweet.read", "bookmark.write", "users.read", "offline.access"] + ) + + tweet_id: str = SchemaField( + description="ID of the tweet to remove bookmark from", + placeholder="Enter tweet ID", + ) + + class Output(BlockSchema): + success: bool = SchemaField( + description="Whether the bookmark was successfully removed" + ) + error: str = SchemaField( + description="Error message if the bookmark removal failed" + ) + + def __init__(self): + super().__init__( + id="e4100684-a62f-11ef-9be9-770cb41a2616", + description="This block removes a bookmark from a tweet on Twitter.", + categories={BlockCategory.SOCIAL}, + input_schema=TwitterRemoveBookmarkTweetBlock.Input, + output_schema=TwitterRemoveBookmarkTweetBlock.Output, + test_input={ + "tweet_id": "1234567890", + "credentials": TEST_CREDENTIALS_INPUT, + }, + test_credentials=TEST_CREDENTIALS, + test_output=[ + ("success", True), + ], + test_mock={"remove_bookmark_tweet": lambda *args, **kwargs: True}, + ) + + @staticmethod + def remove_bookmark_tweet( + credentials: TwitterCredentials, + tweet_id: str, + ): + try: + client = tweepy.Client( + bearer_token=credentials.access_token.get_secret_value() + ) + + client.remove_bookmark(tweet_id) + + return True + + except tweepy.TweepyException: + raise + + def run( + self, + input_data: Input, + *, + credentials: TwitterCredentials, + **kwargs, + ) -> BlockOutput: + try: + success = self.remove_bookmark_tweet(credentials, input_data.tweet_id) + yield "success", success + except Exception as e: + yield "error", handle_tweepy_exception(e) diff --git a/autogpt_platform/backend/backend/blocks/twitter/tweets/hide.py b/autogpt_platform/backend/backend/blocks/twitter/tweets/hide.py new file mode 100644 index 000000000000..ae9998e32d9a --- /dev/null +++ b/autogpt_platform/backend/backend/blocks/twitter/tweets/hide.py @@ -0,0 +1,154 @@ +import tweepy + +from backend.blocks.twitter._auth import ( + TEST_CREDENTIALS, + TEST_CREDENTIALS_INPUT, + TwitterCredentials, + TwitterCredentialsField, + TwitterCredentialsInput, +) +from backend.blocks.twitter.tweepy_exceptions import handle_tweepy_exception +from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema +from backend.data.model import SchemaField + + +class TwitterHideReplyBlock(Block): + """ + Hides a reply of one of your tweets + """ + + class Input(BlockSchema): + credentials: TwitterCredentialsInput = TwitterCredentialsField( + ["tweet.read", "tweet.moderate.write", "users.read", "offline.access"] + ) + + tweet_id: str = SchemaField( + description="ID of the tweet reply to hide", + placeholder="Enter tweet ID", + ) + + class Output(BlockSchema): + success: bool = SchemaField(description="Whether the operation was successful") + error: str = SchemaField(description="Error message if the request failed") + + def __init__(self): + super().__init__( + id="07d58b3e-a630-11ef-a030-93701d1a465e", + description="This block hides a reply to a tweet.", + categories={BlockCategory.SOCIAL}, + input_schema=TwitterHideReplyBlock.Input, + output_schema=TwitterHideReplyBlock.Output, + test_input={ + "tweet_id": "1234567890", + "credentials": TEST_CREDENTIALS_INPUT, + }, + test_credentials=TEST_CREDENTIALS, + test_output=[ + ("success", True), + ], + test_mock={"hide_reply": lambda *args, **kwargs: True}, + ) + + @staticmethod + def hide_reply( + credentials: TwitterCredentials, + tweet_id: str, + ): + try: + client = tweepy.Client( + bearer_token=credentials.access_token.get_secret_value() + ) + + client.hide_reply(id=tweet_id, user_auth=False) + + return True + + except tweepy.TweepyException: + raise + + def run( + self, + input_data: Input, + *, + credentials: TwitterCredentials, + **kwargs, + ) -> BlockOutput: + try: + success = self.hide_reply( + credentials, + input_data.tweet_id, + ) + yield "success", success + except Exception as e: + yield "error", handle_tweepy_exception(e) + + +class TwitterUnhideReplyBlock(Block): + """ + Unhides a reply to a tweet + """ + + class Input(BlockSchema): + credentials: TwitterCredentialsInput = TwitterCredentialsField( + ["tweet.read", "tweet.moderate.write", "users.read", "offline.access"] + ) + + tweet_id: str = SchemaField( + description="ID of the tweet reply to unhide", + placeholder="Enter tweet ID", + ) + + class Output(BlockSchema): + success: bool = SchemaField(description="Whether the operation was successful") + error: str = SchemaField(description="Error message if the request failed") + + def __init__(self): + super().__init__( + id="fcf9e4e4-a62f-11ef-9d85-57d3d06b616a", + description="This block unhides a reply to a tweet.", + categories={BlockCategory.SOCIAL}, + input_schema=TwitterUnhideReplyBlock.Input, + output_schema=TwitterUnhideReplyBlock.Output, + test_input={ + "tweet_id": "1234567890", + "credentials": TEST_CREDENTIALS_INPUT, + }, + test_credentials=TEST_CREDENTIALS, + test_output=[ + ("success", True), + ], + test_mock={"unhide_reply": lambda *args, **kwargs: True}, + ) + + @staticmethod + def unhide_reply( + credentials: TwitterCredentials, + tweet_id: str, + ): + try: + client = tweepy.Client( + bearer_token=credentials.access_token.get_secret_value() + ) + + client.unhide_reply(id=tweet_id, user_auth=False) + + return True + + except tweepy.TweepyException: + raise + + def run( + self, + input_data: Input, + *, + credentials: TwitterCredentials, + **kwargs, + ) -> BlockOutput: + try: + success = self.unhide_reply( + credentials, + input_data.tweet_id, + ) + yield "success", success + except Exception as e: + yield "error", handle_tweepy_exception(e) diff --git a/autogpt_platform/backend/backend/blocks/twitter/tweets/like.py b/autogpt_platform/backend/backend/blocks/twitter/tweets/like.py new file mode 100644 index 000000000000..c1816a6ce31c --- /dev/null +++ b/autogpt_platform/backend/backend/blocks/twitter/tweets/like.py @@ -0,0 +1,576 @@ +from typing import cast + +import tweepy +from tweepy.client import Response + +from backend.blocks.twitter._auth import ( + TEST_CREDENTIALS, + TEST_CREDENTIALS_INPUT, + TwitterCredentials, + TwitterCredentialsField, + TwitterCredentialsInput, +) +from backend.blocks.twitter._builders import ( + TweetExpansionsBuilder, + UserExpansionsBuilder, +) +from backend.blocks.twitter._serializer import ( + IncludesSerializer, + ResponseDataSerializer, +) +from backend.blocks.twitter._types import ( + ExpansionFilter, + TweetExpansionInputs, + TweetFieldsFilter, + TweetMediaFieldsFilter, + TweetPlaceFieldsFilter, + TweetPollFieldsFilter, + TweetUserFieldsFilter, + UserExpansionInputs, + UserExpansionsFilter, +) +from backend.blocks.twitter.tweepy_exceptions import handle_tweepy_exception +from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema +from backend.data.model import SchemaField + + +class TwitterLikeTweetBlock(Block): + """ + Likes a tweet + """ + + class Input(BlockSchema): + credentials: TwitterCredentialsInput = TwitterCredentialsField( + ["tweet.read", "like.write", "users.read", "offline.access"] + ) + + tweet_id: str = SchemaField( + description="ID of the tweet to like", + placeholder="Enter tweet ID", + ) + + class Output(BlockSchema): + success: bool = SchemaField(description="Whether the operation was successful") + error: str = SchemaField(description="Error message if the request failed") + + def __init__(self): + super().__init__( + id="4d0b4c5c-a630-11ef-8e08-1b14c507b347", + description="This block likes a tweet.", + categories={BlockCategory.SOCIAL}, + input_schema=TwitterLikeTweetBlock.Input, + output_schema=TwitterLikeTweetBlock.Output, + test_input={ + "tweet_id": "1234567890", + "credentials": TEST_CREDENTIALS_INPUT, + }, + test_credentials=TEST_CREDENTIALS, + test_output=[ + ("success", True), + ], + test_mock={"like_tweet": lambda *args, **kwargs: True}, + ) + + @staticmethod + def like_tweet( + credentials: TwitterCredentials, + tweet_id: str, + ): + try: + client = tweepy.Client( + bearer_token=credentials.access_token.get_secret_value() + ) + + client.like(tweet_id=tweet_id, user_auth=False) + + return True + + except tweepy.TweepyException: + raise + + def run( + self, + input_data: Input, + *, + credentials: TwitterCredentials, + **kwargs, + ) -> BlockOutput: + try: + success = self.like_tweet( + credentials, + input_data.tweet_id, + ) + yield "success", success + except Exception as e: + yield "error", handle_tweepy_exception(e) + + +class TwitterGetLikingUsersBlock(Block): + """ + Gets information about users who liked a one of your tweet + """ + + class Input(UserExpansionInputs): + credentials: TwitterCredentialsInput = TwitterCredentialsField( + ["tweet.read", "users.read", "like.read", "offline.access"] + ) + + tweet_id: str = SchemaField( + description="ID of the tweet to get liking users for", + placeholder="Enter tweet ID", + ) + max_results: int | None = SchemaField( + description="Maximum number of results to return (1-100)", + placeholder="Enter max results", + default=10, + advanced=True, + ) + pagination_token: str | None = SchemaField( + description="Token for getting next/previous page of results", + placeholder="Enter pagination token", + default="", + advanced=True, + ) + + class Output(BlockSchema): + # Common Outputs that user commonly uses + id: list[str] = SchemaField(description="All User IDs who liked the tweet") + username: list[str] = SchemaField( + description="All User usernames who liked the tweet" + ) + next_token: str = SchemaField(description="Next token for pagination") + + # Complete Outputs for advanced use + data: list[dict] = SchemaField(description="Complete Tweet data") + included: dict = SchemaField( + description="Additional data that you have requested (Optional) via Expansions field" + ) + meta: dict = SchemaField( + description="Provides metadata such as pagination info (next_token) or result counts" + ) + + # error + error: str = SchemaField(description="Error message if the request failed") + + def __init__(self): + super().__init__( + id="34275000-a630-11ef-b01e-5f00d9077c08", + description="This block gets information about users who liked a tweet.", + categories={BlockCategory.SOCIAL}, + input_schema=TwitterGetLikingUsersBlock.Input, + output_schema=TwitterGetLikingUsersBlock.Output, + test_input={ + "tweet_id": "1234567890", + "max_results": 1, + "pagination_token": None, + "credentials": TEST_CREDENTIALS_INPUT, + "expansions": None, + "tweet_fields": None, + "user_fields": None, + }, + test_credentials=TEST_CREDENTIALS, + test_output=[ + ("id", ["1234567890"]), + ("username", ["testuser"]), + ("data", [{"id": "1234567890", "username": "testuser"}]), + ], + test_mock={ + "get_liking_users": lambda *args, **kwargs: ( + ["1234567890"], + ["testuser"], + [{"id": "1234567890", "username": "testuser"}], + {}, + {}, + None, + ) + }, + ) + + @staticmethod + def get_liking_users( + credentials: TwitterCredentials, + tweet_id: str, + max_results: int | None, + pagination_token: str | None, + expansions: UserExpansionsFilter | None, + tweet_fields: TweetFieldsFilter | None, + user_fields: TweetUserFieldsFilter | None, + ): + try: + client = tweepy.Client( + bearer_token=credentials.access_token.get_secret_value() + ) + + params = { + "id": tweet_id, + "max_results": max_results, + "pagination_token": ( + None if pagination_token == "" else pagination_token + ), + "user_auth": False, + } + + params = ( + UserExpansionsBuilder(params) + .add_expansions(expansions) + .add_tweet_fields(tweet_fields) + .add_user_fields(user_fields) + .build() + ) + + response = cast(Response, client.get_liking_users(**params)) + + if not response.data and not response.meta: + raise Exception("No liking users found") + + meta = {} + user_ids = [] + usernames = [] + next_token = None + + if response.meta: + meta = response.meta + next_token = meta.get("next_token") + + included = IncludesSerializer.serialize(response.includes) + data = ResponseDataSerializer.serialize_list(response.data) + + if response.data: + user_ids = [str(user.id) for user in response.data] + usernames = [user.username for user in response.data] + + return user_ids, usernames, data, included, meta, next_token + + raise Exception("No liking users found") + + except tweepy.TweepyException: + raise + + def run( + self, + input_data: Input, + *, + credentials: TwitterCredentials, + **kwargs, + ) -> BlockOutput: + try: + ids, usernames, data, included, meta, next_token = self.get_liking_users( + credentials, + input_data.tweet_id, + input_data.max_results, + input_data.pagination_token, + input_data.expansions, + input_data.tweet_fields, + input_data.user_fields, + ) + if ids: + yield "id", ids + if usernames: + yield "username", usernames + if next_token: + yield "next_token", next_token + if data: + yield "data", data + if included: + yield "included", included + if meta: + yield "meta", meta + except Exception as e: + yield "error", handle_tweepy_exception(e) + + +class TwitterGetLikedTweetsBlock(Block): + """ + Gets information about tweets liked by you + """ + + class Input(TweetExpansionInputs): + credentials: TwitterCredentialsInput = TwitterCredentialsField( + ["tweet.read", "users.read", "like.read", "offline.access"] + ) + + user_id: str = SchemaField( + description="ID of the user to get liked tweets for", + placeholder="Enter user ID", + ) + max_results: int | None = SchemaField( + description="Maximum number of results to return (5-100)", + placeholder="100", + default=10, + advanced=True, + ) + pagination_token: str | None = SchemaField( + description="Token for getting next/previous page of results", + placeholder="Enter pagination token", + default="", + advanced=True, + ) + + class Output(BlockSchema): + # Common Outputs that user commonly uses + ids: list[str] = SchemaField(description="All Tweet IDs") + texts: list[str] = SchemaField(description="All Tweet texts") + userIds: list[str] = SchemaField( + description="List of user ids that authored the tweets" + ) + userNames: list[str] = SchemaField( + description="List of user names that authored the tweets" + ) + next_token: str = SchemaField(description="Next token for pagination") + + # Complete Outputs for advanced use + data: list[dict] = SchemaField(description="Complete Tweet data") + included: dict = SchemaField( + description="Additional data that you have requested (Optional) via Expansions field" + ) + meta: dict = SchemaField( + description="Provides metadata such as pagination info (next_token) or result counts" + ) + + # error + error: str = SchemaField(description="Error message if the request failed") + + def __init__(self): + super().__init__( + id="292e7c78-a630-11ef-9f40-df5dffaca106", + description="This block gets information about tweets liked by a user.", + categories={BlockCategory.SOCIAL}, + input_schema=TwitterGetLikedTweetsBlock.Input, + output_schema=TwitterGetLikedTweetsBlock.Output, + test_input={ + "user_id": "1234567890", + "max_results": 2, + "pagination_token": None, + "credentials": TEST_CREDENTIALS_INPUT, + "expansions": None, + "media_fields": None, + "place_fields": None, + "poll_fields": None, + "tweet_fields": None, + "user_fields": None, + }, + test_credentials=TEST_CREDENTIALS, + test_output=[ + ("ids", ["12345", "67890"]), + ("texts", ["Tweet 1", "Tweet 2"]), + ("userIds", ["67890", "67891"]), + ("userNames", ["testuser1", "testuser2"]), + ( + "data", + [ + {"id": "12345", "text": "Tweet 1"}, + {"id": "67890", "text": "Tweet 2"}, + ], + ), + ], + test_mock={ + "get_liked_tweets": lambda *args, **kwargs: ( + ["12345", "67890"], + ["Tweet 1", "Tweet 2"], + ["67890", "67891"], + ["testuser1", "testuser2"], + [ + {"id": "12345", "text": "Tweet 1"}, + {"id": "67890", "text": "Tweet 2"}, + ], + {}, + {}, + None, + ) + }, + ) + + @staticmethod + def get_liked_tweets( + credentials: TwitterCredentials, + user_id: str, + max_results: int | None, + pagination_token: str | None, + expansions: ExpansionFilter | None, + media_fields: TweetMediaFieldsFilter | None, + place_fields: TweetPlaceFieldsFilter | None, + poll_fields: TweetPollFieldsFilter | None, + tweet_fields: TweetFieldsFilter | None, + user_fields: TweetUserFieldsFilter | None, + ): + try: + client = tweepy.Client( + bearer_token=credentials.access_token.get_secret_value() + ) + + params = { + "id": user_id, + "max_results": max_results, + "pagination_token": ( + None if pagination_token == "" else pagination_token + ), + "user_auth": False, + } + + params = ( + TweetExpansionsBuilder(params) + .add_expansions(expansions) + .add_media_fields(media_fields) + .add_place_fields(place_fields) + .add_poll_fields(poll_fields) + .add_tweet_fields(tweet_fields) + .add_user_fields(user_fields) + .build() + ) + + response = cast(Response, client.get_liked_tweets(**params)) + + if not response.data and not response.meta: + raise Exception("No liked tweets found") + + meta = {} + tweet_ids = [] + tweet_texts = [] + user_ids = [] + user_names = [] + next_token = None + + if response.meta: + meta = response.meta + next_token = meta.get("next_token") + + included = IncludesSerializer.serialize(response.includes) + data = ResponseDataSerializer.serialize_list(response.data) + + if response.data: + tweet_ids = [str(tweet.id) for tweet in response.data] + tweet_texts = [tweet.text for tweet in response.data] + + if "users" in response.includes: + user_ids = [str(user["id"]) for user in response.includes["users"]] + user_names = [ + user["username"] for user in response.includes["users"] + ] + + return ( + tweet_ids, + tweet_texts, + user_ids, + user_names, + data, + included, + meta, + next_token, + ) + + raise Exception("No liked tweets found") + + except tweepy.TweepyException: + raise + + def run( + self, + input_data: Input, + *, + credentials: TwitterCredentials, + **kwargs, + ) -> BlockOutput: + try: + ids, texts, user_ids, user_names, data, included, meta, next_token = ( + self.get_liked_tweets( + credentials, + input_data.user_id, + input_data.max_results, + input_data.pagination_token, + input_data.expansions, + input_data.media_fields, + input_data.place_fields, + input_data.poll_fields, + input_data.tweet_fields, + input_data.user_fields, + ) + ) + if ids: + yield "ids", ids + if texts: + yield "texts", texts + if user_ids: + yield "userIds", user_ids + if user_names: + yield "userNames", user_names + if next_token: + yield "next_token", next_token + if data: + yield "data", data + if included: + yield "included", included + if meta: + yield "meta", meta + except Exception as e: + yield "error", handle_tweepy_exception(e) + + +class TwitterUnlikeTweetBlock(Block): + """ + Unlikes a tweet that was previously liked + """ + + class Input(BlockSchema): + credentials: TwitterCredentialsInput = TwitterCredentialsField( + ["tweet.read", "like.write", "users.read", "offline.access"] + ) + + tweet_id: str = SchemaField( + description="ID of the tweet to unlike", + placeholder="Enter tweet ID", + ) + + class Output(BlockSchema): + success: bool = SchemaField(description="Whether the operation was successful") + error: str = SchemaField(description="Error message if the request failed") + + def __init__(self): + super().__init__( + id="1ed5eab8-a630-11ef-8e21-cbbbc80cbb85", + description="This block unlikes a tweet.", + categories={BlockCategory.SOCIAL}, + input_schema=TwitterUnlikeTweetBlock.Input, + output_schema=TwitterUnlikeTweetBlock.Output, + test_input={ + "tweet_id": "1234567890", + "credentials": TEST_CREDENTIALS_INPUT, + }, + test_credentials=TEST_CREDENTIALS, + test_output=[ + ("success", True), + ], + test_mock={"unlike_tweet": lambda *args, **kwargs: True}, + ) + + @staticmethod + def unlike_tweet( + credentials: TwitterCredentials, + tweet_id: str, + ): + try: + client = tweepy.Client( + bearer_token=credentials.access_token.get_secret_value() + ) + + client.unlike(tweet_id=tweet_id, user_auth=False) + + return True + + except tweepy.TweepyException: + raise + + def run( + self, + input_data: Input, + *, + credentials: TwitterCredentials, + **kwargs, + ) -> BlockOutput: + try: + success = self.unlike_tweet( + credentials, + input_data.tweet_id, + ) + yield "success", success + except Exception as e: + yield "error", handle_tweepy_exception(e) diff --git a/autogpt_platform/backend/backend/blocks/twitter/tweets/manage.py b/autogpt_platform/backend/backend/blocks/twitter/tweets/manage.py new file mode 100644 index 000000000000..7c86c0abcd57 --- /dev/null +++ b/autogpt_platform/backend/backend/blocks/twitter/tweets/manage.py @@ -0,0 +1,545 @@ +from datetime import datetime +from typing import List, Literal, Optional, Union, cast + +import tweepy +from pydantic import BaseModel +from tweepy.client import Response + +from backend.blocks.twitter._auth import ( + TEST_CREDENTIALS, + TEST_CREDENTIALS_INPUT, + TwitterCredentials, + TwitterCredentialsField, + TwitterCredentialsInput, +) +from backend.blocks.twitter._builders import ( + TweetDurationBuilder, + TweetExpansionsBuilder, + TweetPostBuilder, + TweetSearchBuilder, +) +from backend.blocks.twitter._serializer import ( + IncludesSerializer, + ResponseDataSerializer, +) +from backend.blocks.twitter._types import ( + ExpansionFilter, + TweetExpansionInputs, + TweetFieldsFilter, + TweetMediaFieldsFilter, + TweetPlaceFieldsFilter, + TweetPollFieldsFilter, + TweetReplySettingsFilter, + TweetTimeWindowInputs, + TweetUserFieldsFilter, +) +from backend.blocks.twitter.tweepy_exceptions import handle_tweepy_exception +from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema +from backend.data.model import SchemaField + + +class Media(BaseModel): + discriminator: Literal["media"] + media_ids: Optional[List[str]] = None + media_tagged_user_ids: Optional[List[str]] = None + + +class DeepLink(BaseModel): + discriminator: Literal["deep_link"] + direct_message_deep_link: Optional[str] = None + + +class Poll(BaseModel): + discriminator: Literal["poll"] + poll_options: Optional[List[str]] = None + poll_duration_minutes: Optional[int] = None + + +class Place(BaseModel): + discriminator: Literal["place"] + place_id: Optional[str] = None + + +class Quote(BaseModel): + discriminator: Literal["quote"] + quote_tweet_id: Optional[str] = None + + +class TwitterPostTweetBlock(Block): + """ + Create a tweet on Twitter with the option to include one additional element such as a media, quote, or deep link. + """ + + class Input(BlockSchema): + credentials: TwitterCredentialsInput = TwitterCredentialsField( + ["tweet.read", "tweet.write", "users.read", "offline.access"] + ) + + tweet_text: str | None = SchemaField( + description="Text of the tweet to post", + placeholder="Enter your tweet", + default=None, + advanced=False, + ) + + for_super_followers_only: bool = SchemaField( + description="Tweet exclusively for Super Followers", + placeholder="Enter for super followers only", + advanced=True, + default=False, + ) + + attachment: Union[Media, DeepLink, Poll, Place, Quote] | None = SchemaField( + discriminator="discriminator", + description="Additional tweet data (media, deep link, poll, place or quote)", + advanced=True, + ) + + exclude_reply_user_ids: Optional[List[str]] = SchemaField( + description="User IDs to exclude from reply Tweet thread. [ex - 6253282]", + placeholder="Enter user IDs to exclude", + advanced=True, + default=None, + ) + + in_reply_to_tweet_id: Optional[str] = SchemaField( + description="Tweet ID being replied to. Please note that in_reply_to_tweet_id needs to be in the request if exclude_reply_user_ids is present", + default=None, + placeholder="Enter in reply to tweet ID", + advanced=True, + ) + + reply_settings: TweetReplySettingsFilter = SchemaField( + description="Who can reply to the Tweet (mentionedUsers or following)", + placeholder="Enter reply settings", + advanced=True, + default=TweetReplySettingsFilter(All_Users=True), + ) + + class Output(BlockSchema): + tweet_id: str = SchemaField(description="ID of the created tweet") + tweet_url: str = SchemaField(description="URL to the tweet") + error: str = SchemaField( + description="Error message if the tweet posting failed" + ) + + def __init__(self): + super().__init__( + id="7bb0048a-a630-11ef-aeb8-abc0dadb9b12", + description="This block posts a tweet on Twitter.", + categories={BlockCategory.SOCIAL}, + input_schema=TwitterPostTweetBlock.Input, + output_schema=TwitterPostTweetBlock.Output, + test_input={ + "tweet_text": "This is a test tweet.", + "credentials": TEST_CREDENTIALS_INPUT, + "attachment": { + "discriminator": "deep_link", + "direct_message_deep_link": "https://twitter.com/messages/compose", + }, + "for_super_followers_only": False, + "exclude_reply_user_ids": [], + "in_reply_to_tweet_id": "", + }, + test_credentials=TEST_CREDENTIALS, + test_output=[ + ("tweet_id", "1234567890"), + ("tweet_url", "https://twitter.com/user/status/1234567890"), + ], + test_mock={ + "post_tweet": lambda *args, **kwargs: ( + "1234567890", + "https://twitter.com/user/status/1234567890", + ) + }, + ) + + def post_tweet( + self, + credentials: TwitterCredentials, + input_txt: str | None, + attachment: Union[Media, DeepLink, Poll, Place, Quote] | None, + for_super_followers_only: bool, + exclude_reply_user_ids: Optional[List[str]], + in_reply_to_tweet_id: Optional[str], + reply_settings: TweetReplySettingsFilter, + ): + try: + client = tweepy.Client( + bearer_token=credentials.access_token.get_secret_value() + ) + + params = ( + TweetPostBuilder() + .add_text(input_txt) + .add_super_followers(for_super_followers_only) + .add_reply_settings( + exclude_reply_user_ids or [], + in_reply_to_tweet_id or "", + reply_settings, + ) + ) + + if isinstance(attachment, Media): + params.add_media( + attachment.media_ids or [], attachment.media_tagged_user_ids or [] + ) + elif isinstance(attachment, DeepLink): + params.add_deep_link(attachment.direct_message_deep_link or "") + elif isinstance(attachment, Poll): + params.add_poll_options(attachment.poll_options or []) + params.add_poll_duration(attachment.poll_duration_minutes or 0) + elif isinstance(attachment, Place): + params.add_place(attachment.place_id or "") + elif isinstance(attachment, Quote): + params.add_quote(attachment.quote_tweet_id or "") + + tweet = cast(Response, client.create_tweet(**params.build())) + + if not tweet.data: + raise Exception("Failed to create tweet") + + tweet_id = tweet.data["id"] + tweet_url = f"https://twitter.com/user/status/{tweet_id}" + return str(tweet_id), tweet_url + + except tweepy.TweepyException: + raise + except Exception: + raise + + def run( + self, + input_data: Input, + *, + credentials: TwitterCredentials, + **kwargs, + ) -> BlockOutput: + try: + tweet_id, tweet_url = self.post_tweet( + credentials, + input_data.tweet_text, + input_data.attachment, + input_data.for_super_followers_only, + input_data.exclude_reply_user_ids, + input_data.in_reply_to_tweet_id, + input_data.reply_settings, + ) + yield "tweet_id", tweet_id + yield "tweet_url", tweet_url + + except Exception as e: + yield "error", handle_tweepy_exception(e) + + +class TwitterDeleteTweetBlock(Block): + """ + Deletes a tweet on Twitter using twitter Id + """ + + class Input(BlockSchema): + credentials: TwitterCredentialsInput = TwitterCredentialsField( + ["tweet.read", "tweet.write", "users.read", "offline.access"] + ) + + tweet_id: str = SchemaField( + description="ID of the tweet to delete", + placeholder="Enter tweet ID", + ) + + class Output(BlockSchema): + success: bool = SchemaField( + description="Whether the tweet was successfully deleted" + ) + error: str = SchemaField( + description="Error message if the tweet deletion failed" + ) + + def __init__(self): + super().__init__( + id="761babf0-a630-11ef-a03d-abceb082f58f", + description="This block deletes a tweet on Twitter.", + categories={BlockCategory.SOCIAL}, + input_schema=TwitterDeleteTweetBlock.Input, + output_schema=TwitterDeleteTweetBlock.Output, + test_input={ + "tweet_id": "1234567890", + "credentials": TEST_CREDENTIALS_INPUT, + }, + test_credentials=TEST_CREDENTIALS, + test_output=[("success", True)], + test_mock={"delete_tweet": lambda *args, **kwargs: True}, + ) + + @staticmethod + def delete_tweet(credentials: TwitterCredentials, tweet_id: str): + try: + client = tweepy.Client( + bearer_token=credentials.access_token.get_secret_value() + ) + client.delete_tweet(id=tweet_id, user_auth=False) + return True + except tweepy.TweepyException: + raise + except Exception: + raise + + def run( + self, + input_data: Input, + *, + credentials: TwitterCredentials, + **kwargs, + ) -> BlockOutput: + try: + success = self.delete_tweet( + credentials, + input_data.tweet_id, + ) + yield "success", success + + except Exception as e: + yield "error", handle_tweepy_exception(e) + + +class TwitterSearchRecentTweetsBlock(Block): + """ + Searches all public Tweets in Twitter history + """ + + class Input(TweetExpansionInputs, TweetTimeWindowInputs): + credentials: TwitterCredentialsInput = TwitterCredentialsField( + ["tweet.read", "users.read", "offline.access"] + ) + + query: str = SchemaField( + description="Search query (up to 1024 characters)", + placeholder="Enter search query", + ) + + max_results: int = SchemaField( + description="Maximum number of results per page (10-500)", + placeholder="Enter max results", + default=10, + advanced=True, + ) + + pagination: str | None = SchemaField( + description="Token for pagination", + default="", + placeholder="Enter pagination token", + advanced=True, + ) + + class Output(BlockSchema): + # Common Outputs that user commonly uses + tweet_ids: list[str] = SchemaField(description="All Tweet IDs") + tweet_texts: list[str] = SchemaField(description="All Tweet texts") + next_token: str = SchemaField(description="Next token for pagination") + + # Complete Outputs for advanced use + data: list[dict] = SchemaField(description="Complete Tweet data") + included: dict = SchemaField( + description="Additional data that you have requested (Optional) via Expansions field" + ) + meta: dict = SchemaField( + description="Provides metadata such as pagination info (next_token) or result counts" + ) + + # error + error: str = SchemaField(description="Error message if the request failed") + + def __init__(self): + super().__init__( + id="53e5cf8e-a630-11ef-ba85-df6d666fa5d5", + description="This block searches all public Tweets in Twitter history.", + categories={BlockCategory.SOCIAL}, + input_schema=TwitterSearchRecentTweetsBlock.Input, + output_schema=TwitterSearchRecentTweetsBlock.Output, + test_input={ + "query": "from:twitterapi #twitterapi", + "credentials": TEST_CREDENTIALS_INPUT, + "max_results": 2, + "start_time": "2024-12-14T18:30:00.000Z", + "end_time": "2024-12-17T18:30:00.000Z", + "since_id": None, + "until_id": None, + "sort_order": None, + "pagination": None, + "expansions": None, + "media_fields": None, + "place_fields": None, + "poll_fields": None, + "tweet_fields": None, + "user_fields": None, + }, + test_credentials=TEST_CREDENTIALS, + test_output=[ + ("tweet_ids", ["1373001119480344583", "1372627771717869568"]), + ( + "tweet_texts", + [ + "Looking to get started with the Twitter API but new to APIs in general?", + "Thanks to everyone who joined and made today a great session!", + ], + ), + ( + "data", + [ + { + "id": "1373001119480344583", + "text": "Looking to get started with the Twitter API but new to APIs in general?", + }, + { + "id": "1372627771717869568", + "text": "Thanks to everyone who joined and made today a great session!", + }, + ], + ), + ], + test_mock={ + "search_tweets": lambda *args, **kwargs: ( + ["1373001119480344583", "1372627771717869568"], + [ + "Looking to get started with the Twitter API but new to APIs in general?", + "Thanks to everyone who joined and made today a great session!", + ], + [ + { + "id": "1373001119480344583", + "text": "Looking to get started with the Twitter API but new to APIs in general?", + }, + { + "id": "1372627771717869568", + "text": "Thanks to everyone who joined and made today a great session!", + }, + ], + {}, + {}, + None, + ) + }, + ) + + @staticmethod + def search_tweets( + credentials: TwitterCredentials, + query: str, + max_results: int, + start_time: datetime | None, + end_time: datetime | None, + since_id: str | None, + until_id: str | None, + sort_order: str | None, + pagination: str | None, + expansions: ExpansionFilter | None, + media_fields: TweetMediaFieldsFilter | None, + place_fields: TweetPlaceFieldsFilter | None, + poll_fields: TweetPollFieldsFilter | None, + tweet_fields: TweetFieldsFilter | None, + user_fields: TweetUserFieldsFilter | None, + ): + try: + client = tweepy.Client( + bearer_token=credentials.access_token.get_secret_value() + ) + + # Building common params + params = ( + TweetSearchBuilder() + .add_query(query) + .add_pagination(max_results, pagination) + .build() + ) + + # Adding expansions to params If required by the user + params = ( + TweetExpansionsBuilder(params) + .add_expansions(expansions) + .add_media_fields(media_fields) + .add_place_fields(place_fields) + .add_poll_fields(poll_fields) + .add_tweet_fields(tweet_fields) + .add_user_fields(user_fields) + .build() + ) + + # Adding time window to params If required by the user + params = ( + TweetDurationBuilder(params) + .add_start_time(start_time) + .add_end_time(end_time) + .add_since_id(since_id) + .add_until_id(until_id) + .add_sort_order(sort_order) + .build() + ) + + response = cast(Response, client.search_recent_tweets(**params)) + + if not response.data and not response.meta: + raise Exception("No tweets found") + + meta = {} + tweet_ids = [] + tweet_texts = [] + next_token = None + + if response.meta: + meta = response.meta + next_token = meta.get("next_token") + + included = IncludesSerializer.serialize(response.includes) + data = ResponseDataSerializer.serialize_list(response.data) + + if response.data: + tweet_ids = [str(tweet.id) for tweet in response.data] + tweet_texts = [tweet.text for tweet in response.data] + + return tweet_ids, tweet_texts, data, included, meta, next_token + + raise Exception("No tweets found") + + except tweepy.TweepyException: + raise + + def run( + self, + input_data: Input, + *, + credentials: TwitterCredentials, + **kwargs, + ) -> BlockOutput: + try: + ids, texts, data, included, meta, next_token = self.search_tweets( + credentials, + input_data.query, + input_data.max_results, + input_data.start_time, + input_data.end_time, + input_data.since_id, + input_data.until_id, + input_data.sort_order, + input_data.pagination, + input_data.expansions, + input_data.media_fields, + input_data.place_fields, + input_data.poll_fields, + input_data.tweet_fields, + input_data.user_fields, + ) + if ids: + yield "tweet_ids", ids + if texts: + yield "tweet_texts", texts + if next_token: + yield "next_token", next_token + if data: + yield "data", data + if included: + yield "included", included + if meta: + yield "meta", meta + + except Exception as e: + yield "error", handle_tweepy_exception(e) diff --git a/autogpt_platform/backend/backend/blocks/twitter/tweets/quote.py b/autogpt_platform/backend/backend/blocks/twitter/tweets/quote.py new file mode 100644 index 000000000000..d46b5647c9a1 --- /dev/null +++ b/autogpt_platform/backend/backend/blocks/twitter/tweets/quote.py @@ -0,0 +1,222 @@ +from typing import cast + +import tweepy +from tweepy.client import Response + +from backend.blocks.twitter._auth import ( + TEST_CREDENTIALS, + TEST_CREDENTIALS_INPUT, + TwitterCredentials, + TwitterCredentialsField, + TwitterCredentialsInput, +) +from backend.blocks.twitter._builders import TweetExpansionsBuilder +from backend.blocks.twitter._serializer import ( + IncludesSerializer, + ResponseDataSerializer, +) +from backend.blocks.twitter._types import ( + ExpansionFilter, + TweetExcludesFilter, + TweetExpansionInputs, + TweetFieldsFilter, + TweetMediaFieldsFilter, + TweetPlaceFieldsFilter, + TweetPollFieldsFilter, + TweetUserFieldsFilter, +) +from backend.blocks.twitter.tweepy_exceptions import handle_tweepy_exception +from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema +from backend.data.model import SchemaField + + +class TwitterGetQuoteTweetsBlock(Block): + """ + Gets quote tweets for a specified tweet ID + """ + + class Input(TweetExpansionInputs): + credentials: TwitterCredentialsInput = TwitterCredentialsField( + ["tweet.read", "users.read", "offline.access"] + ) + + tweet_id: str = SchemaField( + description="ID of the tweet to get quotes for", + placeholder="Enter tweet ID", + ) + + max_results: int | None = SchemaField( + description="Number of results to return (max 100)", + default=10, + advanced=True, + ) + + exclude: TweetExcludesFilter | None = SchemaField( + description="Types of tweets to exclude", advanced=True, default=None + ) + + pagination_token: str | None = SchemaField( + description="Token for pagination", + advanced=True, + default="", + ) + + class Output(BlockSchema): + # Common Outputs that user commonly uses + ids: list = SchemaField(description="All Tweet IDs ") + texts: list = SchemaField(description="All Tweet texts") + next_token: str = SchemaField(description="Next token for pagination") + + # Complete Outputs for advanced use + data: list[dict] = SchemaField(description="Complete Tweet data") + included: dict = SchemaField( + description="Additional data that you have requested (Optional) via Expansions field" + ) + meta: dict = SchemaField( + description="Provides metadata such as pagination info (next_token) or result counts" + ) + + # error + error: str = SchemaField(description="Error message if the request failed") + + def __init__(self): + super().__init__( + id="9fbdd208-a630-11ef-9b97-ab7a3a695ca3", + description="This block gets quote tweets for a specific tweet.", + categories={BlockCategory.SOCIAL}, + input_schema=TwitterGetQuoteTweetsBlock.Input, + output_schema=TwitterGetQuoteTweetsBlock.Output, + test_input={ + "tweet_id": "1234567890", + "max_results": 2, + "pagination_token": None, + "credentials": TEST_CREDENTIALS_INPUT, + }, + test_credentials=TEST_CREDENTIALS, + test_output=[ + ("ids", ["12345", "67890"]), + ("texts", ["Tweet 1", "Tweet 2"]), + ( + "data", + [ + {"id": "12345", "text": "Tweet 1"}, + {"id": "67890", "text": "Tweet 2"}, + ], + ), + ], + test_mock={ + "get_quote_tweets": lambda *args, **kwargs: ( + ["12345", "67890"], + ["Tweet 1", "Tweet 2"], + [ + {"id": "12345", "text": "Tweet 1"}, + {"id": "67890", "text": "Tweet 2"}, + ], + {}, + {}, + None, + ) + }, + ) + + @staticmethod + def get_quote_tweets( + credentials: TwitterCredentials, + tweet_id: str, + max_results: int | None, + exclude: TweetExcludesFilter | None, + pagination_token: str | None, + expansions: ExpansionFilter | None, + media_fields: TweetMediaFieldsFilter | None, + place_fields: TweetPlaceFieldsFilter | None, + poll_fields: TweetPollFieldsFilter | None, + tweet_fields: TweetFieldsFilter | None, + user_fields: TweetUserFieldsFilter | None, + ): + try: + client = tweepy.Client( + bearer_token=credentials.access_token.get_secret_value() + ) + + params = { + "id": tweet_id, + "max_results": max_results, + "pagination_token": ( + None if pagination_token == "" else pagination_token + ), + "exclude": None if exclude == TweetExcludesFilter() else exclude, + "user_auth": False, + } + + params = ( + TweetExpansionsBuilder(params) + .add_expansions(expansions) + .add_media_fields(media_fields) + .add_place_fields(place_fields) + .add_poll_fields(poll_fields) + .add_tweet_fields(tweet_fields) + .add_user_fields(user_fields) + .build() + ) + + response = cast(Response, client.get_quote_tweets(**params)) + + meta = {} + tweet_ids = [] + tweet_texts = [] + next_token = None + + if response.meta: + meta = response.meta + next_token = meta.get("next_token") + + included = IncludesSerializer.serialize(response.includes) + data = ResponseDataSerializer.serialize_list(response.data) + + if response.data: + tweet_ids = [str(tweet.id) for tweet in response.data] + tweet_texts = [tweet.text for tweet in response.data] + + return tweet_ids, tweet_texts, data, included, meta, next_token + + raise Exception("No quote tweets found") + + except tweepy.TweepyException: + raise + + def run( + self, + input_data: Input, + *, + credentials: TwitterCredentials, + **kwargs, + ) -> BlockOutput: + try: + ids, texts, data, included, meta, next_token = self.get_quote_tweets( + credentials, + input_data.tweet_id, + input_data.max_results, + input_data.exclude, + input_data.pagination_token, + input_data.expansions, + input_data.media_fields, + input_data.place_fields, + input_data.poll_fields, + input_data.tweet_fields, + input_data.user_fields, + ) + if ids: + yield "ids", ids + if texts: + yield "texts", texts + if next_token: + yield "next_token", next_token + if data: + yield "data", data + if included: + yield "included", included + if meta: + yield "meta", meta + + except Exception as e: + yield "error", handle_tweepy_exception(e) diff --git a/autogpt_platform/backend/backend/blocks/twitter/tweets/retweet.py b/autogpt_platform/backend/backend/blocks/twitter/tweets/retweet.py new file mode 100644 index 000000000000..d46216c0854c --- /dev/null +++ b/autogpt_platform/backend/backend/blocks/twitter/tweets/retweet.py @@ -0,0 +1,363 @@ +from typing import cast + +import tweepy +from tweepy.client import Response + +from backend.blocks.twitter._auth import ( + TEST_CREDENTIALS, + TEST_CREDENTIALS_INPUT, + TwitterCredentials, + TwitterCredentialsField, + TwitterCredentialsInput, +) +from backend.blocks.twitter._builders import UserExpansionsBuilder +from backend.blocks.twitter._serializer import ( + IncludesSerializer, + ResponseDataSerializer, +) +from backend.blocks.twitter._types import ( + TweetFieldsFilter, + TweetUserFieldsFilter, + UserExpansionInputs, + UserExpansionsFilter, +) +from backend.blocks.twitter.tweepy_exceptions import handle_tweepy_exception +from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema +from backend.data.model import SchemaField + + +class TwitterRetweetBlock(Block): + """ + Retweets a tweet on Twitter + """ + + class Input(BlockSchema): + credentials: TwitterCredentialsInput = TwitterCredentialsField( + ["tweet.read", "tweet.write", "users.read", "offline.access"] + ) + + tweet_id: str = SchemaField( + description="ID of the tweet to retweet", + placeholder="Enter tweet ID", + ) + + class Output(BlockSchema): + success: bool = SchemaField(description="Whether the retweet was successful") + error: str = SchemaField(description="Error message if the retweet failed") + + def __init__(self): + super().__init__( + id="bd7b8d3a-a630-11ef-be96-6f4aa4c3c4f4", + description="This block retweets a tweet on Twitter.", + categories={BlockCategory.SOCIAL}, + input_schema=TwitterRetweetBlock.Input, + output_schema=TwitterRetweetBlock.Output, + test_input={ + "tweet_id": "1234567890", + "credentials": TEST_CREDENTIALS_INPUT, + }, + test_credentials=TEST_CREDENTIALS, + test_output=[ + ("success", True), + ], + test_mock={"retweet": lambda *args, **kwargs: True}, + ) + + @staticmethod + def retweet( + credentials: TwitterCredentials, + tweet_id: str, + ): + try: + client = tweepy.Client( + bearer_token=credentials.access_token.get_secret_value() + ) + + client.retweet( + tweet_id=tweet_id, + user_auth=False, + ) + + return True + + except tweepy.TweepyException: + raise + + def run( + self, + input_data: Input, + *, + credentials: TwitterCredentials, + **kwargs, + ) -> BlockOutput: + try: + success = self.retweet( + credentials, + input_data.tweet_id, + ) + yield "success", success + except Exception as e: + yield "error", handle_tweepy_exception(e) + + +class TwitterRemoveRetweetBlock(Block): + """ + Removes a retweet on Twitter + """ + + class Input(BlockSchema): + credentials: TwitterCredentialsInput = TwitterCredentialsField( + ["tweet.read", "tweet.write", "users.read", "offline.access"] + ) + + tweet_id: str = SchemaField( + description="ID of the tweet to remove retweet", + placeholder="Enter tweet ID", + ) + + class Output(BlockSchema): + success: bool = SchemaField( + description="Whether the retweet was successfully removed" + ) + error: str = SchemaField(description="Error message if the removal failed") + + def __init__(self): + super().__init__( + id="b6e663f0-a630-11ef-a7f0-8b9b0c542ff8", + description="This block removes a retweet on Twitter.", + categories={BlockCategory.SOCIAL}, + input_schema=TwitterRemoveRetweetBlock.Input, + output_schema=TwitterRemoveRetweetBlock.Output, + test_input={ + "tweet_id": "1234567890", + "credentials": TEST_CREDENTIALS_INPUT, + }, + test_credentials=TEST_CREDENTIALS, + test_output=[ + ("success", True), + ], + test_mock={"remove_retweet": lambda *args, **kwargs: True}, + ) + + @staticmethod + def remove_retweet( + credentials: TwitterCredentials, + tweet_id: str, + ): + try: + client = tweepy.Client( + bearer_token=credentials.access_token.get_secret_value() + ) + + client.unretweet( + source_tweet_id=tweet_id, + user_auth=False, + ) + + return True + + except tweepy.TweepyException: + raise + + def run( + self, + input_data: Input, + *, + credentials: TwitterCredentials, + **kwargs, + ) -> BlockOutput: + try: + success = self.remove_retweet( + credentials, + input_data.tweet_id, + ) + yield "success", success + except Exception as e: + yield "error", handle_tweepy_exception(e) + + +class TwitterGetRetweetersBlock(Block): + """ + Gets information about who has retweeted a tweet + """ + + class Input(UserExpansionInputs): + credentials: TwitterCredentialsInput = TwitterCredentialsField( + ["tweet.read", "users.read", "offline.access"] + ) + + tweet_id: str = SchemaField( + description="ID of the tweet to get retweeters for", + placeholder="Enter tweet ID", + ) + + max_results: int | None = SchemaField( + description="Maximum number of results per page (1-100)", + default=10, + placeholder="Enter max results", + advanced=True, + ) + + pagination_token: str | None = SchemaField( + description="Token for pagination", + placeholder="Enter pagination token", + default="", + ) + + class Output(BlockSchema): + # Common Outputs that user commonly uses + ids: list = SchemaField(description="List of user ids who retweeted") + names: list = SchemaField(description="List of user names who retweeted") + usernames: list = SchemaField( + description="List of user usernames who retweeted" + ) + next_token: str = SchemaField(description="Token for next page of results") + + # Complete Outputs for advanced use + data: list[dict] = SchemaField(description="Complete Tweet data") + included: dict = SchemaField( + description="Additional data that you have requested (Optional) via Expansions field" + ) + meta: dict = SchemaField( + description="Provides metadata such as pagination info (next_token) or result counts" + ) + + error: str = SchemaField(description="Error message if the request failed") + + def __init__(self): + super().__init__( + id="ad7aa6fa-a630-11ef-a6b0-e7ca640aa030", + description="This block gets information about who has retweeted a tweet.", + categories={BlockCategory.SOCIAL}, + input_schema=TwitterGetRetweetersBlock.Input, + output_schema=TwitterGetRetweetersBlock.Output, + test_input={ + "tweet_id": "1234567890", + "credentials": TEST_CREDENTIALS_INPUT, + "max_results": 1, + "pagination_token": "", + "expansions": None, + "media_fields": None, + "place_fields": None, + "poll_fields": None, + "tweet_fields": None, + "user_fields": None, + }, + test_credentials=TEST_CREDENTIALS, + test_output=[ + ("ids", ["12345"]), + ("names", ["Test User"]), + ("usernames", ["testuser"]), + ( + "data", + [{"id": "12345", "name": "Test User", "username": "testuser"}], + ), + ], + test_mock={ + "get_retweeters": lambda *args, **kwargs: ( + [{"id": "12345", "name": "Test User", "username": "testuser"}], + {}, + {}, + ["12345"], + ["Test User"], + ["testuser"], + None, + ) + }, + ) + + @staticmethod + def get_retweeters( + credentials: TwitterCredentials, + tweet_id: str, + max_results: int | None, + pagination_token: str | None, + expansions: UserExpansionsFilter | None, + tweet_fields: TweetFieldsFilter | None, + user_fields: TweetUserFieldsFilter | None, + ): + try: + client = tweepy.Client( + bearer_token=credentials.access_token.get_secret_value() + ) + + params = { + "id": tweet_id, + "max_results": max_results, + "pagination_token": ( + None if pagination_token == "" else pagination_token + ), + "user_auth": False, + } + + params = ( + UserExpansionsBuilder(params) + .add_expansions(expansions) + .add_tweet_fields(tweet_fields) + .add_user_fields(user_fields) + .build() + ) + + response = cast(Response, client.get_retweeters(**params)) + + meta = {} + ids = [] + names = [] + usernames = [] + next_token = None + + if response.meta: + meta = response.meta + next_token = meta.get("next_token") + + included = IncludesSerializer.serialize(response.includes) + data = ResponseDataSerializer.serialize_list(response.data) + + if response.data: + ids = [str(user.id) for user in response.data] + names = [user.name for user in response.data] + usernames = [user.username for user in response.data] + return data, included, meta, ids, names, usernames, next_token + + raise Exception("No retweeters found") + + except tweepy.TweepyException: + raise + + def run( + self, + input_data: Input, + *, + credentials: TwitterCredentials, + **kwargs, + ) -> BlockOutput: + try: + data, included, meta, ids, names, usernames, next_token = ( + self.get_retweeters( + credentials, + input_data.tweet_id, + input_data.max_results, + input_data.pagination_token, + input_data.expansions, + input_data.tweet_fields, + input_data.user_fields, + ) + ) + + if ids: + yield "ids", ids + if names: + yield "names", names + if usernames: + yield "usernames", usernames + if next_token: + yield "next_token", next_token + if data: + yield "data", data + if included: + yield "included", included + if meta: + yield "meta", meta + + except Exception as e: + yield "error", handle_tweepy_exception(e) diff --git a/autogpt_platform/backend/backend/blocks/twitter/tweets/timeline.py b/autogpt_platform/backend/backend/blocks/twitter/tweets/timeline.py new file mode 100644 index 000000000000..9bcbcaa347e4 --- /dev/null +++ b/autogpt_platform/backend/backend/blocks/twitter/tweets/timeline.py @@ -0,0 +1,757 @@ +from datetime import datetime +from typing import cast + +import tweepy +from tweepy.client import Response + +from backend.blocks.twitter._auth import ( + TEST_CREDENTIALS, + TEST_CREDENTIALS_INPUT, + TwitterCredentials, + TwitterCredentialsField, + TwitterCredentialsInput, +) +from backend.blocks.twitter._builders import ( + TweetDurationBuilder, + TweetExpansionsBuilder, +) +from backend.blocks.twitter._serializer import ( + IncludesSerializer, + ResponseDataSerializer, +) +from backend.blocks.twitter._types import ( + ExpansionFilter, + TweetExpansionInputs, + TweetFieldsFilter, + TweetMediaFieldsFilter, + TweetPlaceFieldsFilter, + TweetPollFieldsFilter, + TweetTimeWindowInputs, + TweetUserFieldsFilter, +) +from backend.blocks.twitter.tweepy_exceptions import handle_tweepy_exception +from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema +from backend.data.model import SchemaField + + +class TwitterGetUserMentionsBlock(Block): + """ + Returns Tweets where a single user is mentioned, just put that user id + """ + + class Input(TweetExpansionInputs, TweetTimeWindowInputs): + credentials: TwitterCredentialsInput = TwitterCredentialsField( + ["tweet.read", "users.read", "offline.access"] + ) + + user_id: str = SchemaField( + description="Unique identifier of the user for whom to return Tweets mentioning the user", + placeholder="Enter user ID", + ) + + max_results: int | None = SchemaField( + description="Number of tweets to retrieve (5-100)", + default=10, + advanced=True, + ) + + pagination_token: str | None = SchemaField( + description="Token for pagination", default="", advanced=True + ) + + class Output(BlockSchema): + # Common Outputs that user commonly uses + ids: list[str] = SchemaField(description="List of Tweet IDs") + texts: list[str] = SchemaField(description="All Tweet texts") + + userIds: list[str] = SchemaField( + description="List of user ids that mentioned the user" + ) + userNames: list[str] = SchemaField( + description="List of user names that mentioned the user" + ) + next_token: str = SchemaField(description="Next token for pagination") + + # Complete Outputs for advanced use + data: list[dict] = SchemaField(description="Complete Tweet data") + included: dict = SchemaField( + description="Additional data that you have requested (Optional) via Expansions field" + ) + meta: dict = SchemaField( + description="Provides metadata such as pagination info (next_token) or result counts" + ) + + # error + error: str = SchemaField(description="Error message if the request failed") + + def __init__(self): + super().__init__( + id="e01c890c-a630-11ef-9e20-37da24888bd0", + description="This block retrieves Tweets mentioning a specific user.", + categories={BlockCategory.SOCIAL}, + input_schema=TwitterGetUserMentionsBlock.Input, + output_schema=TwitterGetUserMentionsBlock.Output, + test_input={ + "user_id": "12345", + "credentials": TEST_CREDENTIALS_INPUT, + "max_results": 2, + "start_time": "2024-12-14T18:30:00.000Z", + "end_time": "2024-12-17T18:30:00.000Z", + "since_id": "", + "until_id": "", + "sort_order": None, + "pagination_token": None, + "expansions": None, + "media_fields": None, + "place_fields": None, + "poll_fields": None, + "tweet_fields": None, + "user_fields": None, + }, + test_credentials=TEST_CREDENTIALS, + test_output=[ + ("ids", ["1373001119480344583", "1372627771717869568"]), + ("texts", ["Test mention 1", "Test mention 2"]), + ("userIds", ["67890", "67891"]), + ("userNames", ["testuser1", "testuser2"]), + ( + "data", + [ + {"id": "1373001119480344583", "text": "Test mention 1"}, + {"id": "1372627771717869568", "text": "Test mention 2"}, + ], + ), + ], + test_mock={ + "get_mentions": lambda *args, **kwargs: ( + ["1373001119480344583", "1372627771717869568"], + ["Test mention 1", "Test mention 2"], + ["67890", "67891"], + ["testuser1", "testuser2"], + [ + {"id": "1373001119480344583", "text": "Test mention 1"}, + {"id": "1372627771717869568", "text": "Test mention 2"}, + ], + {}, + {}, + None, + ) + }, + ) + + @staticmethod + def get_mentions( + credentials: TwitterCredentials, + user_id: str, + max_results: int | None, + start_time: datetime | None, + end_time: datetime | None, + since_id: str | None, + until_id: str | None, + sort_order: str | None, + pagination: str | None, + expansions: ExpansionFilter | None, + media_fields: TweetMediaFieldsFilter | None, + place_fields: TweetPlaceFieldsFilter | None, + poll_fields: TweetPollFieldsFilter | None, + tweet_fields: TweetFieldsFilter | None, + user_fields: TweetUserFieldsFilter | None, + ): + try: + client = tweepy.Client( + bearer_token=credentials.access_token.get_secret_value() + ) + + params = { + "id": user_id, + "max_results": max_results, + "pagination_token": None if pagination == "" else pagination, + "user_auth": False, + } + + # Adding expansions to params If required by the user + params = ( + TweetExpansionsBuilder(params) + .add_expansions(expansions) + .add_media_fields(media_fields) + .add_place_fields(place_fields) + .add_poll_fields(poll_fields) + .add_tweet_fields(tweet_fields) + .add_user_fields(user_fields) + .build() + ) + + # Adding time window to params If required by the user + params = ( + TweetDurationBuilder(params) + .add_start_time(start_time) + .add_end_time(end_time) + .add_since_id(since_id) + .add_until_id(until_id) + .add_sort_order(sort_order) + .build() + ) + + response = cast( + Response, + client.get_users_mentions(**params), + ) + + if not response.data and not response.meta: + raise Exception("No tweets found") + + included = IncludesSerializer.serialize(response.includes) + data = ResponseDataSerializer.serialize_list(response.data) + meta = response.meta or {} + next_token = meta.get("next_token", "") + + tweet_ids = [] + tweet_texts = [] + user_ids = [] + user_names = [] + + if response.data: + tweet_ids = [str(tweet.id) for tweet in response.data] + tweet_texts = [tweet.text for tweet in response.data] + + if "users" in included: + user_ids = [str(user["id"]) for user in included["users"]] + user_names = [user["username"] for user in included["users"]] + + return ( + tweet_ids, + tweet_texts, + user_ids, + user_names, + data, + included, + meta, + next_token, + ) + + except tweepy.TweepyException: + raise + + def run( + self, + input_data: Input, + *, + credentials: TwitterCredentials, + **kwargs, + ) -> BlockOutput: + try: + ids, texts, user_ids, user_names, data, included, meta, next_token = ( + self.get_mentions( + credentials, + input_data.user_id, + input_data.max_results, + input_data.start_time, + input_data.end_time, + input_data.since_id, + input_data.until_id, + input_data.sort_order, + input_data.pagination_token, + input_data.expansions, + input_data.media_fields, + input_data.place_fields, + input_data.poll_fields, + input_data.tweet_fields, + input_data.user_fields, + ) + ) + if ids: + yield "ids", ids + if texts: + yield "texts", texts + if user_ids: + yield "userIds", user_ids + if user_names: + yield "userNames", user_names + if next_token: + yield "next_token", next_token + if data: + yield "data", data + if included: + yield "included", included + if meta: + yield "meta", meta + + except Exception as e: + yield "error", handle_tweepy_exception(e) + + +class TwitterGetHomeTimelineBlock(Block): + """ + Returns a collection of the most recent Tweets and Retweets posted by you and users you follow + """ + + class Input(TweetExpansionInputs, TweetTimeWindowInputs): + credentials: TwitterCredentialsInput = TwitterCredentialsField( + ["tweet.read", "users.read", "offline.access"] + ) + + max_results: int | None = SchemaField( + description="Number of tweets to retrieve (5-100)", + default=10, + advanced=True, + ) + + pagination_token: str | None = SchemaField( + description="Token for pagination", default="", advanced=True + ) + + class Output(BlockSchema): + # Common Outputs that user commonly uses + ids: list[str] = SchemaField(description="List of Tweet IDs") + texts: list[str] = SchemaField(description="All Tweet texts") + + userIds: list[str] = SchemaField( + description="List of user ids that authored the tweets" + ) + userNames: list[str] = SchemaField( + description="List of user names that authored the tweets" + ) + next_token: str = SchemaField(description="Next token for pagination") + + # Complete Outputs for advanced use + data: list[dict] = SchemaField(description="Complete Tweet data") + included: dict = SchemaField( + description="Additional data that you have requested (Optional) via Expansions field" + ) + meta: dict = SchemaField( + description="Provides metadata such as pagination info (next_token) or result counts" + ) + + # error + error: str = SchemaField(description="Error message if the request failed") + + def __init__(self): + super().__init__( + id="d222a070-a630-11ef-a18a-3f52f76c6962", + description="This block retrieves the authenticated user's home timeline.", + categories={BlockCategory.SOCIAL}, + input_schema=TwitterGetHomeTimelineBlock.Input, + output_schema=TwitterGetHomeTimelineBlock.Output, + test_input={ + "credentials": TEST_CREDENTIALS_INPUT, + "max_results": 2, + "start_time": "2024-12-14T18:30:00.000Z", + "end_time": "2024-12-17T18:30:00.000Z", + "since_id": None, + "until_id": None, + "sort_order": None, + "pagination_token": None, + }, + test_credentials=TEST_CREDENTIALS, + test_output=[ + ("ids", ["1373001119480344583", "1372627771717869568"]), + ("texts", ["Test tweet 1", "Test tweet 2"]), + ("userIds", ["67890", "67891"]), + ("userNames", ["testuser1", "testuser2"]), + ( + "data", + [ + {"id": "1373001119480344583", "text": "Test tweet 1"}, + {"id": "1372627771717869568", "text": "Test tweet 2"}, + ], + ), + ], + test_mock={ + "get_timeline": lambda *args, **kwargs: ( + ["1373001119480344583", "1372627771717869568"], + ["Test tweet 1", "Test tweet 2"], + ["67890", "67891"], + ["testuser1", "testuser2"], + [ + {"id": "1373001119480344583", "text": "Test tweet 1"}, + {"id": "1372627771717869568", "text": "Test tweet 2"}, + ], + {}, + {}, + None, + ) + }, + ) + + @staticmethod + def get_timeline( + credentials: TwitterCredentials, + max_results: int | None, + start_time: datetime | None, + end_time: datetime | None, + since_id: str | None, + until_id: str | None, + sort_order: str | None, + pagination: str | None, + expansions: ExpansionFilter | None, + media_fields: TweetMediaFieldsFilter | None, + place_fields: TweetPlaceFieldsFilter | None, + poll_fields: TweetPollFieldsFilter | None, + tweet_fields: TweetFieldsFilter | None, + user_fields: TweetUserFieldsFilter | None, + ): + try: + client = tweepy.Client( + bearer_token=credentials.access_token.get_secret_value() + ) + + params = { + "max_results": max_results, + "pagination_token": None if pagination == "" else pagination, + "user_auth": False, + } + + # Adding expansions to params If required by the user + params = ( + TweetExpansionsBuilder(params) + .add_expansions(expansions) + .add_media_fields(media_fields) + .add_place_fields(place_fields) + .add_poll_fields(poll_fields) + .add_tweet_fields(tweet_fields) + .add_user_fields(user_fields) + .build() + ) + + # Adding time window to params If required by the user + params = ( + TweetDurationBuilder(params) + .add_start_time(start_time) + .add_end_time(end_time) + .add_since_id(since_id) + .add_until_id(until_id) + .add_sort_order(sort_order) + .build() + ) + + response = cast( + Response, + client.get_home_timeline(**params), + ) + + if not response.data and not response.meta: + raise Exception("No tweets found") + + included = IncludesSerializer.serialize(response.includes) + data = ResponseDataSerializer.serialize_list(response.data) + meta = response.meta or {} + next_token = meta.get("next_token", "") + + tweet_ids = [] + tweet_texts = [] + user_ids = [] + user_names = [] + + if response.data: + tweet_ids = [str(tweet.id) for tweet in response.data] + tweet_texts = [tweet.text for tweet in response.data] + + if "users" in included: + user_ids = [str(user["id"]) for user in included["users"]] + user_names = [user["username"] for user in included["users"]] + + return ( + tweet_ids, + tweet_texts, + user_ids, + user_names, + data, + included, + meta, + next_token, + ) + + except tweepy.TweepyException: + raise + + def run( + self, + input_data: Input, + *, + credentials: TwitterCredentials, + **kwargs, + ) -> BlockOutput: + try: + ids, texts, user_ids, user_names, data, included, meta, next_token = ( + self.get_timeline( + credentials, + input_data.max_results, + input_data.start_time, + input_data.end_time, + input_data.since_id, + input_data.until_id, + input_data.sort_order, + input_data.pagination_token, + input_data.expansions, + input_data.media_fields, + input_data.place_fields, + input_data.poll_fields, + input_data.tweet_fields, + input_data.user_fields, + ) + ) + if ids: + yield "ids", ids + if texts: + yield "texts", texts + if user_ids: + yield "userIds", user_ids + if user_names: + yield "userNames", user_names + if next_token: + yield "next_token", next_token + if data: + yield "data", data + if included: + yield "included", included + if meta: + yield "meta", meta + + except Exception as e: + yield "error", handle_tweepy_exception(e) + + +class TwitterGetUserTweetsBlock(Block): + """ + Returns Tweets composed by a single user, specified by the requested user ID + """ + + class Input(TweetExpansionInputs, TweetTimeWindowInputs): + credentials: TwitterCredentialsInput = TwitterCredentialsField( + ["tweet.read", "users.read", "offline.access"] + ) + + user_id: str = SchemaField( + description="Unique identifier of the Twitter account (user ID) for whom to return results", + placeholder="Enter user ID", + ) + + max_results: int | None = SchemaField( + description="Number of tweets to retrieve (5-100)", + default=10, + advanced=True, + ) + + pagination_token: str | None = SchemaField( + description="Token for pagination", default="", advanced=True + ) + + class Output(BlockSchema): + # Common Outputs that user commonly uses + ids: list[str] = SchemaField(description="List of Tweet IDs") + texts: list[str] = SchemaField(description="All Tweet texts") + + userIds: list[str] = SchemaField( + description="List of user ids that authored the tweets" + ) + userNames: list[str] = SchemaField( + description="List of user names that authored the tweets" + ) + next_token: str = SchemaField(description="Next token for pagination") + + # Complete Outputs for advanced use + data: list[dict] = SchemaField(description="Complete Tweet data") + included: dict = SchemaField( + description="Additional data that you have requested (Optional) via Expansions field" + ) + meta: dict = SchemaField( + description="Provides metadata such as pagination info (next_token) or result counts" + ) + + # error + error: str = SchemaField(description="Error message if the request failed") + + def __init__(self): + super().__init__( + id="c44c3ef2-a630-11ef-9ff7-eb7b5ea3a5cb", + description="This block retrieves Tweets composed by a single user.", + categories={BlockCategory.SOCIAL}, + input_schema=TwitterGetUserTweetsBlock.Input, + output_schema=TwitterGetUserTweetsBlock.Output, + test_input={ + "user_id": "12345", + "credentials": TEST_CREDENTIALS_INPUT, + "max_results": 2, + "start_time": "2024-12-14T18:30:00.000Z", + "end_time": "2024-12-17T18:30:00.000Z", + "since_id": None, + "until_id": None, + "sort_order": None, + "pagination_token": None, + "expansions": None, + "media_fields": None, + "place_fields": None, + "poll_fields": None, + "tweet_fields": None, + "user_fields": None, + }, + test_credentials=TEST_CREDENTIALS, + test_output=[ + ("ids", ["1373001119480344583", "1372627771717869568"]), + ("texts", ["Test tweet 1", "Test tweet 2"]), + ("userIds", ["67890", "67891"]), + ("userNames", ["testuser1", "testuser2"]), + ( + "data", + [ + {"id": "1373001119480344583", "text": "Test tweet 1"}, + {"id": "1372627771717869568", "text": "Test tweet 2"}, + ], + ), + ], + test_mock={ + "get_user_tweets": lambda *args, **kwargs: ( + ["1373001119480344583", "1372627771717869568"], + ["Test tweet 1", "Test tweet 2"], + ["67890", "67891"], + ["testuser1", "testuser2"], + [ + {"id": "1373001119480344583", "text": "Test tweet 1"}, + {"id": "1372627771717869568", "text": "Test tweet 2"}, + ], + {}, + {}, + None, + ) + }, + ) + + @staticmethod + def get_user_tweets( + credentials: TwitterCredentials, + user_id: str, + max_results: int | None, + start_time: datetime | None, + end_time: datetime | None, + since_id: str | None, + until_id: str | None, + sort_order: str | None, + pagination: str | None, + expansions: ExpansionFilter | None, + media_fields: TweetMediaFieldsFilter | None, + place_fields: TweetPlaceFieldsFilter | None, + poll_fields: TweetPollFieldsFilter | None, + tweet_fields: TweetFieldsFilter | None, + user_fields: TweetUserFieldsFilter | None, + ): + try: + client = tweepy.Client( + bearer_token=credentials.access_token.get_secret_value() + ) + + params = { + "id": user_id, + "max_results": max_results, + "pagination_token": None if pagination == "" else pagination, + "user_auth": False, + } + + # Adding expansions to params If required by the user + params = ( + TweetExpansionsBuilder(params) + .add_expansions(expansions) + .add_media_fields(media_fields) + .add_place_fields(place_fields) + .add_poll_fields(poll_fields) + .add_tweet_fields(tweet_fields) + .add_user_fields(user_fields) + .build() + ) + + # Adding time window to params If required by the user + params = ( + TweetDurationBuilder(params) + .add_start_time(start_time) + .add_end_time(end_time) + .add_since_id(since_id) + .add_until_id(until_id) + .add_sort_order(sort_order) + .build() + ) + + response = cast( + Response, + client.get_users_tweets(**params), + ) + + if not response.data and not response.meta: + raise Exception("No tweets found") + + included = IncludesSerializer.serialize(response.includes) + data = ResponseDataSerializer.serialize_list(response.data) + meta = response.meta or {} + next_token = meta.get("next_token", "") + + tweet_ids = [] + tweet_texts = [] + user_ids = [] + user_names = [] + + if response.data: + tweet_ids = [str(tweet.id) for tweet in response.data] + tweet_texts = [tweet.text for tweet in response.data] + + if "users" in included: + user_ids = [str(user["id"]) for user in included["users"]] + user_names = [user["username"] for user in included["users"]] + + return ( + tweet_ids, + tweet_texts, + user_ids, + user_names, + data, + included, + meta, + next_token, + ) + + except tweepy.TweepyException: + raise + + def run( + self, + input_data: Input, + *, + credentials: TwitterCredentials, + **kwargs, + ) -> BlockOutput: + try: + ids, texts, user_ids, user_names, data, included, meta, next_token = ( + self.get_user_tweets( + credentials, + input_data.user_id, + input_data.max_results, + input_data.start_time, + input_data.end_time, + input_data.since_id, + input_data.until_id, + input_data.sort_order, + input_data.pagination_token, + input_data.expansions, + input_data.media_fields, + input_data.place_fields, + input_data.poll_fields, + input_data.tweet_fields, + input_data.user_fields, + ) + ) + if ids: + yield "ids", ids + if texts: + yield "texts", texts + if user_ids: + yield "userIds", user_ids + if user_names: + yield "userNames", user_names + if next_token: + yield "next_token", next_token + if data: + yield "data", data + if included: + yield "included", included + if meta: + yield "meta", meta + + except Exception as e: + yield "error", handle_tweepy_exception(e) diff --git a/autogpt_platform/backend/backend/blocks/twitter/tweets/tweet_lookup.py b/autogpt_platform/backend/backend/blocks/twitter/tweets/tweet_lookup.py new file mode 100644 index 000000000000..54d4f5b43ef5 --- /dev/null +++ b/autogpt_platform/backend/backend/blocks/twitter/tweets/tweet_lookup.py @@ -0,0 +1,361 @@ +from typing import cast + +import tweepy +from tweepy.client import Response + +from backend.blocks.twitter._auth import ( + TEST_CREDENTIALS, + TEST_CREDENTIALS_INPUT, + TwitterCredentials, + TwitterCredentialsField, + TwitterCredentialsInput, +) +from backend.blocks.twitter._builders import TweetExpansionsBuilder +from backend.blocks.twitter._serializer import ( + IncludesSerializer, + ResponseDataSerializer, +) +from backend.blocks.twitter._types import ( + ExpansionFilter, + TweetExpansionInputs, + TweetFieldsFilter, + TweetMediaFieldsFilter, + TweetPlaceFieldsFilter, + TweetPollFieldsFilter, + TweetUserFieldsFilter, +) +from backend.blocks.twitter.tweepy_exceptions import handle_tweepy_exception +from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema +from backend.data.model import SchemaField + + +class TwitterGetTweetBlock(Block): + """ + Returns information about a single Tweet specified by the requested ID + """ + + class Input(TweetExpansionInputs): + credentials: TwitterCredentialsInput = TwitterCredentialsField( + ["tweet.read", "users.read", "offline.access"] + ) + + tweet_id: str = SchemaField( + description="Unique identifier of the Tweet to request (ex: 1460323737035677698)", + placeholder="Enter tweet ID", + ) + + class Output(BlockSchema): + # Common Outputs that user commonly uses + id: str = SchemaField(description="Tweet ID") + text: str = SchemaField(description="Tweet text") + userId: str = SchemaField(description="ID of the tweet author") + userName: str = SchemaField(description="Username of the tweet author") + + # Complete Outputs for advanced use + data: dict = SchemaField(description="Tweet data") + included: dict = SchemaField( + description="Additional data that you have requested (Optional) via Expansions field" + ) + meta: dict = SchemaField(description="Metadata about the tweet") + + error: str = SchemaField(description="Error message if the request failed") + + def __init__(self): + super().__init__( + id="f5155c3a-a630-11ef-9cc1-a309988b4d92", + description="This block retrieves information about a specific Tweet.", + categories={BlockCategory.SOCIAL}, + input_schema=TwitterGetTweetBlock.Input, + output_schema=TwitterGetTweetBlock.Output, + test_input={ + "tweet_id": "1460323737035677698", + "credentials": TEST_CREDENTIALS_INPUT, + "expansions": None, + "media_fields": None, + "place_fields": None, + "poll_fields": None, + "tweet_fields": None, + "user_fields": None, + }, + test_credentials=TEST_CREDENTIALS, + test_output=[ + ("id", "1460323737035677698"), + ("text", "Test tweet content"), + ("userId", "12345"), + ("userName", "testuser"), + ("data", {"id": "1460323737035677698", "text": "Test tweet content"}), + ("included", {"users": [{"id": "12345", "username": "testuser"}]}), + ("meta", {"result_count": 1}), + ], + test_mock={ + "get_tweet": lambda *args, **kwargs: ( + {"id": "1460323737035677698", "text": "Test tweet content"}, + {"users": [{"id": "12345", "username": "testuser"}]}, + {"result_count": 1}, + "12345", + "testuser", + ) + }, + ) + + @staticmethod + def get_tweet( + credentials: TwitterCredentials, + tweet_id: str, + expansions: ExpansionFilter | None, + media_fields: TweetMediaFieldsFilter | None, + place_fields: TweetPlaceFieldsFilter | None, + poll_fields: TweetPollFieldsFilter | None, + tweet_fields: TweetFieldsFilter | None, + user_fields: TweetUserFieldsFilter | None, + ): + try: + client = tweepy.Client( + bearer_token=credentials.access_token.get_secret_value() + ) + params = {"id": tweet_id, "user_auth": False} + + # Adding expansions to params If required by the user + params = ( + TweetExpansionsBuilder(params) + .add_expansions(expansions) + .add_media_fields(media_fields) + .add_place_fields(place_fields) + .add_poll_fields(poll_fields) + .add_tweet_fields(tweet_fields) + .add_user_fields(user_fields) + .build() + ) + + response = cast(Response, client.get_tweet(**params)) + + meta = {} + user_id = "" + user_name = "" + + if response.meta: + meta = response.meta + + included = IncludesSerializer.serialize(response.includes) + data = ResponseDataSerializer.serialize_dict(response.data) + + if included and "users" in included: + user_id = str(included["users"][0]["id"]) + user_name = included["users"][0]["username"] + + if response.data: + return data, included, meta, user_id, user_name + + raise Exception("Tweet not found") + + except tweepy.TweepyException: + raise + + def run( + self, + input_data: Input, + *, + credentials: TwitterCredentials, + **kwargs, + ) -> BlockOutput: + try: + + tweet_data, included, meta, user_id, user_name = self.get_tweet( + credentials, + input_data.tweet_id, + input_data.expansions, + input_data.media_fields, + input_data.place_fields, + input_data.poll_fields, + input_data.tweet_fields, + input_data.user_fields, + ) + + yield "id", str(tweet_data["id"]) + yield "text", tweet_data["text"] + if user_id: + yield "userId", user_id + if user_name: + yield "userName", user_name + yield "data", tweet_data + if included: + yield "included", included + if meta: + yield "meta", meta + + except Exception as e: + yield "error", handle_tweepy_exception(e) + + +class TwitterGetTweetsBlock(Block): + """ + Returns information about multiple Tweets specified by the requested IDs + """ + + class Input(TweetExpansionInputs): + credentials: TwitterCredentialsInput = TwitterCredentialsField( + ["tweet.read", "users.read", "offline.access"] + ) + + tweet_ids: list[str] = SchemaField( + description="List of Tweet IDs to request (up to 100)", + placeholder="Enter tweet IDs", + ) + + class Output(BlockSchema): + # Common Outputs that user commonly uses + ids: list[str] = SchemaField(description="All Tweet IDs") + texts: list[str] = SchemaField(description="All Tweet texts") + userIds: list[str] = SchemaField( + description="List of user ids that authored the tweets" + ) + userNames: list[str] = SchemaField( + description="List of user names that authored the tweets" + ) + + # Complete Outputs for advanced use + data: list[dict] = SchemaField(description="Complete Tweet data") + included: dict = SchemaField( + description="Additional data that you have requested (Optional) via Expansions field" + ) + meta: dict = SchemaField(description="Metadata about the tweets") + + error: str = SchemaField(description="Error message if the request failed") + + def __init__(self): + super().__init__( + id="e7cc5420-a630-11ef-bfaf-13bdd8096a51", + description="This block retrieves information about multiple Tweets.", + categories={BlockCategory.SOCIAL}, + input_schema=TwitterGetTweetsBlock.Input, + output_schema=TwitterGetTweetsBlock.Output, + test_input={ + "tweet_ids": ["1460323737035677698"], + "credentials": TEST_CREDENTIALS_INPUT, + "expansions": None, + "media_fields": None, + "place_fields": None, + "poll_fields": None, + "tweet_fields": None, + "user_fields": None, + }, + test_credentials=TEST_CREDENTIALS, + test_output=[ + ("ids", ["1460323737035677698"]), + ("texts", ["Test tweet content"]), + ("userIds", ["67890"]), + ("userNames", ["testuser1"]), + ("data", [{"id": "1460323737035677698", "text": "Test tweet content"}]), + ("included", {"users": [{"id": "67890", "username": "testuser1"}]}), + ("meta", {"result_count": 1}), + ], + test_mock={ + "get_tweets": lambda *args, **kwargs: ( + ["1460323737035677698"], # ids + ["Test tweet content"], # texts + ["67890"], # user_ids + ["testuser1"], # user_names + [ + {"id": "1460323737035677698", "text": "Test tweet content"} + ], # data + {"users": [{"id": "67890", "username": "testuser1"}]}, # included + {"result_count": 1}, # meta + ) + }, + ) + + @staticmethod + def get_tweets( + credentials: TwitterCredentials, + tweet_ids: list[str], + expansions: ExpansionFilter | None, + media_fields: TweetMediaFieldsFilter | None, + place_fields: TweetPlaceFieldsFilter | None, + poll_fields: TweetPollFieldsFilter | None, + tweet_fields: TweetFieldsFilter | None, + user_fields: TweetUserFieldsFilter | None, + ): + try: + client = tweepy.Client( + bearer_token=credentials.access_token.get_secret_value() + ) + params = {"ids": tweet_ids, "user_auth": False} + + # Adding expansions to params If required by the user + params = ( + TweetExpansionsBuilder(params) + .add_expansions(expansions) + .add_media_fields(media_fields) + .add_place_fields(place_fields) + .add_poll_fields(poll_fields) + .add_tweet_fields(tweet_fields) + .add_user_fields(user_fields) + .build() + ) + + response = cast(Response, client.get_tweets(**params)) + + if not response.data and not response.meta: + raise Exception("No tweets found") + + tweet_ids = [] + tweet_texts = [] + user_ids = [] + user_names = [] + meta = {} + + included = IncludesSerializer.serialize(response.includes) + data = ResponseDataSerializer.serialize_list(response.data) + + if response.data: + tweet_ids = [str(tweet.id) for tweet in response.data] + tweet_texts = [tweet.text for tweet in response.data] + + if included and "users" in included: + for user in included["users"]: + user_ids.append(str(user["id"])) + user_names.append(user["username"]) + + if response.meta: + meta = response.meta + + return tweet_ids, tweet_texts, user_ids, user_names, data, included, meta + + except tweepy.TweepyException: + raise + + def run( + self, + input_data: Input, + *, + credentials: TwitterCredentials, + **kwargs, + ) -> BlockOutput: + try: + ids, texts, user_ids, user_names, data, included, meta = self.get_tweets( + credentials, + input_data.tweet_ids, + input_data.expansions, + input_data.media_fields, + input_data.place_fields, + input_data.poll_fields, + input_data.tweet_fields, + input_data.user_fields, + ) + if ids: + yield "ids", ids + if texts: + yield "texts", texts + if user_ids: + yield "userIds", user_ids + if user_names: + yield "userNames", user_names + if data: + yield "data", data + if included: + yield "included", included + if meta: + yield "meta", meta + + except Exception as e: + yield "error", handle_tweepy_exception(e) diff --git a/autogpt_platform/backend/backend/blocks/twitter/users/blocks.py b/autogpt_platform/backend/backend/blocks/twitter/users/blocks.py new file mode 100644 index 000000000000..62575976ee16 --- /dev/null +++ b/autogpt_platform/backend/backend/blocks/twitter/users/blocks.py @@ -0,0 +1,175 @@ +from typing import cast + +import tweepy +from tweepy.client import Response + +from backend.blocks.twitter._auth import ( + TEST_CREDENTIALS, + TEST_CREDENTIALS_INPUT, + TwitterCredentials, + TwitterCredentialsField, + TwitterCredentialsInput, +) +from backend.blocks.twitter._builders import UserExpansionsBuilder +from backend.blocks.twitter._serializer import IncludesSerializer +from backend.blocks.twitter._types import ( + TweetFieldsFilter, + TweetUserFieldsFilter, + UserExpansionInputs, + UserExpansionsFilter, +) +from backend.blocks.twitter.tweepy_exceptions import handle_tweepy_exception +from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema +from backend.data.model import SchemaField + + +class TwitterGetBlockedUsersBlock(Block): + """ + Get a list of users who are blocked by the authenticating user + """ + + class Input(UserExpansionInputs): + credentials: TwitterCredentialsInput = TwitterCredentialsField( + ["users.read", "offline.access", "block.read"] + ) + + max_results: int | None = SchemaField( + description="Maximum number of results to return (1-1000, default 100)", + placeholder="Enter max results", + default=10, + advanced=True, + ) + + pagination_token: str | None = SchemaField( + description="Token for retrieving next/previous page of results", + placeholder="Enter pagination token", + default="", + advanced=True, + ) + + class Output(BlockSchema): + user_ids: list[str] = SchemaField(description="List of blocked user IDs") + usernames_: list[str] = SchemaField(description="List of blocked usernames") + included: dict = SchemaField( + description="Additional data requested via expansions" + ) + meta: dict = SchemaField(description="Metadata including pagination info") + next_token: str = SchemaField(description="Next token for pagination") + error: str = SchemaField(description="Error message if the request failed") + + def __init__(self): + super().__init__( + id="05f409e8-a631-11ef-ae89-93de863ee30d", + description="This block retrieves a list of users blocked by the authenticating user.", + categories={BlockCategory.SOCIAL}, + input_schema=TwitterGetBlockedUsersBlock.Input, + output_schema=TwitterGetBlockedUsersBlock.Output, + test_input={ + "max_results": 10, + "pagination_token": "", + "credentials": TEST_CREDENTIALS_INPUT, + "expansions": None, + "tweet_fields": None, + "user_fields": None, + }, + test_credentials=TEST_CREDENTIALS, + test_output=[ + ("user_ids", ["12345", "67890"]), + ("usernames_", ["testuser1", "testuser2"]), + ], + test_mock={ + "get_blocked_users": lambda *args, **kwargs: ( + {}, # included + {}, # meta + ["12345", "67890"], # user_ids + ["testuser1", "testuser2"], # usernames + None, # next_token + ) + }, + ) + + @staticmethod + def get_blocked_users( + credentials: TwitterCredentials, + max_results: int | None, + pagination_token: str | None, + expansions: UserExpansionsFilter | None, + tweet_fields: TweetFieldsFilter | None, + user_fields: TweetUserFieldsFilter | None, + ): + try: + client = tweepy.Client( + bearer_token=credentials.access_token.get_secret_value() + ) + + params = { + "max_results": max_results, + "pagination_token": ( + None if pagination_token == "" else pagination_token + ), + "user_auth": False, + } + + params = ( + UserExpansionsBuilder(params) + .add_expansions(expansions) + .add_tweet_fields(tweet_fields) + .add_user_fields(user_fields) + .build() + ) + + response = cast(Response, client.get_blocked(**params)) + + meta = {} + user_ids = [] + usernames = [] + next_token = None + + included = IncludesSerializer.serialize(response.includes) + + if response.data: + for user in response.data: + user_ids.append(str(user.id)) + usernames.append(user.username) + + if response.meta: + meta = response.meta + if "next_token" in meta: + next_token = meta["next_token"] + + if user_ids and usernames: + return included, meta, user_ids, usernames, next_token + else: + raise tweepy.TweepyException("No blocked users found") + + except tweepy.TweepyException: + raise + + def run( + self, + input_data: Input, + *, + credentials: TwitterCredentials, + **kwargs, + ) -> BlockOutput: + try: + included, meta, user_ids, usernames, next_token = self.get_blocked_users( + credentials, + input_data.max_results, + input_data.pagination_token, + input_data.expansions, + input_data.tweet_fields, + input_data.user_fields, + ) + if user_ids: + yield "user_ids", user_ids + if usernames: + yield "usernames_", usernames + if included: + yield "included", included + if meta: + yield "meta", meta + if next_token: + yield "next_token", next_token + except Exception as e: + yield "error", handle_tweepy_exception(e) diff --git a/autogpt_platform/backend/backend/blocks/twitter/users/follows.py b/autogpt_platform/backend/backend/blocks/twitter/users/follows.py new file mode 100644 index 000000000000..3ffafa606291 --- /dev/null +++ b/autogpt_platform/backend/backend/blocks/twitter/users/follows.py @@ -0,0 +1,510 @@ +from typing import cast + +import tweepy +from tweepy.client import Response + +from backend.blocks.twitter._auth import ( + TEST_CREDENTIALS, + TEST_CREDENTIALS_INPUT, + TwitterCredentials, + TwitterCredentialsField, + TwitterCredentialsInput, +) +from backend.blocks.twitter._builders import UserExpansionsBuilder +from backend.blocks.twitter._serializer import ( + IncludesSerializer, + ResponseDataSerializer, +) +from backend.blocks.twitter._types import ( + TweetFieldsFilter, + TweetUserFieldsFilter, + UserExpansionInputs, + UserExpansionsFilter, +) +from backend.blocks.twitter.tweepy_exceptions import handle_tweepy_exception +from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema +from backend.data.model import SchemaField + + +class TwitterUnfollowUserBlock(Block): + """ + Allows a user to unfollow another user specified by target user ID. + The request succeeds with no action when the authenticated user sends a request to a user they're not following or have already unfollowed. + """ + + class Input(BlockSchema): + credentials: TwitterCredentialsInput = TwitterCredentialsField( + ["users.read", "users.write", "follows.write", "offline.access"] + ) + + target_user_id: str = SchemaField( + description="The user ID of the user that you would like to unfollow", + placeholder="Enter target user ID", + ) + + class Output(BlockSchema): + success: bool = SchemaField( + description="Whether the unfollow action was successful" + ) + error: str = SchemaField(description="Error message if the request failed") + + def __init__(self): + super().__init__( + id="37e386a4-a631-11ef-b7bd-b78204b35fa4", + description="This block unfollows a specified Twitter user.", + categories={BlockCategory.SOCIAL}, + input_schema=TwitterUnfollowUserBlock.Input, + output_schema=TwitterUnfollowUserBlock.Output, + test_input={ + "target_user_id": "12345", + "credentials": TEST_CREDENTIALS_INPUT, + }, + test_credentials=TEST_CREDENTIALS, + test_output=[ + ("success", True), + ], + test_mock={"unfollow_user": lambda *args, **kwargs: True}, + ) + + @staticmethod + def unfollow_user(credentials: TwitterCredentials, target_user_id: str): + try: + client = tweepy.Client( + bearer_token=credentials.access_token.get_secret_value() + ) + + client.unfollow_user(target_user_id=target_user_id, user_auth=False) + + return True + + except tweepy.TweepyException: + raise + + def run( + self, + input_data: Input, + *, + credentials: TwitterCredentials, + **kwargs, + ) -> BlockOutput: + try: + success = self.unfollow_user(credentials, input_data.target_user_id) + yield "success", success + + except Exception as e: + yield "error", handle_tweepy_exception(e) + + +class TwitterFollowUserBlock(Block): + """ + Allows a user to follow another user specified by target user ID. If the target user does not have public Tweets, + this endpoint will send a follow request. The request succeeds with no action when the authenticated user sends a + request to a user they're already following, or if they're sending a follower request to a user that does not have + public Tweets. + """ + + class Input(BlockSchema): + credentials: TwitterCredentialsInput = TwitterCredentialsField( + ["users.read", "users.write", "follows.write", "offline.access"] + ) + + target_user_id: str = SchemaField( + description="The user ID of the user that you would like to follow", + placeholder="Enter target user ID", + ) + + class Output(BlockSchema): + success: bool = SchemaField( + description="Whether the follow action was successful" + ) + error: str = SchemaField(description="Error message if the request failed") + + def __init__(self): + super().__init__( + id="1aae6a5e-a631-11ef-a090-435900c6d429", + description="This block follows a specified Twitter user.", + categories={BlockCategory.SOCIAL}, + input_schema=TwitterFollowUserBlock.Input, + output_schema=TwitterFollowUserBlock.Output, + test_input={ + "target_user_id": "12345", + "credentials": TEST_CREDENTIALS_INPUT, + }, + test_credentials=TEST_CREDENTIALS, + test_output=[("success", True)], + test_mock={"follow_user": lambda *args, **kwargs: True}, + ) + + @staticmethod + def follow_user(credentials: TwitterCredentials, target_user_id: str): + try: + client = tweepy.Client( + bearer_token=credentials.access_token.get_secret_value() + ) + + client.follow_user(target_user_id=target_user_id, user_auth=False) + + return True + + except tweepy.TweepyException: + raise + + def run( + self, + input_data: Input, + *, + credentials: TwitterCredentials, + **kwargs, + ) -> BlockOutput: + try: + success = self.follow_user(credentials, input_data.target_user_id) + yield "success", success + + except Exception as e: + yield "error", handle_tweepy_exception(e) + + +class TwitterGetFollowersBlock(Block): + """ + Retrieves a list of followers for a specified Twitter user ID + """ + + class Input(UserExpansionInputs): + credentials: TwitterCredentialsInput = TwitterCredentialsField( + ["users.read", "offline.access", "follows.read"] + ) + + target_user_id: str = SchemaField( + description="The user ID whose followers you would like to retrieve", + placeholder="Enter target user ID", + ) + + max_results: int | None = SchemaField( + description="Maximum number of results to return (1-1000, default 100)", + placeholder="Enter max results", + default=10, + advanced=True, + ) + + pagination_token: str | None = SchemaField( + description="Token for retrieving next/previous page of results", + placeholder="Enter pagination token", + default="", + advanced=True, + ) + + class Output(BlockSchema): + ids: list[str] = SchemaField(description="List of follower user IDs") + usernames: list[str] = SchemaField(description="List of follower usernames") + next_token: str = SchemaField(description="Next token for pagination") + + data: list[dict] = SchemaField(description="Complete user data for followers") + includes: dict = SchemaField( + description="Additional data requested via expansions" + ) + meta: dict = SchemaField(description="Metadata including pagination info") + + error: str = SchemaField(description="Error message if the request failed") + + def __init__(self): + super().__init__( + id="30f66410-a631-11ef-8fe7-d7f888b4f43c", + description="This block retrieves followers of a specified Twitter user.", + categories={BlockCategory.SOCIAL}, + input_schema=TwitterGetFollowersBlock.Input, + output_schema=TwitterGetFollowersBlock.Output, + test_input={ + "target_user_id": "12345", + "max_results": 1, + "pagination_token": "", + "expansions": None, + "tweet_fields": None, + "user_fields": None, + "credentials": TEST_CREDENTIALS_INPUT, + }, + test_credentials=TEST_CREDENTIALS, + test_output=[ + ("ids", ["1234567890"]), + ("usernames", ["testuser"]), + ("data", [{"id": "1234567890", "username": "testuser"}]), + ], + test_mock={ + "get_followers": lambda *args, **kwargs: ( + ["1234567890"], + ["testuser"], + [{"id": "1234567890", "username": "testuser"}], + {}, + {}, + None, + ) + }, + ) + + @staticmethod + def get_followers( + credentials: TwitterCredentials, + target_user_id: str, + max_results: int | None, + pagination_token: str | None, + expansions: UserExpansionsFilter | None, + tweet_fields: TweetFieldsFilter | None, + user_fields: TweetUserFieldsFilter | None, + ): + try: + client = tweepy.Client( + bearer_token=credentials.access_token.get_secret_value() + ) + + params = { + "id": target_user_id, + "max_results": max_results, + "pagination_token": ( + None if pagination_token == "" else pagination_token + ), + "user_auth": False, + } + + params = ( + UserExpansionsBuilder(params) + .add_expansions(expansions) + .add_tweet_fields(tweet_fields) + .add_user_fields(user_fields) + .build() + ) + + response = cast(Response, client.get_users_followers(**params)) + + meta = {} + follower_ids = [] + follower_usernames = [] + next_token = None + + if response.meta: + meta = response.meta + next_token = meta.get("next_token") + + included = IncludesSerializer.serialize(response.includes) + data = ResponseDataSerializer.serialize_list(response.data) + + if response.data: + follower_ids = [str(user.id) for user in response.data] + follower_usernames = [user.username for user in response.data] + + return ( + follower_ids, + follower_usernames, + data, + included, + meta, + next_token, + ) + + raise Exception("Followers not found") + + except tweepy.TweepyException: + raise + + def run( + self, + input_data: Input, + *, + credentials: TwitterCredentials, + **kwargs, + ) -> BlockOutput: + try: + ids, usernames, data, includes, meta, next_token = self.get_followers( + credentials, + input_data.target_user_id, + input_data.max_results, + input_data.pagination_token, + input_data.expansions, + input_data.tweet_fields, + input_data.user_fields, + ) + if ids: + yield "ids", ids + if usernames: + yield "usernames", usernames + if next_token: + yield "next_token", next_token + if data: + yield "data", data + if includes: + yield "includes", includes + if meta: + yield "meta", meta + except Exception as e: + yield "error", handle_tweepy_exception(e) + + +class TwitterGetFollowingBlock(Block): + """ + Retrieves a list of users that a specified Twitter user ID is following + """ + + class Input(UserExpansionInputs): + credentials: TwitterCredentialsInput = TwitterCredentialsField( + ["users.read", "offline.access", "follows.read"] + ) + + target_user_id: str = SchemaField( + description="The user ID whose following you would like to retrieve", + placeholder="Enter target user ID", + ) + + max_results: int | None = SchemaField( + description="Maximum number of results to return (1-1000, default 100)", + placeholder="Enter max results", + default=10, + advanced=True, + ) + + pagination_token: str | None = SchemaField( + description="Token for retrieving next/previous page of results", + placeholder="Enter pagination token", + default="", + advanced=True, + ) + + class Output(BlockSchema): + ids: list[str] = SchemaField(description="List of following user IDs") + usernames: list[str] = SchemaField(description="List of following usernames") + next_token: str = SchemaField(description="Next token for pagination") + + data: list[dict] = SchemaField(description="Complete user data for following") + includes: dict = SchemaField( + description="Additional data requested via expansions" + ) + meta: dict = SchemaField(description="Metadata including pagination info") + + error: str = SchemaField(description="Error message if the request failed") + + def __init__(self): + super().__init__( + id="264a399c-a631-11ef-a97d-bfde4ca91173", + description="This block retrieves the users that a specified Twitter user is following.", + categories={BlockCategory.SOCIAL}, + input_schema=TwitterGetFollowingBlock.Input, + output_schema=TwitterGetFollowingBlock.Output, + test_input={ + "target_user_id": "12345", + "max_results": 1, + "pagination_token": None, + "expansions": None, + "tweet_fields": None, + "user_fields": None, + "credentials": TEST_CREDENTIALS_INPUT, + }, + test_credentials=TEST_CREDENTIALS, + test_output=[ + ("ids", ["1234567890"]), + ("usernames", ["testuser"]), + ("data", [{"id": "1234567890", "username": "testuser"}]), + ], + test_mock={ + "get_following": lambda *args, **kwargs: ( + ["1234567890"], + ["testuser"], + [{"id": "1234567890", "username": "testuser"}], + {}, + {}, + None, + ) + }, + ) + + @staticmethod + def get_following( + credentials: TwitterCredentials, + target_user_id: str, + max_results: int | None, + pagination_token: str | None, + expansions: UserExpansionsFilter | None, + tweet_fields: TweetFieldsFilter | None, + user_fields: TweetUserFieldsFilter | None, + ): + try: + client = tweepy.Client( + bearer_token=credentials.access_token.get_secret_value() + ) + + params = { + "id": target_user_id, + "max_results": max_results, + "pagination_token": ( + None if pagination_token == "" else pagination_token + ), + "user_auth": False, + } + + params = ( + UserExpansionsBuilder(params) + .add_expansions(expansions) + .add_tweet_fields(tweet_fields) + .add_user_fields(user_fields) + .build() + ) + + response = cast(Response, client.get_users_following(**params)) + + meta = {} + following_ids = [] + following_usernames = [] + next_token = None + + if response.meta: + meta = response.meta + next_token = meta.get("next_token") + + included = IncludesSerializer.serialize(response.includes) + data = ResponseDataSerializer.serialize_list(response.data) + + if response.data: + following_ids = [str(user.id) for user in response.data] + following_usernames = [user.username for user in response.data] + + return ( + following_ids, + following_usernames, + data, + included, + meta, + next_token, + ) + + raise Exception("Following not found") + + except tweepy.TweepyException: + raise + + def run( + self, + input_data: Input, + *, + credentials: TwitterCredentials, + **kwargs, + ) -> BlockOutput: + try: + ids, usernames, data, includes, meta, next_token = self.get_following( + credentials, + input_data.target_user_id, + input_data.max_results, + input_data.pagination_token, + input_data.expansions, + input_data.tweet_fields, + input_data.user_fields, + ) + if ids: + yield "ids", ids + if usernames: + yield "usernames", usernames + if next_token: + yield "next_token", next_token + if data: + yield "data", data + if includes: + yield "includes", includes + if meta: + yield "meta", meta + except Exception as e: + yield "error", handle_tweepy_exception(e) diff --git a/autogpt_platform/backend/backend/blocks/twitter/users/mutes.py b/autogpt_platform/backend/backend/blocks/twitter/users/mutes.py new file mode 100644 index 000000000000..175a39011d33 --- /dev/null +++ b/autogpt_platform/backend/backend/blocks/twitter/users/mutes.py @@ -0,0 +1,328 @@ +from typing import cast + +import tweepy +from tweepy.client import Response + +from backend.blocks.twitter._auth import ( + TEST_CREDENTIALS, + TEST_CREDENTIALS_INPUT, + TwitterCredentials, + TwitterCredentialsField, + TwitterCredentialsInput, +) +from backend.blocks.twitter._builders import UserExpansionsBuilder +from backend.blocks.twitter._serializer import ( + IncludesSerializer, + ResponseDataSerializer, +) +from backend.blocks.twitter._types import ( + TweetFieldsFilter, + TweetUserFieldsFilter, + UserExpansionInputs, + UserExpansionsFilter, +) +from backend.blocks.twitter.tweepy_exceptions import handle_tweepy_exception +from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema +from backend.data.model import SchemaField + + +class TwitterUnmuteUserBlock(Block): + """ + Allows a user to unmute another user specified by target user ID. + The request succeeds with no action when the user sends a request to a user they're not muting or have already unmuted. + """ + + class Input(BlockSchema): + credentials: TwitterCredentialsInput = TwitterCredentialsField( + ["users.read", "users.write", "offline.access"] + ) + + target_user_id: str = SchemaField( + description="The user ID of the user that you would like to unmute", + placeholder="Enter target user ID", + ) + + class Output(BlockSchema): + success: bool = SchemaField( + description="Whether the unmute action was successful" + ) + error: str = SchemaField(description="Error message if the request failed") + + def __init__(self): + super().__init__( + id="40458504-a631-11ef-940b-eff92be55422", + description="This block unmutes a specified Twitter user.", + categories={BlockCategory.SOCIAL}, + input_schema=TwitterUnmuteUserBlock.Input, + output_schema=TwitterUnmuteUserBlock.Output, + test_input={ + "target_user_id": "12345", + "credentials": TEST_CREDENTIALS_INPUT, + }, + test_credentials=TEST_CREDENTIALS, + test_output=[ + ("success", True), + ], + test_mock={"unmute_user": lambda *args, **kwargs: True}, + ) + + @staticmethod + def unmute_user(credentials: TwitterCredentials, target_user_id: str): + try: + client = tweepy.Client( + bearer_token=credentials.access_token.get_secret_value() + ) + + client.unmute(target_user_id=target_user_id, user_auth=False) + + return True + + except tweepy.TweepyException: + raise + + def run( + self, + input_data: Input, + *, + credentials: TwitterCredentials, + **kwargs, + ) -> BlockOutput: + try: + success = self.unmute_user(credentials, input_data.target_user_id) + yield "success", success + + except Exception as e: + yield "error", handle_tweepy_exception(e) + + +class TwitterGetMutedUsersBlock(Block): + """ + Returns a list of users who are muted by the authenticating user + """ + + class Input(UserExpansionInputs): + credentials: TwitterCredentialsInput = TwitterCredentialsField( + ["users.read", "offline.access"] + ) + + max_results: int | None = SchemaField( + description="The maximum number of results to be returned per page (1-1000). Default is 100.", + placeholder="Enter max results", + default=10, + advanced=True, + ) + + pagination_token: str | None = SchemaField( + description="Token to request next/previous page of results", + placeholder="Enter pagination token", + default="", + advanced=True, + ) + + class Output(BlockSchema): + ids: list[str] = SchemaField(description="List of muted user IDs") + usernames: list[str] = SchemaField(description="List of muted usernames") + next_token: str = SchemaField(description="Next token for pagination") + + data: list[dict] = SchemaField(description="Complete user data for muted users") + includes: dict = SchemaField( + description="Additional data requested via expansions" + ) + meta: dict = SchemaField(description="Metadata including pagination info") + + error: str = SchemaField(description="Error message if the request failed") + + def __init__(self): + super().__init__( + id="475024da-a631-11ef-9ccd-f724b8b03cda", + description="This block gets a list of users muted by the authenticating user.", + categories={BlockCategory.SOCIAL}, + input_schema=TwitterGetMutedUsersBlock.Input, + output_schema=TwitterGetMutedUsersBlock.Output, + test_input={ + "max_results": 2, + "pagination_token": "", + "credentials": TEST_CREDENTIALS_INPUT, + "expansions": None, + "tweet_fields": None, + "user_fields": None, + }, + test_credentials=TEST_CREDENTIALS, + test_output=[ + ("ids", ["12345", "67890"]), + ("usernames", ["testuser1", "testuser2"]), + ( + "data", + [ + {"id": "12345", "username": "testuser1"}, + {"id": "67890", "username": "testuser2"}, + ], + ), + ], + test_mock={ + "get_muted_users": lambda *args, **kwargs: ( + ["12345", "67890"], + ["testuser1", "testuser2"], + [ + {"id": "12345", "username": "testuser1"}, + {"id": "67890", "username": "testuser2"}, + ], + {}, + {}, + None, + ) + }, + ) + + @staticmethod + def get_muted_users( + credentials: TwitterCredentials, + max_results: int | None, + pagination_token: str | None, + expansions: UserExpansionsFilter | None, + tweet_fields: TweetFieldsFilter | None, + user_fields: TweetUserFieldsFilter | None, + ): + try: + client = tweepy.Client( + bearer_token=credentials.access_token.get_secret_value() + ) + + params = { + "max_results": max_results, + "pagination_token": ( + None if pagination_token == "" else pagination_token + ), + "user_auth": False, + } + + params = ( + UserExpansionsBuilder(params) + .add_expansions(expansions) + .add_tweet_fields(tweet_fields) + .add_user_fields(user_fields) + .build() + ) + + response = cast(Response, client.get_muted(**params)) + + meta = {} + user_ids = [] + usernames = [] + next_token = None + + if response.meta: + meta = response.meta + next_token = meta.get("next_token") + + included = IncludesSerializer.serialize(response.includes) + data = ResponseDataSerializer.serialize_list(response.data) + + if response.data: + user_ids = [str(item.id) for item in response.data] + usernames = [item.username for item in response.data] + + return user_ids, usernames, data, included, meta, next_token + + raise Exception("Muted users not found") + + except tweepy.TweepyException: + raise + + def run( + self, + input_data: Input, + *, + credentials: TwitterCredentials, + **kwargs, + ) -> BlockOutput: + try: + ids, usernames, data, includes, meta, next_token = self.get_muted_users( + credentials, + input_data.max_results, + input_data.pagination_token, + input_data.expansions, + input_data.tweet_fields, + input_data.user_fields, + ) + if ids: + yield "ids", ids + if usernames: + yield "usernames", usernames + if next_token: + yield "next_token", next_token + if data: + yield "data", data + if includes: + yield "includes", includes + if meta: + yield "meta", meta + except Exception as e: + yield "error", handle_tweepy_exception(e) + + +class TwitterMuteUserBlock(Block): + """ + Allows a user to mute another user specified by target user ID + """ + + class Input(BlockSchema): + credentials: TwitterCredentialsInput = TwitterCredentialsField( + ["users.read", "users.write", "offline.access"] + ) + + target_user_id: str = SchemaField( + description="The user ID of the user that you would like to mute", + placeholder="Enter target user ID", + ) + + class Output(BlockSchema): + success: bool = SchemaField( + description="Whether the mute action was successful" + ) + error: str = SchemaField(description="Error message if the request failed") + + def __init__(self): + super().__init__( + id="4d1919d0-a631-11ef-90ab-3b73af9ce8f1", + description="This block mutes a specified Twitter user.", + categories={BlockCategory.SOCIAL}, + input_schema=TwitterMuteUserBlock.Input, + output_schema=TwitterMuteUserBlock.Output, + test_input={ + "target_user_id": "12345", + "credentials": TEST_CREDENTIALS_INPUT, + }, + test_credentials=TEST_CREDENTIALS, + test_output=[ + ("success", True), + ], + test_mock={"mute_user": lambda *args, **kwargs: True}, + ) + + @staticmethod + def mute_user(credentials: TwitterCredentials, target_user_id: str): + try: + client = tweepy.Client( + bearer_token=credentials.access_token.get_secret_value() + ) + + client.mute(target_user_id=target_user_id, user_auth=False) + + return True + + except tweepy.TweepyException: + raise + + def run( + self, + input_data: Input, + *, + credentials: TwitterCredentials, + **kwargs, + ) -> BlockOutput: + try: + success = self.mute_user(credentials, input_data.target_user_id) + yield "success", success + except Exception as e: + yield "error", handle_tweepy_exception(e) diff --git a/autogpt_platform/backend/backend/blocks/twitter/users/user_lookup.py b/autogpt_platform/backend/backend/blocks/twitter/users/user_lookup.py new file mode 100644 index 000000000000..16c207f6dd87 --- /dev/null +++ b/autogpt_platform/backend/backend/blocks/twitter/users/user_lookup.py @@ -0,0 +1,383 @@ +from typing import Literal, Union, cast + +import tweepy +from pydantic import BaseModel +from tweepy.client import Response + +from backend.blocks.twitter._auth import ( + TEST_CREDENTIALS, + TEST_CREDENTIALS_INPUT, + TwitterCredentials, + TwitterCredentialsField, + TwitterCredentialsInput, +) +from backend.blocks.twitter._builders import UserExpansionsBuilder +from backend.blocks.twitter._serializer import ( + IncludesSerializer, + ResponseDataSerializer, +) +from backend.blocks.twitter._types import ( + TweetFieldsFilter, + TweetUserFieldsFilter, + UserExpansionInputs, + UserExpansionsFilter, +) +from backend.blocks.twitter.tweepy_exceptions import handle_tweepy_exception +from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema +from backend.data.model import SchemaField + + +class UserId(BaseModel): + discriminator: Literal["user_id"] + user_id: str = SchemaField(description="The ID of the user to lookup", default="") + + +class Username(BaseModel): + discriminator: Literal["username"] + username: str = SchemaField( + description="The Twitter username (handle) of the user", default="" + ) + + +class TwitterGetUserBlock(Block): + """ + Gets information about a single Twitter user specified by ID or username + """ + + class Input(UserExpansionInputs): + credentials: TwitterCredentialsInput = TwitterCredentialsField( + ["users.read", "offline.access"] + ) + + identifier: Union[UserId, Username] = SchemaField( + discriminator="discriminator", + description="Choose whether to identify the user by their unique Twitter ID or by their username", + advanced=False, + ) + + class Output(BlockSchema): + # Common outputs + id: str = SchemaField(description="User ID") + username_: str = SchemaField(description="User username") + name_: str = SchemaField(description="User name") + + # Complete outputs + data: dict = SchemaField(description="Complete user data") + included: dict = SchemaField( + description="Additional data requested via expansions" + ) + error: str = SchemaField(description="Error message if the request failed") + + def __init__(self): + super().__init__( + id="5446db8e-a631-11ef-812a-cf315d373ee9", + description="This block retrieves information about a specified Twitter user.", + categories={BlockCategory.SOCIAL}, + input_schema=TwitterGetUserBlock.Input, + output_schema=TwitterGetUserBlock.Output, + test_input={ + "identifier": {"discriminator": "username", "username": "twitter"}, + "credentials": TEST_CREDENTIALS_INPUT, + "expansions": None, + "tweet_fields": None, + "user_fields": None, + }, + test_credentials=TEST_CREDENTIALS, + test_output=[ + ("id", "783214"), + ("username_", "twitter"), + ("name_", "Twitter"), + ( + "data", + { + "user": { + "id": "783214", + "username": "twitter", + "name": "Twitter", + } + }, + ), + ], + test_mock={ + "get_user": lambda *args, **kwargs: ( + { + "user": { + "id": "783214", + "username": "twitter", + "name": "Twitter", + } + }, + {}, + "twitter", + "783214", + "Twitter", + ) + }, + ) + + @staticmethod + def get_user( + credentials: TwitterCredentials, + identifier: Union[UserId, Username], + expansions: UserExpansionsFilter | None, + tweet_fields: TweetFieldsFilter | None, + user_fields: TweetUserFieldsFilter | None, + ): + try: + client = tweepy.Client( + bearer_token=credentials.access_token.get_secret_value() + ) + + params = { + "id": identifier.user_id if isinstance(identifier, UserId) else None, + "username": ( + identifier.username if isinstance(identifier, Username) else None + ), + "user_auth": False, + } + + params = ( + UserExpansionsBuilder(params) + .add_expansions(expansions) + .add_tweet_fields(tweet_fields) + .add_user_fields(user_fields) + .build() + ) + + response = cast(Response, client.get_user(**params)) + + username = "" + id = "" + name = "" + + included = IncludesSerializer.serialize(response.includes) + data = ResponseDataSerializer.serialize_dict(response.data) + + if response.data: + username = response.data.username + id = str(response.data.id) + name = response.data.name + + if username and id: + return data, included, username, id, name + else: + raise tweepy.TweepyException("User not found") + + except tweepy.TweepyException: + raise + + def run( + self, + input_data: Input, + *, + credentials: TwitterCredentials, + **kwargs, + ) -> BlockOutput: + try: + data, included, username, id, name = self.get_user( + credentials, + input_data.identifier, + input_data.expansions, + input_data.tweet_fields, + input_data.user_fields, + ) + if id: + yield "id", id + if username: + yield "username_", username + if name: + yield "name_", name + if data: + yield "data", data + if included: + yield "included", included + except Exception as e: + yield "error", handle_tweepy_exception(e) + + +class UserIdList(BaseModel): + discriminator: Literal["user_id_list"] + user_ids: list[str] = SchemaField( + description="List of user IDs to lookup (max 100)", + placeholder="Enter user IDs", + default=[], + advanced=False, + ) + + +class UsernameList(BaseModel): + discriminator: Literal["username_list"] + usernames: list[str] = SchemaField( + description="List of Twitter usernames/handles to lookup (max 100)", + placeholder="Enter usernames", + default=[], + advanced=False, + ) + + +class TwitterGetUsersBlock(Block): + """ + Gets information about multiple Twitter users specified by IDs or usernames + """ + + class Input(UserExpansionInputs): + credentials: TwitterCredentialsInput = TwitterCredentialsField( + ["users.read", "offline.access"] + ) + + identifier: Union[UserIdList, UsernameList] = SchemaField( + discriminator="discriminator", + description="Choose whether to identify users by their unique Twitter IDs or by their usernames", + advanced=False, + ) + + class Output(BlockSchema): + # Common outputs + ids: list[str] = SchemaField(description="User IDs") + usernames_: list[str] = SchemaField(description="User usernames") + names_: list[str] = SchemaField(description="User names") + + # Complete outputs + data: list[dict] = SchemaField(description="Complete users data") + included: dict = SchemaField( + description="Additional data requested via expansions" + ) + error: str = SchemaField(description="Error message if the request failed") + + def __init__(self): + super().__init__( + id="5abc857c-a631-11ef-8cfc-f7b79354f7a1", + description="This block retrieves information about multiple Twitter users.", + categories={BlockCategory.SOCIAL}, + input_schema=TwitterGetUsersBlock.Input, + output_schema=TwitterGetUsersBlock.Output, + test_input={ + "identifier": { + "discriminator": "username_list", + "usernames": ["twitter", "twitterdev"], + }, + "credentials": TEST_CREDENTIALS_INPUT, + "expansions": None, + "tweet_fields": None, + "user_fields": None, + }, + test_credentials=TEST_CREDENTIALS, + test_output=[ + ("ids", ["783214", "2244994945"]), + ("usernames_", ["twitter", "twitterdev"]), + ("names_", ["Twitter", "Twitter Dev"]), + ( + "data", + [ + {"id": "783214", "username": "twitter", "name": "Twitter"}, + { + "id": "2244994945", + "username": "twitterdev", + "name": "Twitter Dev", + }, + ], + ), + ], + test_mock={ + "get_users": lambda *args, **kwargs: ( + [ + {"id": "783214", "username": "twitter", "name": "Twitter"}, + { + "id": "2244994945", + "username": "twitterdev", + "name": "Twitter Dev", + }, + ], + {}, + ["twitter", "twitterdev"], + ["783214", "2244994945"], + ["Twitter", "Twitter Dev"], + ) + }, + ) + + @staticmethod + def get_users( + credentials: TwitterCredentials, + identifier: Union[UserIdList, UsernameList], + expansions: UserExpansionsFilter | None, + tweet_fields: TweetFieldsFilter | None, + user_fields: TweetUserFieldsFilter | None, + ): + try: + client = tweepy.Client( + bearer_token=credentials.access_token.get_secret_value() + ) + + params = { + "ids": ( + ",".join(identifier.user_ids) + if isinstance(identifier, UserIdList) + else None + ), + "usernames": ( + ",".join(identifier.usernames) + if isinstance(identifier, UsernameList) + else None + ), + "user_auth": False, + } + + params = ( + UserExpansionsBuilder(params) + .add_expansions(expansions) + .add_tweet_fields(tweet_fields) + .add_user_fields(user_fields) + .build() + ) + + response = cast(Response, client.get_users(**params)) + + usernames = [] + ids = [] + names = [] + + included = IncludesSerializer.serialize(response.includes) + data = ResponseDataSerializer.serialize_list(response.data) + + if response.data: + for user in response.data: + usernames.append(user.username) + ids.append(str(user.id)) + names.append(user.name) + + if usernames and ids: + return data, included, usernames, ids, names + else: + raise tweepy.TweepyException("Users not found") + + except tweepy.TweepyException: + raise + + def run( + self, + input_data: Input, + *, + credentials: TwitterCredentials, + **kwargs, + ) -> BlockOutput: + try: + data, included, usernames, ids, names = self.get_users( + credentials, + input_data.identifier, + input_data.expansions, + input_data.tweet_fields, + input_data.user_fields, + ) + if ids: + yield "ids", ids + if usernames: + yield "usernames_", usernames + if names: + yield "names_", names + if data: + yield "data", data + if included: + yield "included", included + except Exception as e: + yield "error", handle_tweepy_exception(e) diff --git a/autogpt_platform/backend/backend/blocks/youtube.py b/autogpt_platform/backend/backend/blocks/youtube.py new file mode 100644 index 000000000000..648d9d6dae07 --- /dev/null +++ b/autogpt_platform/backend/backend/blocks/youtube.py @@ -0,0 +1,90 @@ +from urllib.parse import parse_qs, urlparse + +from youtube_transcript_api import YouTubeTranscriptApi +from youtube_transcript_api.formatters import TextFormatter + +from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema +from backend.data.model import SchemaField + + +class TranscribeYoutubeVideoBlock(Block): + class Input(BlockSchema): + youtube_url: str = SchemaField( + title="YouTube URL", + description="The URL of the YouTube video to transcribe", + placeholder="https://www.youtube.com/watch?v=dQw4w9WgXcQ", + ) + + class Output(BlockSchema): + video_id: str = SchemaField(description="The extracted YouTube video ID") + transcript: str = SchemaField(description="The transcribed text of the video") + error: str = SchemaField( + description="Any error message if the transcription fails" + ) + + def __init__(self): + super().__init__( + id="f3a8f7e1-4b1d-4e5f-9f2a-7c3d5a2e6b4c", + input_schema=TranscribeYoutubeVideoBlock.Input, + output_schema=TranscribeYoutubeVideoBlock.Output, + description="Transcribes a YouTube video.", + categories={BlockCategory.SOCIAL}, + test_input={"youtube_url": "https://www.youtube.com/watch?v=dQw4w9WgXcQ"}, + test_output=[ + ("video_id", "dQw4w9WgXcQ"), + ( + "transcript", + "Never gonna give you up\nNever gonna let you down", + ), + ], + test_mock={ + "get_transcript": lambda video_id: [ + {"text": "Never gonna give you up"}, + {"text": "Never gonna let you down"}, + ], + }, + ) + + @staticmethod + def extract_video_id(url: str) -> str: + parsed_url = urlparse(url) + if parsed_url.netloc == "youtu.be": + return parsed_url.path[1:] + if parsed_url.netloc in ("www.youtube.com", "youtube.com"): + if parsed_url.path == "/watch": + p = parse_qs(parsed_url.query) + return p["v"][0] + if parsed_url.path[:7] == "/embed/": + return parsed_url.path.split("/")[2] + if parsed_url.path[:3] == "/v/": + return parsed_url.path.split("/")[2] + raise ValueError(f"Invalid YouTube URL: {url}") + + @staticmethod + def get_transcript(video_id: str): + try: + transcript_list = YouTubeTranscriptApi.list_transcripts(video_id) + + if not transcript_list: + raise ValueError(f"No transcripts found for the video: {video_id}") + + for transcript in transcript_list: + first_transcript = transcript_list.find_transcript( + [transcript.language_code] + ) + return YouTubeTranscriptApi.get_transcript( + video_id, languages=[first_transcript.language_code] + ) + + except Exception: + raise ValueError(f"No transcripts found for the video: {video_id}") + + def run(self, input_data: Input, **kwargs) -> BlockOutput: + video_id = self.extract_video_id(input_data.youtube_url) + yield "video_id", video_id + + transcript = self.get_transcript(video_id) + formatter = TextFormatter() + transcript_text = formatter.format_transcript(transcript) + + yield "transcript", transcript_text diff --git a/autogpt_platform/backend/backend/cli.py b/autogpt_platform/backend/backend/cli.py new file mode 100755 index 000000000000..efaadd02b282 --- /dev/null +++ b/autogpt_platform/backend/backend/cli.py @@ -0,0 +1,257 @@ +""" +The command line interface for the agent server +""" + +import os +import pathlib + +import click +import psutil + +from backend import app +from backend.util.process import AppProcess + + +def get_pid_path() -> pathlib.Path: + home_dir = pathlib.Path.home() + new_dir = home_dir / ".config" / "agpt" + file_path = new_dir / "running.tmp" + return file_path + + +def get_pid() -> int | None: + file_path = get_pid_path() + if not file_path.exists(): + return None + + os.makedirs(file_path.parent, exist_ok=True) + with open(file_path, "r", encoding="utf-8") as file: + pid = file.read() + try: + return int(pid) + except ValueError: + return None + + +def write_pid(pid: int): + file_path = get_pid_path() + os.makedirs(file_path.parent, exist_ok=True) + with open(file_path, "w", encoding="utf-8") as file: + file.write(str(pid)) + + +class MainApp(AppProcess): + def run(self): + app.main(silent=True) + + +@click.group() +def main(): + """AutoGPT Server CLI Tool""" + pass + + +@main.command() +def start(): + """ + Starts the server in the background and saves the PID + """ + # Define the path for the new directory and file + pid = get_pid() + if pid and psutil.pid_exists(pid): + print("Server is already running") + exit(1) + elif pid: + print("PID does not exist deleting file") + os.remove(get_pid_path()) + + print("Starting server") + pid = MainApp().start(background=True, silent=True) + print(f"Server running in process: {pid}") + + write_pid(pid) + print("done") + os._exit(status=0) + + +@main.command() +def stop(): + """ + Stops the server + """ + pid = get_pid() + if not pid: + print("Server is not running") + return + + os.remove(get_pid_path()) + process = psutil.Process(int(pid)) + for child in process.children(recursive=True): + child.terminate() + process.terminate() + + print("Server Stopped") + + +@main.command() +def gen_encrypt_key(): + """ + Generate a new encryption key + """ + from cryptography.fernet import Fernet + + print(Fernet.generate_key().decode()) + + +@click.group() +def test(): + """ + Group for test commands + """ + pass + + +@test.command() +@click.argument("server_address") +def reddit(server_address: str): + """ + Create an event graph + """ + import requests + + from backend.usecases.reddit_marketing import create_test_graph + + test_graph = create_test_graph() + url = f"{server_address}/graphs" + headers = {"Content-Type": "application/json"} + data = test_graph.model_dump_json() + + response = requests.post(url, headers=headers, data=data) + + graph_id = response.json()["id"] + print(f"Graph created with ID: {graph_id}") + + +@test.command() +@click.argument("server_address") +def populate_db(server_address: str): + """ + Create an event graph + """ + import requests + + from backend.usecases.sample import create_test_graph + + test_graph = create_test_graph() + url = f"{server_address}/graphs" + headers = {"Content-Type": "application/json"} + data = test_graph.model_dump_json() + + response = requests.post(url, headers=headers, data=data) + + graph_id = response.json()["id"] + + if response.status_code == 200: + execute_url = f"{server_address}/graphs/{response.json()['id']}/execute" + text = "Hello, World!" + input_data = {"input": text} + response = requests.post(execute_url, headers=headers, json=input_data) + + schedule_url = f"{server_address}/graphs/{graph_id}/schedules" + data = { + "graph_id": graph_id, + "cron": "*/5 * * * *", + "input_data": {"input": "Hello, World!"}, + } + response = requests.post(schedule_url, headers=headers, json=data) + + print("Database populated with: \n- graph\n- execution\n- schedule") + + +@test.command() +@click.argument("server_address") +def graph(server_address: str): + """ + Create an event graph + """ + import requests + + from backend.usecases.sample import create_test_graph + + url = f"{server_address}/graphs" + headers = {"Content-Type": "application/json"} + data = create_test_graph().model_dump_json() + response = requests.post(url, headers=headers, data=data) + + if response.status_code == 200: + print(response.json()["id"]) + execute_url = f"{server_address}/graphs/{response.json()['id']}/execute" + text = "Hello, World!" + input_data = {"input": text} + response = requests.post(execute_url, headers=headers, json=input_data) + + else: + print("Failed to send graph") + print(f"Response: {response.text}") + + +@test.command() +@click.argument("graph_id") +@click.argument("content") +def execute(graph_id: str, content: dict): + """ + Create an event graph + """ + import requests + + headers = {"Content-Type": "application/json"} + + execute_url = f"http://0.0.0.0:8000/graphs/{graph_id}/execute" + requests.post(execute_url, headers=headers, json=content) + + +@test.command() +def event(): + """ + Send an event to the running server + """ + print("Event sent") + + +@test.command() +@click.argument("server_address") +@click.argument("graph_id") +def websocket(server_address: str, graph_id: str): + """ + Tests the websocket connection. + """ + import asyncio + + import websockets.asyncio.client + + from backend.server.ws_api import ExecutionSubscription, Methods, WsMessage + + async def send_message(server_address: str): + uri = f"ws://{server_address}" + async with websockets.asyncio.client.connect(uri) as websocket: + try: + msg = WsMessage( + method=Methods.SUBSCRIBE, + data=ExecutionSubscription(graph_id=graph_id).model_dump(), + ).model_dump_json() + await websocket.send(msg) + print(f"Sending: {msg}") + while True: + response = await websocket.recv() + print(f"Response from server: {response}") + except InterruptedError: + exit(0) + + asyncio.run(send_message(server_address)) + print("Testing WS") + + +main.add_command(test) + +if __name__ == "__main__": + main() diff --git a/autogpt_platform/backend/backend/data/analytics.py b/autogpt_platform/backend/backend/data/analytics.py new file mode 100644 index 000000000000..e0ee6bc4e2b5 --- /dev/null +++ b/autogpt_platform/backend/backend/data/analytics.py @@ -0,0 +1,43 @@ +import logging + +import prisma.types + +logger = logging.getLogger(__name__) + + +async def log_raw_analytics( + user_id: str, + type: str, + data: dict, + data_index: str, +): + details = await prisma.models.AnalyticsDetails.prisma().create( + data={ + "userId": user_id, + "type": type, + "data": prisma.Json(data), + "dataIndex": data_index, + } + ) + return details + + +async def log_raw_metric( + user_id: str, + metric_name: str, + metric_value: float, + data_string: str, +): + if metric_value < 0: + raise ValueError("metric_value must be non-negative") + + result = await prisma.models.AnalyticsMetrics.prisma().create( + data={ + "value": metric_value, + "analyticMetric": metric_name, + "userId": user_id, + "dataString": data_string, + }, + ) + + return result diff --git a/autogpt_platform/backend/backend/data/api_key.py b/autogpt_platform/backend/backend/data/api_key.py new file mode 100644 index 000000000000..91fb33622e28 --- /dev/null +++ b/autogpt_platform/backend/backend/data/api_key.py @@ -0,0 +1,325 @@ +import logging +import uuid +from datetime import datetime, timezone +from typing import List, Optional + +from autogpt_libs.api_key.key_manager import APIKeyManager +from prisma.enums import APIKeyPermission, APIKeyStatus +from prisma.errors import PrismaError +from prisma.models import APIKey as PrismaAPIKey +from prisma.types import ( + APIKeyCreateInput, + APIKeyUpdateInput, + APIKeyWhereInput, + APIKeyWhereUniqueInput, +) +from pydantic import BaseModel + +from backend.data.db import BaseDbModel + +logger = logging.getLogger(__name__) + + +# Some basic exceptions +class APIKeyError(Exception): + """Base exception for API key operations""" + + pass + + +class APIKeyNotFoundError(APIKeyError): + """Raised when an API key is not found""" + + pass + + +class APIKeyPermissionError(APIKeyError): + """Raised when there are permission issues with API key operations""" + + pass + + +class APIKeyValidationError(APIKeyError): + """Raised when API key validation fails""" + + pass + + +class APIKey(BaseDbModel): + name: str + prefix: str + key: str + status: APIKeyStatus = APIKeyStatus.ACTIVE + permissions: List[APIKeyPermission] + postfix: str + created_at: datetime + last_used_at: Optional[datetime] = None + revoked_at: Optional[datetime] = None + description: Optional[str] = None + user_id: str + + @staticmethod + def from_db(api_key: PrismaAPIKey): + try: + return APIKey( + id=api_key.id, + name=api_key.name, + prefix=api_key.prefix, + postfix=api_key.postfix, + key=api_key.key, + status=APIKeyStatus(api_key.status), + permissions=[APIKeyPermission(p) for p in api_key.permissions], + created_at=api_key.createdAt, + last_used_at=api_key.lastUsedAt, + revoked_at=api_key.revokedAt, + description=api_key.description, + user_id=api_key.userId, + ) + except Exception as e: + logger.error(f"Error creating APIKey from db: {str(e)}") + raise APIKeyError(f"Failed to create API key object: {str(e)}") + + +class APIKeyWithoutHash(BaseModel): + id: str + name: str + prefix: str + postfix: str + status: APIKeyStatus + permissions: List[APIKeyPermission] + created_at: datetime + last_used_at: Optional[datetime] + revoked_at: Optional[datetime] + description: Optional[str] + user_id: str + + @staticmethod + def from_db(api_key: PrismaAPIKey): + try: + return APIKeyWithoutHash( + id=api_key.id, + name=api_key.name, + prefix=api_key.prefix, + postfix=api_key.postfix, + status=APIKeyStatus(api_key.status), + permissions=[APIKeyPermission(p) for p in api_key.permissions], + created_at=api_key.createdAt, + last_used_at=api_key.lastUsedAt, + revoked_at=api_key.revokedAt, + description=api_key.description, + user_id=api_key.userId, + ) + except Exception as e: + logger.error(f"Error creating APIKeyWithoutHash from db: {str(e)}") + raise APIKeyError(f"Failed to create API key object: {str(e)}") + + +async def generate_api_key( + name: str, + user_id: str, + permissions: List[APIKeyPermission], + description: Optional[str] = None, +) -> tuple[APIKeyWithoutHash, str]: + """ + Generate a new API key and store it in the database. + Returns the API key object (without hash) and the plain text key. + """ + try: + api_manager = APIKeyManager() + key = api_manager.generate_api_key() + + api_key = await PrismaAPIKey.prisma().create( + data=APIKeyCreateInput( + id=str(uuid.uuid4()), + name=name, + prefix=key.prefix, + postfix=key.postfix, + key=key.hash, + permissions=[p for p in permissions], + description=description, + userId=user_id, + ) + ) + + api_key_without_hash = APIKeyWithoutHash.from_db(api_key) + return api_key_without_hash, key.raw + except PrismaError as e: + logger.error(f"Database error while generating API key: {str(e)}") + raise APIKeyError(f"Failed to generate API key: {str(e)}") + except Exception as e: + logger.error(f"Unexpected error while generating API key: {str(e)}") + raise APIKeyError(f"Failed to generate API key: {str(e)}") + + +async def validate_api_key(plain_text_key: str) -> Optional[APIKey]: + """ + Validate an API key and return the API key object if valid. + """ + try: + if not plain_text_key.startswith(APIKeyManager.PREFIX): + logger.warning("Invalid API key format") + return None + + prefix = plain_text_key[: APIKeyManager.PREFIX_LENGTH] + api_manager = APIKeyManager() + + api_key = await PrismaAPIKey.prisma().find_first( + where=APIKeyWhereInput(prefix=prefix, status=(APIKeyStatus.ACTIVE)) + ) + + if not api_key: + logger.warning(f"No active API key found with prefix {prefix}") + return None + + is_valid = api_manager.verify_api_key(plain_text_key, api_key.key) + if not is_valid: + logger.warning("API key verification failed") + return None + + return APIKey.from_db(api_key) + except Exception as e: + logger.error(f"Error validating API key: {str(e)}") + raise APIKeyValidationError(f"Failed to validate API key: {str(e)}") + + +async def revoke_api_key(key_id: str, user_id: str) -> Optional[APIKeyWithoutHash]: + try: + api_key = await PrismaAPIKey.prisma().find_unique(where={"id": key_id}) + + if not api_key: + raise APIKeyNotFoundError(f"API key with id {key_id} not found") + + if api_key.userId != user_id: + raise APIKeyPermissionError( + "You do not have permission to revoke this API key." + ) + + where_clause: APIKeyWhereUniqueInput = {"id": key_id} + updated_api_key = await PrismaAPIKey.prisma().update( + where=where_clause, + data=APIKeyUpdateInput( + status=APIKeyStatus.REVOKED, revokedAt=datetime.now(timezone.utc) + ), + ) + + if updated_api_key: + return APIKeyWithoutHash.from_db(updated_api_key) + return None + except (APIKeyNotFoundError, APIKeyPermissionError) as e: + raise e + except PrismaError as e: + logger.error(f"Database error while revoking API key: {str(e)}") + raise APIKeyError(f"Failed to revoke API key: {str(e)}") + except Exception as e: + logger.error(f"Unexpected error while revoking API key: {str(e)}") + raise APIKeyError(f"Failed to revoke API key: {str(e)}") + + +async def list_user_api_keys(user_id: str) -> List[APIKeyWithoutHash]: + try: + where_clause: APIKeyWhereInput = {"userId": user_id} + + api_keys = await PrismaAPIKey.prisma().find_many( + where=where_clause, order={"createdAt": "desc"} + ) + + return [APIKeyWithoutHash.from_db(key) for key in api_keys] + except PrismaError as e: + logger.error(f"Database error while listing API keys: {str(e)}") + raise APIKeyError(f"Failed to list API keys: {str(e)}") + except Exception as e: + logger.error(f"Unexpected error while listing API keys: {str(e)}") + raise APIKeyError(f"Failed to list API keys: {str(e)}") + + +async def suspend_api_key(key_id: str, user_id: str) -> Optional[APIKeyWithoutHash]: + try: + api_key = await PrismaAPIKey.prisma().find_unique(where={"id": key_id}) + + if not api_key: + raise APIKeyNotFoundError(f"API key with id {key_id} not found") + + if api_key.userId != user_id: + raise APIKeyPermissionError( + "You do not have permission to suspend this API key." + ) + + where_clause: APIKeyWhereUniqueInput = {"id": key_id} + updated_api_key = await PrismaAPIKey.prisma().update( + where=where_clause, + data=APIKeyUpdateInput(status=APIKeyStatus.SUSPENDED), + ) + + if updated_api_key: + return APIKeyWithoutHash.from_db(updated_api_key) + return None + except (APIKeyNotFoundError, APIKeyPermissionError) as e: + raise e + except PrismaError as e: + logger.error(f"Database error while suspending API key: {str(e)}") + raise APIKeyError(f"Failed to suspend API key: {str(e)}") + except Exception as e: + logger.error(f"Unexpected error while suspending API key: {str(e)}") + raise APIKeyError(f"Failed to suspend API key: {str(e)}") + + +def has_permission(api_key: APIKey, required_permission: APIKeyPermission) -> bool: + try: + return required_permission in api_key.permissions + except Exception as e: + logger.error(f"Error checking API key permissions: {str(e)}") + return False + + +async def get_api_key_by_id(key_id: str, user_id: str) -> Optional[APIKeyWithoutHash]: + try: + api_key = await PrismaAPIKey.prisma().find_first( + where=APIKeyWhereInput(id=key_id, userId=user_id) + ) + + if not api_key: + return None + + return APIKeyWithoutHash.from_db(api_key) + except PrismaError as e: + logger.error(f"Database error while getting API key: {str(e)}") + raise APIKeyError(f"Failed to get API key: {str(e)}") + except Exception as e: + logger.error(f"Unexpected error while getting API key: {str(e)}") + raise APIKeyError(f"Failed to get API key: {str(e)}") + + +async def update_api_key_permissions( + key_id: str, user_id: str, permissions: List[APIKeyPermission] +) -> Optional[APIKeyWithoutHash]: + """ + Update the permissions of an API key. + """ + try: + api_key = await PrismaAPIKey.prisma().find_unique(where={"id": key_id}) + + if api_key is None: + raise APIKeyNotFoundError("No such API key found.") + + if api_key.userId != user_id: + raise APIKeyPermissionError( + "You do not have permission to update this API key." + ) + + where_clause: APIKeyWhereUniqueInput = {"id": key_id} + updated_api_key = await PrismaAPIKey.prisma().update( + where=where_clause, + data=APIKeyUpdateInput(permissions=permissions), + ) + + if updated_api_key: + return APIKeyWithoutHash.from_db(updated_api_key) + return None + except (APIKeyNotFoundError, APIKeyPermissionError) as e: + raise e + except PrismaError as e: + logger.error(f"Database error while updating API key permissions: {str(e)}") + raise APIKeyError(f"Failed to update API key permissions: {str(e)}") + except Exception as e: + logger.error(f"Unexpected error while updating API key permissions: {str(e)}") + raise APIKeyError(f"Failed to update API key permissions: {str(e)}") diff --git a/autogpt_platform/backend/backend/data/block.py b/autogpt_platform/backend/backend/data/block.py new file mode 100644 index 000000000000..5592af8dc7ae --- /dev/null +++ b/autogpt_platform/backend/backend/data/block.py @@ -0,0 +1,466 @@ +import inspect +from abc import ABC, abstractmethod +from enum import Enum +from typing import ( + Any, + ClassVar, + Generator, + Generic, + Optional, + Type, + TypeVar, + cast, + get_origin, +) + +import jsonref +import jsonschema +from prisma.models import AgentBlock +from pydantic import BaseModel + +from backend.util import json +from backend.util.settings import Config + +from .model import ( + ContributorDetails, + Credentials, + CredentialsMetaInput, + is_credentials_field_name, +) + +app_config = Config() + +BlockData = tuple[str, Any] # Input & Output data should be a tuple of (name, data). +BlockInput = dict[str, Any] # Input: 1 input pin consumes 1 data. +BlockOutput = Generator[BlockData, None, None] # Output: 1 output pin produces n data. +CompletedBlockOutput = dict[str, list[Any]] # Completed stream, collected as a dict. + + +class BlockType(Enum): + STANDARD = "Standard" + INPUT = "Input" + OUTPUT = "Output" + NOTE = "Note" + WEBHOOK = "Webhook" + WEBHOOK_MANUAL = "Webhook (manual)" + AGENT = "Agent" + + +class BlockCategory(Enum): + AI = "Block that leverages AI to perform a task." + SOCIAL = "Block that interacts with social media platforms." + TEXT = "Block that processes text data." + SEARCH = "Block that searches or extracts information from the internet." + BASIC = "Block that performs basic operations." + INPUT = "Block that interacts with input of the graph." + OUTPUT = "Block that interacts with output of the graph." + LOGIC = "Programming logic to control the flow of your agent" + COMMUNICATION = "Block that interacts with communication platforms." + DEVELOPER_TOOLS = "Developer tools such as GitHub blocks." + DATA = "Block that interacts with structured data." + HARDWARE = "Block that interacts with hardware." + AGENT = "Block that interacts with other agents." + CRM = "Block that interacts with CRM services." + SAFETY = ( + "Block that provides AI safety mechanisms such as detecting harmful content" + ) + PRODUCTIVITY = "Block that helps with productivity" + ISSUE_TRACKING = "Block that helps with issue tracking" + MULTIMEDIA = "Block that interacts with multimedia content" + + def dict(self) -> dict[str, str]: + return {"category": self.name, "description": self.value} + + +class BlockSchema(BaseModel): + cached_jsonschema: ClassVar[dict[str, Any]] + + @classmethod + def jsonschema(cls) -> dict[str, Any]: + if cls.cached_jsonschema: + return cls.cached_jsonschema + + model = jsonref.replace_refs(cls.model_json_schema(), merge_props=True) + + def ref_to_dict(obj): + if isinstance(obj, dict): + # OpenAPI <3.1 does not support sibling fields that has a $ref key + # So sometimes, the schema has an "allOf"/"anyOf"/"oneOf" with 1 item. + keys = {"allOf", "anyOf", "oneOf"} + one_key = next((k for k in keys if k in obj and len(obj[k]) == 1), None) + if one_key: + obj.update(obj[one_key][0]) + + return { + key: ref_to_dict(value) + for key, value in obj.items() + if not key.startswith("$") and key != one_key + } + elif isinstance(obj, list): + return [ref_to_dict(item) for item in obj] + + return obj + + cls.cached_jsonschema = cast(dict[str, Any], ref_to_dict(model)) + + return cls.cached_jsonschema + + @classmethod + def validate_data(cls, data: BlockInput) -> str | None: + return json.validate_with_jsonschema(schema=cls.jsonschema(), data=data) + + @classmethod + def validate_field(cls, field_name: str, data: BlockInput) -> str | None: + """ + Validate the data against a specific property (one of the input/output name). + Returns the validation error message if the data does not match the schema. + """ + model_schema = cls.jsonschema().get("properties", {}) + if not model_schema: + return f"Invalid model schema {cls}" + + property_schema = model_schema.get(field_name) + if not property_schema: + return f"Invalid property name {field_name}" + + try: + jsonschema.validate(json.to_dict(data), property_schema) + return None + except jsonschema.ValidationError as e: + return str(e) + + @classmethod + def get_fields(cls) -> set[str]: + return set(cls.model_fields.keys()) + + @classmethod + def get_required_fields(cls) -> set[str]: + return { + field + for field, field_info in cls.model_fields.items() + if field_info.is_required() + } + + @classmethod + def __pydantic_init_subclass__(cls, **kwargs): + """Validates the schema definition. Rules: + - Fields with annotation `CredentialsMetaInput` MUST be + named `credentials` or `*_credentials` + - Fields named `credentials` or `*_credentials` MUST be + of type `CredentialsMetaInput` + """ + super().__pydantic_init_subclass__(**kwargs) + + # Reset cached JSON schema to prevent inheriting it from parent class + cls.cached_jsonschema = {} + + credentials_fields = cls.get_credentials_fields() + + for field_name in cls.get_fields(): + if is_credentials_field_name(field_name): + if field_name not in credentials_fields: + raise TypeError( + f"Credentials field '{field_name}' on {cls.__qualname__} " + f"is not of type {CredentialsMetaInput.__name__}" + ) + + credentials_fields[field_name].validate_credentials_field_schema(cls) + + elif field_name in credentials_fields: + raise KeyError( + f"Credentials field '{field_name}' on {cls.__qualname__} " + "has invalid name: must be 'credentials' or *_credentials" + ) + + @classmethod + def get_credentials_fields(cls) -> dict[str, type[CredentialsMetaInput]]: + return { + field_name: info.annotation + for field_name, info in cls.model_fields.items() + if ( + inspect.isclass(info.annotation) + and issubclass( + get_origin(info.annotation) or info.annotation, + CredentialsMetaInput, + ) + ) + } + + +BlockSchemaInputType = TypeVar("BlockSchemaInputType", bound=BlockSchema) +BlockSchemaOutputType = TypeVar("BlockSchemaOutputType", bound=BlockSchema) + + +class EmptySchema(BlockSchema): + pass + + +# --8<-- [start:BlockWebhookConfig] +class BlockManualWebhookConfig(BaseModel): + """ + Configuration model for webhook-triggered blocks on which + the user has to manually set up the webhook at the provider. + """ + + provider: str + """The service provider that the webhook connects to""" + + webhook_type: str + """ + Identifier for the webhook type. E.g. GitHub has repo and organization level hooks. + + Only for use in the corresponding `WebhooksManager`. + """ + + event_filter_input: str = "" + """ + Name of the block's event filter input. + Leave empty if the corresponding webhook doesn't have distinct event/payload types. + """ + + event_format: str = "{event}" + """ + Template string for the event(s) that a block instance subscribes to. + Applied individually to each event selected in the event filter input. + + Example: `"pull_request.{event}"` -> `"pull_request.opened"` + """ + + +class BlockWebhookConfig(BlockManualWebhookConfig): + """ + Configuration model for webhook-triggered blocks for which + the webhook can be automatically set up through the provider's API. + """ + + resource_format: str + """ + Template string for the resource that a block instance subscribes to. + Fields will be filled from the block's inputs (except `payload`). + + Example: `f"{repo}/pull_requests"` (note: not how it's actually implemented) + + Only for use in the corresponding `WebhooksManager`. + """ + # --8<-- [end:BlockWebhookConfig] + + +class Block(ABC, Generic[BlockSchemaInputType, BlockSchemaOutputType]): + def __init__( + self, + id: str = "", + description: str = "", + contributors: list[ContributorDetails] = [], + categories: set[BlockCategory] | None = None, + input_schema: Type[BlockSchemaInputType] = EmptySchema, + output_schema: Type[BlockSchemaOutputType] = EmptySchema, + test_input: BlockInput | list[BlockInput] | None = None, + test_output: BlockData | list[BlockData] | None = None, + test_mock: dict[str, Any] | None = None, + test_credentials: Optional[Credentials | dict[str, Credentials]] = None, + disabled: bool = False, + static_output: bool = False, + block_type: BlockType = BlockType.STANDARD, + webhook_config: Optional[BlockWebhookConfig | BlockManualWebhookConfig] = None, + ): + """ + Initialize the block with the given schema. + + Args: + id: The unique identifier for the block, this value will be persisted in the + DB. So it should be a unique and constant across the application run. + Use the UUID format for the ID. + description: The description of the block, explaining what the block does. + contributors: The list of contributors who contributed to the block. + input_schema: The schema, defined as a Pydantic model, for the input data. + output_schema: The schema, defined as a Pydantic model, for the output data. + test_input: The list or single sample input data for the block, for testing. + test_output: The list or single expected output if the test_input is run. + test_mock: function names on the block implementation to mock on test run. + disabled: If the block is disabled, it will not be available for execution. + static_output: Whether the output links of the block are static by default. + """ + self.id = id + self.input_schema = input_schema + self.output_schema = output_schema + self.test_input = test_input + self.test_output = test_output + self.test_mock = test_mock + self.test_credentials = test_credentials + self.description = description + self.categories = categories or set() + self.contributors = contributors or set() + self.disabled = disabled + self.static_output = static_output + self.block_type = block_type + self.webhook_config = webhook_config + self.execution_stats = {} + + if self.webhook_config: + if isinstance(self.webhook_config, BlockWebhookConfig): + # Enforce presence of credentials field on auto-setup webhook blocks + if not (cred_fields := self.input_schema.get_credentials_fields()): + raise TypeError( + "credentials field is required on auto-setup webhook blocks" + ) + # Disallow multiple credentials inputs on webhook blocks + elif len(cred_fields) > 1: + raise ValueError( + "Multiple credentials inputs not supported on webhook blocks" + ) + + self.block_type = BlockType.WEBHOOK + else: + self.block_type = BlockType.WEBHOOK_MANUAL + + # Enforce shape of webhook event filter, if present + if self.webhook_config.event_filter_input: + event_filter_field = self.input_schema.model_fields[ + self.webhook_config.event_filter_input + ] + if not ( + isinstance(event_filter_field.annotation, type) + and issubclass(event_filter_field.annotation, BaseModel) + and all( + field.annotation is bool + for field in event_filter_field.annotation.model_fields.values() + ) + ): + raise NotImplementedError( + f"{self.name} has an invalid webhook event selector: " + "field must be a BaseModel and all its fields must be boolean" + ) + + # Enforce presence of 'payload' input + if "payload" not in self.input_schema.model_fields: + raise TypeError( + f"{self.name} is webhook-triggered but has no 'payload' input" + ) + + # Disable webhook-triggered block if webhook functionality not available + if not app_config.platform_base_url: + self.disabled = True + + @classmethod + def create(cls: Type["Block"]) -> "Block": + return cls() + + @abstractmethod + def run(self, input_data: BlockSchemaInputType, **kwargs) -> BlockOutput: + """ + Run the block with the given input data. + Args: + input_data: The input data with the structure of input_schema. + Returns: + A Generator that yields (output_name, output_data). + output_name: One of the output name defined in Block's output_schema. + output_data: The data for the output_name, matching the defined schema. + """ + pass + + def run_once(self, input_data: BlockSchemaInputType, output: str, **kwargs) -> Any: + for name, data in self.run(input_data, **kwargs): + if name == output: + return data + raise ValueError(f"{self.name} did not produce any output for {output}") + + def merge_stats(self, stats: dict[str, Any]) -> dict[str, Any]: + for key, value in stats.items(): + if isinstance(value, dict): + self.execution_stats.setdefault(key, {}).update(value) + elif isinstance(value, (int, float)): + self.execution_stats.setdefault(key, 0) + self.execution_stats[key] += value + elif isinstance(value, list): + self.execution_stats.setdefault(key, []) + self.execution_stats[key].extend(value) + else: + self.execution_stats[key] = value + return self.execution_stats + + @property + def name(self): + return self.__class__.__name__ + + def to_dict(self): + return { + "id": self.id, + "name": self.name, + "inputSchema": self.input_schema.jsonschema(), + "outputSchema": self.output_schema.jsonschema(), + "description": self.description, + "categories": [category.dict() for category in self.categories], + "contributors": [ + contributor.model_dump() for contributor in self.contributors + ], + "staticOutput": self.static_output, + "uiType": self.block_type.value, + } + + def execute(self, input_data: BlockInput, **kwargs) -> BlockOutput: + # Merge the input data with the extra execution arguments, preferring the args for security + if error := self.input_schema.validate_data(input_data): + raise ValueError( + f"Unable to execute block with invalid input data: {error}" + ) + + for output_name, output_data in self.run( + self.input_schema(**input_data), **kwargs + ): + if output_name == "error": + raise RuntimeError(output_data) + if self.block_type == BlockType.STANDARD and ( + error := self.output_schema.validate_field(output_name, output_data) + ): + raise ValueError(f"Block produced an invalid output data: {error}") + yield output_name, output_data + + +# ======================= Block Helper Functions ======================= # + + +def get_blocks() -> dict[str, Type[Block]]: + from backend.blocks import AVAILABLE_BLOCKS # noqa: E402 + + return AVAILABLE_BLOCKS + + +async def initialize_blocks() -> None: + for cls in get_blocks().values(): + block = cls() + existing_block = await AgentBlock.prisma().find_first( + where={"OR": [{"id": block.id}, {"name": block.name}]} + ) + if not existing_block: + await AgentBlock.prisma().create( + data={ + "id": block.id, + "name": block.name, + "inputSchema": json.dumps(block.input_schema.jsonschema()), + "outputSchema": json.dumps(block.output_schema.jsonschema()), + } + ) + continue + + input_schema = json.dumps(block.input_schema.jsonschema()) + output_schema = json.dumps(block.output_schema.jsonschema()) + if ( + block.id != existing_block.id + or block.name != existing_block.name + or input_schema != existing_block.inputSchema + or output_schema != existing_block.outputSchema + ): + await AgentBlock.prisma().update( + where={"id": existing_block.id}, + data={ + "id": block.id, + "name": block.name, + "inputSchema": input_schema, + "outputSchema": output_schema, + }, + ) + + +def get_block(block_id: str) -> Block | None: + cls = get_blocks().get(block_id) + return cls() if cls else None diff --git a/autogpt_platform/backend/backend/data/block_cost_config.py b/autogpt_platform/backend/backend/data/block_cost_config.py new file mode 100644 index 000000000000..8209a2d95a9f --- /dev/null +++ b/autogpt_platform/backend/backend/data/block_cost_config.py @@ -0,0 +1,265 @@ +from typing import Type + +from backend.blocks.ai_music_generator import AIMusicGeneratorBlock +from backend.blocks.ai_shortform_video_block import AIShortformVideoCreatorBlock +from backend.blocks.ideogram import IdeogramModelBlock +from backend.blocks.jina.embeddings import JinaEmbeddingBlock +from backend.blocks.jina.search import ExtractWebsiteContentBlock, SearchTheWebBlock +from backend.blocks.llm import ( + MODEL_METADATA, + AIConversationBlock, + AIListGeneratorBlock, + AIStructuredResponseGeneratorBlock, + AITextGeneratorBlock, + AITextSummarizerBlock, + LlmModel, +) +from backend.blocks.replicate_flux_advanced import ReplicateFluxAdvancedModelBlock +from backend.blocks.talking_head import CreateTalkingAvatarVideoBlock +from backend.blocks.text_to_speech_block import UnrealTextToSpeechBlock +from backend.data.block import Block +from backend.data.cost import BlockCost, BlockCostType +from backend.integrations.credentials_store import ( + anthropic_credentials, + did_credentials, + groq_credentials, + ideogram_credentials, + jina_credentials, + open_router_credentials, + openai_credentials, + replicate_credentials, + revid_credentials, + unreal_credentials, +) + +# =============== Configure the cost for each LLM Model call =============== # + +MODEL_COST: dict[LlmModel, int] = { + LlmModel.O1_PREVIEW: 16, + LlmModel.O1_MINI: 4, + LlmModel.GPT4O_MINI: 1, + LlmModel.GPT4O: 3, + LlmModel.GPT4_TURBO: 10, + LlmModel.GPT3_5_TURBO: 1, + LlmModel.CLAUDE_3_5_SONNET: 4, + LlmModel.CLAUDE_3_HAIKU: 1, + LlmModel.LLAMA3_8B: 1, + LlmModel.LLAMA3_70B: 1, + LlmModel.MIXTRAL_8X7B: 1, + LlmModel.GEMMA_7B: 1, + LlmModel.GEMMA2_9B: 1, + LlmModel.LLAMA3_1_405B: 1, + LlmModel.LLAMA3_1_70B: 1, + LlmModel.LLAMA3_1_8B: 1, + LlmModel.OLLAMA_LLAMA3_2: 1, + LlmModel.OLLAMA_LLAMA3_8B: 1, + LlmModel.OLLAMA_LLAMA3_405B: 1, + LlmModel.OLLAMA_DOLPHIN: 1, + LlmModel.GEMINI_FLASH_1_5_8B: 1, + LlmModel.GROK_BETA: 5, + LlmModel.MISTRAL_NEMO: 1, + LlmModel.COHERE_COMMAND_R_08_2024: 1, + LlmModel.COHERE_COMMAND_R_PLUS_08_2024: 3, + LlmModel.EVA_QWEN_2_5_32B: 1, + LlmModel.DEEPSEEK_CHAT: 2, + LlmModel.PERPLEXITY_LLAMA_3_1_SONAR_LARGE_128K_ONLINE: 1, + LlmModel.QWEN_QWQ_32B_PREVIEW: 2, + LlmModel.NOUSRESEARCH_HERMES_3_LLAMA_3_1_405B: 1, + LlmModel.NOUSRESEARCH_HERMES_3_LLAMA_3_1_70B: 1, + LlmModel.AMAZON_NOVA_LITE_V1: 1, + LlmModel.AMAZON_NOVA_MICRO_V1: 1, + LlmModel.AMAZON_NOVA_PRO_V1: 1, + LlmModel.MICROSOFT_WIZARDLM_2_8X22B: 1, + LlmModel.GRYPHE_MYTHOMAX_L2_13B: 1, +} + +for model in LlmModel: + if model not in MODEL_COST: + raise ValueError(f"Missing MODEL_COST for model: {model}") + + +LLM_COST = ( + # Anthropic Models + [ + BlockCost( + cost_type=BlockCostType.RUN, + cost_filter={ + "model": model, + "credentials": { + "id": anthropic_credentials.id, + "provider": anthropic_credentials.provider, + "type": anthropic_credentials.type, + }, + }, + cost_amount=cost, + ) + for model, cost in MODEL_COST.items() + if MODEL_METADATA[model].provider == "anthropic" + ] + # OpenAI Models + + [ + BlockCost( + cost_type=BlockCostType.RUN, + cost_filter={ + "model": model, + "credentials": { + "id": openai_credentials.id, + "provider": openai_credentials.provider, + "type": openai_credentials.type, + }, + }, + cost_amount=cost, + ) + for model, cost in MODEL_COST.items() + if MODEL_METADATA[model].provider == "openai" + ] + # Groq Models + + [ + BlockCost( + cost_type=BlockCostType.RUN, + cost_filter={ + "model": model, + "credentials": {"id": groq_credentials.id}, + }, + cost_amount=cost, + ) + for model, cost in MODEL_COST.items() + if MODEL_METADATA[model].provider == "groq" + ] + # Open Router Models + + [ + BlockCost( + cost_type=BlockCostType.RUN, + cost_filter={ + "model": model, + "credentials": { + "id": open_router_credentials.id, + "provider": open_router_credentials.provider, + "type": open_router_credentials.type, + }, + }, + cost_amount=cost, + ) + for model, cost in MODEL_COST.items() + if MODEL_METADATA[model].provider == "open_router" + ] +) + +# =============== This is the exhaustive list of cost for each Block =============== # + +BLOCK_COSTS: dict[Type[Block], list[BlockCost]] = { + AIConversationBlock: LLM_COST, + AITextGeneratorBlock: LLM_COST, + AIStructuredResponseGeneratorBlock: LLM_COST, + AITextSummarizerBlock: LLM_COST, + AIListGeneratorBlock: LLM_COST, + CreateTalkingAvatarVideoBlock: [ + BlockCost( + cost_amount=15, + cost_filter={ + "credentials": { + "id": did_credentials.id, + "provider": did_credentials.provider, + "type": did_credentials.type, + } + }, + ) + ], + SearchTheWebBlock: [ + BlockCost( + cost_amount=1, + cost_filter={ + "credentials": { + "id": jina_credentials.id, + "provider": jina_credentials.provider, + "type": jina_credentials.type, + } + }, + ) + ], + ExtractWebsiteContentBlock: [ + BlockCost( + cost_amount=1, + cost_filter={ + "raw_content": False, + "credentials": { + "id": jina_credentials.id, + "provider": jina_credentials.provider, + "type": jina_credentials.type, + }, + }, + ) + ], + IdeogramModelBlock: [ + BlockCost( + cost_amount=16, + cost_filter={ + "credentials": { + "id": ideogram_credentials.id, + "provider": ideogram_credentials.provider, + "type": ideogram_credentials.type, + } + }, + ) + ], + AIShortformVideoCreatorBlock: [ + BlockCost( + cost_amount=50, + cost_filter={ + "credentials": { + "id": revid_credentials.id, + "provider": revid_credentials.provider, + "type": revid_credentials.type, + } + }, + ) + ], + ReplicateFluxAdvancedModelBlock: [ + BlockCost( + cost_amount=10, + cost_filter={ + "credentials": { + "id": replicate_credentials.id, + "provider": replicate_credentials.provider, + "type": replicate_credentials.type, + } + }, + ) + ], + AIMusicGeneratorBlock: [ + BlockCost( + cost_amount=11, + cost_filter={ + "credentials": { + "id": replicate_credentials.id, + "provider": replicate_credentials.provider, + "type": replicate_credentials.type, + } + }, + ) + ], + JinaEmbeddingBlock: [ + BlockCost( + cost_amount=12, + cost_filter={ + "credentials": { + "id": jina_credentials.id, + "provider": jina_credentials.provider, + "type": jina_credentials.type, + } + }, + ) + ], + UnrealTextToSpeechBlock: [ + BlockCost( + cost_amount=5, + cost_filter={ + "credentials": { + "id": unreal_credentials.id, + "provider": unreal_credentials.provider, + "type": unreal_credentials.type, + } + }, + ) + ], +} diff --git a/autogpt_platform/backend/backend/data/cost.py b/autogpt_platform/backend/backend/data/cost.py new file mode 100644 index 000000000000..3e3e9bae65aa --- /dev/null +++ b/autogpt_platform/backend/backend/data/cost.py @@ -0,0 +1,33 @@ +from enum import Enum +from typing import Any, Optional + +from pydantic import BaseModel + +from backend.data.block import BlockInput + + +class BlockCostType(str, Enum): + RUN = "run" # cost X credits per run + BYTE = "byte" # cost X credits per byte + SECOND = "second" # cost X credits per second + DOLLAR = "dollar" # cost X dollars per run + + +class BlockCost(BaseModel): + cost_amount: int + cost_filter: BlockInput + cost_type: BlockCostType + + def __init__( + self, + cost_amount: int, + cost_type: BlockCostType = BlockCostType.RUN, + cost_filter: Optional[BlockInput] = None, + **data: Any, + ) -> None: + super().__init__( + cost_amount=cost_amount, + cost_filter=cost_filter or {}, + cost_type=cost_type, + **data, + ) diff --git a/autogpt_platform/backend/backend/data/credit.py b/autogpt_platform/backend/backend/data/credit.py new file mode 100644 index 000000000000..5feb5f929221 --- /dev/null +++ b/autogpt_platform/backend/backend/data/credit.py @@ -0,0 +1,537 @@ +import logging +from abc import ABC, abstractmethod +from datetime import datetime, timezone + +import stripe +from prisma import Json +from prisma.enums import CreditTransactionType +from prisma.errors import UniqueViolationError +from prisma.models import CreditTransaction, User +from prisma.types import CreditTransactionCreateInput, CreditTransactionWhereInput + +from backend.data import db +from backend.data.block import Block, BlockInput, get_block +from backend.data.block_cost_config import BLOCK_COSTS +from backend.data.cost import BlockCost, BlockCostType +from backend.data.execution import NodeExecutionEntry +from backend.data.model import AutoTopUpConfig +from backend.data.user import get_user_by_id +from backend.util.settings import Settings + +settings = Settings() +stripe.api_key = settings.secrets.stripe_api_key +logger = logging.getLogger(__name__) + + +class UserCreditBase(ABC): + @abstractmethod + async def get_credits(self, user_id: str) -> int: + """ + Get the current credits for the user. + + Returns: + int: The current credits for the user. + """ + pass + + @abstractmethod + async def spend_credits( + self, + entry: NodeExecutionEntry, + data_size: float, + run_time: float, + ) -> int: + """ + Spend the credits for the user based on the block usage. + + Args: + entry (NodeExecutionEntry): The node execution identifiers & data. + data_size (float): The size of the data being processed. + run_time (float): The time taken to run the block. + + Returns: + int: amount of credit spent + """ + pass + + @abstractmethod + async def top_up_credits(self, user_id: str, amount: int): + """ + Top up the credits for the user immediately. + + Args: + user_id (str): The user ID. + amount (int): The amount to top up. + """ + pass + + @abstractmethod + async def top_up_intent(self, user_id: str, amount: int) -> str: + """ + Create a payment intent to top up the credits for the user. + + Args: + user_id (str): The user ID. + amount (int): The amount of credits to top up. + + Returns: + str: The redirect url to the payment page. + """ + pass + + @abstractmethod + async def fulfill_checkout( + self, *, session_id: str | None = None, user_id: str | None = None + ): + """ + Fulfill the Stripe checkout session. + + Args: + session_id (str | None): The checkout session ID. Will try to fulfill most recent if None. + user_id (str | None): The user ID must be provided if session_id is None. + """ + pass + + @staticmethod + def time_now() -> datetime: + return datetime.now(timezone.utc) + + # ====== Transaction Helper Methods ====== # + # Any modifications to the transaction table should only be done through these methods # + + async def _get_credits(self, user_id: str) -> tuple[int, datetime]: + """ + Returns the current balance of the user & the latest balance snapshot time. + """ + top_time = self.time_now() + snapshot = await CreditTransaction.prisma().find_first( + where={ + "userId": user_id, + "createdAt": {"lte": top_time}, + "isActive": True, + "runningBalance": {"not": None}, # type: ignore + }, + order={"createdAt": "desc"}, + ) + datetime_min = datetime.min.replace(tzinfo=timezone.utc) + snapshot_balance = snapshot.runningBalance or 0 if snapshot else 0 + snapshot_time = snapshot.createdAt if snapshot else datetime_min + + # Get transactions after the snapshot, this should not exist, but just in case. + transactions = await CreditTransaction.prisma().group_by( + by=["userId"], + sum={"amount": True}, + max={"createdAt": True}, + where={ + "userId": user_id, + "createdAt": { + "gt": snapshot_time, + "lte": top_time, + }, + "isActive": True, + }, + ) + transaction_balance = ( + int(transactions[0].get("_sum", {}).get("amount", 0) + snapshot_balance) + if transactions + else snapshot_balance + ) + transaction_time = ( + datetime.fromisoformat( + str(transactions[0].get("_max", {}).get("createdAt", datetime_min)) + ) + if transactions + else snapshot_time + ) + return transaction_balance, transaction_time + + async def _enable_transaction( + self, transaction_key: str, user_id: str, metadata: Json + ): + + transaction = await CreditTransaction.prisma().find_first_or_raise( + where={"transactionKey": transaction_key, "userId": user_id} + ) + + if transaction.isActive: + return + + async with db.locked_transaction(f"usr_trx_{user_id}"): + user_balance, _ = await self._get_credits(user_id) + await CreditTransaction.prisma().update( + where={ + "creditTransactionIdentifier": { + "transactionKey": transaction_key, + "userId": user_id, + } + }, + data={ + "isActive": True, + "runningBalance": user_balance + transaction.amount, + "createdAt": self.time_now(), + "metadata": metadata, + }, + ) + + async def _add_transaction( + self, + user_id: str, + amount: int, + transaction_type: CreditTransactionType, + is_active: bool = True, + transaction_key: str | None = None, + metadata: Json = Json({}), + ) -> int: + async with db.locked_transaction(f"usr_trx_{user_id}"): + # Get latest balance snapshot + user_balance, _ = await self._get_credits(user_id) + + if amount < 0 and user_balance < abs(amount): + raise ValueError( + f"Insufficient balance for user {user_id}, balance: {user_balance}, amount: {amount}" + ) + + # Create the transaction + transaction_data: CreditTransactionCreateInput = { + "userId": user_id, + "amount": amount, + "runningBalance": user_balance + amount, + "type": transaction_type, + "metadata": metadata, + "isActive": is_active, + "createdAt": self.time_now(), + } + if transaction_key: + transaction_data["transactionKey"] = transaction_key + await CreditTransaction.prisma().create(data=transaction_data) + + return user_balance + amount + + +class UserCredit(UserCreditBase): + + def _block_usage_cost( + self, + block: Block, + input_data: BlockInput, + data_size: float, + run_time: float, + ) -> tuple[int, BlockInput]: + block_costs = BLOCK_COSTS.get(type(block)) + if not block_costs: + return 0, {} + + for block_cost in block_costs: + if not self._is_cost_filter_match(block_cost.cost_filter, input_data): + continue + + if block_cost.cost_type == BlockCostType.RUN: + return block_cost.cost_amount, block_cost.cost_filter + + if block_cost.cost_type == BlockCostType.SECOND: + return ( + int(run_time * block_cost.cost_amount), + block_cost.cost_filter, + ) + + if block_cost.cost_type == BlockCostType.BYTE: + return ( + int(data_size * block_cost.cost_amount), + block_cost.cost_filter, + ) + + return 0, {} + + def _is_cost_filter_match( + self, cost_filter: BlockInput, input_data: BlockInput + ) -> bool: + """ + Filter rules: + - If cost_filter is an object, then check if cost_filter is the subset of input_data + - Otherwise, check if cost_filter is equal to input_data. + - Undefined, null, and empty string are considered as equal. + """ + if not isinstance(cost_filter, dict) or not isinstance(input_data, dict): + return cost_filter == input_data + + return all( + (not input_data.get(k) and not v) + or (input_data.get(k) and self._is_cost_filter_match(v, input_data[k])) + for k, v in cost_filter.items() + ) + + async def spend_credits( + self, + entry: NodeExecutionEntry, + data_size: float, + run_time: float, + ) -> int: + block = get_block(entry.block_id) + if not block: + raise ValueError(f"Block not found: {entry.block_id}") + + cost, matching_filter = self._block_usage_cost( + block=block, input_data=entry.data, data_size=data_size, run_time=run_time + ) + if cost == 0: + return 0 + + balance = await self._add_transaction( + user_id=entry.user_id, + amount=-cost, + transaction_type=CreditTransactionType.USAGE, + metadata=Json( + { + "graph_exec_id": entry.graph_exec_id, + "graph_id": entry.graph_id, + "node_id": entry.node_id, + "node_exec_id": entry.node_exec_id, + "block_id": entry.block_id, + "block": block.name, + "input": matching_filter, + } + ), + ) + user_id = entry.user_id + + # Auto top-up if balance just went below threshold due to this transaction. + auto_top_up = await get_auto_top_up(user_id) + if balance < auto_top_up.threshold <= balance - cost: + try: + await self.top_up_credits(user_id=user_id, amount=auto_top_up.amount) + except Exception as e: + # Failed top-up is not critical, we can move on. + logger.error( + f"Auto top-up failed for user {user_id}, balance: {balance}, amount: {auto_top_up.amount}, error: {e}" + ) + + return cost + + async def top_up_credits(self, user_id: str, amount: int): + if amount < 0: + raise ValueError(f"Top up amount must not be negative: {amount}") + + customer_id = await get_stripe_customer_id(user_id) + + payment_methods = stripe.PaymentMethod.list(customer=customer_id, type="card") + if not payment_methods: + raise ValueError("No payment method found, please add it on the platform.") + + for payment_method in payment_methods: + if amount == 0: + setup_intent = stripe.SetupIntent.create( + customer=customer_id, + usage="off_session", + confirm=True, + payment_method=payment_method.id, + automatic_payment_methods={ + "enabled": True, + "allow_redirects": "never", + }, + ) + if setup_intent.status == "succeeded": + return + + else: + payment_intent = stripe.PaymentIntent.create( + amount=amount, + currency="usd", + description="AutoGPT Platform Credits", + customer=customer_id, + off_session=True, + confirm=True, + payment_method=payment_method.id, + automatic_payment_methods={ + "enabled": True, + "allow_redirects": "never", + }, + ) + if payment_intent.status == "succeeded": + await self._add_transaction( + user_id=user_id, + amount=amount, + transaction_type=CreditTransactionType.TOP_UP, + transaction_key=payment_intent.id, + metadata=Json({"payment_intent": payment_intent}), + is_active=True, + ) + return + + raise ValueError( + f"Out of {len(payment_methods)} payment methods tried, none is supported" + ) + + async def top_up_intent(self, user_id: str, amount: int) -> str: + # Create checkout session + # https://docs.stripe.com/checkout/quickstart?client=react + # unit_amount param is always in the smallest currency unit (so cents for usd) + # which is equal to amount of credits + checkout_session = stripe.checkout.Session.create( + customer=await get_stripe_customer_id(user_id), + line_items=[ + { + "price_data": { + "currency": "usd", + "product_data": { + "name": "AutoGPT Platform Credits", + }, + "unit_amount": amount, + }, + "quantity": 1, + } + ], + mode="payment", + payment_intent_data={"setup_future_usage": "off_session"}, + saved_payment_method_options={"payment_method_save": "enabled"}, + success_url=settings.config.platform_base_url + + "/marketplace/credits?topup=success", + cancel_url=settings.config.platform_base_url + + "/marketplace/credits?topup=cancel", + ) + + await self._add_transaction( + user_id=user_id, + amount=amount, + transaction_type=CreditTransactionType.TOP_UP, + transaction_key=checkout_session.id, + is_active=False, + metadata=Json({"checkout_session": checkout_session}), + ) + + return checkout_session.url or "" + + # https://docs.stripe.com/checkout/fulfillment + async def fulfill_checkout( + self, *, session_id: str | None = None, user_id: str | None = None + ): + if (not session_id and not user_id) or (session_id and user_id): + raise ValueError("Either session_id or user_id must be provided") + + # Retrieve CreditTransaction + find_filter: CreditTransactionWhereInput = { + "type": CreditTransactionType.TOP_UP, + "isActive": False, + } + if session_id: + find_filter["transactionKey"] = session_id + if user_id: + find_filter["userId"] = user_id + + # Find the most recent inactive top-up transaction + credit_transaction = await CreditTransaction.prisma().find_first( + where=find_filter, + order={"createdAt": "desc"}, + ) + + # This can be called multiple times for one id, so ignore if already fulfilled + if not credit_transaction: + return + + # Retrieve the Checkout Session from the API + checkout_session = stripe.checkout.Session.retrieve( + credit_transaction.transactionKey + ) + + # Check the Checkout Session's payment_status property + # to determine if fulfillment should be performed + if checkout_session.payment_status in ["paid", "no_payment_required"]: + await self._enable_transaction( + transaction_key=credit_transaction.transactionKey, + user_id=credit_transaction.userId, + metadata=Json({"checkout_session": checkout_session}), + ) + + async def get_credits(self, user_id: str) -> int: + balance, _ = await self._get_credits(user_id) + return balance + + +class BetaUserCredit(UserCredit): + """ + This is a temporary class to handle the test user utilizing monthly credit refill. + TODO: Remove this class & its feature toggle. + """ + + def __init__(self, num_user_credits_refill: int): + self.num_user_credits_refill = num_user_credits_refill + + async def get_credits(self, user_id: str) -> int: + cur_time = self.time_now().date() + balance, snapshot_time = await self._get_credits(user_id) + if (snapshot_time.year, snapshot_time.month) == (cur_time.year, cur_time.month): + return balance + + try: + return await self._add_transaction( + user_id=user_id, + amount=max(self.num_user_credits_refill - balance, 0), + transaction_type=CreditTransactionType.TOP_UP, + transaction_key=f"MONTHLY-CREDIT-TOP-UP-{cur_time}", + ) + except UniqueViolationError: + # Already refilled this month + return (await self._get_credits(user_id))[0] + + +class DisabledUserCredit(UserCreditBase): + async def get_credits(self, *args, **kwargs) -> int: + return 0 + + async def spend_credits(self, *args, **kwargs) -> int: + return 0 + + async def top_up_credits(self, *args, **kwargs): + pass + + async def top_up_intent(self, *args, **kwargs) -> str: + return "" + + async def fulfill_checkout(self, *args, **kwargs): + pass + + +def get_user_credit_model() -> UserCreditBase: + if not settings.config.enable_credit: + return DisabledUserCredit() + + if settings.config.enable_beta_monthly_credit: + return BetaUserCredit(settings.config.num_user_credits_refill) + + return UserCredit() + + +def get_block_costs() -> dict[str, list[BlockCost]]: + return {block().id: costs for block, costs in BLOCK_COSTS.items()} + + +async def get_stripe_customer_id(user_id: str) -> str: + user = await get_user_by_id(user_id) + if not user: + raise ValueError(f"User not found: {user_id}") + + if user.stripeCustomerId: + return user.stripeCustomerId + + customer = stripe.Customer.create(name=user.name or "", email=user.email) + await User.prisma().update( + where={"id": user_id}, data={"stripeCustomerId": customer.id} + ) + return customer.id + + +async def set_auto_top_up(user_id: str, config: AutoTopUpConfig): + await User.prisma().update( + where={"id": user_id}, + data={"topUpConfig": Json(config.model_dump())}, + ) + + +async def get_auto_top_up(user_id: str) -> AutoTopUpConfig: + user = await get_user_by_id(user_id) + if not user: + raise ValueError("Invalid user ID") + + if not user.topUpConfig: + return AutoTopUpConfig(threshold=0, amount=0) + + return AutoTopUpConfig.model_validate(user.topUpConfig) diff --git a/autogpt_platform/backend/backend/data/db.py b/autogpt_platform/backend/backend/data/db.py new file mode 100644 index 000000000000..66d4f167ada9 --- /dev/null +++ b/autogpt_platform/backend/backend/data/db.py @@ -0,0 +1,72 @@ +import logging +import os +import zlib +from contextlib import asynccontextmanager +from uuid import uuid4 + +from dotenv import load_dotenv +from prisma import Prisma +from pydantic import BaseModel, Field, field_validator + +from backend.util.retry import conn_retry + +load_dotenv() + +PRISMA_SCHEMA = os.getenv("PRISMA_SCHEMA", "schema.prisma") +os.environ["PRISMA_SCHEMA_PATH"] = PRISMA_SCHEMA + +prisma = Prisma(auto_register=True) + +logger = logging.getLogger(__name__) + + +@conn_retry("Prisma", "Acquiring connection") +async def connect(): + if prisma.is_connected(): + return + + await prisma.connect() + + if not prisma.is_connected(): + raise ConnectionError("Failed to connect to Prisma.") + + # Connection acquired from a pool like Supabase somehow still possibly allows + # the db client obtains a connection but still reject query connection afterward. + try: + await prisma.execute_raw("SELECT 1") + except Exception as e: + raise ConnectionError("Failed to connect to Prisma.") from e + + +@conn_retry("Prisma", "Releasing connection") +async def disconnect(): + if not prisma.is_connected(): + return + + await prisma.disconnect() + + if prisma.is_connected(): + raise ConnectionError("Failed to disconnect from Prisma.") + + +@asynccontextmanager +async def transaction(): + async with prisma.tx() as tx: + yield tx + + +@asynccontextmanager +async def locked_transaction(key: str): + lock_key = zlib.crc32(key.encode("utf-8")) + async with transaction() as tx: + await tx.execute_raw(f"SELECT pg_advisory_xact_lock({lock_key})") + yield tx + + +class BaseDbModel(BaseModel): + id: str = Field(default_factory=lambda: str(uuid4())) + + @field_validator("id", mode="before") + def set_model_id(cls, id: str) -> str: + # In case an empty ID is submitted + return id or str(uuid4()) diff --git a/autogpt_platform/backend/backend/data/execution.py b/autogpt_platform/backend/backend/data/execution.py new file mode 100644 index 000000000000..714ea0f51c6c --- /dev/null +++ b/autogpt_platform/backend/backend/data/execution.py @@ -0,0 +1,510 @@ +from collections import defaultdict +from datetime import datetime, timezone +from multiprocessing import Manager +from typing import Any, AsyncGenerator, Generator, Generic, Optional, TypeVar + +from prisma.enums import AgentExecutionStatus +from prisma.errors import PrismaError +from prisma.models import ( + AgentGraphExecution, + AgentNodeExecution, + AgentNodeExecutionInputOutput, +) +from pydantic import BaseModel + +from backend.data.block import BlockData, BlockInput, CompletedBlockOutput +from backend.data.includes import EXECUTION_RESULT_INCLUDE, GRAPH_EXECUTION_INCLUDE +from backend.data.queue import AsyncRedisEventBus, RedisEventBus +from backend.util import json, mock +from backend.util.settings import Config + + +class GraphExecutionEntry(BaseModel): + user_id: str + graph_exec_id: str + graph_id: str + start_node_execs: list["NodeExecutionEntry"] + + +class NodeExecutionEntry(BaseModel): + user_id: str + graph_exec_id: str + graph_id: str + node_exec_id: str + node_id: str + block_id: str + data: BlockInput + + +ExecutionStatus = AgentExecutionStatus + +T = TypeVar("T") + + +class ExecutionQueue(Generic[T]): + """ + Queue for managing the execution of agents. + This will be shared between different processes + """ + + def __init__(self): + self.queue = Manager().Queue() + + def add(self, execution: T) -> T: + self.queue.put(execution) + return execution + + def get(self) -> T: + return self.queue.get() + + def empty(self) -> bool: + return self.queue.empty() + + +class ExecutionResult(BaseModel): + graph_id: str + graph_version: int + graph_exec_id: str + node_exec_id: str + node_id: str + block_id: str + status: ExecutionStatus + input_data: BlockInput + output_data: CompletedBlockOutput + add_time: datetime + queue_time: datetime | None + start_time: datetime | None + end_time: datetime | None + + @staticmethod + def from_graph(graph: AgentGraphExecution): + return ExecutionResult( + graph_id=graph.agentGraphId, + graph_version=graph.agentGraphVersion, + graph_exec_id=graph.id, + node_exec_id="", + node_id="", + block_id="", + status=graph.executionStatus, + # TODO: Populate input_data & output_data from AgentNodeExecutions + # Input & Output comes AgentInputBlock & AgentOutputBlock. + input_data={}, + output_data={}, + add_time=graph.createdAt, + queue_time=graph.createdAt, + start_time=graph.startedAt, + end_time=graph.updatedAt, + ) + + @staticmethod + def from_db(execution: AgentNodeExecution): + if execution.executionData: + # Execution that has been queued for execution will persist its data. + input_data = json.loads(execution.executionData, target_type=dict[str, Any]) + else: + # For incomplete execution, executionData will not be yet available. + input_data: BlockInput = defaultdict() + for data in execution.Input or []: + input_data[data.name] = json.loads(data.data) + + output_data: CompletedBlockOutput = defaultdict(list) + for data in execution.Output or []: + output_data[data.name].append(json.loads(data.data)) + + graph_execution: AgentGraphExecution | None = execution.AgentGraphExecution + + return ExecutionResult( + graph_id=graph_execution.agentGraphId if graph_execution else "", + graph_version=graph_execution.agentGraphVersion if graph_execution else 0, + graph_exec_id=execution.agentGraphExecutionId, + block_id=execution.AgentNode.agentBlockId if execution.AgentNode else "", + node_exec_id=execution.id, + node_id=execution.agentNodeId, + status=execution.executionStatus, + input_data=input_data, + output_data=output_data, + add_time=execution.addedTime, + queue_time=execution.queuedTime, + start_time=execution.startedTime, + end_time=execution.endedTime, + ) + + +# --------------------- Model functions --------------------- # + + +async def create_graph_execution( + graph_id: str, + graph_version: int, + nodes_input: list[tuple[str, BlockInput]], + user_id: str, +) -> tuple[str, list[ExecutionResult]]: + """ + Create a new AgentGraphExecution record. + Returns: + The id of the AgentGraphExecution and the list of ExecutionResult for each node. + """ + result = await AgentGraphExecution.prisma().create( + data={ + "agentGraphId": graph_id, + "agentGraphVersion": graph_version, + "executionStatus": ExecutionStatus.QUEUED, + "AgentNodeExecutions": { + "create": [ # type: ignore + { + "agentNodeId": node_id, + "executionStatus": ExecutionStatus.INCOMPLETE, + "Input": { + "create": [ + {"name": name, "data": json.dumps(data)} + for name, data in node_input.items() + ] + }, + } + for node_id, node_input in nodes_input + ] + }, + "userId": user_id, + }, + include=GRAPH_EXECUTION_INCLUDE, + ) + + return result.id, [ + ExecutionResult.from_db(execution) + for execution in result.AgentNodeExecutions or [] + ] + + +async def upsert_execution_input( + node_id: str, + graph_exec_id: str, + input_name: str, + input_data: Any, + node_exec_id: str | None = None, +) -> tuple[str, BlockInput]: + """ + Insert AgentNodeExecutionInputOutput record for as one of AgentNodeExecution.Input. + If there is no AgentNodeExecution that has no `input_name` as input, create new one. + + Args: + node_id: The id of the AgentNode. + graph_exec_id: The id of the AgentGraphExecution. + input_name: The name of the input data. + input_data: The input data to be inserted. + node_exec_id: [Optional] The id of the AgentNodeExecution that has no `input_name` as input. If not provided, it will find the eligible incomplete AgentNodeExecution or create a new one. + + Returns: + * The id of the created or existing AgentNodeExecution. + * Dict of node input data, key is the input name, value is the input data. + """ + existing_execution = await AgentNodeExecution.prisma().find_first( + where={ # type: ignore + **({"id": node_exec_id} if node_exec_id else {}), + "agentNodeId": node_id, + "agentGraphExecutionId": graph_exec_id, + "executionStatus": ExecutionStatus.INCOMPLETE, + "Input": {"every": {"name": {"not": input_name}}}, + }, + order={"addedTime": "asc"}, + include={"Input": True}, + ) + json_input_data = json.dumps(input_data) + + if existing_execution: + await AgentNodeExecutionInputOutput.prisma().create( + data={ + "name": input_name, + "data": json_input_data, + "referencedByInputExecId": existing_execution.id, + } + ) + return existing_execution.id, { + **{ + input_data.name: json.loads(input_data.data) + for input_data in existing_execution.Input or [] + }, + input_name: input_data, + } + + elif not node_exec_id: + result = await AgentNodeExecution.prisma().create( + data={ + "agentNodeId": node_id, + "agentGraphExecutionId": graph_exec_id, + "executionStatus": ExecutionStatus.INCOMPLETE, + "Input": {"create": {"name": input_name, "data": json_input_data}}, + } + ) + return result.id, {input_name: input_data} + + else: + raise ValueError( + f"NodeExecution {node_exec_id} not found or already has input {input_name}." + ) + + +async def upsert_execution_output( + node_exec_id: str, + output_name: str, + output_data: Any, +) -> None: + """ + Insert AgentNodeExecutionInputOutput record for as one of AgentNodeExecution.Output. + """ + await AgentNodeExecutionInputOutput.prisma().create( + data={ + "name": output_name, + "data": json.dumps(output_data), + "referencedByOutputExecId": node_exec_id, + } + ) + + +async def update_graph_execution_start_time(graph_exec_id: str): + await AgentGraphExecution.prisma().update( + where={"id": graph_exec_id}, + data={ + "executionStatus": ExecutionStatus.RUNNING, + "startedAt": datetime.now(tz=timezone.utc), + }, + ) + + +async def update_graph_execution_stats( + graph_exec_id: str, + status: ExecutionStatus, + stats: dict[str, Any], +) -> ExecutionResult: + res = await AgentGraphExecution.prisma().update( + where={"id": graph_exec_id}, + data={ + "executionStatus": status, + "stats": json.dumps(stats), + }, + ) + if not res: + raise ValueError(f"Execution {graph_exec_id} not found.") + + return ExecutionResult.from_graph(res) + + +async def update_node_execution_stats(node_exec_id: str, stats: dict[str, Any]): + await AgentNodeExecution.prisma().update( + where={"id": node_exec_id}, + data={"stats": json.dumps(stats)}, + ) + + +async def update_execution_status( + node_exec_id: str, + status: ExecutionStatus, + execution_data: BlockInput | None = None, + stats: dict[str, Any] | None = None, +) -> ExecutionResult: + if status == ExecutionStatus.QUEUED and execution_data is None: + raise ValueError("Execution data must be provided when queuing an execution.") + + now = datetime.now(tz=timezone.utc) + data = { + **({"executionStatus": status}), + **({"queuedTime": now} if status == ExecutionStatus.QUEUED else {}), + **({"startedTime": now} if status == ExecutionStatus.RUNNING else {}), + **({"endedTime": now} if status == ExecutionStatus.FAILED else {}), + **({"endedTime": now} if status == ExecutionStatus.COMPLETED else {}), + **({"executionData": json.dumps(execution_data)} if execution_data else {}), + **({"stats": json.dumps(stats)} if stats else {}), + } + + res = await AgentNodeExecution.prisma().update( + where={"id": node_exec_id}, + data=data, # type: ignore + include=EXECUTION_RESULT_INCLUDE, + ) + if not res: + raise ValueError(f"Execution {node_exec_id} not found.") + + return ExecutionResult.from_db(res) + + +async def get_execution( + execution_id: str, user_id: str +) -> Optional[AgentNodeExecution]: + """ + Get an execution by ID. Returns None if not found. + + Args: + execution_id: The ID of the execution to retrieve + + Returns: + The execution if found, None otherwise + """ + try: + execution = await AgentNodeExecution.prisma().find_unique( + where={ + "id": execution_id, + "userId": user_id, + } + ) + return execution + except PrismaError: + return None + + +async def get_execution_results(graph_exec_id: str) -> list[ExecutionResult]: + executions = await AgentNodeExecution.prisma().find_many( + where={"agentGraphExecutionId": graph_exec_id}, + include=EXECUTION_RESULT_INCLUDE, + order=[ + {"queuedTime": "asc"}, + {"addedTime": "asc"}, # Fallback: Incomplete execs has no queuedTime. + ], + ) + res = [ExecutionResult.from_db(execution) for execution in executions] + return res + + +LIST_SPLIT = "_$_" +DICT_SPLIT = "_#_" +OBJC_SPLIT = "_@_" + + +def parse_execution_output(output: BlockData, name: str) -> Any | None: + # Allow extracting partial output data by name. + output_name, output_data = output + + if name == output_name: + return output_data + + if name.startswith(f"{output_name}{LIST_SPLIT}"): + index = int(name.split(LIST_SPLIT)[1]) + if not isinstance(output_data, list) or len(output_data) <= index: + return None + return output_data[int(name.split(LIST_SPLIT)[1])] + + if name.startswith(f"{output_name}{DICT_SPLIT}"): + index = name.split(DICT_SPLIT)[1] + if not isinstance(output_data, dict) or index not in output_data: + return None + return output_data[index] + + if name.startswith(f"{output_name}{OBJC_SPLIT}"): + index = name.split(OBJC_SPLIT)[1] + if isinstance(output_data, object) and hasattr(output_data, index): + return getattr(output_data, index) + return None + + return None + + +def merge_execution_input(data: BlockInput) -> BlockInput: + """ + Merge all dynamic input pins which described by the following pattern: + -Error Type: {errorType}
} + {errorCode &&Error Code: {errorCode}
} + {errorDescription &&Error Description: {errorDescription}
} ++ We're sorry, but an unexpected error has occurred. Please try + again later or contact support if the issue persists. +
++ {topupStatus === "success" && ( + + Your payment was successful. Your credits will be updated + shortly. You can click the refresh icon 🔄 in case it is not + updated. + + )} + {topupStatus === "cancel" && ( + + Payment failed. Your payment method has not been charged. + + )} +
+ + + + {/* Auto Top-up Form */} + ++ You can manage your cards and see your payment history in the + billing portal. +
++ Select from the list of agents you currently have, or upload from + your local machine. +
+Please log in to view your profile
++ About +
+Loading...
++ Try adjusting your search terms or filters +
++ Hello {user.email} +
+ +You do not have permission to view this page.
+
+ {data.webhook.url}
+
+
+ + (A Webhook URL will be generated when you save the agent) +
+ ))} + {data.inputSchema && + generateInputHandles(data.inputSchema, data.uiType)} ++ by {creatorName} +
+ )} + + {/* Description */} ++ {description} +
+ + {/* Stats Row */} +( + WrappedComponent: React.ComponentType
, + flagKey: string, +) { + return function FeatureFlaggedComponent(props: P) { + const flags = useFlags(); + const router = useRouter(); + const [hasFlagLoaded, setHasFlagLoaded] = useState(false); + + useEffect(() => { + // Only proceed if flags received + if (flags && flagKey in flags) { + setHasFlagLoaded(true); + } + }, [flags]); + + useEffect(() => { + if (hasFlagLoaded && !flags[flagKey]) { + router.push("/404"); + } + }, [hasFlagLoaded, flags, router]); + + // Show loading state until flags loaded + if (!hasFlagLoaded) { + return ( +
+// {agent.description} +//
+//
+ Agent ID: {flow.id}
+
+ Run ID: {execution.execution_id}
+
+ Started:{" "} + {moment(execution.started_at).format("YYYY-MM-DD HH:mm:ss")} +
++ Finished:{" "} + {moment(execution.ended_at).format("YYYY-MM-DD HH:mm:ss")} +
++ Duration (run time):{" "} + {execution.duration.toFixed(1)} ( + {execution.total_run_time.toFixed(1)}) seconds +
++ Total runs: {filteredFlowRuns.length} +
++ Total run time:{" "} + {filteredFlowRuns.reduce( + (total, run) => total + run.total_run_time, + 0, + )}{" "} + seconds +
+ {/*Total cost: €1,23
*/} ++ Agent: {flow ? flow.name : "Unknown"} +
++ Started:{" "} + {moment(data.started_at).format("YYYY-MM-DD HH:mm:ss")} +
++ Duration / run time:{" "} + {formatDuration(data.duration)} /{" "} + {formatDuration(data.total_run_time)} +
+