finatic-server-python 0.1.0__py3-none-any.whl

finatic_server/types/auth.py

@@ -0,0 +1,142 @@
+"""Authentication-related type definitions."""
+
+from datetime import datetime
+from typing import Optional, Dict, Any
+from pydantic import BaseModel, Field
+
+
+class UserToken(BaseModel):
+    """User authentication token information."""
+    
+    access_token: str = Field(..., description="Access token")
+    refresh_token: str = Field(..., description="Refresh token")
+    expires_in: int = Field(..., description="Token expiration time in seconds")
+    user_id: str = Field(..., description="User ID")
+    token_type: str = Field(default="Bearer", description="Token type")
+    scope: str = Field(default="", description="Token scope")
+
+
+class SessionResponseData(BaseModel):
+    """Session response data structure."""
+    
+    session_id: str = Field(..., description="Unique session identifier")
+    state: Optional[str] = Field(None, description="Session state (PENDING, ACTIVE, etc.)")
+    device_info: Optional[Dict[str, str]] = Field(None, description="Device information")
+    company_id: Optional[str] = Field(None, description="Company ID")
+    status: Optional[str] = Field(None, description="Session status")
+    expires_at: Optional[str] = Field(None, description="Session expiration time")
+    user_id: Optional[str] = Field(None, description="User ID")
+    auto_login: Optional[bool] = Field(None, description="Auto login flag")
+    access_token: Optional[str] = Field(None, description="Access token")
+    refresh_token: Optional[str] = Field(None, description="Refresh token")
+    expires_in: Optional[int] = Field(None, description="Token expiration time in seconds")
+    token_type: Optional[str] = Field(None, description="Token type")
+    scope: Optional[str] = Field(None, description="Token scope")
+
+
+class SessionResponse(BaseModel):
+    """Session initialization response."""
+    
+    # Handle both nested data structure and flat structure
+    data: Optional[SessionResponseData] = Field(None, description="Session data (nested)")
+    message: Optional[str] = Field(None, description="Response message")
+    
+    # Flat structure fields (for direct API responses)
+    session_id: Optional[str] = Field(None, description="Session ID (flat structure)")
+    auto_login: Optional[bool] = Field(None, description="Auto login flag (flat structure)")
+    company_id: Optional[str] = Field(None, description="Company ID (flat structure)")
+    state: Optional[str] = Field(None, description="Session state (flat structure)")
+    
+    model_config = {"populate_by_name": True}
+
+
+class SessionInitResponse(BaseModel):
+    """Session initialization response from API key."""
+    
+    success: bool = Field(..., description="Request success status")
+    message: str = Field(..., description="Response message")
+    data: Dict[str, Any] = Field(..., description="Response data containing one_time_token")
+
+
+class OtpRequestResponse(BaseModel):
+    """OTP request response."""
+    
+    success: bool = Field(..., description="Request success status")
+    message: str = Field(..., description="Response message")
+    data: Optional[Dict[str, Any]] = Field(None, description="Response data")
+
+
+class OtpVerifyResponse(BaseModel):
+    """OTP verification response."""
+    
+    success: bool = Field(..., description="Request success status")
+    message: str = Field(..., description="Response message")
+    data: Optional[Dict[str, Any]] = Field(None, description="Response data with tokens")
+
+
+class SessionAuthenticateResponse(BaseModel):
+    """Session authentication response."""
+    
+    success: bool = Field(..., description="Request success status")
+    message: str = Field(..., description="Response message")
+    data: Optional[Dict[str, Any]] = Field(None, description="Response data with tokens")
+
+
+class PortalUrlResponse(BaseModel):
+    """Portal URL response."""
+    
+    success: bool = Field(..., description="Request success status")
+    message: str = Field(..., description="Response message")
+    data: Dict[str, str] = Field(..., description="Response data containing portal_url")
+
+
+class SessionValidationResponse(BaseModel):
+    """Session validation response."""
+    
+    valid: bool = Field(..., description="Whether the session is valid")
+    company_id: str = Field(..., description="Company ID")
+    status: str = Field(..., description="Session status")
+
+
+class SessionUserResponse(BaseModel):
+    """Response when getting user info from completed session."""
+    
+    success: bool = Field(..., description="Request success status")
+    message: str = Field(..., description="Response message")
+    data: Dict[str, Any] = Field(..., description="Response data containing user info and tokens")
+    
+    def get_user_id(self) -> str:
+        """Get user ID from the data object."""
+        return self.data['user_id']
+    
+    def get_access_token(self) -> str:
+        """Get access token from the data object."""
+        return self.data['access_token']
+    
+    def get_refresh_token(self) -> str:
+        """Get refresh token from the data object."""
+        return self.data['refresh_token']
+    
+    def get_expires_in(self) -> int:
+        """Get expires_in from the data object."""
+        return self.data['expires_in']
+    
+    def get_token_type(self) -> str:
+        """Get token type from the data object."""
+        return self.data['token_type']
+    
+    def get_scope(self) -> str:
+        """Get scope from the data object."""
+        return self.data['scope']
+    
+    def get_company_id(self) -> str:
+        """Get company ID from the data object."""
+        return self.data['company_id']
+
+
+class DeviceInfo(BaseModel):
+    """Device information for authentication."""
+    
+    ip_address: str = Field(..., description="Device IP address")
+    user_agent: str = Field(..., description="User agent string")
+    fingerprint: str = Field(..., description="Device fingerprint") 

