reportify-sdk 0.2.8__tar.gz → 0.2.9__tar.gz

{reportify_sdk-0.2.8/reportify_sdk.egg-info → reportify_sdk-0.2.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: reportify-sdk
-Version: 0.2.8
+Version: 0.2.9
 Summary: Python SDK for Reportify API - Financial data and document search
 Author-email: Reportify <support@reportify.cn>
 License-Expression: MIT

{reportify_sdk-0.2.8 → reportify_sdk-0.2.9}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "reportify-sdk"
-version = "0.2.8"
+version = "0.2.9"
 description = "Python SDK for Reportify API - Financial data and document search"
 readme = "README.md"
 license = "MIT"

{reportify_sdk-0.2.8 → reportify_sdk-0.2.9}/reportify_sdk/__init__.py

@@ -20,7 +20,7 @@ from reportify_sdk.exceptions import (
     APIError,
 )
 
-__version__ = "0.1.0"
+__version__ = "0.2.9"
 __all__ = [
     "Reportify",
     "ReportifyError",

reportify_sdk-0.2.9/reportify_sdk/agent.py

@@ -0,0 +1,213 @@
+"""
+Agent Module
+
+Provides access to AI agent conversations and workflow execution.
+"""
+
+from typing import TYPE_CHECKING, Any, Iterator
+
+if TYPE_CHECKING:
+    from reportify_sdk.client import Reportify
+
+
+class AgentModule:
+    """
+    Agent module for AI-powered conversations and workflows
+
+    Access through the main client:
+        >>> client = Reportify(api_key="xxx")
+        >>> conv = client.agent.create_conversation(agent_id=11887655289749510)
+    """
+
+    def __init__(self, client: "Reportify"):
+        self._client = client
+
+    def _get(self, path: str, params: dict[str, Any] | None = None) -> dict[str, Any]:
+        return self._client._get(path, params=params)
+
+    def _post(self, path: str, json: dict[str, Any] | None = None) -> dict[str, Any]:
+        return self._client._post(path, json=json)
+
+    def create_conversation(
+        self,
+        agent_id: int,
+        *,
+        title: str | None = None,
+    ) -> dict[str, Any]:
+        """
+        Create a new agent conversation
+
+        Args:
+            agent_id: Agent ID
+            title: Conversation title (optional)
+
+        Returns:
+            Conversation details including id, user_id, agent_id, type, status, etc.
+
+        Example:
+            >>> conv = client.agent.create_conversation(
+            ...     agent_id=11887655289749510,
+            ...     title="NVIDIA analysis"
+            ... )
+            >>> print(conv["id"])
+        """
+        data: dict[str, Any] = {"agent_id": agent_id}
+        if title:
+            data["title"] = title
+
+        return self._post("/v1/agent/conversations", json=data)
+
+    def get_conversation(self, conversation_id: int) -> dict[str, Any]:
+        """
+        Get agent conversation details
+
+        Args:
+            conversation_id: Conversation ID
+
+        Returns:
+            Conversation details including messages, status, etc.
+        """
+        return self._get(f"/v1/agent/conversations/{conversation_id}")
+
+    def chat(
+        self,
+        conversation_id: int,
+        message: str,
+        *,
+        documents: list[dict[str, Any]] | None = None,
+        stream: bool = True,
+    ) -> dict[str, Any] | Iterator[dict[str, Any]]:
+        """
+        Chat with agent (streaming or non-streaming)
+
+        Args:
+            conversation_id: Conversation ID
+            message: User message content
+            documents: List of related documents (optional)
+                Each document should have: doc_id, doc_title, file_type (optional)
+            stream: Whether to use streaming response (default: True)
+
+        Returns:
+            For streaming: Iterator of WorkflowStreamEvent objects
+            For non-streaming: Response with message content
+
+        Example:
+            >>> # Non-streaming
+            >>> response = client.agent.chat(
+            ...     conversation_id=123456,
+            ...     message="Analyze NVIDIA's latest earnings",
+            ...     stream=False
+            ... )
+            
+            >>> # Streaming
+            >>> for event in client.agent.chat(conv_id, "Hello", stream=True):
+            ...     print(event)
+        """
+        data: dict[str, Any] = {
+            "message": message,
+            "stream": stream,
+        }
+        if documents:
+            data["documents"] = documents
+
+        return self._post(
+            f"/v1/agent/conversations/{conversation_id}/chat",
+            json=data,
+        )
+
+    def list_messages(
+        self,
+        conversation_id: int,
+        *,
+        limit: int = 10,
+        before_message_id: int | None = None,
+    ) -> dict[str, Any]:
+        """
+        List agent conversation messages
+
+        Args:
+            conversation_id: Conversation ID
+            limit: Number of messages to return (default: 10, max: 100)
+            before_message_id: Fetch messages created before this message ID
+
+        Returns:
+            Dictionary with messages list
+        """
+        params: dict[str, Any] = {"limit": limit}
+        if before_message_id is not None:
+            params["before_message_id"] = before_message_id
+
+        return self._get(
+            f"/v1/agent/conversations/{conversation_id}/messages",
+            params=params,
+        )
+
+    def get_message_events(
+        self,
+        conversation_id: int,
+        assistant_message_id: str,
+        *,
+        stream: bool = True,
+        timeout: int = 1800,
+        from_offset: int = 0,
+    ) -> dict[str, Any] | Iterator[dict[str, Any]]:
+        """
+        Get assistant message events from a specific offset
+
+        Args:
+            conversation_id: Conversation ID
+            assistant_message_id: Assistant message ID (from chat response header)
+            stream: Whether to stream events via SSE (default: True)
+            timeout: Timeout in seconds for streaming mode (default: 1800)
+            from_offset: Start streaming from specific offset (default: 0)
+
+        Returns:
+            For streaming: Iterator of WorkflowStreamEvent objects
+            For non-streaming: Dictionary with assistant_events list
+        """
+        params: dict[str, Any] = {
+            "stream": stream,
+            "timeout": timeout,
+            "from_offset": from_offset,
+        }
+
+        return self._get(
+            f"/v1/agent/conversations/{conversation_id}/messages/{assistant_message_id}",
+            params=params,
+        )
+
+    def cancel_execution(
+        self,
+        conversation_id: int,
+        assistant_message_id: str,
+    ) -> dict[str, Any]:
+        """
+        Cancel agent execution
+
+        Args:
+            conversation_id: Conversation ID
+            assistant_message_id: Assistant message ID to cancel
+
+        Returns:
+            Dictionary with response_id and status
+        """
+        return self._post(
+            f"/v1/agent/conversations/{conversation_id}/messages/{assistant_message_id}/cancel"
+        )
+
+    def get_file(self, file_id: str) -> bytes:
+        """
+        Get agent generated file
+
+        Args:
+            file_id: Agent generated file ID
+
+        Returns:
+            File content as bytes
+
+        Example:
+            >>> file_content = client.agent.get_file("file_abc123")
+            >>> with open("output.xlsx", "wb") as f:
+            ...     f.write(file_content)
+        """
+        return self._client._get_bytes(f"/v1/agent/files/{file_id}")

reportify_sdk-0.2.9/reportify_sdk/channels.py

@@ -0,0 +1,126 @@
+"""
+Channels Module
+
+Provides access to channel management and following functionality.
+"""
+
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from reportify_sdk.client import Reportify
+
+
+class ChannelsModule:
+    """
+    Channels module for searching and following channels
+
+    Access through the main client:
+        >>> client = Reportify(api_key="xxx")
+        >>> channels = client.channels.search("Goldman Sachs")
+    """
+
+    def __init__(self, client: "Reportify"):
+        self._client = client
+
+    def _get(self, path: str, params: dict[str, Any] | None = None) -> dict[str, Any]:
+        return self._client._get(path, params=params)
+
+    def _post(self, path: str, json: dict[str, Any] | None = None) -> dict[str, Any]:
+        return self._client._post(path, json=json)
+
+    def search(
+        self,
+        query: str,
+        *,
+        page_num: int = 1,
+        page_size: int = 10,
+    ) -> dict[str, Any]:
+        """
+        Search for channels by query string
+
+        Args:
+            query: Search query string or URL
+            page_num: Page number (default: 1)
+            page_size: Number of items per page (default: 10)
+
+        Returns:
+            Dictionary with channels list and pagination info
+
+        Example:
+            >>> result = client.channels.search("Goldman Sachs")
+            >>> for channel in result["channels"]:
+            ...     print(channel["name"])
+        """
+        return self._post(
+            "/v1/channels/search",
+            json={"query": query, "page_num": page_num, "page_size": page_size},
+        )
+
+    def followings(
+        self,
+        *,
+        page_num: int = 1,
+        page_size: int = 10,
+    ) -> dict[str, Any]:
+        """
+        Get list of channels user is following
+
+        Args:
+            page_num: Page number (default: 1)
+            page_size: Number of items per page (default: 10)
+
+        Returns:
+            Dictionary with channels list and pagination info
+        """
+        return self._get(
+            "/v1/channels/followings",
+            params={"page_num": page_num, "page_size": page_size},
+        )
+
+    def follow(self, channel_id: str) -> dict[str, Any]:
+        """
+        Follow a specific channel
+
+        Args:
+            channel_id: Channel ID to follow
+
+        Returns:
+            Channel information with following status
+        """
+        return self._post(f"/v1/channels/{channel_id}/follow")
+
+    def unfollow(self, channel_id: str) -> dict[str, Any]:
+        """
+        Unfollow a specific channel
+
+        Args:
+            channel_id: Channel ID to unfollow
+
+        Returns:
+            Status message
+        """
+        return self._client._request("DELETE", f"/v1/channels/{channel_id}/unfollow")
+
+    def get_docs(
+        self,
+        *,
+        channel_ids: str | None = None,
+        page_num: int = 1,
+        page_size: int = 10,
+    ) -> dict[str, Any]:
+        """
+        Get documents from followed channels
+
+        Args:
+            channel_ids: Comma-separated channel IDs (optional, uses all followed if not provided)
+            page_num: Page number (default: 1)
+            page_size: Number of items per page (default: 10)
+
+        Returns:
+            Dictionary with documents list and pagination info
+        """
+        params: dict[str, Any] = {"page_num": page_num, "page_size": page_size}
+        if channel_ids:
+            params["channel_ids"] = channel_ids
+
+        return self._get("/v1/channels/followings/docs", params=params)

reportify_sdk-0.2.9/reportify_sdk/chat.py

@@ -0,0 +1,107 @@
+"""
+Chat Module
+
+Provides chat completion functionality based on document content.
+"""
+
+from typing import TYPE_CHECKING, Any, Iterator, Literal
+
+if TYPE_CHECKING:
+    from reportify_sdk.client import Reportify
+
+
+class ChatModule:
+    """
+    Chat module for document-based Q&A
+
+    Access through the main client:
+        >>> client = Reportify(api_key="xxx")
+        >>> response = client.chat.completion("What are Tesla's revenue?")
+    """
+
+    def __init__(self, client: "Reportify"):
+        self._client = client
+
+    def _post(self, path: str, json: dict[str, Any] | None = None) -> dict[str, Any]:
+        return self._client._post(path, json=json)
+
+    def completion(
+        self,
+        query: str,
+        *,
+        folder_ids: list[str] | None = None,
+        doc_ids: list[str] | None = None,
+        categories: list[str] | None = None,
+        markets: list[str] | None = None,
+        institutions: list[str] | None = None,
+        symbols: list[str] | None = None,
+        tags: dict[str, list] | None = None,
+        start_date: str | None = None,
+        end_date: str | None = None,
+        min_score: float | None = None,
+        extended_filters: list[dict] | None = None,
+        mode: Literal["concise", "comprehensive", "deepresearch"] = "concise",
+        session_id: str = "",
+        stream: bool = False,
+    ) -> dict[str, Any] | Iterator[dict[str, Any]]:
+        """
+        Chat completion based on document content
+
+        Args:
+            query: User question
+            folder_ids: Filter by folder IDs
+            doc_ids: Filter by document IDs
+            categories: Filter by document categories
+            markets: Filter by markets (cn, hk, us)
+            institutions: Filter by institutions
+            symbols: Filter by stock symbols
+            tags: Filter by tags
+            start_date: Start date filter (YYYY-MM-DD)
+            end_date: End date filter (YYYY-MM-DD)
+            min_score: Minimum relevance score
+            extended_filters: Extended filter conditions
+            mode: Response mode ("concise", "comprehensive", "deepresearch")
+            session_id: Session ID for conversation continuity
+            stream: Whether to stream the response
+
+        Returns:
+            Chat completion response with type, message_id, message, and extra
+
+        Example:
+            >>> response = client.chat.completion(
+            ...     "What are Tesla's revenue projections?",
+            ...     symbols=["US:TSLA"],
+            ...     mode="comprehensive"
+            ... )
+            >>> print(response["message"])
+        """
+        data: dict[str, Any] = {
+            "query": query,
+            "mode": mode,
+            "session_id": session_id,
+            "stream": stream,
+        }
+        if folder_ids:
+            data["folder_ids"] = folder_ids
+        if doc_ids:
+            data["doc_ids"] = doc_ids
+        if categories:
+            data["categories"] = categories
+        if markets:
+            data["markets"] = markets
+        if institutions:
+            data["institutions"] = institutions
+        if symbols:
+            data["symbols"] = symbols
+        if tags:
+            data["tags"] = tags
+        if start_date:
+            data["start_date"] = start_date
+        if end_date:
+            data["end_date"] = end_date
+        if min_score is not None:
+            data["min_score"] = min_score
+        if extended_filters:
+            data["extended_filters"] = extended_filters
+
+        return self._post("/v1/chat/completion", json=data)