laplace-python-sdk 1.1.1__tar.gz → 1.2.1__tar.gz

{laplace_python_sdk-1.1.1/src/laplace_python_sdk.egg-info → laplace_python_sdk-1.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: laplace-python-sdk
-Version: 1.1.1
+Version: 1.2.1
 Summary: Python SDK for Laplace stock data platform
 Author: Laplace SDK Team
 License: MIT

{laplace_python_sdk-1.1.1 → laplace_python_sdk-1.2.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "laplace-python-sdk"
-version = "1.1.1"
+version = "1.2.1"
 description = "Python SDK for Laplace stock data platform"
 readme = "README.md"
 requires-python = ">=3.8"
@@ -64,16 +64,18 @@ profile = "black"
 line_length = 100
 
 [tool.mypy]
-python_version = "1.1.1"
+python_version = "1.2.1"
 strict = true
 warn_return_any = true
 warn_unused_configs = true
 
 [tool.ruff]
 line-length = 100
-target-version = "1.1.1"
+target-version = "1.2.1"
+
+[tool.ruff.lint]
 select = ["E", "W", "F", "I", "N", "B", "UP"]
 ignore = ["B008", "N805"]
 
-[tool.ruff.isort]
+[tool.ruff.lint.isort]
 known-first-party = ["laplace"]

{laplace_python_sdk-1.1.1 → laplace_python_sdk-1.2.1}/src/laplace/models.py

@@ -908,6 +908,25 @@ class News(BaseModel):
 
     quality_score: int = Field(alias="qualityScore")
 
+    model_config = {"populate_by_name": True}
+
+class NewsV2(BaseModel):
+    created_at: datetime = Field(alias="createdAt")
+    url: str
+    image_url: str = Field(alias="imageUrl")
+    timestamp: datetime
+    publisher_url: str = Field(alias="publisherUrl")
+
+    publisher: NewsPublisher
+
+    tickers: Optional[List[NewsTicker]] = None
+    categories: Optional[NewsCategory] = None
+    sectors: Optional[NewsSector] = None
+    content: Optional[NewsContent] = None
+    industries: Optional[NewsIndustry] = None
+
+    quality_score: int = Field(alias="qualityScore")
+
     model_config = {"populate_by_name": True}
 class NewsHighlight(BaseModel):
     consumer: List[str]

laplace_python_sdk-1.2.1/src/laplace/news.py

@@ -0,0 +1,333 @@
+import asyncio
+import json
+import urllib.parse
+from typing import AsyncGenerator, Dict, Generic, List, Optional
+
+import httpx
+
+from laplace.base import BaseClient
+
+from .models import (
+    Locale,
+    News,
+    NewsV2,
+    NewsHighlight,
+    NewsOrderBy,
+    NewsType,
+    PaginatedResponse,
+    PaginationPageSize,
+    Region,
+    SortDirection,
+    T,
+)
+
+
+class NewsStreamResult(Generic[T]):
+    """Result wrapper for news stream data."""
+
+    def __init__(self, data: Optional[T] = None, error: Optional[str] = None):
+        self.data = data
+        self.error = error
+
+    @property
+    def is_error(self) -> bool:
+        return self.error is not None
+
+
+class NewsStream:
+    """Handles Server-Sent Events (SSE) stream for news."""
+
+    def __init__(
+        self,
+        base_client: BaseClient,
+        locale: Locale,
+        region: Region,
+        sectors: Optional[List[str]] = None,
+        tickers: Optional[List[str]] = None,
+        categories: Optional[List[str]] = None,
+        industries: Optional[List[str]] = None,
+    ):
+        self.base_client = base_client
+        self.locale = locale
+        self.region = region
+        self.sectors = sectors
+        self.tickers = tickers
+        self.categories = categories
+        self.industries = industries
+        self._task: Optional[asyncio.Task] = None
+        self._queue: Optional[asyncio.Queue[NewsStreamResult[List[NewsV2]]]] = None
+        self._is_closed = False
+
+    async def subscribe(self) -> None:
+        """Subscribe to news updates stream."""
+        await self._cleanup_existing_stream()
+
+        self._queue = asyncio.Queue[NewsStreamResult[List[NewsV2]]]()
+        self._is_closed = False
+        self._task = asyncio.create_task(self._start_streaming())
+
+    async def receive(self) -> AsyncGenerator[NewsStreamResult[List[NewsV2]], None]:
+        """Receive news data from the stream."""
+        if not self._queue:
+            raise RuntimeError("Not subscribed. Call subscribe() first.")
+
+        while not self._is_closed:
+            try:
+                result = await asyncio.wait_for(self._queue.get(), timeout=1.0)
+                yield result
+            except asyncio.TimeoutError:
+                continue
+            except asyncio.CancelledError:
+                break
+
+    async def close(self) -> None:
+        """Close the stream and cleanup resources."""
+        if self._is_closed:
+            return
+
+        self._is_closed = True
+        await self._cleanup_existing_stream()
+
+    async def _cleanup_existing_stream(self) -> None:
+        """Cancel and cleanup existing streaming task."""
+        if self._task and not self._task.done():
+            self._task.cancel()
+            try:
+                await self._task
+            except asyncio.CancelledError:
+                pass
+
+    def _build_stream_url(self) -> str:
+        """Build the streaming URL for the news endpoint."""
+        url = f"{self.base_client.base_url}/v1/news/stream"
+        params = {"locale": self.locale, "region": self.region.value}
+        if self.sectors:
+            params["sectors"] = ",".join(self.sectors)
+        if self.tickers:
+            params["tickers"] = ",".join(self.tickers)
+        if self.categories:
+            params["categories"] = ",".join(self.categories)
+        if self.industries:
+            params["industries"] = ",".join(self.industries)
+
+        query_string = urllib.parse.urlencode(params)
+        return f"{url}?{query_string}"
+
+    async def _start_streaming(self) -> None:
+        """Start the SSE streaming connection."""
+        url = self._build_stream_url()
+        headers = {
+            "Accept": "text/event-stream",
+            "Cache-Control": "no-cache",
+            "Connection": "keep-alive",
+            "Authorization": f"Bearer {self.base_client.api_key}",
+        }
+
+        try:
+            async with httpx.AsyncClient(timeout=30.0) as client:
+                async with client.stream("GET", url, headers=headers) as response:
+                    if response.status_code != 200:
+                        error_body = await response.aread()
+                        error_msg = f"News stream failed: {response.status_code} - "
+                        error_msg += f"{error_body.decode()}"
+                        await self._put_error(error_msg)
+                        return
+
+                    await self._process_stream_lines(response)
+
+        except (httpx.TimeoutException, httpx.ConnectError) as e:
+            await self._put_error(f"Connection error: {e}")
+        except Exception as e:
+            await self._put_error(f"Streaming error: {e}")
+        finally:
+            self._is_closed = True
+
+    async def _process_stream_lines(self, response) -> None:
+        """Process individual lines from the SSE stream."""
+        async for line in response.aiter_lines():
+            if self._is_closed:
+                break
+
+            if not line.startswith("data:"):
+                continue
+
+            try:
+                # Parse the JSON data after "data:" prefix
+                json_data = line[5:].strip()  # Remove "data:" prefix
+                if not json_data:
+                    continue
+
+                parsed_data = json.loads(json_data)
+
+                # Process array of news items
+                news_items = [NewsV2(**item) for item in parsed_data]
+                result = NewsStreamResult[List[NewsV2]](data=news_items)
+                await self._queue.put(result)
+
+            except Exception as e:
+                await self._put_error(f"Error processing news data: {e}")
+                continue
+
+    async def _put_error(self, error_message: str) -> None:
+        """Put an error result in the queue."""
+        if self._queue:
+            error_result = NewsStreamResult[List[NewsV2]](error=error_message)
+            await self._queue.put(error_result)
+
+
+class NewsClient:
+    """Client for news API endpoints."""
+
+    def __init__(self, base_client: BaseClient):
+        """Initialize the news client.
+
+        Args:
+            base_client: The base Laplace client instance
+        """
+        self._client = base_client
+
+    def get_news(
+        self,
+        locale: Locale,
+        region: Region,
+        news_type: Optional[NewsType] = None,
+        news_order_by: Optional[NewsOrderBy] = None,
+        direction: Optional[SortDirection] = None,
+        extra_filters: Optional[str] = None,
+        page: int = 0,
+        page_size: PaginationPageSize = PaginationPageSize.PAGE_SIZE_10,
+    ) -> PaginatedResponse[News]:
+        """Retrieve paginated news.
+
+        Args:
+            locale: Locale code (e.g. "tr", "en")
+            region: Region enum (e.g. Region.TR)
+            news_type: Optional news type filter
+            news_order_by: Optional sorting field
+            direction: Optional sort direction
+            extra_filters: Optional extra filters (API-specific)
+            page: Page number (default: 0)
+            page_size: Page size enum (default: 10)
+
+        Returns:
+            PaginatedResponse[News]
+        """
+        params: Dict[str, object] = {
+            "locale": locale,
+            "region": region.value,
+            "page": page,
+            "size": page_size.value,
+        }
+
+        if news_type is not None:
+            params["newsType"] = news_type.value
+        if news_order_by is not None:
+            params["orderBy"] = news_order_by.value
+        if direction is not None:
+            params["orderByDirection"] = direction.value
+        if extra_filters:
+            params["extraFilters"] = extra_filters
+
+        response = self._client.get("v1/news", params=params)
+        return PaginatedResponse[News](**response)
+
+    def get_news_v2(
+        self,
+        locale: Locale,
+        region: Region,
+        news_type: Optional[NewsType] = None,
+        news_order_by: Optional[NewsOrderBy] = None,
+        direction: Optional[SortDirection] = None,
+        extra_filters: Optional[str] = None,
+        page: int = 0,
+        page_size: PaginationPageSize = PaginationPageSize.PAGE_SIZE_10,
+    ) -> PaginatedResponse[NewsV2]:
+        """Retrieve paginated news (v2).
+
+        Args:
+            locale: Locale code (e.g. "tr", "en")
+            region: Region enum (e.g. Region.TR)
+            news_type: Optional news type filter
+            news_order_by: Optional sorting field
+            direction: Optional sort direction
+            extra_filters: Optional extra filters (API-specific)
+            page: Page number (default: 0)
+            page_size: Page size enum (default: 10)
+
+        Returns:
+            PaginatedResponse[NewsV2]
+        """
+        params: Dict[str, object] = {
+            "locale": locale,
+            "region": region.value,
+            "page": page,
+            "size": page_size.value,
+        }
+
+        if news_type is not None:
+            params["newsType"] = news_type.value
+        if news_order_by is not None:
+            params["orderBy"] = news_order_by.value
+        if direction is not None:
+            params["orderByDirection"] = direction.value
+        if extra_filters:
+            params["extraFilters"] = extra_filters
+
+        response = self._client.get("v2/news", params=params)
+        return PaginatedResponse[NewsV2](**response)
+
+    def get_highlights(
+        self,
+        locale: Locale,
+        region: Region
+    ) -> NewsHighlight:
+        """Retrieve news highlights.
+
+        Args:
+            locale: Locale code (e.g. "tr", "en")
+            region: Region enum (e.g. Region.TR)
+
+        Returns:
+            NewsHighlight
+        """
+        params: Dict[str, object] = {
+            "locale": locale,
+            "region": region.value
+        }
+
+        response = self._client.get("v1/news/highlights", params=params)
+        return NewsHighlight(**response)
+
+    async def get_news_stream(
+        self,
+        locale: Locale,
+        region: Region,
+        sectors: Optional[List[str]] = None,
+        tickers: Optional[List[str]] = None,
+        categories: Optional[List[str]] = None,
+        industries: Optional[List[str]] = None,
+    ) -> NewsStream:
+        """Start streaming news updates.
+
+        Args:
+            locale: Locale code (e.g., "tr", "en")
+            region: Region enum (e.g. Region.TR)
+            sectors: Optional list of sectors
+            tickers: Optional list of tickers
+            categories: Optional list of categories
+            industries: Optional list of industries
+
+        Returns:
+            NewsStream for consuming news items
+        """
+        stream = NewsStream(
+            self._client,
+            locale,
+            region,
+            sectors=sectors,
+            tickers=tickers,
+            categories=categories,
+            industries=industries,
+        )
+        await stream.subscribe()
+        return stream

{laplace_python_sdk-1.1.1 → laplace_python_sdk-1.2.1/src/laplace_python_sdk.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: laplace-python-sdk
-Version: 1.1.1
+Version: 1.2.1
 Summary: Python SDK for Laplace stock data platform
 Author: Laplace SDK Team
 License: MIT

laplace_python_sdk-1.1.1/src/laplace/news.py

@@ -1,94 +0,0 @@
-from typing import Dict, Optional
-
-from laplace.base import BaseClient
-
-from .models import (
-    Locale,
-    News,
-    NewsHighlight,
-    NewsOrderBy,
-    NewsType,
-    PaginatedResponse,
-    Region,
-    PaginationPageSize,
-    SortDirection,
-)
-
-
-class NewsClient:
-    """Client for news API endpoints."""
-
-    def __init__(self, base_client: BaseClient):
-        """Initialize the news client.
-
-        Args:
-            base_client: The base Laplace client instance
-        """
-        self._client = base_client
-
-    def get_news(
-        self,
-        locale: Locale,
-        region: Region,
-        news_type: Optional[NewsType] = None,
-        news_order_by: Optional[NewsOrderBy] = None,
-        direction: Optional[SortDirection] = None,
-        extra_filters: Optional[str] = None,
-        page: int = 0,
-        page_size: PaginationPageSize = PaginationPageSize.PAGE_SIZE_10,
-    ) -> PaginatedResponse[News]:
-        """Retrieve paginated news.
-
-        Args:
-            locale: Locale code (e.g. "tr", "en")
-            region: Region enum (e.g. Region.TR)
-            news_type: Optional news type filter
-            news_order_by: Optional sorting field
-            direction: Optional sort direction
-            extra_filters: Optional extra filters (API-specific)
-            page: Page number (default: 0)
-            page_size: Page size enum (default: 10)
-
-        Returns:
-            PaginatedResponse[News]
-        """
-        params: Dict[str, object] = {
-            "locale": locale,
-            "region": region.value,
-            "page": page,
-            "size": page_size.value,
-        }
-
-        if news_type is not None:
-            params["newsType"] = news_type.value
-        if news_order_by is not None:
-            params["orderBy"] = news_order_by.value
-        if direction is not None:
-            params["orderByDirection"] = direction.value
-        if extra_filters:
-            params["extraFilters"] = extra_filters
-
-        response = self._client.get("v1/news", params=params)
-        return PaginatedResponse[News](**response)
-
-    def get_highlights(
-        self,
-        locale: Locale,
-        region: Region
-    ) -> NewsHighlight:
-        """Retrieve news highlights.
-
-        Args:
-            locale: Locale code (e.g. "tr", "en")
-            region: Region enum (e.g. Region.TR)
-
-        Returns:
-            NewsHighlight
-        """
-        params: Dict[str, object] = {
-            "locale": locale,
-            "region": region.value
-        }
-
-        response = self._client.get("v1/news/highlights", params=params)
-        return NewsHighlight(**response)