finatic_server/types/broker.py

@@ -0,0 +1,147 @@
+"""Broker-related type definitions."""
+
+from typing import Optional, List, Dict, Any
+from pydantic import BaseModel, Field
+
+
+class BrokerDataOptions(BaseModel):
+    """Options for filtering broker data."""
+    
+    broker_name: Optional[str] = Field(None, description="Filter by broker name")
+    account_id: Optional[str] = Field(None, description="Filter by account ID")
+    symbol: Optional[str] = Field(None, description="Filter by symbol")
+
+
+class BrokerInfo(BaseModel):
+    """Broker information."""
+    
+    id: str = Field(..., description="Broker ID")
+    name: str = Field(..., description="Broker name")
+    display_name: str = Field(..., description="Display name")
+    description: str = Field(..., description="Broker description")
+    website: str = Field(..., description="Broker website")
+    features: List[str] = Field(..., description="Available features")
+    auth_type: str = Field(..., description="Authentication type (oauth, api_key, username_password, etc.)")
+    logo_path: str = Field(..., description="Logo path")
+    is_active: bool = Field(..., description="Whether broker is active")
+
+
+class BrokerAccount(BaseModel):
+    """Broker account information."""
+    
+    id: str = Field(..., description="Account ID")
+    user_broker_connection_id: str = Field(..., description="User broker connection ID")
+    broker_provided_account_id: str = Field(..., description="Broker provided account ID")
+    account_name: str = Field(..., description="Account name")
+    account_type: Optional[str] = Field(None, description="Account type")
+    currency: Optional[str] = Field(None, description="Account currency")
+    cash_balance: Optional[float] = Field(None, description="Cash balance")
+    buying_power: Optional[float] = Field(None, description="Buying power")
+    status: Optional[str] = Field(None, description="Account status")
+    created_at: str = Field(..., description="Creation timestamp")
+    updated_at: str = Field(..., description="Last update timestamp")
+    last_synced_at: str = Field(..., description="Last sync timestamp")
+
+
+class BrokerOrder(BaseModel):
+    """Broker order information."""
+    
+    id: str = Field(..., description="Order ID")
+    user_broker_connection_id: str = Field(..., description="User broker connection ID")
+    broker_provided_account_id: str = Field(..., description="Broker provided account ID")
+    order_id: Optional[str] = Field(None, description="Order ID")
+    symbol: str = Field(..., description="Trading symbol")
+    order_type: str = Field(..., description="Order type")
+    side: str = Field(..., description="Order side (buy/sell)")
+    quantity: float = Field(..., description="Order quantity")
+    price: Optional[float] = Field(None, description="Order price")
+    status: str = Field(..., description="Order status")
+    created_at: str = Field(..., description="Creation timestamp")
+    updated_at: str = Field(..., description="Last update timestamp")
+    filled_at: Optional[str] = Field(None, description="Fill timestamp")
+    filled_quantity: Optional[float] = Field(None, description="Filled quantity")
+    filled_avg_price: Optional[float] = Field(None, description="Filled average price")
+
+
+class BrokerPosition(BaseModel):
+    """Broker position information."""
+    
+    id: str = Field(..., description="Position ID")
+    user_broker_connection_id: str = Field(..., description="User broker connection ID")
+    broker_provided_account_id: str = Field(..., description="Broker provided account ID")
+    symbol: str = Field(..., description="Trading symbol")
+    asset_type: str = Field(..., description="Asset type")
+    quantity: float = Field(..., description="Position quantity")
+    average_price: Optional[float] = Field(None, description="Average price")
+    market_value: float = Field(..., description="Market value")
+    cost_basis: float = Field(..., description="Cost basis")
+    unrealized_gain_loss: Optional[float] = Field(None, description="Unrealized gain/loss")
+    unrealized_gain_loss_percent: Optional[float] = Field(None, description="Unrealized gain/loss percentage")
+    current_price: Optional[float] = Field(None, description="Current price")
+    last_price: Optional[float] = Field(None, description="Last price")
+    last_price_updated_at: Optional[str] = Field(None, description="Last price update timestamp")
+    created_at: str = Field(..., description="Creation timestamp")
+    updated_at: str = Field(..., description="Last update timestamp")
+
+
+class BrokerConnection(BaseModel):
+    """Broker connection information."""
+    
+    id: str = Field(..., description="Connection ID")
+    broker_id: str = Field(..., description="Broker ID")
+    user_id: str = Field(..., description="User ID")
+    company_id: Optional[str] = Field(None, description="Company ID")
+    status: str = Field(..., description="Connection status")
+    connected_at: Optional[str] = Field(None, description="Connection timestamp")
+    last_synced_at: Optional[str] = Field(None, description="Last sync timestamp")
+    permissions: Optional[Dict[str, bool]] = Field(None, description="Connection permissions")
+    metadata: Optional[Dict[str, Any]] = Field(None, description="Connection metadata")
+    needs_reauth: Optional[bool] = Field(None, description="Whether re-authentication is needed")
+
+
+# Filter types for pagination
+class OrdersFilter(BaseModel):
+    """Filter options for orders 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")
+    symbol: Optional[str] = Field(None, description="Filter by symbol")
+    status: Optional[str] = Field(None, description="Filter by status")
+    side: Optional[str] = Field(None, description="Filter by side")
+    asset_type: Optional[str] = Field(None, description="Filter by asset type")
+    limit: Optional[int] = Field(None, description="Result limit")
+    offset: Optional[int] = Field(None, description="Result offset")
+    created_after: Optional[str] = Field(None, description="Filter by creation date after (ISO 8601)")
+    created_before: Optional[str] = Field(None, description="Filter by creation date before (ISO 8601)")
+    with_metadata: Optional[bool] = Field(None, description="Include metadata")
+
+
+class PositionsFilter(BaseModel):
+    """Filter options for positions 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")
+    symbol: Optional[str] = Field(None, description="Filter by symbol")
+    side: Optional[str] = Field(None, description="Filter by side")
+    asset_type: Optional[str] = Field(None, description="Filter by asset type")
+    position_status: Optional[str] = Field(None, description="Filter by position status")
+    limit: Optional[int] = Field(None, description="Result limit")
+    offset: Optional[int] = Field(None, description="Result offset")
+    updated_after: Optional[str] = Field(None, description="Filter by update date after (ISO 8601)")
+    updated_before: Optional[str] = Field(None, description="Filter by update date before (ISO 8601)")
+    with_metadata: Optional[bool] = Field(None, description="Include metadata")
+
+
+class AccountsFilter(BaseModel):
+    """Filter options for accounts pagination."""
+    
+    broker_id: Optional[str] = Field(None, description="Filter by broker ID")
+    connection_id: Optional[str] = Field(None, description="Filter by connection ID")
+    account_type: Optional[str] = Field(None, description="Filter by account type")
+    status: Optional[str] = Field(None, description="Filter by status")
+    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") 

