problee 0.1.0__tar.gz

problee-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Problee
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

problee-0.1.0/PKG-INFO

@@ -0,0 +1,209 @@
+Metadata-Version: 2.1
+Name: problee
+Version: 0.1.0
+Summary: Official Python SDK for the Problee prediction market API
+Author-email: Problee <dev@problee.com>
+License: MIT
+Project-URL: Homepage, https://problee.com
+Project-URL: Documentation, https://docs.problee.com
+Project-URL: Repository, https://github.com/problee/problee-python
+Project-URL: Changelog, https://github.com/problee/problee-python/blob/main/CHANGELOG.md
+Keywords: problee,prediction-market,api,sdk,trading,world-chain
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.28.0
+Provides-Extra: websocket
+Requires-Dist: websockets>=10.0; extra == "websocket"
+Provides-Extra: all
+Requires-Dist: websockets>=10.0; extra == "all"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.21.0; extra == "dev"
+Requires-Dist: mypy>=1.0; extra == "dev"
+Requires-Dist: ruff>=0.1.0; extra == "dev"
+Requires-Dist: responses>=0.23.0; extra == "dev"
+
+# Problee Python SDK
+
+Official Python SDK for the Problee prediction market API.
+
+## Installation
+
+```bash
+pip install problee
+```
+
+For WebSocket support:
+
+```bash
+pip install problee[websocket]
+```
+
+## Quick Start
+
+```python
+from problee import ProbClient
+
+# Initialize client with your API key
+client = ProbClient(api_key="pk_live_...")
+
+# List open markets
+markets = client.markets.list(status="open")
+for market in markets.markets:
+    print(f"{market.question}")
+    print(f"  YES: {market.prices.yes:.2%}")
+    print(f"  NO:  {market.prices.no:.2%}")
+```
+
+## Features
+
+- **Markets API**: List, filter, and get market details
+- **Positions API**: Check wallet positions
+- **Quotes API**: Get trade quotes and build transactions
+- **SSE Streaming**: Real-time price updates via Server-Sent Events
+- **WebSocket**: Real-time market updates via WebSocket
+
+## Usage Examples
+
+### List Markets
+
+```python
+# List all open markets
+markets = client.markets.list(status="open")
+
+# Filter by category
+crypto_markets = client.markets.list(category="crypto")
+
+# Sort by volume
+trending = client.markets.list(sort="volume_24h")
+```
+
+### Get Market Details
+
+```python
+# Get single market
+market = client.markets.get("0x1234...")
+print(f"Question: {market.question}")
+print(f"Status: {market.status}")
+print(f"YES Price: {market.prices.yes}")
+
+# Get price history
+history = client.markets.get_history("0x1234...", interval="1h")
+
+# Get recent trades
+trades = client.markets.get_trades("0x1234...", limit=50)
+```
+
+### Get Quote
+
+```python
+# Get quote to buy YES shares
+quote = client.quotes.get(
+    market_id="0x1234...",
+    side="buy",
+    outcome="yes",
+    amount="1000000000000000000",  # 1 USDC in wei
+)
+
+print(f"Price: {quote.price:.4f}")
+print(f"Shares: {quote.shares_out}")
+print(f"Price Impact: {quote.price_impact:.2%}")
+print(f"Quote ID: {quote.quote_id}")
+```
+
+### Check Positions
+
+```python
+# Get all positions for a wallet
+positions = client.positions.list("0xYourWallet...")
+for pos in positions.positions:
+    print(f"Market: {pos.market_address}")
+    print(f"YES Shares: {pos.yes_shares}")
+    print(f"NO Shares: {pos.no_shares}")
+```
+
+### Stream Prices (SSE)
+
+```python
+# Stream real-time price updates
+for update in client.stream.prices():
+    if update.event_type == "price":
+        print(f"Price: YES={update.data['yes']}, NO={update.data['no']}")
+    elif update.event_type == "tokenPrice":
+        print(f"Token: {update.data['symbol']} = ${update.data['price']}")
+```
+
+### WebSocket Streaming
+
+```python
+import asyncio
+
+async def stream_updates():
+    async with client.ws.connect() as ws:
+        # Subscribe to market updates
+        await ws.subscribe("market", "0x1234...")
+
+        async for msg in ws:
+            if msg.type == "price_update":
+                print(f"Price: {msg.data['prices']}")
+            elif msg.type == "trade":
+                print(f"Trade: {msg.data}")
+
+asyncio.run(stream_updates())
+```
+
+## Error Handling
+
+```python
+from problee import ProbClient
+from problee.exceptions import (
+    AuthenticationError,
+    RateLimitError,
+    NotFoundError,
+    ValidationError,
+)
+
+client = ProbClient(api_key="pk_live_...")
+
+try:
+    market = client.markets.get("0xinvalid")
+except NotFoundError:
+    print("Market not found")
+except AuthenticationError:
+    print("Invalid API key")
+except RateLimitError as e:
+    print(f"Rate limited. Retry after {e.retry_after} seconds")
+except ValidationError as e:
+    print(f"Invalid request: {e.errors}")
+```
+
+## Builder Attribution
+
+If you're building an app on Problee, you can include your builder ID:
+
+```python
+client = ProbClient(
+    api_key="pk_live_...",
+    builder_id="your-builder-id",
+)
+```
+
+## API Documentation
+
+For full API documentation, visit: https://docs.problee.com
+
+## License
+
+MIT License - see LICENSE file for details.

