reportify-sdk 0.2.8__py3-none-any.whl → 0.2.9__py3-none-any.whl

reportify_sdk/client.py

@@ -63,13 +63,17 @@ class Reportify:
         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.8",
+            "User-Agent": "reportify-sdk-python/0.2.9",
         }
 
     def _request(
@@ -136,6 +140,23 @@ class Reportify:
         """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
     # -------------------------------------------------------------------------
@@ -145,10 +166,11 @@ class Reportify:
         query: str,
         *,
         num: int = 10,
-        categories: list[str] | None = None,
         symbols: list[str] | None = None,
-        start_date: str | None = None,
-        end_date: 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
@@ -156,10 +178,11 @@ class Reportify:
         Args:
             query: Search query string
             num: Number of results to return (default: 10, max: 100)
-            categories: Filter by document categories
             symbols: Filter by stock symbols (e.g., ["US:AAPL", "HK:0700"])
-            start_date: Start date filter (YYYY-MM-DD)
-            end_date: End date filter (YYYY-MM-DD)
+            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
@@ -169,18 +192,20 @@ class Reportify:
             >>> for doc in docs:
             ...     print(doc["title"])
         """
-        data = {
+        data: dict[str, Any] = {
             "query": query,
             "num": num,
         }
-        if categories:
-            data["categories"] = categories
         if symbols:
             data["symbols"] = symbols
-        if start_date:
-            data["start_date"] = start_date
-        if end_date:
-            data["end_date"] = end_date
+        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", [])
@@ -191,8 +216,9 @@ class Reportify:
         *,
         num: int = 10,
         symbols: list[str] | None = None,
-        start_date: str | None = None,
-        end_date: 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
@@ -201,19 +227,22 @@ class Reportify:
             query: Search query string
             num: Number of results to return
             symbols: Filter by stock symbols
-            start_date: Start date filter (YYYY-MM-DD)
-            end_date: End date filter (YYYY-MM-DD)
+            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 = {"query": query, "num": num}
+        data: dict[str, Any] = {"query": query, "num": num}
         if symbols:
             data["symbols"] = symbols
-        if start_date:
-            data["start_date"] = start_date
-        if end_date:
-            data["end_date"] = end_date
+        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", [])
@@ -224,8 +253,10 @@ class Reportify:
         *,
         num: int = 10,
         symbols: list[str] | None = None,
-        start_date: str | None = None,
-        end_date: 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
@@ -234,19 +265,25 @@ class Reportify:
             query: Search query string
             num: Number of results to return
             symbols: Filter by stock symbols
-            start_date: Start date filter (YYYY-MM-DD)
-            end_date: End date filter (YYYY-MM-DD)
+            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 = {"query": query, "num": num}
+        data: dict[str, Any] = {"query": query, "num": num}
         if symbols:
             data["symbols"] = symbols
-        if start_date:
-            data["start_date"] = start_date
-        if end_date:
-            data["end_date"] = end_date
+        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", [])
@@ -254,67 +291,198 @@ class Reportify:
     def search_filings(
         self,
         query: str,
+        symbols: list[str],
         *,
         num: int = 10,
-        symbols: list[str] | None = None,
-        start_date: str | None = None,
-        end_date: str | None = None,
+        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
-            symbols: Filter by stock symbols
-            start_date: Start date filter (YYYY-MM-DD)
-            end_date: End date filter (YYYY-MM-DD)
+            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 = {"query": query, "num": num}
-        if symbols:
-            data["symbols"] = symbols
-        if start_date:
-            data["start_date"] = start_date
-        if end_date:
-            data["end_date"] = end_date
+        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_date: str | None = None,
-        end_date: str | None = None,
+        start_datetime: str | None = None,
+        end_datetime: str | None = None,
     ) -> list[dict[str, Any]]:
         """
-        Search earnings call transcripts
+        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_date: Start date filter (YYYY-MM-DD)
-            end_date: End date filter (YYYY-MM-DD)
+            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
+            List of minutes transcripts
         """
-        data = {"query": query, "num": num}
+        data: dict[str, Any] = {"query": query, "num": num}
         if symbols:
             data["symbols"] = symbols
-        if start_date:
-            data["start_date"] = start_date
-        if end_date:
-            data["end_date"] = end_date
+        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)
+        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", [])
 
     # -------------------------------------------------------------------------
@@ -369,6 +537,38 @@ class Reportify:
             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()