finatic-server-python 0.1.3__tar.gz → 0.1.4__tar.gz

{finatic_server_python-0.1.3 → finatic_server_python-0.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: finatic-server-python
-Version: 0.1.3
+Version: 0.1.4
 Summary: Python SDK for Finatic Server API
 Author-email: Finatic <support@finatic.dev>
 License: MIT

{finatic_server_python-0.1.3 → finatic_server_python-0.1.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "finatic-server-python"
-version = "0.1.3"
+version = "0.1.4"
 description = "Python SDK for Finatic Server API"
 authors = [{ name = "Finatic", email = "support@finatic.dev" }]
 license = { text = "MIT" }

{finatic_server_python-0.1.3 → finatic_server_python-0.1.4}/src/finatic_server/core/api_client.py

@@ -23,11 +23,13 @@ from ..types import (
     BrokerAccount,
     BrokerOrder,
     BrokerPosition,
+    BrokerBalance,
     BrokerConnection,
     BrokerDataOptions,
     OrdersFilter,
     PositionsFilter,
     AccountsFilter,
+    BalancesFilter,
     OrderResponse,
     BrokerOrderParams,
     BrokerExtras,
@@ -760,6 +762,68 @@ class ApiClient:
             navigation_callback
         )
     
+    async def get_broker_balances(self, page: int = 1, per_page: int = 100, options: Optional[BrokerDataOptions] = None, filters: Optional[BalancesFilter] = None) -> PaginatedResult:
+        """Get broker balances with pagination support."""
+        access_token = await self.get_valid_access_token()
+        offset = (page - 1) * per_page
+        
+        # Build query parameters
+        params = {
+            'limit': str(per_page),
+            'offset': str(offset),
+        }
+        
+        # Add options
+        if options:
+            if options.broker_name:
+                params['broker_id'] = options.broker_name
+            if options.account_id:
+                params['account_id'] = options.account_id
+            if options.symbol:
+                params['symbol'] = options.symbol
+        
+        # Add filters
+        if filters:
+            if filters.broker_id:
+                params['broker_id'] = filters.broker_id
+            if filters.connection_id:
+                params['connection_id'] = filters.connection_id
+            if filters.account_id:
+                params['account_id'] = filters.account_id
+            if filters.is_end_of_day_snapshot is not None:
+                params['is_end_of_day_snapshot'] = str(filters.is_end_of_day_snapshot).lower()
+            if filters.balance_created_after:
+                params['balance_created_after'] = filters.balance_created_after
+            if filters.balance_created_before:
+                params['balance_created_before'] = filters.balance_created_before
+            if filters.with_metadata is not None:
+                params['with_metadata'] = str(filters.with_metadata).lower()
+        
+        # Make the API request
+        response = await self._make_request(
+            'GET',
+            f'{self.base_url}/api/v1/brokers/data/balances',
+            headers={'Authorization': f'Bearer {access_token}'},
+            params=params
+        )
+        
+        # Create pagination info
+        pagination_info = ApiPaginationInfo(
+            has_more=response.get('pagination', {}).get('has_more', False),
+            next_offset=response.get('pagination', {}).get('next_offset', offset),
+            current_offset=response.get('pagination', {}).get('current_offset', offset),
+            limit=response.get('pagination', {}).get('limit', per_page),
+        )
+        
+        # Create navigation callback
+        navigation_callback = self._create_navigation_callback('brokers/data/balances', access_token, params)
+        
+        return PaginatedResult(
+            [BrokerBalance(**balance) for balance in response.get('response_data', [])],
+            pagination_info,
+            navigation_callback
+        )
+    
     # Helper methods to get all data across pages
     async def get_all_broker_accounts(self, options: Optional[BrokerDataOptions] = None, filters: Optional[AccountsFilter] = None) -> List[BrokerAccount]:
         """Get all broker accounts across all pages."""
@@ -811,6 +875,23 @@ class ApiClient:
             page += 1
         
         return all_positions
+
+    async def get_all_broker_balances(self, options: Optional[BrokerDataOptions] = None, filters: Optional[BalancesFilter] = None) -> List[BrokerBalance]:
+        """Get all broker balances across all pages."""
+        all_balances = []
+        page = 1
+        per_page = 100
+        
+        while True:
+            result = await self.get_broker_balances(page, per_page, options, filters)
+            if not result.data:
+                break
+            all_balances.extend(result.data)
+            if not result.has_next:
+                break
+            page += 1
+        
+        return all_balances
     
     async def get_broker_connections_auto(self) -> List[BrokerConnection]:
         """Get broker connections using stored access token."""
@@ -821,6 +902,27 @@ class ApiClient:
             access_token=access_token
         )
         return [BrokerConnection(**connection) for connection in response.get('response_data', [])]
+
+    async def get_balances(self, options: Optional[BrokerDataOptions] = None) -> List[Dict[str, Any]]:
+        """Get account balances."""
+        access_token = await self.get_valid_access_token()
+        response = await self._request(
+            method='GET',
+            path='/brokers/data/balances',
+            params=options or {},
+            access_token=access_token
+        )
+        return response.get('response_data', [])
+
+    async def disconnect_company(self, connection_id: str) -> Dict[str, Any]:
+        """Disconnect a company from a broker connection."""
+        access_token = await self.get_valid_access_token()
+        response = await self._request(
+            method='DELETE',
+            path=f'/brokers/connections/{connection_id}',
+            access_token=access_token
+        )
+        return response
     
     # Trading context methods
     def set_broker(self, broker: str):

{finatic_server_python-0.1.3 → finatic_server_python-0.1.4}/src/finatic_server/core/client.py

@@ -21,11 +21,13 @@ from ..types import (
     BrokerAccount,
     BrokerOrder,
     BrokerPosition,
+    BrokerBalance,
     BrokerConnection,
     BrokerDataOptions,
     OrdersFilter,
     PositionsFilter,
     AccountsFilter,
+    BalancesFilter,
     OrderResponse,
     BrokerOrderParams,
     BrokerExtras,
@@ -176,6 +178,23 @@ class FinaticServerClient:
             )
         
         return session_response
+
+    async def set_user_id(self, user_id: str) -> None:
+        """Set the user ID for the current session.
+        
+        Args:
+            user_id: The user ID to set for the session
+            
+        Raises:
+            AuthenticationError: If session is not initialized
+        """
+        if not self._session_id:
+            raise AuthenticationError("Session not initialized. Please start a session first.")
+        
+        self._user_id = user_id
+        # Update the API client with the new user ID if needed
+        if hasattr(self._api_client, 'set_user_id'):
+            await self._api_client.set_user_id(user_id)
     
     async def request_otp(self, email: str) -> OtpRequestResponse:
         """Request OTP for session authentication.
@@ -294,11 +313,16 @@ class FinaticServerClient:
         
         return auth_response
     
-    async def get_portal_url(self) -> str:
-        """Get the portal URL for user authentication.
+    async def get_portal_url(self, theme: Optional[Dict[str, Any]] = None, brokers: Optional[List[str]] = None, email: Optional[str] = None) -> str:
+        """Get the portal URL for user authentication with optional theming and configuration.
         
+        Args:
+            theme: Optional theme configuration (preset or custom)
+            brokers: Optional list of broker names to filter by
+            email: Optional email to pre-fill in the portal
+            
         Returns:
-            Portal URL string
+            Portal URL string with applied configuration
             
         Raises:
             AuthenticationError: If session is not initialized
@@ -308,9 +332,78 @@ class FinaticServerClient:
         
         try:
             response = await self._api_client.get_portal_url(self._session_id)
-            return response.data['portal_url']
+            portal_url = response.data['portal_url']
+            
+            # Use stored configuration as defaults if not provided
+            final_theme = theme or getattr(self, '_portal_theme', None)
+            final_brokers = brokers or getattr(self, '_portal_brokers', None)
+            final_email = email or getattr(self, '_portal_email', None)
+            
+            # Apply theming and configuration to the URL
+            portal_url = self._apply_portal_config(portal_url, final_theme, final_brokers, final_email)
+            
+            return portal_url
         except Exception as e:
             raise AuthenticationError(f"Failed to get portal URL: {str(e)}")
+    
+    def _apply_portal_config(self, base_url: str, theme: Optional[Dict[str, Any]] = None, brokers: Optional[List[str]] = None, email: Optional[str] = None) -> str:
+        """Apply theming and configuration to a portal URL."""
+        try:
+            from urllib.parse import urlparse, urlunparse, parse_qs, urlencode
+            import base64
+            import json
+            
+            parsed = urlparse(base_url)
+            query_params = parse_qs(parsed.query)
+            
+            # Apply theme configuration
+            if theme:
+                if theme.get('preset'):
+                    query_params['theme'] = [theme['preset']]
+                elif theme.get('custom'):
+                    # Encode custom theme as base64 JSON
+                    theme_json = json.dumps(theme['custom'])
+                    theme_b64 = base64.b64encode(theme_json.encode()).decode()
+                    query_params['theme'] = ['custom']
+                    query_params['themeObject'] = [theme_b64]
+            
+            # Apply broker filtering
+            if brokers:
+                # Convert broker names to IDs and encode
+                supported_brokers = {
+                    'alpaca': 'alpaca',
+                    'robinhood': 'robinhood',
+                    'tasty_trade': 'tasty_trade',
+                    'ninja_trader': 'ninja_trader',
+                    'tradovate': 'ninja_trader',  # Alias
+                    'interactive_brokers': 'interactive_brokers',
+                }
+                
+                broker_ids = []
+                for broker in brokers:
+                    broker_id = supported_brokers.get(broker.lower())
+                    if broker_id:
+                        broker_ids.append(broker_id)
+                
+                if broker_ids:
+                    brokers_json = json.dumps(broker_ids)
+                    brokers_b64 = base64.b64encode(brokers_json.encode()).decode()
+                    query_params['brokers'] = [brokers_b64]
+            
+            # Apply email parameter
+            if email:
+                query_params['email'] = [email]
+            
+            # Rebuild URL with new query parameters
+            new_query = urlencode(query_params, doseq=True)
+            new_parsed = parsed._replace(query=new_query)
+            
+            return urlunparse(new_parsed)
+            
+        except Exception as e:
+            # If URL manipulation fails, return original URL
+            print(f"Warning: Failed to apply portal configuration: {e}")
+            return base_url
 
     async def get_session_user(self) -> Dict[str, Any]:
         """Get the user and tokens for a completed session.
@@ -539,9 +632,20 @@ class FinaticServerClient:
         """Get broker positions with pagination support."""
         return await self._api_client.get_broker_positions(page, per_page, options, filters)
     
+    async def get_broker_balances(self, page: int = 1, per_page: int = 100, options: Optional[BrokerDataOptions] = None, filters: Optional[BalancesFilter] = None) -> PaginatedResult:
+        """Get broker balances with pagination support."""
+        return await self._api_client.get_broker_balances(page, per_page, options, filters)
+    
     async def get_broker_connections(self) -> List[BrokerConnection]:
         """Get broker connections using stored access token."""
         return await self._api_client.get_broker_connections_auto()
+
+    async def get_balances(self, options: Optional[BrokerDataOptions] = None) -> List[Dict[str, Any]]:
+        """Get account balances for the authenticated user."""
+        if not self.is_authenticated():
+            raise AuthenticationError("Not authenticated. Please complete authentication first.")
+        
+        return await self._api_client.get_balances(options)
     
     # Helper methods to get all data across pages
     async def get_all_broker_accounts(self, options: Optional[BrokerDataOptions] = None, filters: Optional[AccountsFilter] = None) -> List[BrokerAccount]:
@@ -556,6 +660,170 @@ class FinaticServerClient:
         """Get all broker positions across all pages."""
         return await self._api_client.get_all_broker_positions(options, filters)
 
+    async def get_all_orders(self, options: Optional[BrokerDataOptions] = None, filters: Optional[OrdersFilter] = None) -> List[BrokerOrder]:
+        """Get all orders across all pages (convenience method)."""
+        return await self._api_client.get_all_broker_orders(options, filters)
+
+    async def get_all_positions(self, options: Optional[BrokerDataOptions] = None, filters: Optional[PositionsFilter] = None) -> List[BrokerPosition]:
+        """Get all positions across all pages (convenience method)."""
+        return await self._api_client.get_all_broker_positions(options, filters)
+
+    async def get_all_accounts(self, options: Optional[BrokerDataOptions] = None, filters: Optional[AccountsFilter] = None) -> List[BrokerAccount]:
+        """Get all accounts across all pages (convenience method)."""
+        return await self._api_client.get_all_broker_accounts(options, filters)
+
+    async def disconnect_company(self, connection_id: str) -> Dict[str, Any]:
+        """Disconnect a company from a broker connection.
+        
+        Args:
+            connection_id: The connection ID to disconnect
+            
+        Returns:
+            Disconnect response data
+            
+        Raises:
+            AuthenticationError: If not authenticated
+        """
+        if not self.is_authenticated():
+            raise AuthenticationError("Not authenticated. Please complete authentication first.")
+        
+        return await self._api_client.disconnect_company(connection_id)
+
+    # Convenience filtering methods
+    async def get_open_positions(self, options: Optional[BrokerDataOptions] = None, filters: Optional[PositionsFilter] = None) -> List[BrokerPosition]:
+        """Get only open positions."""
+        if not self.is_authenticated():
+            raise AuthenticationError("Not authenticated. Please complete authentication first.")
+        
+        open_filters = {**(filters or {}), 'position_status': 'open'}
+        result = await self.get_broker_positions(options=options, filters=open_filters)
+        return result.data or []
+
+    async def get_filled_orders(self, options: Optional[BrokerDataOptions] = None, filters: Optional[OrdersFilter] = None) -> List[BrokerOrder]:
+        """Get only filled orders."""
+        if not self.is_authenticated():
+            raise AuthenticationError("Not authenticated. Please complete authentication first.")
+        
+        filled_filters = {**(filters or {}), 'status': 'filled'}
+        result = await self.get_broker_orders(options=options, filters=filled_filters)
+        return result.data or []
+
+    async def get_pending_orders(self, options: Optional[BrokerDataOptions] = None, filters: Optional[OrdersFilter] = None) -> List[BrokerOrder]:
+        """Get only pending orders."""
+        if not self.is_authenticated():
+            raise AuthenticationError("Not authenticated. Please complete authentication first.")
+        
+        pending_filters = {**(filters or {}), 'status': 'pending'}
+        result = await self.get_broker_orders(options=options, filters=pending_filters)
+        return result.data or []
+
+    async def get_active_accounts(self, options: Optional[BrokerDataOptions] = None, filters: Optional[AccountsFilter] = None) -> List[BrokerAccount]:
+        """Get only active accounts."""
+        if not self.is_authenticated():
+            raise AuthenticationError("Not authenticated. Please complete authentication first.")
+        
+        active_filters = {**(filters or {}), 'status': 'active'}
+        return await self.get_broker_accounts(options=options, filters=active_filters)
+
+    async def get_orders_by_symbol(self, symbol: str, options: Optional[BrokerDataOptions] = None, filters: Optional[OrdersFilter] = None) -> List[BrokerOrder]:
+        """Get orders filtered by symbol."""
+        if not self.is_authenticated():
+            raise AuthenticationError("Not authenticated. Please complete authentication first.")
+        
+        symbol_filters = {**(filters or {}), 'symbol': symbol}
+        result = await self.get_broker_orders(options=options, filters=symbol_filters)
+        return result.data or []
+
+    async def get_positions_by_symbol(self, symbol: str, options: Optional[BrokerDataOptions] = None, filters: Optional[PositionsFilter] = None) -> List[BrokerPosition]:
+        """Get positions filtered by symbol."""
+        if not self.is_authenticated():
+            raise AuthenticationError("Not authenticated. Please complete authentication first.")
+        
+        symbol_filters = {**(filters or {}), 'symbol': symbol}
+        result = await self.get_broker_positions(options=options, filters=symbol_filters)
+        return result.data or []
+
+    async def get_orders_by_broker(self, broker_id: str, options: Optional[BrokerDataOptions] = None, filters: Optional[OrdersFilter] = None) -> List[BrokerOrder]:
+        """Get orders filtered by broker."""
+        if not self.is_authenticated():
+            raise AuthenticationError("Not authenticated. Please complete authentication first.")
+        
+        broker_filters = {**(filters or {}), 'broker_id': broker_id}
+        result = await self.get_broker_orders(options=options, filters=broker_filters)
+        return result.data or []
+
+    async def get_positions_by_broker(self, broker_id: str, options: Optional[BrokerDataOptions] = None, filters: Optional[PositionsFilter] = None) -> List[BrokerPosition]:
+        """Get positions filtered by broker."""
+        if not self.is_authenticated():
+            raise AuthenticationError("Not authenticated. Please complete authentication first.")
+        
+        broker_filters = {**(filters or {}), 'broker_id': broker_id}
+        result = await self.get_broker_positions(options=options, filters=broker_filters)
+        return result.data or []
+
+    # Pagination helper methods
+    async def get_orders_page(self, page: int, per_page: int, options: Optional[BrokerDataOptions] = None, filters: Optional[OrdersFilter] = None) -> PaginatedResult:
+        """Get a specific page of orders."""
+        if not self.is_authenticated():
+            raise AuthenticationError("Not authenticated. Please complete authentication first.")
+        
+        return await self.get_broker_orders(page=page, per_page=per_page, options=options, filters=filters)
+
+    async def get_positions_page(self, page: int, per_page: int, options: Optional[BrokerDataOptions] = None, filters: Optional[PositionsFilter] = None) -> PaginatedResult:
+        """Get a specific page of positions."""
+        if not self.is_authenticated():
+            raise AuthenticationError("Not authenticated. Please complete authentication first.")
+        
+        return await self.get_broker_positions(page=page, per_page=per_page, options=options, filters=filters)
+
+    async def get_accounts_page(self, page: int, per_page: int, options: Optional[BrokerDataOptions] = None, filters: Optional[AccountsFilter] = None) -> List[BrokerAccount]:
+        """Get a specific page of accounts."""
+        if not self.is_authenticated():
+            raise AuthenticationError("Not authenticated. Please complete authentication first.")
+        
+        return await self.get_broker_accounts(page=page, per_page=per_page, options=options, filters=filters)
+
+    async def get_next_orders_page(self, current_result: PaginatedResult) -> Optional[PaginatedResult]:
+        """Get the next page of orders."""
+        if not self.is_authenticated():
+            raise AuthenticationError("Not authenticated. Please complete authentication first.")
+        
+        if not current_result.has_next():
+            return None
+        
+        # For now, return None as the API doesn't support cursor-based pagination
+        # This would need to be implemented based on the actual API pagination structure
+        return None
+
+    async def get_next_positions_page(self, current_result: PaginatedResult) -> Optional[PaginatedResult]:
+        """Get the next page of positions."""
+        if not self.is_authenticated():
+            raise AuthenticationError("Not authenticated. Please complete authentication first.")
+        
+        if not current_result.has_next():
+            return None
+        
+        # For now, return None as the API doesn't support cursor-based pagination
+        # This would need to be implemented based on the actual API pagination structure
+        return None
+
+    async def get_next_accounts_page(self, current_page: int, per_page: int, options: Optional[BrokerDataOptions] = None, filters: Optional[AccountsFilter] = None) -> Optional[List[BrokerAccount]]:
+        """Get the next page of accounts."""
+        if not self.is_authenticated():
+            raise AuthenticationError("Not authenticated. Please complete authentication first.")
+        
+        next_page = current_page + 1
+        accounts = await self.get_broker_accounts(page=next_page, per_page=per_page, options=options, filters=filters)
+        
+        if not accounts:
+            return None
+        
+        return accounts
+
+    async def get_all_broker_balances(self, options: Optional[BrokerDataOptions] = None, filters: Optional[BalancesFilter] = None) -> List[BrokerBalance]:
+        """Get all broker balances across all pages."""
+        return await self._api_client.get_all_broker_balances(options, filters)
+
     # ============================================================================
     # TRADING METHODS
     # ============================================================================
@@ -939,6 +1207,49 @@ class FinaticServerClient:
         except Exception as e:
             print(f"Warning: Error during client close: {e}")
     
+    # Portal configuration convenience methods
+    def set_portal_theme(self, theme: Dict[str, Any]) -> None:
+        """Set the default portal theme configuration.
+        
+        Args:
+            theme: Theme configuration (preset or custom)
+        """
+        self._portal_theme = theme
+    
+    def set_portal_brokers(self, brokers: List[str]) -> None:
+        """Set the default broker filter for the portal.
+        
+        Args:
+            brokers: List of broker names to filter by
+        """
+        self._portal_brokers = brokers
+    
+    def set_portal_email(self, email: str) -> None:
+        """Set the default email for the portal.
+        
+        Args:
+            email: Email to pre-fill in the portal
+        """
+        self._portal_email = email
+    
+    def get_portal_config(self) -> Dict[str, Any]:
+        """Get the current portal configuration.
+        
+        Returns:
+            Dictionary with current portal configuration
+        """
+        return {
+            'theme': getattr(self, '_portal_theme', None),
+            'brokers': getattr(self, '_portal_brokers', None),
+            'email': getattr(self, '_portal_email', None),
+        }
+    
+    def clear_portal_config(self) -> None:
+        """Clear all portal configuration settings."""
+        self._portal_theme = None
+        self._portal_brokers = None
+        self._portal_email = None
+    
     def __del__(self):
         """Destructor to ensure cleanup if context manager is not used."""
         try:

{finatic_server_python-0.1.3 → finatic_server_python-0.1.4}/src/finatic_server/types/__init__.py

@@ -47,12 +47,14 @@ from .broker import (
     BrokerAccount,
     BrokerOrder,
     BrokerPosition,
+    BrokerBalance,
     BrokerInfo,
     BrokerConnection,
     BrokerDataOptions,
     OrdersFilter,
     PositionsFilter,
     AccountsFilter,
+    BalancesFilter,
 )
 
 __all__ = [
@@ -94,10 +96,12 @@ __all__ = [
     "BrokerAccount",
     "BrokerOrder",
     "BrokerPosition",
+    "BrokerBalance",
     "BrokerInfo",
     "BrokerConnection",
     "BrokerDataOptions",
     "OrdersFilter",
     "PositionsFilter",
     "AccountsFilter",
+    "BalancesFilter",
 ] 

{finatic_server_python-0.1.3 → finatic_server_python-0.1.4}/src/finatic_server/types/broker.py

@@ -41,6 +41,12 @@ class BrokerAccount(BaseModel):
     created_at: str = Field(..., description="Creation timestamp")
     updated_at: str = Field(..., description="Last update timestamp")
     last_synced_at: str = Field(..., description="Last sync timestamp")
+    positions_synced_at: Optional[str] = Field(None, description="When positions were last synced")
+    orders_synced_at: Optional[str] = Field(None, description="When orders were last synced")
+    balances_synced_at: Optional[str] = Field(None, description="When balances were last synced")
+    account_created_at: Optional[str] = Field(None, description="When the account was created")
+    account_updated_at: Optional[str] = Field(None, description="When the account was last updated")
+    account_first_trade_at: Optional[str] = Field(None, description="When the first trade occurred")
 
 
 class BrokerOrder(BaseModel):
@@ -84,6 +90,25 @@ class BrokerPosition(BaseModel):
     updated_at: str = Field(..., description="Last update timestamp")
 
 
+class BrokerBalance(BaseModel):
+    """Broker balance information."""
+    
+    id: str = Field(..., description="Balance ID")
+    account_id: str = Field(..., description="Account ID")
+    total_cash_value: Optional[float] = Field(None, description="Total cash value")
+    net_liquidation_value: Optional[float] = Field(None, description="Net liquidation value")
+    initial_margin: Optional[float] = Field(None, description="Initial margin")
+    maintenance_margin: Optional[float] = Field(None, description="Maintenance margin")
+    available_to_withdraw: Optional[float] = Field(None, description="Available to withdraw")
+    total_realized_pnl: Optional[float] = Field(None, description="Total realized P&L")
+    balance_created_at: Optional[str] = Field(None, description="Balance creation timestamp")
+    balance_updated_at: Optional[str] = Field(None, description="Balance update timestamp")
+    is_end_of_day_snapshot: Optional[bool] = Field(None, description="Whether this is an end-of-day snapshot")
+    raw_payload: Optional[Dict[str, Any]] = Field(None, description="Raw broker payload")
+    created_at: str = Field(..., description="Creation timestamp")
+    updated_at: str = Field(..., description="Last update timestamp")
+
+
 class BrokerConnection(BaseModel):
     """Broker connection information."""
     
@@ -144,4 +169,18 @@ class AccountsFilter(BaseModel):
     currency: Optional[str] = Field(None, description="Filter by currency")
     limit: Optional[int] = Field(None, description="Result limit")
     offset: Optional[int] = Field(None, description="Result offset")
+    with_metadata: Optional[bool] = Field(None, description="Include metadata")
+
+
+class BalancesFilter(BaseModel):
+    """Filter options for balances pagination."""
+    
+    broker_id: Optional[str] = Field(None, description="Filter by broker ID")
+    connection_id: Optional[str] = Field(None, description="Filter by connection ID")
+    account_id: Optional[str] = Field(None, description="Filter by account ID")
+    is_end_of_day_snapshot: Optional[bool] = Field(None, description="Filter by end-of-day snapshot status")
+    limit: Optional[int] = Field(None, description="Result limit")
+    offset: Optional[int] = Field(None, description="Result offset")
+    balance_created_after: Optional[str] = Field(None, description="Filter by balance creation date after (ISO 8601)")
+    balance_created_before: Optional[str] = Field(None, description="Filter by balance creation date before (ISO 8601)")
     with_metadata: Optional[bool] = Field(None, description="Include metadata") 

{finatic_server_python-0.1.3 → finatic_server_python-0.1.4}/src/finatic_server_python.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: finatic-server-python
-Version: 0.1.3
+Version: 0.1.4
 Summary: Python SDK for Finatic Server API
 Author-email: Finatic <support@finatic.dev>
 License: MIT