finatic_server/types/common.py

@@ -0,0 +1,177 @@
+"""Common type definitions used across the Finatic Server SDK."""
+
+from typing import Optional, List, Dict, Any, Callable, Awaitable
+from pydantic import BaseModel, Field
+
+
+class DeviceInfo(BaseModel):
+    """Device information for authentication and tracking."""
+    
+    ip_address: str = Field(..., description="Device IP address")
+    user_agent: str = Field(..., description="User agent string")
+    fingerprint: str = Field(..., description="Device fingerprint")
+
+
+class ApiResponse(BaseModel):
+    """Standard API response wrapper."""
+    
+    success: bool = Field(..., description="Request success status")
+    message: str = Field(..., description="Response message")
+    status_code: Optional[int] = Field(None, description="HTTP status code")
+
+
+class ApiPaginationInfo(BaseModel):
+    """API pagination information."""
+    
+    has_more: bool = Field(..., description="Whether there are more pages")
+    next_offset: Optional[int] = Field(None, description="Next page offset")
+    current_offset: int = Field(..., description="Current page offset")
+    limit: int = Field(..., description="Items per page")
+
+
+class PaginationMetadata(BaseModel):
+    """Pagination metadata for client use."""
+    
+    has_more: bool = Field(..., description="Whether there are more pages")
+    next_offset: Optional[int] = Field(None, description="Next page offset")
+    current_offset: Optional[int] = Field(None, description="Current page offset")
+    limit: Optional[int] = Field(None, description="Items per page")
+    current_page: Optional[int] = Field(None, description="Current page number")
+    has_next: bool = Field(..., description="Whether there is a next page")
+    has_previous: bool = Field(..., description="Whether there is a previous page")
+
+
+class TradingContext(BaseModel):
+    """Trading context for order placement."""
+    
+    broker: Optional[str] = Field(None, description="Selected broker")
+    account_number: Optional[str] = Field(None, description="Account number")
+    account_id: Optional[str] = Field(None, description="Account ID")
+
+
+class RequestHeaders(BaseModel):
+    """Common request headers."""
+    
+    x_api_key: Optional[str] = Field(None, alias="X-API-Key", description="API key header")
+    one_time_token: Optional[str] = Field(None, alias="One-Time-Token", description="One-time token header")
+    x_device_info: Optional[str] = Field(None, alias="X-Device-Info", description="Device info header")
+    x_session_id: Optional[str] = Field(None, alias="X-Session-ID", description="Session ID header")
+    session_id: Optional[str] = Field(None, alias="Session-ID", description="Session ID header")
+    x_company_id: Optional[str] = Field(None, alias="X-Company-ID", description="Company ID header")
+    authorization: Optional[str] = Field(None, alias="Authorization", description="Authorization header")
+    
+    model_config = {"populate_by_name": True}
+
+
+class PaginatedResult:
+    """Paginated result with navigation capabilities."""
+    
+    def __init__(
+        self,
+        data: Any,
+        pagination_info: ApiPaginationInfo,
+        navigation_callback: Optional[Callable[[int, int], Awaitable['PaginatedResult']]] = None
+    ):
+        self.data = data
+        self.navigation_callback = navigation_callback
+        # Default to 0 if any are None
+        next_offset = pagination_info.next_offset if pagination_info.next_offset is not None else 0
+        current_offset = pagination_info.current_offset if pagination_info.current_offset is not None else 0
+        limit = pagination_info.limit if pagination_info.limit is not None else 0
+        current_page = (current_offset // limit + 1) if limit else 1
+        # has_next: only if next_offset is not None and not equal to current_offset
+        has_next = (
+            pagination_info.next_offset is not None
+            and pagination_info.next_offset != pagination_info.current_offset
+        )
+        # has_previous: only if current_offset is not None and > 0
+        has_previous = (
+            pagination_info.current_offset is not None
+            and pagination_info.current_offset > 0
+        )
+        self.metadata = PaginationMetadata(
+            has_more=pagination_info.has_more,
+            next_offset=next_offset,
+            current_offset=current_offset,
+            limit=limit,
+            current_page=current_page,
+            has_next=has_next,
+            has_previous=has_previous,
+        )
+    
+    @property
+    def has_next(self) -> bool:
+        return self.metadata.has_next
+    
+    @property
+    def has_previous(self) -> bool:
+        return self.metadata.has_previous
+    
+    @property
+    def current_page(self) -> int:
+        return self.metadata.current_page or 1
+    
+    async def next_page(self) -> Optional['PaginatedResult']:
+        if not self.has_next or not self.navigation_callback:
+            return None
+        try:
+            return await self.navigation_callback(self.metadata.next_offset, self.metadata.limit)
+        except Exception as e:
+            print(f'Error fetching next page: {e}')
+            return None
+    
+    async def previous_page(self) -> Optional['PaginatedResult']:
+        if not self.has_previous or not self.navigation_callback:
+            return None
+        previous_offset = max(0, (self.metadata.current_offset or 0) - (self.metadata.limit or 0))
+        try:
+            return await self.navigation_callback(previous_offset, self.metadata.limit)
+        except Exception as e:
+            print(f'Error fetching previous page: {e}')
+            return None
+    
+    async def go_to_page(self, page_number: int) -> Optional['PaginatedResult']:
+        """Go to a specific page."""
+        if not self.navigation_callback or page_number < 1:
+            return None
+        
+        offset = (page_number - 1) * self.metadata.limit
+        try:
+            return await self.navigation_callback(offset, self.metadata.limit)
+        except Exception as e:
+            print(f'Error fetching page {page_number}: {e}')
+            return None
+    
+    async def first_page(self) -> Optional['PaginatedResult']:
+        """Get the first page."""
+        if not self.navigation_callback:
+            return None
+        
+        try:
+            return await self.navigation_callback(0, self.metadata.limit)
+        except Exception as e:
+            print(f'Error fetching first page: {e}')
+            return None
+    
+    async def last_page(self) -> Optional['PaginatedResult']:
+        """Get the last page by navigating through all pages."""
+        if not self.navigation_callback:
+            return None
+        
+        async def find_last(page: PaginatedResult) -> PaginatedResult:
+            if not page.has_next:
+                return page
+            next_page = await page.next_page()
+            if not next_page:
+                return page
+            return await find_last(next_page)
+        
+        try:
+            return await find_last(self)
+        except Exception as e:
+            print(f'Error fetching last page: {e}')
+            return None
+    
+    def get_pagination_info(self) -> str:
+        """Get pagination info as string."""
+        return f"Page {self.current_page} ({self.metadata.current_offset + 1}-{self.metadata.current_offset + self.metadata.limit})" 

finatic_server/types/orders.py

@@ -0,0 +1,74 @@
+"""Order-related type definitions."""
+
+from typing import Optional, Literal
+from pydantic import BaseModel, Field
+
+
+class Order(BaseModel):
+    """Basic order structure."""
+    
+    symbol: str = Field(..., description="Trading symbol")
+    side: Literal["buy", "sell"] = Field(..., description="Order side")
+    quantity: float = Field(..., description="Order quantity")
+    type_: Literal["market", "limit", "stop", "stop_limit"] = Field(..., alias="type", description="Order type")
+    price: Optional[float] = Field(None, description="Order price")
+    stop_price: Optional[float] = Field(None, description="Stop price")
+    time_in_force: Literal["day", "gtc", "opg", "cls", "ioc", "fok"] = Field(..., description="Time in force")
+    
+    model_config = {"populate_by_name": True}
+
+
+class OptionsOrder(Order):
+    """Options-specific order."""
+    
+    option_type: Literal["call", "put"] = Field(..., description="Option type")
+    strike_price: float = Field(..., description="Strike price")
+    expiration_date: str = Field(..., description="Expiration date")
+
+
+class CryptoOrderOptions(BaseModel):
+    """Crypto order options."""
+    
+    quantity: Optional[float] = Field(None, description="Quantity")
+    notional: Optional[float] = Field(None, description="Notional value")
+
+
+class OptionsOrderOptions(BaseModel):
+    """Options order options."""
+    
+    strike_price: float = Field(..., description="Strike price")
+    expiration_date: str = Field(..., description="Expiration date")
+    option_type: Literal["call", "put"] = Field(..., description="Option type")
+    contract_size: Optional[int] = Field(None, description="Contract size")
+
+
+class OrderResponse(BaseModel):
+    """Order response from API."""
+    
+    success: bool = Field(..., description="Order success status")
+    response_data: dict = Field(..., description="Order response data")
+    message: str = Field(..., description="Response message")
+    status_code: int = Field(..., description="HTTP status code")
+
+
+class BrokerOrderParams(BaseModel):
+    """Broker order parameters."""
+    
+    broker: Literal["robinhood", "tasty_trade", "ninja_trader"] = Field(..., description="Broker name")
+    account_number: str = Field(..., description="Account number")
+    symbol: str = Field(..., description="Trading symbol")
+    order_qty: float = Field(..., description="Order quantity")
+    action: Literal["Buy", "Sell"] = Field(..., description="Order action")
+    order_type: Literal["Market", "Limit", "Stop", "TrailingStop"] = Field(..., description="Order type")
+    asset_type: Literal["Equity", "Equity Option", "Crypto", "Futures", "Futures Option"] = Field(..., description="Asset type")
+    time_in_force: Literal["day", "gtc", "gtd", "ioc", "fok"] = Field(..., description="Time in force")
+    price: Optional[float] = Field(None, description="Order price")
+    stop_price: Optional[float] = Field(None, description="Stop price")
+
+
+class BrokerExtras(BaseModel):
+    """Broker-specific extras for orders."""
+    
+    robinhood: Optional[dict] = Field(None, description="Robinhood-specific options")
+    ninja_trader: Optional[dict] = Field(None, description="NinjaTrader-specific options")
+    tasty_trade: Optional[dict] = Field(None, description="TastyTrade-specific options") 

finatic_server/types/portfolio.py

@@ -0,0 +1,61 @@
+"""Portfolio-related type definitions."""
+
+from typing import List, Optional
+from pydantic import BaseModel, Field
+
+
+class Holding(BaseModel):
+    """Individual holding/position in portfolio."""
+    
+    symbol: str = Field(..., description="Trading symbol")
+    quantity: float = Field(..., description="Quantity held")
+    average_price: float = Field(..., description="Average purchase price")
+    current_price: float = Field(..., description="Current market price")
+    market_value: float = Field(..., description="Current market value")
+    unrealized_pnl: float = Field(..., description="Unrealized profit/loss")
+    realized_pnl: float = Field(..., description="Realized profit/loss")
+    cost_basis: float = Field(..., description="Total cost basis")
+    currency: str = Field(..., description="Currency")
+
+
+class PerformanceMetrics(BaseModel):
+    """Portfolio performance metrics."""
+    
+    total_return: float = Field(..., description="Total return percentage")
+    daily_return: float = Field(..., description="Daily return percentage")
+    weekly_return: float = Field(..., description="Weekly return percentage")
+    monthly_return: float = Field(..., description="Monthly return percentage")
+    yearly_return: float = Field(..., description="Yearly return percentage")
+    max_drawdown: float = Field(..., description="Maximum drawdown")
+    sharpe_ratio: float = Field(..., description="Sharpe ratio")
+    beta: float = Field(..., description="Beta")
+    alpha: float = Field(..., description="Alpha")
+
+
+class Portfolio(BaseModel):
+    """Portfolio information."""
+    
+    id: str = Field(..., description="Portfolio ID")
+    name: str = Field(..., description="Portfolio name")
+    type: str = Field(..., description="Portfolio type")
+    status: str = Field(..., description="Portfolio status")
+    cash: float = Field(..., description="Available cash")
+    buying_power: float = Field(..., description="Buying power")
+    equity: float = Field(..., description="Total equity")
+    long_market_value: float = Field(..., description="Long market value")
+    short_market_value: float = Field(..., description="Short market value")
+    initial_margin: float = Field(..., description="Initial margin requirement")
+    maintenance_margin: float = Field(..., description="Maintenance margin requirement")
+    last_equity: float = Field(..., description="Last equity value")
+    positions: List[Holding] = Field(..., description="Portfolio positions")
+    performance: PerformanceMetrics = Field(..., description="Performance metrics")
+
+
+class PortfolioSnapshot(BaseModel):
+    """Portfolio snapshot at a point in time."""
+    
+    timestamp: str = Field(..., description="Snapshot timestamp")
+    total_value: float = Field(..., description="Total portfolio value")
+    cash: float = Field(..., description="Available cash")
+    equity: float = Field(..., description="Total equity")
+    positions: List[dict] = Field(..., description="Position data") 

finatic_server/utils/__init__.py

@@ -0,0 +1,17 @@
+"""Utility functions and classes for the Finatic Server SDK."""
+
+from .errors import (
+    FinaticError,
+    ApiError,
+    AuthenticationError,
+    ValidationError,
+    RateLimitError,
+)
+
+__all__ = [
+    "FinaticError",
+    "ApiError", 
+    "AuthenticationError",
+    "ValidationError",
+    "RateLimitError",
+]