problee-0.1.0/README.md

@@ -0,0 +1,172 @@
+# Problee Python SDK
+
+Official Python SDK for the Problee prediction market API.
+
+## Installation
+
+```bash
+pip install problee
+```
+
+For WebSocket support:
+
+```bash
+pip install problee[websocket]
+```
+
+## Quick Start
+
+```python
+from problee import ProbClient
+
+# Initialize client with your API key
+client = ProbClient(api_key="pk_live_...")
+
+# List open markets
+markets = client.markets.list(status="open")
+for market in markets.markets:
+    print(f"{market.question}")
+    print(f"  YES: {market.prices.yes:.2%}")
+    print(f"  NO:  {market.prices.no:.2%}")
+```
+
+## Features
+
+- **Markets API**: List, filter, and get market details
+- **Positions API**: Check wallet positions
+- **Quotes API**: Get trade quotes and build transactions
+- **SSE Streaming**: Real-time price updates via Server-Sent Events
+- **WebSocket**: Real-time market updates via WebSocket
+
+## Usage Examples
+
+### List Markets
+
+```python
+# List all open markets
+markets = client.markets.list(status="open")
+
+# Filter by category
+crypto_markets = client.markets.list(category="crypto")
+
+# Sort by volume
+trending = client.markets.list(sort="volume_24h")
+```
+
+### Get Market Details
+
+```python
+# Get single market
+market = client.markets.get("0x1234...")
+print(f"Question: {market.question}")
+print(f"Status: {market.status}")
+print(f"YES Price: {market.prices.yes}")
+
+# Get price history
+history = client.markets.get_history("0x1234...", interval="1h")
+
+# Get recent trades
+trades = client.markets.get_trades("0x1234...", limit=50)
+```
+
+### Get Quote
+
+```python
+# Get quote to buy YES shares
+quote = client.quotes.get(
+    market_id="0x1234...",
+    side="buy",
+    outcome="yes",
+    amount="1000000000000000000",  # 1 USDC in wei
+)
+
+print(f"Price: {quote.price:.4f}")
+print(f"Shares: {quote.shares_out}")
+print(f"Price Impact: {quote.price_impact:.2%}")
+print(f"Quote ID: {quote.quote_id}")
+```
+
+### Check Positions
+
+```python
+# Get all positions for a wallet
+positions = client.positions.list("0xYourWallet...")
+for pos in positions.positions:
+    print(f"Market: {pos.market_address}")
+    print(f"YES Shares: {pos.yes_shares}")
+    print(f"NO Shares: {pos.no_shares}")
+```
+
+### Stream Prices (SSE)
+
+```python
+# Stream real-time price updates
+for update in client.stream.prices():
+    if update.event_type == "price":
+        print(f"Price: YES={update.data['yes']}, NO={update.data['no']}")
+    elif update.event_type == "tokenPrice":
+        print(f"Token: {update.data['symbol']} = ${update.data['price']}")
+```
+
+### WebSocket Streaming
+
+```python
+import asyncio
+
+async def stream_updates():
+    async with client.ws.connect() as ws:
+        # Subscribe to market updates
+        await ws.subscribe("market", "0x1234...")
+
+        async for msg in ws:
+            if msg.type == "price_update":
+                print(f"Price: {msg.data['prices']}")
+            elif msg.type == "trade":
+                print(f"Trade: {msg.data}")
+
+asyncio.run(stream_updates())
+```
+
+## Error Handling
+
+```python
+from problee import ProbClient
+from problee.exceptions import (
+    AuthenticationError,
+    RateLimitError,
+    NotFoundError,
+    ValidationError,
+)
+
+client = ProbClient(api_key="pk_live_...")
+
+try:
+    market = client.markets.get("0xinvalid")
+except NotFoundError:
+    print("Market not found")
+except AuthenticationError:
+    print("Invalid API key")
+except RateLimitError as e:
+    print(f"Rate limited. Retry after {e.retry_after} seconds")
+except ValidationError as e:
+    print(f"Invalid request: {e.errors}")
+```
+
+## Builder Attribution
+
+If you're building an app on Problee, you can include your builder ID:
+
+```python
+client = ProbClient(
+    api_key="pk_live_...",
+    builder_id="your-builder-id",
+)
+```
+
+## API Documentation
+
+For full API documentation, visit: https://docs.problee.com
+
+## License
+
+MIT License - see LICENSE file for details.

