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

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

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

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

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

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

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

reportify_sdk-0.2.10/reportify_sdk/client.py

@@ -0,0 +1,262 @@
+"""
+Reportify Client
+
+Main client class for interacting with the Reportify API.
+"""
+
+from typing import Any
+
+import httpx
+
+from reportify_sdk.exceptions import (
+    APIError,
+    AuthenticationError,
+    NotFoundError,
+    RateLimitError,
+)
+
+
+class Reportify:
+    """
+    Reportify API Client
+
+    A user-friendly client for accessing financial data, document search,
+    and knowledge base through the Reportify API.
+
+    Args:
+        api_key: Your Reportify API key
+        base_url: Base URL for the API (default: https://api.reportify.cn)
+        timeout: Request timeout in seconds (default: 30)
+
+    Example:
+        >>> from reportify_sdk import Reportify
+        >>> client = Reportify(api_key="your-api-key")
+        >>> docs = client.search("Tesla earnings", num=10)
+    """
+
+    DEFAULT_BASE_URL = "https://api.reportify.cn"
+
+    def __init__(
+        self,
+        api_key: str,
+        base_url: str | None = None,
+        timeout: float = 30.0,
+    ):
+        if not api_key:
+            raise AuthenticationError("API key is required")
+
+        self.api_key = api_key
+        self.base_url = (base_url or self.DEFAULT_BASE_URL).rstrip("/")
+        self.timeout = timeout
+
+        self._client = httpx.Client(
+            base_url=self.base_url,
+            headers=self._get_headers(),
+            timeout=timeout,
+        )
+
+        # Initialize sub-modules (lazy loading)
+        self._stock = None
+        self._timeline = None
+        self._kb = None
+        self._docs = None
+        self._tools = None
+        self._quant = None
+        self._concepts = None
+        self._channels = None
+        self._chat = None
+        self._agent = None
+        self._user = None
+        self._search = None
+
+    def _get_headers(self) -> dict[str, str]:
+        """Get default headers for API requests"""
+        return {
+            "Authorization": f"Bearer {self.api_key}",
+            "Content-Type": "application/json",
+            "User-Agent": "reportify-sdk-python/0.2.10",
+        }
+
+    def _request(
+        self,
+        method: str,
+        path: str,
+        params: dict[str, Any] | None = None,
+        json: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        """
+        Make an HTTP request to the API
+
+        Args:
+            method: HTTP method (GET, POST, etc.)
+            path: API endpoint path
+            params: Query parameters
+            json: JSON body data
+
+        Returns:
+            Response data as dictionary
+
+        Raises:
+            AuthenticationError: If API key is invalid
+            RateLimitError: If rate limit is exceeded
+            NotFoundError: If resource is not found
+            APIError: For other API errors
+        """
+        try:
+            response = self._client.request(
+                method=method,
+                url=path,
+                params=params,
+                json=json,
+            )
+
+            # Handle error responses
+            if response.status_code == 401:
+                raise AuthenticationError()
+            elif response.status_code == 429:
+                raise RateLimitError()
+            elif response.status_code == 404:
+                raise NotFoundError()
+            elif response.status_code >= 400:
+                error_msg = response.text
+                try:
+                    error_data = response.json()
+                    error_msg = error_data.get("detail", error_data.get("message", error_msg))
+                except Exception:
+                    pass
+                raise APIError(error_msg, status_code=response.status_code)
+
+            return response.json()
+
+        except httpx.TimeoutException:
+            raise APIError("Request timeout", status_code=408)
+        except httpx.RequestError as e:
+            raise APIError(f"Request failed: {str(e)}")
+
+    def _get(self, path: str, params: dict[str, Any] | None = None) -> dict[str, Any]:
+        """Make a GET request"""
+        return self._request("GET", path, params=params)
+
+    def _post(self, path: str, json: dict[str, Any] | None = None) -> dict[str, Any]:
+        """Make a POST request"""
+        return self._request("POST", path, json=json)
+
+    def _get_bytes(self, path: str) -> bytes:
+        """Make a GET request and return raw bytes (for file downloads)"""
+        try:
+            response = self._client.get(path)
+            response.raise_for_status()
+            return response.content
+        except httpx.HTTPStatusError as e:
+            status_code = e.response.status_code
+            if status_code == 401:
+                raise AuthenticationError("Invalid API key")
+            elif status_code == 404:
+                raise NotFoundError(f"Resource not found: {path}")
+            elif status_code == 429:
+                raise RateLimitError("Rate limit exceeded")
+            else:
+                raise APIError(f"API error: {status_code}")
+
+
+    # -------------------------------------------------------------------------
+    # Sub-modules (lazy loading)
+    # -------------------------------------------------------------------------
+
+    @property
+    def search(self):
+        """Search module for document search across all categories"""
+        if self._search is None:
+            from reportify_sdk.search import SearchModule
+            self._search = SearchModule(self)
+        return self._search
+
+    @property
+    def stock(self):
+        """Stock data module for financial statements, prices, etc."""
+        if self._stock is None:
+            from reportify_sdk.stock import StockModule
+            self._stock = StockModule(self)
+        return self._stock
+
+    @property
+    def timeline(self):
+        """Timeline module for following companies, topics, etc."""
+        if self._timeline is None:
+            from reportify_sdk.timeline import TimelineModule
+            self._timeline = TimelineModule(self)
+        return self._timeline
+
+    @property
+    def kb(self):
+        """Knowledge base module for searching user uploaded documents"""
+        if self._kb is None:
+            from reportify_sdk.kb import KBModule
+            self._kb = KBModule(self)
+        return self._kb
+
+    @property
+    def docs(self):
+        """Documents module for accessing document content and metadata"""
+        if self._docs is None:
+            from reportify_sdk.docs import DocsModule
+            self._docs = DocsModule(self)
+        return self._docs
+
+    @property
+    def quant(self):
+        """Quant module for indicators, factors, quotes, and backtesting"""
+        if self._quant is None:
+            from reportify_sdk.quant import QuantModule
+            self._quant = QuantModule(self)
+        return self._quant
+
+    @property
+    def concepts(self):
+        """Concepts module for accessing concept data and feeds"""
+        if self._concepts is None:
+            from reportify_sdk.concepts import ConceptsModule
+            self._concepts = ConceptsModule(self)
+        return self._concepts
+
+    @property
+    def channels(self):
+        """Channels module for searching and following channels"""
+        if self._channels is None:
+            from reportify_sdk.channels import ChannelsModule
+            self._channels = ChannelsModule(self)
+        return self._channels
+
+    @property
+    def chat(self):
+        """Chat module for document-based Q&A"""
+        if self._chat is None:
+            from reportify_sdk.chat import ChatModule
+            self._chat = ChatModule(self)
+        return self._chat
+
+    @property
+    def agent(self):
+        """Agent module for AI-powered conversations and workflows"""
+        if self._agent is None:
+            from reportify_sdk.agent import AgentModule
+            self._agent = AgentModule(self)
+        return self._agent
+
+    @property
+    def user(self):
+        """User module for user-related tools and data"""
+        if self._user is None:
+            from reportify_sdk.user import UserModule
+            self._user = UserModule(self)
+        return self._user
+
+    def close(self):
+        """Close the HTTP client"""
+        self._client.close()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.close()

reportify_sdk-0.2.10/reportify_sdk/search.py

@@ -0,0 +1,357 @@
+"""
+Search Module
+
+Provides document search functionality across various categories.
+"""
+
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from reportify_sdk.client import Reportify
+
+
+class SearchModule:
+    """
+    Search module for document search functionality.
+
+    Access via client.search:
+        >>> results = client.search.all("Tesla earnings")
+        >>> news = client.search.news("Apple iPhone")
+    """
+
+    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 all(
+        self,
+        query: str,
+        *,
+        num: int = 10,
+        categories: list[str] | None = None,
+        symbols: list[str] | None = None,
+        industries: list[str] | None = None,
+        channel_ids: list[str] | None = None,
+        start_datetime: str | None = None,
+        end_datetime: str | None = None,
+    ) -> list[dict[str, Any]]:
+        """
+        Search documents across all categories
+
+        Args:
+            query: Search query string
+            num: Number of results to return (default: 10, max: 100)
+            categories: Filter by categories (news, reports, filings, transcripts, socials)
+            symbols: Filter by stock symbols (e.g., ["US:AAPL", "HK:0700"])
+            industries: Filter by industries
+            channel_ids: Filter by channel IDs
+            start_datetime: Start datetime filter (YYYY-MM-DD or YYYY-MM-DD HH:MM:SS)
+            end_datetime: End datetime filter (YYYY-MM-DD or YYYY-MM-DD HH:MM:SS)
+
+        Returns:
+            List of matching documents
+        """
+        data: dict[str, Any] = {"query": query, "num": num}
+        if categories:
+            data["categories"] = categories
+        if symbols:
+            data["symbols"] = symbols
+        if industries:
+            data["industries"] = industries
+        if channel_ids:
+            data["channel_ids"] = channel_ids
+        if start_datetime:
+            data["start_datetime"] = start_datetime
+        if end_datetime:
+            data["end_datetime"] = end_datetime
+
+        response = self._post("/v2/search", json=data)
+        return response.get("docs", [])
+
+    def news(
+        self,
+        query: str,
+        *,
+        num: int = 10,
+        symbols: list[str] | None = None,
+        channel_ids: list[str] | None = None,
+        start_datetime: str | None = None,
+        end_datetime: str | None = None,
+    ) -> list[dict[str, Any]]:
+        """
+        Search news articles
+
+        Args:
+            query: Search query string
+            num: Number of results to return
+            symbols: Filter by stock symbols
+            channel_ids: Filter by channel IDs
+            start_datetime: Start datetime filter
+            end_datetime: End datetime filter
+
+        Returns:
+            List of news documents
+        """
+        data: dict[str, Any] = {"query": query, "num": num}
+        if symbols:
+            data["symbols"] = symbols
+        if channel_ids:
+            data["channel_ids"] = channel_ids
+        if start_datetime:
+            data["start_datetime"] = start_datetime
+        if end_datetime:
+            data["end_datetime"] = end_datetime
+
+        response = self._post("/v2/search/news", json=data)
+        return response.get("docs", [])
+
+    def reports(
+        self,
+        query: str,
+        *,
+        num: int = 10,
+        symbols: list[str] | None = None,
+        industries: list[str] | None = None,
+        channel_ids: list[str] | None = None,
+        start_datetime: str | None = None,
+        end_datetime: str | None = None,
+    ) -> list[dict[str, Any]]:
+        """
+        Search research reports
+
+        Args:
+            query: Search query string
+            num: Number of results to return
+            symbols: Filter by stock symbols
+            industries: Filter by industries
+            channel_ids: Filter by channel IDs
+            start_datetime: Start datetime filter
+            end_datetime: End datetime filter
+
+        Returns:
+            List of research reports
+        """
+        data: dict[str, Any] = {"query": query, "num": num}
+        if symbols:
+            data["symbols"] = symbols
+        if industries:
+            data["industries"] = industries
+        if channel_ids:
+            data["channel_ids"] = channel_ids
+        if start_datetime:
+            data["start_datetime"] = start_datetime
+        if end_datetime:
+            data["end_datetime"] = end_datetime
+
+        response = self._post("/v2/search/reports", json=data)
+        return response.get("docs", [])
+
+    def filings(
+        self,
+        query: str,
+        symbols: list[str],
+        *,
+        num: int = 10,
+        start_datetime: str | None = None,
+        end_datetime: str | None = None,
+    ) -> list[dict[str, Any]]:
+        """
+        Search company filings
+
+        Args:
+            query: Search query string
+            symbols: Stock symbols to filter by (required)
+            num: Number of results to return
+            start_datetime: Start datetime filter
+            end_datetime: End datetime filter
+
+        Returns:
+            List of filing documents
+        """
+        data: dict[str, Any] = {"query": query, "symbols": symbols, "num": num}
+        if start_datetime:
+            data["start_datetime"] = start_datetime
+        if end_datetime:
+            data["end_datetime"] = end_datetime
+
+        response = self._post("/v2/search/filings", json=data)
+        return response.get("docs", [])
+
+    def conference_calls(
+        self,
+        query: str,
+        symbols: list[str],
+        *,
+        num: int = 10,
+        start_datetime: str | None = None,
+        end_datetime: str | None = None,
+        fiscal_year: str | None = None,
+        fiscal_quarter: str | None = None,
+    ) -> list[dict[str, Any]]:
+        """
+        Search earnings call transcripts and slides
+
+        Args:
+            query: Search query string
+            symbols: Stock symbols to filter by (required)
+            num: Number of results to return
+            start_datetime: Start datetime filter (YYYY-MM-DD or YYYY-MM-DD HH:MM:SS)
+            end_datetime: End datetime filter (YYYY-MM-DD or YYYY-MM-DD HH:MM:SS)
+            fiscal_year: Fiscal year filter (e.g., '2025', '2026')
+            fiscal_quarter: Fiscal quarter filter (e.g., 'Q1', 'Q2', 'Q3', 'Q4')
+
+        Returns:
+            List of conference call documents
+        """
+        data: dict[str, Any] = {"query": query, "symbols": symbols, "num": num}
+        if start_datetime:
+            data["start_datetime"] = start_datetime
+        if end_datetime:
+            data["end_datetime"] = end_datetime
+        if fiscal_year:
+            data["fiscal_year"] = fiscal_year
+        if fiscal_quarter:
+            data["fiscal_quarter"] = fiscal_quarter
+
+        response = self._post("/v2/search/conference-calls", json=data)
+        return response.get("docs", [])
+
+    def earnings_pack(
+        self,
+        query: str,
+        symbols: list[str],
+        *,
+        num: int = 10,
+        start_datetime: str | None = None,
+        end_datetime: str | None = None,
+        fiscal_year: str | None = None,
+        fiscal_quarter: str | None = None,
+    ) -> list[dict[str, Any]]:
+        """
+        Search earnings financial reports
+
+        Args:
+            query: Search query string
+            symbols: Stock symbols to filter by (required)
+            num: Number of results to return
+            start_datetime: Start datetime filter (YYYY-MM-DD or YYYY-MM-DD HH:MM:SS)
+            end_datetime: End datetime filter (YYYY-MM-DD or YYYY-MM-DD HH:MM:SS)
+            fiscal_year: Fiscal year filter (e.g., '2025', '2026')
+            fiscal_quarter: Fiscal quarter filter (e.g., 'Q1', 'Q2', 'Q3', 'Q4')
+
+        Returns:
+            List of earnings pack documents
+        """
+        data: dict[str, Any] = {"query": query, "symbols": symbols, "num": num}
+        if start_datetime:
+            data["start_datetime"] = start_datetime
+        if end_datetime:
+            data["end_datetime"] = end_datetime
+        if fiscal_year:
+            data["fiscal_year"] = fiscal_year
+        if fiscal_quarter:
+            data["fiscal_quarter"] = fiscal_quarter
+
+        response = self._post("/v2/search/earnings-pack", json=data)
+        return response.get("docs", [])
+
+    def minutes(
+        self,
+        query: str,
+        *,
+        num: int = 10,
+        symbols: list[str] | None = None,
+        start_datetime: str | None = None,
+        end_datetime: str | None = None,
+    ) -> list[dict[str, Any]]:
+        """
+        Search conference calls and IR (Investor Relations) meetings
+
+        Args:
+            query: Search query string
+            num: Number of results to return
+            symbols: Filter by stock symbols
+            start_datetime: Start datetime filter
+            end_datetime: End datetime filter
+
+        Returns:
+            List of minutes documents
+        """
+        data: dict[str, Any] = {"query": query, "num": num}
+        if symbols:
+            data["symbols"] = symbols
+        if start_datetime:
+            data["start_datetime"] = start_datetime
+        if end_datetime:
+            data["end_datetime"] = end_datetime
+
+        response = self._post("/v2/search/minutes", json=data)
+        return response.get("docs", [])
+
+    def socials(
+        self,
+        query: str,
+        *,
+        num: int = 10,
+        symbols: list[str] | None = None,
+        channel_ids: list[str] | None = None,
+        start_datetime: str | None = None,
+        end_datetime: str | None = None,
+    ) -> list[dict[str, Any]]:
+        """
+        Search social media content
+
+        Args:
+            query: Search query string
+            num: Number of results to return
+            symbols: Filter by stock symbols
+            channel_ids: Filter by channel IDs
+            start_datetime: Start datetime filter
+            end_datetime: End datetime filter
+
+        Returns:
+            List of social media documents
+        """
+        data: dict[str, Any] = {"query": query, "num": num}
+        if symbols:
+            data["symbols"] = symbols
+        if channel_ids:
+            data["channel_ids"] = channel_ids
+        if start_datetime:
+            data["start_datetime"] = start_datetime
+        if end_datetime:
+            data["end_datetime"] = end_datetime
+
+        response = self._post("/v2/search/socials", json=data)
+        return response.get("docs", [])
+
+    def webpages(
+        self,
+        query: str,
+        *,
+        num: int = 10,
+        start_datetime: str | None = None,
+        end_datetime: str | None = None,
+    ) -> list[dict[str, Any]]:
+        """
+        Search webpage content
+
+        Args:
+            query: Search query string
+            num: Number of results to return
+            start_datetime: Start datetime filter
+            end_datetime: End datetime filter
+
+        Returns:
+            List of webpage content
+        """
+        data: dict[str, Any] = {"query": query, "num": num}
+        if start_datetime:
+            data["start_datetime"] = start_datetime
+        if end_datetime:
+            data["end_datetime"] = end_datetime
+
+        response = self._post("/v2/search/webpages", json=data)
+        return response.get("docs", [])

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

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

{reportify_sdk-0.2.9 → reportify_sdk-0.2.10}/reportify_sdk.egg-info/SOURCES.txt

@@ -11,6 +11,7 @@ reportify_sdk/docs.py
 reportify_sdk/exceptions.py
 reportify_sdk/kb.py
 reportify_sdk/quant.py
+reportify_sdk/search.py
 reportify_sdk/stock.py
 reportify_sdk/timeline.py
 reportify_sdk/user.py

reportify_sdk-0.2.9/reportify_sdk/client.py

@@ -1,580 +0,0 @@
-"""
-Reportify Client
-
-Main client class for interacting with the Reportify API.
-"""
-
-from typing import Any
-
-import httpx
-
-from reportify_sdk.exceptions import (
-    APIError,
-    AuthenticationError,
-    NotFoundError,
-    RateLimitError,
-)
-
-
-class Reportify:
-    """
-    Reportify API Client
-
-    A user-friendly client for accessing financial data, document search,
-    and knowledge base through the Reportify API.
-
-    Args:
-        api_key: Your Reportify API key
-        base_url: Base URL for the API (default: https://api.reportify.cn)
-        timeout: Request timeout in seconds (default: 30)
-
-    Example:
-        >>> from reportify_sdk import Reportify
-        >>> client = Reportify(api_key="your-api-key")
-        >>> docs = client.search("Tesla earnings", num=10)
-    """
-
-    DEFAULT_BASE_URL = "https://api.reportify.cn"
-
-    def __init__(
-        self,
-        api_key: str,
-        base_url: str | None = None,
-        timeout: float = 30.0,
-    ):
-        if not api_key:
-            raise AuthenticationError("API key is required")
-
-        self.api_key = api_key
-        self.base_url = (base_url or self.DEFAULT_BASE_URL).rstrip("/")
-        self.timeout = timeout
-
-        self._client = httpx.Client(
-            base_url=self.base_url,
-            headers=self._get_headers(),
-            timeout=timeout,
-        )
-
-        # Initialize sub-modules (lazy loading)
-        self._stock = None
-        self._timeline = None
-        self._kb = None
-        self._docs = None
-        self._tools = None
-        self._quant = None
-        self._concepts = None
-        self._channels = None
-        self._chat = None
-        self._agent = None
-        self._user = None
-
-    def _get_headers(self) -> dict[str, str]:
-        """Get default headers for API requests"""
-        return {
-            "Authorization": f"Bearer {self.api_key}",
-            "Content-Type": "application/json",
-            "User-Agent": "reportify-sdk-python/0.2.9",
-        }
-
-    def _request(
-        self,
-        method: str,
-        path: str,
-        params: dict[str, Any] | None = None,
-        json: dict[str, Any] | None = None,
-    ) -> dict[str, Any]:
-        """
-        Make an HTTP request to the API
-
-        Args:
-            method: HTTP method (GET, POST, etc.)
-            path: API endpoint path
-            params: Query parameters
-            json: JSON body data
-
-        Returns:
-            Response data as dictionary
-
-        Raises:
-            AuthenticationError: If API key is invalid
-            RateLimitError: If rate limit is exceeded
-            NotFoundError: If resource is not found
-            APIError: For other API errors
-        """
-        try:
-            response = self._client.request(
-                method=method,
-                url=path,
-                params=params,
-                json=json,
-            )
-
-            # Handle error responses
-            if response.status_code == 401:
-                raise AuthenticationError()
-            elif response.status_code == 429:
-                raise RateLimitError()
-            elif response.status_code == 404:
-                raise NotFoundError()
-            elif response.status_code >= 400:
-                error_msg = response.text
-                try:
-                    error_data = response.json()
-                    error_msg = error_data.get("detail", error_data.get("message", error_msg))
-                except Exception:
-                    pass
-                raise APIError(error_msg, status_code=response.status_code)
-
-            return response.json()
-
-        except httpx.TimeoutException:
-            raise APIError("Request timeout", status_code=408)
-        except httpx.RequestError as e:
-            raise APIError(f"Request failed: {str(e)}")
-
-    def _get(self, path: str, params: dict[str, Any] | None = None) -> dict[str, Any]:
-        """Make a GET request"""
-        return self._request("GET", path, params=params)
-
-    def _post(self, path: str, json: dict[str, Any] | None = None) -> dict[str, Any]:
-        """Make a POST request"""
-        return self._request("POST", path, json=json)
-
-    def _get_bytes(self, path: str) -> bytes:
-        """Make a GET request and return raw bytes (for file downloads)"""
-        try:
-            response = self._client.get(path)
-            response.raise_for_status()
-            return response.content
-        except httpx.HTTPStatusError as e:
-            status_code = e.response.status_code
-            if status_code == 401:
-                raise AuthenticationError("Invalid API key")
-            elif status_code == 404:
-                raise NotFoundError(f"Resource not found: {path}")
-            elif status_code == 429:
-                raise RateLimitError("Rate limit exceeded")
-            else:
-                raise APIError(f"API error: {status_code}")
-
-    # -------------------------------------------------------------------------
-    # Search Methods
-    # -------------------------------------------------------------------------
-
-    def search(
-        self,
-        query: str,
-        *,
-        num: int = 10,
-        symbols: list[str] | None = None,
-        industries: list[str] | None = None,
-        channel_ids: list[str] | None = None,
-        start_datetime: str | None = None,
-        end_datetime: str | None = None,
-    ) -> list[dict[str, Any]]:
-        """
-        Search documents across all categories
-
-        Args:
-            query: Search query string
-            num: Number of results to return (default: 10, max: 100)
-            symbols: Filter by stock symbols (e.g., ["US:AAPL", "HK:0700"])
-            industries: Filter by industries
-            channel_ids: Filter by channel IDs
-            start_datetime: Start datetime filter (YYYY-MM-DD or YYYY-MM-DD HH:MM:SS)
-            end_datetime: End datetime filter (YYYY-MM-DD or YYYY-MM-DD HH:MM:SS)
-
-        Returns:
-            List of matching documents
-
-        Example:
-            >>> docs = client.search("Tesla earnings", num=10)
-            >>> for doc in docs:
-            ...     print(doc["title"])
-        """
-        data: dict[str, Any] = {
-            "query": query,
-            "num": num,
-        }
-        if symbols:
-            data["symbols"] = symbols
-        if industries:
-            data["industries"] = industries
-        if channel_ids:
-            data["channel_ids"] = channel_ids
-        if start_datetime:
-            data["start_datetime"] = start_datetime
-        if end_datetime:
-            data["end_datetime"] = end_datetime
-
-        response = self._post("/v2/search", json=data)
-        return response.get("docs", [])
-
-    def search_news(
-        self,
-        query: str,
-        *,
-        num: int = 10,
-        symbols: list[str] | None = None,
-        channel_ids: list[str] | None = None,
-        start_datetime: str | None = None,
-        end_datetime: str | None = None,
-    ) -> list[dict[str, Any]]:
-        """
-        Search news articles
-
-        Args:
-            query: Search query string
-            num: Number of results to return
-            symbols: Filter by stock symbols
-            channel_ids: Filter by channel IDs
-            start_datetime: Start datetime filter (YYYY-MM-DD or YYYY-MM-DD HH:MM:SS)
-            end_datetime: End datetime filter (YYYY-MM-DD or YYYY-MM-DD HH:MM:SS)
-
-        Returns:
-            List of news articles
-        """
-        data: dict[str, Any] = {"query": query, "num": num}
-        if symbols:
-            data["symbols"] = symbols
-        if channel_ids:
-            data["channel_ids"] = channel_ids
-        if start_datetime:
-            data["start_datetime"] = start_datetime
-        if end_datetime:
-            data["end_datetime"] = end_datetime
-
-        response = self._post("/v2/search/news", json=data)
-        return response.get("docs", [])
-
-    def search_reports(
-        self,
-        query: str,
-        *,
-        num: int = 10,
-        symbols: list[str] | None = None,
-        industries: list[str] | None = None,
-        channel_ids: list[str] | None = None,
-        start_datetime: str | None = None,
-        end_datetime: str | None = None,
-    ) -> list[dict[str, Any]]:
-        """
-        Search research reports
-
-        Args:
-            query: Search query string
-            num: Number of results to return
-            symbols: Filter by stock symbols
-            industries: Filter by industries
-            channel_ids: Filter by channel IDs
-            start_datetime: Start datetime filter (YYYY-MM-DD or YYYY-MM-DD HH:MM:SS)
-            end_datetime: End datetime filter (YYYY-MM-DD or YYYY-MM-DD HH:MM:SS)
-
-        Returns:
-            List of research reports
-        """
-        data: dict[str, Any] = {"query": query, "num": num}
-        if symbols:
-            data["symbols"] = symbols
-        if industries:
-            data["industries"] = industries
-        if channel_ids:
-            data["channel_ids"] = channel_ids
-        if start_datetime:
-            data["start_datetime"] = start_datetime
-        if end_datetime:
-            data["end_datetime"] = end_datetime
-
-        response = self._post("/v2/search/reports", json=data)
-        return response.get("docs", [])
-
-    def search_filings(
-        self,
-        query: str,
-        symbols: list[str],
-        *,
-        num: int = 10,
-        start_datetime: str | None = None,
-        end_datetime: str | None = None,
-    ) -> list[dict[str, Any]]:
-        """
-        Search company filings and announcements
-
-        Args:
-            query: Search query string
-            symbols: Stock symbols to filter by (required)
-            num: Number of results to return
-            start_datetime: Start datetime filter (YYYY-MM-DD or YYYY-MM-DD HH:MM:SS)
-            end_datetime: End datetime filter (YYYY-MM-DD or YYYY-MM-DD HH:MM:SS)
-
-        Returns:
-            List of filings
-        """
-        data: dict[str, Any] = {"query": query, "symbols": symbols, "num": num}
-        if start_datetime:
-            data["start_datetime"] = start_datetime
-        if end_datetime:
-            data["end_datetime"] = end_datetime
-
-        response = self._post("/v2/search/filings", json=data)
-        return response.get("docs", [])
-
-    def search_transcripts(
-        self,
-        query: str,
-        symbols: list[str],
-        *,
-        num: int = 10,
-        start_datetime: str | None = None,
-        end_datetime: str | None = None,
-    ) -> list[dict[str, Any]]:
-        """
-        Search earnings call transcripts (conference calls)
-
-        Args:
-            query: Search query string
-            symbols: Stock symbols to filter by (required)
-            num: Number of results to return
-            start_datetime: Start datetime filter (YYYY-MM-DD or YYYY-MM-DD HH:MM:SS)
-            end_datetime: End datetime filter (YYYY-MM-DD or YYYY-MM-DD HH:MM:SS)
-
-        Returns:
-            List of transcripts
-        """
-        data: dict[str, Any] = {"query": query, "symbols": symbols, "num": num}
-        if start_datetime:
-            data["start_datetime"] = start_datetime
-        if end_datetime:
-            data["end_datetime"] = end_datetime
-
-        response = self._post("/v2/search/conference-calls", json=data)
-        return response.get("docs", [])
-
-    def search_earnings_pack(
-        self,
-        query: str,
-        symbols: list[str],
-        *,
-        num: int = 10,
-        start_datetime: str | None = None,
-        end_datetime: str | None = None,
-    ) -> list[dict[str, Any]]:
-        """
-        Search earnings pack documents
-
-        Includes financial reports, earnings call transcripts, 
-        presentation materials, and press releases.
-
-        Args:
-            query: Search query string
-            symbols: Stock symbols to filter by (required)
-            num: Number of results to return
-            start_datetime: Start datetime filter (YYYY-MM-DD or YYYY-MM-DD HH:MM:SS)
-            end_datetime: End datetime filter (YYYY-MM-DD or YYYY-MM-DD HH:MM:SS)
-
-        Returns:
-            List of earnings pack documents
-        """
-        data: dict[str, Any] = {"query": query, "symbols": symbols, "num": num}
-        if start_datetime:
-            data["start_datetime"] = start_datetime
-        if end_datetime:
-            data["end_datetime"] = end_datetime
-
-        response = self._post("/v2/search/earnings-pack", json=data)
-        return response.get("docs", [])
-
-    def search_minutes(
-        self,
-        query: str,
-        *,
-        num: int = 10,
-        symbols: list[str] | None = None,
-        start_datetime: str | None = None,
-        end_datetime: str | None = None,
-    ) -> list[dict[str, Any]]:
-        """
-        Search minutes transcripts
-
-        Includes conference calls and IR (Investor Relations) meetings.
-
-        Args:
-            query: Search query string
-            num: Number of results to return
-            symbols: Filter by stock symbols
-            start_datetime: Start datetime filter (YYYY-MM-DD or YYYY-MM-DD HH:MM:SS)
-            end_datetime: End datetime filter (YYYY-MM-DD or YYYY-MM-DD HH:MM:SS)
-
-        Returns:
-            List of minutes transcripts
-        """
-        data: dict[str, Any] = {"query": query, "num": num}
-        if symbols:
-            data["symbols"] = symbols
-        if start_datetime:
-            data["start_datetime"] = start_datetime
-        if end_datetime:
-            data["end_datetime"] = end_datetime
-
-        response = self._post("/v2/search/minutes", json=data)
-        return response.get("docs", [])
-
-    def search_socials(
-        self,
-        query: str,
-        *,
-        num: int = 10,
-        symbols: list[str] | None = None,
-        channel_ids: list[str] | None = None,
-        start_datetime: str | None = None,
-        end_datetime: str | None = None,
-    ) -> list[dict[str, Any]]:
-        """
-        Search social media content and market sentiment
-
-        Args:
-            query: Search query string
-            num: Number of results to return
-            symbols: Filter by stock symbols
-            channel_ids: Filter by channel IDs
-            start_datetime: Start datetime filter (YYYY-MM-DD or YYYY-MM-DD HH:MM:SS)
-            end_datetime: End datetime filter (YYYY-MM-DD or YYYY-MM-DD HH:MM:SS)
-
-        Returns:
-            List of social media content
-        """
-        data: dict[str, Any] = {"query": query, "num": num}
-        if symbols:
-            data["symbols"] = symbols
-        if channel_ids:
-            data["channel_ids"] = channel_ids
-        if start_datetime:
-            data["start_datetime"] = start_datetime
-        if end_datetime:
-            data["end_datetime"] = end_datetime
-
-        response = self._post("/v2/search/socials", json=data)
-        return response.get("docs", [])
-
-    def search_webpages(
-        self,
-        query: str,
-        *,
-        num: int = 10,
-        start_datetime: str | None = None,
-        end_datetime: str | None = None,
-    ) -> list[dict[str, Any]]:
-        """
-        Search webpage content
-
-        Args:
-            query: Search query string
-            num: Number of results to return
-            start_datetime: Start datetime filter (YYYY-MM-DD or YYYY-MM-DD HH:MM:SS)
-            end_datetime: End datetime filter (YYYY-MM-DD or YYYY-MM-DD HH:MM:SS)
-
-        Returns:
-            List of webpage content
-        """
-        data: dict[str, Any] = {"query": query, "num": num}
-        if start_datetime:
-            data["start_datetime"] = start_datetime
-        if end_datetime:
-            data["end_datetime"] = end_datetime
-
-        response = self._post("/v2/search/webpages", json=data)
-        return response.get("docs", [])
-
-    # -------------------------------------------------------------------------
-    # Sub-modules (lazy loading)
-    # -------------------------------------------------------------------------
-
-    @property
-    def stock(self):
-        """Stock data module for financial statements, prices, etc."""
-        if self._stock is None:
-            from reportify_sdk.stock import StockModule
-            self._stock = StockModule(self)
-        return self._stock
-
-    @property
-    def timeline(self):
-        """Timeline module for following companies, topics, etc."""
-        if self._timeline is None:
-            from reportify_sdk.timeline import TimelineModule
-            self._timeline = TimelineModule(self)
-        return self._timeline
-
-    @property
-    def kb(self):
-        """Knowledge base module for searching user uploaded documents"""
-        if self._kb is None:
-            from reportify_sdk.kb import KBModule
-            self._kb = KBModule(self)
-        return self._kb
-
-    @property
-    def docs(self):
-        """Documents module for accessing document content and metadata"""
-        if self._docs is None:
-            from reportify_sdk.docs import DocsModule
-            self._docs = DocsModule(self)
-        return self._docs
-
-    @property
-    def quant(self):
-        """Quant module for indicators, factors, quotes, and backtesting"""
-        if self._quant is None:
-            from reportify_sdk.quant import QuantModule
-            self._quant = QuantModule(self)
-        return self._quant
-
-    @property
-    def concepts(self):
-        """Concepts module for accessing concept data and feeds"""
-        if self._concepts is None:
-            from reportify_sdk.concepts import ConceptsModule
-            self._concepts = ConceptsModule(self)
-        return self._concepts
-
-    @property
-    def channels(self):
-        """Channels module for searching and following channels"""
-        if self._channels is None:
-            from reportify_sdk.channels import ChannelsModule
-            self._channels = ChannelsModule(self)
-        return self._channels
-
-    @property
-    def chat(self):
-        """Chat module for document-based Q&A"""
-        if self._chat is None:
-            from reportify_sdk.chat import ChatModule
-            self._chat = ChatModule(self)
-        return self._chat
-
-    @property
-    def agent(self):
-        """Agent module for AI-powered conversations and workflows"""
-        if self._agent is None:
-            from reportify_sdk.agent import AgentModule
-            self._agent = AgentModule(self)
-        return self._agent
-
-    @property
-    def user(self):
-        """User module for user-related tools and data"""
-        if self._user is None:
-            from reportify_sdk.user import UserModule
-            self._user = UserModule(self)
-        return self._user
-
-    def close(self):
-        """Close the HTTP client"""
-        self._client.close()
-
-    def __enter__(self):
-        return self
-
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        self.close()