problee-0.1.0/problee/__init__.py

@@ -0,0 +1,35 @@
+"""
+Problee Python SDK
+
+Official Python client for the Problee prediction market API.
+"""
+
+__version__ = "0.1.0"
+
+from .client import ProbClient
+from .models.market import Market, MarketStatus, MarketCategory
+from .models.position import Position
+from .models.quote import Quote
+from .exceptions import (
+    ProbError,
+    AuthenticationError,
+    RateLimitError,
+    NotFoundError,
+    ValidationError,
+    APIError,
+)
+
+__all__ = [
+    "ProbClient",
+    "Market",
+    "MarketStatus",
+    "MarketCategory",
+    "Position",
+    "Quote",
+    "ProbError",
+    "AuthenticationError",
+    "RateLimitError",
+    "NotFoundError",
+    "ValidationError",
+    "APIError",
+]

problee-0.1.0/problee/api/__init__.py

@@ -0,0 +1,13 @@
+"""
+Problee API Modules
+"""
+
+from .markets import MarketsAPI
+from .positions import PositionsAPI
+from .quotes import QuotesAPI
+
+__all__ = [
+    "MarketsAPI",
+    "PositionsAPI",
+    "QuotesAPI",
+]

problee-0.1.0/problee/api/markets.py

@@ -0,0 +1,119 @@
+"""
+Markets API
+"""
+
+from typing import Optional, List, TYPE_CHECKING
+from ..models.market import Market, MarketListResponse, MarketStatus, MarketCategory
+
+if TYPE_CHECKING:
+    from ..client import ProbClient
+
+
+class MarketsAPI:
+    """Markets API methods."""
+
+    def __init__(self, client: "ProbClient"):
+        self._client = client
+
+    def list(
+        self,
+        status: Optional[str] = None,
+        category: Optional[str] = None,
+        sort: Optional[str] = None,
+        limit: int = 20,
+        cursor: Optional[str] = None,
+    ) -> MarketListResponse:
+        """
+        List markets with optional filters.
+
+        Args:
+            status: Filter by status (open, closed, resolved)
+            category: Filter by category (sports, politics, crypto, entertainment, other)
+            sort: Sort order (new, trending, volume_24h, closing_soon)
+            limit: Max results per page (default 20, max 100)
+            cursor: Pagination cursor
+
+        Returns:
+            MarketListResponse with list of markets and pagination info
+        """
+        params = {"limit": limit}
+        if status:
+            params["status"] = status
+        if category:
+            params["category"] = category
+        if sort:
+            params["sort"] = sort
+        if cursor:
+            params["cursor"] = cursor
+
+        response = self._client._request("GET", "/api/v1/markets", params=params)
+        return MarketListResponse.from_dict(response)
+
+    def get(self, market_id: str) -> Market:
+        """
+        Get a single market by ID (address).
+
+        Args:
+            market_id: Market address
+
+        Returns:
+            Market object
+        """
+        response = self._client._request("GET", f"/api/v1/markets/{market_id}")
+        return Market.from_dict(response)
+
+    def get_history(
+        self,
+        market_id: str,
+        interval: str = "1h",
+        limit: int = 100,
+    ) -> List[dict]:
+        """
+        Get price history for a market.
+
+        Args:
+            market_id: Market address
+            interval: Time bucket (1m, 5m, 1h, 1d)
+            limit: Max data points
+
+        Returns:
+            List of price history points
+        """
+        params = {"interval": interval, "limit": limit}
+        response = self._client._request(
+            "GET", f"/api/v1/markets/{market_id}/history", params=params
+        )
+        return response.get("history", [])
+
+    def get_trades(
+        self,
+        market_id: str,
+        limit: int = 50,
+    ) -> List[dict]:
+        """
+        Get recent trades for a market.
+
+        Args:
+            market_id: Market address
+            limit: Max trades to return
+
+        Returns:
+            List of trade objects
+        """
+        params = {"limit": limit}
+        response = self._client._request(
+            "GET", f"/api/v1/markets/{market_id}/trades", params=params
+        )
+        return response.get("trades", [])
+
+    def list_open(self, **kwargs) -> MarketListResponse:
+        """List open markets."""
+        return self.list(status="open", **kwargs)
+
+    def list_resolved(self, **kwargs) -> MarketListResponse:
+        """List resolved markets."""
+        return self.list(status="resolved", **kwargs)
+
+    def list_by_category(self, category: str, **kwargs) -> MarketListResponse:
+        """List markets by category."""
+        return self.list(category=category, **kwargs)

problee-0.1.0/problee/api/positions.py

@@ -0,0 +1,49 @@
+"""
+Positions API
+"""
+
+from typing import Optional, TYPE_CHECKING
+from ..models.position import Position, PositionListResponse
+
+if TYPE_CHECKING:
+    from ..client import ProbClient
+
+
+class PositionsAPI:
+    """Positions API methods."""
+
+    def __init__(self, client: "ProbClient"):
+        self._client = client
+
+    def list(self, address: str) -> PositionListResponse:
+        """
+        Get all positions for a wallet address.
+
+        Args:
+            address: Wallet address (0x...)
+
+        Returns:
+            PositionListResponse with list of positions
+        """
+        response = self._client._request("GET", f"/api/v1/positions/{address}")
+        return PositionListResponse.from_dict(response)
+
+    def get(self, address: str, market_id: str) -> Optional[Position]:
+        """
+        Get position for a specific market.
+
+        Args:
+            address: Wallet address
+            market_id: Market address
+
+        Returns:
+            Position or None if no position
+        """
+        params = {"market_id": market_id}
+        response = self._client._request(
+            "GET", f"/api/v1/positions/{address}", params=params
+        )
+        positions = response.get("positions", [])
+        if positions:
+            return Position.from_dict(positions[0])
+        return None

problee-0.1.0/problee/api/quotes.py

@@ -0,0 +1,85 @@
+"""
+Quotes API
+"""
+
+from typing import Optional, TYPE_CHECKING
+from ..models.quote import Quote, TransactionData
+
+if TYPE_CHECKING:
+    from ..client import ProbClient
+
+
+class QuotesAPI:
+    """Quotes API methods."""
+
+    def __init__(self, client: "ProbClient"):
+        self._client = client
+
+    def get(
+        self,
+        market_id: str,
+        side: str,
+        outcome: str,
+        amount: str,
+        slippage_bps: int = 50,
+    ) -> Quote:
+        """
+        Get a quote for a trade.
+
+        Args:
+            market_id: Market address
+            side: "buy" or "sell"
+            outcome: "yes", "no", or "draw"
+            amount: Amount in wei (as string)
+            slippage_bps: Slippage tolerance in basis points (default 50 = 0.5%)
+
+        Returns:
+            Quote object with price and execution details
+        """
+        payload = {
+            "market_id": market_id,
+            "side": side,
+            "outcome": outcome,
+            "amount": amount,
+            "slippage_bps": slippage_bps,
+        }
+        response = self._client._request("POST", "/api/v1/quote", json=payload)
+        return Quote.from_dict(response)
+
+    def get_buy_yes(self, market_id: str, amount: str, **kwargs) -> Quote:
+        """Get quote to buy YES shares."""
+        return self.get(market_id, "buy", "yes", amount, **kwargs)
+
+    def get_buy_no(self, market_id: str, amount: str, **kwargs) -> Quote:
+        """Get quote to buy NO shares."""
+        return self.get(market_id, "buy", "no", amount, **kwargs)
+
+    def get_sell_yes(self, market_id: str, amount: str, **kwargs) -> Quote:
+        """Get quote to sell YES shares."""
+        return self.get(market_id, "sell", "yes", amount, **kwargs)
+
+    def get_sell_no(self, market_id: str, amount: str, **kwargs) -> Quote:
+        """Get quote to sell NO shares."""
+        return self.get(market_id, "sell", "no", amount, **kwargs)
+
+    def build_transaction(
+        self,
+        quote_id: str,
+        rpc_url: str,
+    ) -> TransactionData:
+        """
+        Build transaction data from a quote.
+
+        Args:
+            quote_id: Quote ID from get() response
+            rpc_url: RPC URL for the chain
+
+        Returns:
+            TransactionData with calldata for execution
+        """
+        payload = {"quote_id": quote_id}
+        headers = {"X-RPC-URL": rpc_url}
+        response = self._client._request(
+            "POST", "/api/v1/tx/build", json=payload, headers=headers
+        )
+        return TransactionData.from_dict(response)