iplaygames-sdk 1.0.0__tar.gz

iplaygames_sdk-1.0.0/PKG-INFO

@@ -0,0 +1,20 @@
+Metadata-Version: 2.4
+Name: iplaygames-sdk
+Version: 1.0.0
+Summary: IPlayGames SDK - High-level wrapper for casino game aggregation
+Author-email: IPlayGames <support@iplaygames.ai>
+License: MIT
+Project-URL: Homepage, https://github.com/iplaygamesai/sdk-python
+Project-URL: Documentation, https://docs.iplaygames.ai/sdks/python
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+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
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: iplaygames-api-client>=1.0.0

iplaygames_sdk-1.0.0/iplaygames/__init__.py

@@ -0,0 +1,29 @@
+"""
+IPlayGames SDK
+High-level wrapper for casino game aggregation
+"""
+
+from .client import Client
+from .flows.games import GamesFlow
+from .flows.sessions import SessionsFlow
+from .flows.multi_session import MultiSessionFlow
+from .flows.jackpot import JackpotFlow
+from .flows.promotions import PromotionsFlow
+from .flows.jackpot_widget import JackpotWidgetFlow
+from .flows.promotion_widget import PromotionWidgetFlow
+from .webhooks import WebhookHandler, WebhookPayload
+
+__version__ = "1.0.0"
+
+__all__ = [
+    "Client",
+    "GamesFlow",
+    "SessionsFlow",
+    "MultiSessionFlow",
+    "JackpotFlow",
+    "PromotionsFlow",
+    "JackpotWidgetFlow",
+    "PromotionWidgetFlow",
+    "WebhookHandler",
+    "WebhookPayload",
+]

iplaygames_sdk-1.0.0/iplaygames/client.py

@@ -0,0 +1,189 @@
+"""
+IPlayGames SDK Client
+
+Main entry point for the IPlayGames API SDK.
+Provides high-level flows for common operations.
+"""
+
+from typing import Optional
+from iplaygames_api_client import Configuration, ApiClient
+from iplaygames_api_client.api import (
+    GamesApi,
+    GameSessionsApi,
+    MultiSessionsApi,
+    WidgetManagementApi,
+    FreespinsApi,
+    EndpointsApi,
+    GameTransactionsApi,
+)
+
+from .flows.games import GamesFlow
+from .flows.sessions import SessionsFlow
+from .flows.multi_session import MultiSessionFlow
+from .flows.jackpot import JackpotFlow
+from .flows.promotions import PromotionsFlow
+from .flows.jackpot_widget import JackpotWidgetFlow
+from .flows.promotion_widget import PromotionWidgetFlow
+from .webhooks import WebhookHandler
+
+
+class Client:
+    """Main client for the IPlayGames SDK"""
+
+    def __init__(
+        self,
+        api_key: str,
+        base_url: str = "https://api.iplaygames.ai",
+        webhook_secret: Optional[str] = None,
+        timeout: Optional[int] = None,
+        debug: bool = False,
+    ):
+        """
+        Create a new IPlayGames client
+
+        Args:
+            api_key: Your API key
+            base_url: API base URL (default: https://api.iplaygames.ai)
+            webhook_secret: Secret for verifying webhooks
+            timeout: Request timeout in seconds
+            debug: Enable debug logging
+        """
+        if not api_key:
+            raise ValueError("api_key is required")
+
+        self._config = Configuration(
+            host=base_url,
+            access_token=api_key,
+        )
+        self._api_client = ApiClient(self._config)
+        self._webhook_secret = webhook_secret
+        self._base_url = base_url
+
+        # SDK API instances (lazy-loaded)
+        self._games_api: Optional[GamesApi] = None
+        self._game_sessions_api: Optional[GameSessionsApi] = None
+        self._multi_sessions_api: Optional[MultiSessionsApi] = None
+        self._widget_management_api: Optional[WidgetManagementApi] = None
+        self._freespins_api: Optional[FreespinsApi] = None
+        self._endpoints_api: Optional[EndpointsApi] = None
+        self._game_transactions_api: Optional[GameTransactionsApi] = None
+
+        # Flow instances (lazy-loaded)
+        self._games_flow: Optional[GamesFlow] = None
+        self._sessions_flow: Optional[SessionsFlow] = None
+        self._multi_session_flow: Optional[MultiSessionFlow] = None
+        self._jackpot_flow: Optional[JackpotFlow] = None
+        self._promotions_flow: Optional[PromotionsFlow] = None
+        self._jackpot_widget_flow: Optional[JackpotWidgetFlow] = None
+        self._promotion_widget_flow: Optional[PromotionWidgetFlow] = None
+        self._webhook_handler: Optional[WebhookHandler] = None
+
+    def get_base_url(self) -> str:
+        """Get the base URL"""
+        return self._base_url
+
+    # =========================================================================
+    # SDK API Accessors
+    # =========================================================================
+
+    @property
+    def games_api(self) -> GamesApi:
+        if self._games_api is None:
+            self._games_api = GamesApi(self._api_client)
+        return self._games_api
+
+    @property
+    def game_sessions_api(self) -> GameSessionsApi:
+        if self._game_sessions_api is None:
+            self._game_sessions_api = GameSessionsApi(self._api_client)
+        return self._game_sessions_api
+
+    @property
+    def multi_sessions_api(self) -> MultiSessionsApi:
+        if self._multi_sessions_api is None:
+            self._multi_sessions_api = MultiSessionsApi(self._api_client)
+        return self._multi_sessions_api
+
+    @property
+    def widget_management_api(self) -> WidgetManagementApi:
+        if self._widget_management_api is None:
+            self._widget_management_api = WidgetManagementApi(self._api_client)
+        return self._widget_management_api
+
+    @property
+    def freespins_api(self) -> FreespinsApi:
+        if self._freespins_api is None:
+            self._freespins_api = FreespinsApi(self._api_client)
+        return self._freespins_api
+
+    @property
+    def endpoints_api(self) -> EndpointsApi:
+        if self._endpoints_api is None:
+            self._endpoints_api = EndpointsApi(self._api_client)
+        return self._endpoints_api
+
+    @property
+    def game_transactions_api(self) -> GameTransactionsApi:
+        if self._game_transactions_api is None:
+            self._game_transactions_api = GameTransactionsApi(self._api_client)
+        return self._game_transactions_api
+
+    # =========================================================================
+    # High-Level Flow Accessors
+    # =========================================================================
+
+    def games(self) -> GamesFlow:
+        """Games flow - List and retrieve games"""
+        if self._games_flow is None:
+            self._games_flow = GamesFlow(self)
+        return self._games_flow
+
+    def sessions(self) -> SessionsFlow:
+        """Sessions flow - Start and manage game sessions"""
+        if self._sessions_flow is None:
+            self._sessions_flow = SessionsFlow(self)
+        return self._sessions_flow
+
+    def multi_session(self) -> MultiSessionFlow:
+        """Multi-session flow - TikTok-style game swiping"""
+        if self._multi_session_flow is None:
+            self._multi_session_flow = MultiSessionFlow(self)
+        return self._multi_session_flow
+
+    def jackpot(self) -> JackpotFlow:
+        """Jackpot flow - Configure and manage jackpot pools"""
+        if self._jackpot_flow is None:
+            self._jackpot_flow = JackpotFlow(self)
+        return self._jackpot_flow
+
+    def promotions(self) -> PromotionsFlow:
+        """Promotions flow - Create and manage promotions"""
+        if self._promotions_flow is None:
+            self._promotions_flow = PromotionsFlow(self)
+        return self._promotions_flow
+
+    def jackpot_widget(self) -> JackpotWidgetFlow:
+        """Jackpot Widget flow - Manage widget tokens for jackpot displays"""
+        if self._jackpot_widget_flow is None:
+            self._jackpot_widget_flow = JackpotWidgetFlow(self)
+        return self._jackpot_widget_flow
+
+    def promotion_widget(self) -> PromotionWidgetFlow:
+        """Promotion Widget flow - Manage widget tokens for promotion displays"""
+        if self._promotion_widget_flow is None:
+            self._promotion_widget_flow = PromotionWidgetFlow(self)
+        return self._promotion_widget_flow
+
+    def webhooks(self) -> WebhookHandler:
+        """Webhook handler - Verify and handle callbacks"""
+        if self._webhook_handler is None:
+            if not self._webhook_secret:
+                raise ValueError(
+                    "Webhook secret not configured. Pass webhook_secret in client options."
+                )
+            self._webhook_handler = WebhookHandler(self._webhook_secret)
+        return self._webhook_handler
+
+    def create_webhook_handler(self, secret: str) -> WebhookHandler:
+        """Create webhook handler with a specific secret"""
+        return WebhookHandler(secret)

iplaygames_sdk-1.0.0/iplaygames/flows/__init__.py

@@ -0,0 +1,23 @@
+"""
+IPlayGames SDK Flows
+
+High-level flows for common operations.
+"""
+
+from .games import GamesFlow
+from .sessions import SessionsFlow
+from .multi_session import MultiSessionFlow
+from .jackpot import JackpotFlow
+from .promotions import PromotionsFlow
+from .jackpot_widget import JackpotWidgetFlow
+from .promotion_widget import PromotionWidgetFlow
+
+__all__ = [
+    "GamesFlow",
+    "SessionsFlow",
+    "MultiSessionFlow",
+    "JackpotFlow",
+    "PromotionsFlow",
+    "JackpotWidgetFlow",
+    "PromotionWidgetFlow",
+]

iplaygames_sdk-1.0.0/iplaygames/flows/games.py

@@ -0,0 +1,120 @@
+"""
+Games Flow
+
+List and retrieve available games from the aggregator.
+"""
+
+from typing import TYPE_CHECKING, Any, Dict, List, Optional
+
+if TYPE_CHECKING:
+    from ..client import Client
+
+
+class GamesFlow:
+    """High-level flow for game operations"""
+
+    def __init__(self, client: "Client"):
+        self._client = client
+
+    def list(
+        self,
+        search: Optional[str] = None,
+        producer_id: Optional[int] = None,
+        provider: Optional[str] = None,
+        game_type: Optional[str] = None,
+        per_page: Optional[int] = None,
+    ) -> Dict[str, Any]:
+        """
+        List available games
+
+        Args:
+            search: Search by game title
+            producer_id: Filter by producer ID
+            provider: Filter by provider
+            game_type: Filter by game type
+            per_page: Number of results per page
+
+        Returns:
+            Dict with success, games, and meta
+        """
+        try:
+            response = self._client.games_api.list_games(
+                search=search,
+                producer_id=producer_id,
+                provider=provider,
+                type=game_type,
+                per_page=str(per_page) if per_page else None,
+            )
+
+            games = []
+            for g in response.data or []:
+                games.append({
+                    "id": g.id,
+                    "title": g.title,
+                    "producer": g.producer,
+                    "type": g.type,
+                    "image_url": getattr(g, "image_url", None),
+                    "demo_available": getattr(g, "demo_available", None),
+                })
+
+            meta = {}
+            if hasattr(response, "meta") and response.meta:
+                meta = {
+                    "current_page": getattr(response.meta, "current_page", 1),
+                    "last_page": getattr(response.meta, "last_page", 1),
+                    "per_page": getattr(response.meta, "per_page", 100),
+                    "total": getattr(response.meta, "total", len(games)),
+                }
+
+            return {
+                "success": True,
+                "games": games,
+                "meta": meta,
+            }
+        except Exception as e:
+            return {
+                "success": False,
+                "error": str(e),
+                "games": [],
+                "meta": {"current_page": 1, "last_page": 1, "per_page": 100, "total": 0},
+            }
+
+    def get(self, game_id: int) -> Dict[str, Any]:
+        """
+        Get a single game by ID
+
+        Args:
+            game_id: The game ID
+
+        Returns:
+            Dict with success and data
+        """
+        try:
+            self._client.games_api.get_api_v1_games_id(str(game_id))
+
+            return {
+                "success": True,
+                "data": {"id": game_id},
+            }
+        except Exception as e:
+            return {
+                "success": False,
+                "error": str(e),
+            }
+
+    def by_producer(self, producer_id: int, **kwargs) -> Dict[str, Any]:
+        """Get games by producer"""
+        return self.list(producer_id=producer_id, **kwargs)
+
+    def by_category(self, game_type: str, **kwargs) -> Dict[str, Any]:
+        """Get games by category/type"""
+        return self.list(game_type=game_type, **kwargs)
+
+    def search(self, query: str, **kwargs) -> Dict[str, Any]:
+        """Search games by title"""
+        return self.list(search=query, **kwargs)
+
+    def all(self, **kwargs) -> Dict[str, Any]:
+        """Get all games (no pagination)"""
+        kwargs["per_page"] = "all"
+        return self.list(**kwargs)

iplaygames_sdk-1.0.0/iplaygames/flows/jackpot.py

@@ -0,0 +1,239 @@
+"""
+Jackpot Flow
+
+Configure and manage jackpot pools for your casino.
+"""
+
+from typing import TYPE_CHECKING, Any, Dict, List, Optional
+
+if TYPE_CHECKING:
+    from ..client import Client
+
+
+class JackpotFlow:
+    """High-level flow for jackpot operations"""
+
+    def __init__(self, client: "Client"):
+        self._client = client
+
+    def get_configuration(self) -> Dict[str, Any]:
+        """Get current jackpot configuration"""
+        try:
+            self._client.endpoints_api.configure_jackpot_settings_for_the_operator(None)
+
+            return {
+                "success": True,
+                "message": "Configuration retrieved",
+            }
+        except Exception as e:
+            return {
+                "success": False,
+                "error": str(e),
+            }
+
+    def configure(self, prize_tiers: Optional[List[Any]] = None) -> Dict[str, Any]:
+        """
+        Configure jackpot settings
+
+        Args:
+            prize_tiers: Array of prize tier configurations
+
+        Returns:
+            Dict with success status
+        """
+        try:
+            request = {}
+            if prize_tiers:
+                request["prize_tiers"] = prize_tiers
+
+            self._client.endpoints_api.configure_jackpot_settings_for_the_operator(request)
+
+            return {
+                "success": True,
+                "message": "Configuration updated",
+            }
+        except Exception as e:
+            return {
+                "success": False,
+                "error": str(e),
+            }
+
+    def get_pools(self) -> Dict[str, Any]:
+        """Get all active jackpot pools"""
+        try:
+            self._client.endpoints_api.list_operators_jackpot_pools(None)
+
+            return {
+                "success": True,
+                "pools": [],
+            }
+        except Exception as e:
+            return {
+                "success": False,
+                "error": str(e),
+                "pools": [],
+            }
+
+    def get_pool(self, pool_type: str) -> Dict[str, Any]:
+        """
+        Get a specific pool by type
+
+        Args:
+            pool_type: Pool type: daily, weekly, monthly, progressive
+
+        Returns:
+            Dict with pool details
+        """
+        try:
+            self._client.endpoints_api.list_operators_jackpot_pools({"pool_type": pool_type})
+
+            return {
+                "success": True,
+                "pool_type": pool_type,
+            }
+        except Exception as e:
+            return {
+                "success": False,
+                "error": str(e),
+            }
+
+    def get_winners(self, pool_id: str) -> Dict[str, Any]:
+        """Get winners for a pool"""
+        return {
+            "success": True,
+            "pool_id": pool_id,
+            "winners": [],
+        }
+
+    def get_games(self, pool_type: Optional[str] = None) -> Dict[str, Any]:
+        """
+        Get games eligible for jackpot
+
+        Args:
+            pool_type: Filter by pool type
+
+        Returns:
+            Dict with list of games
+        """
+        try:
+            request = {"pool_type": pool_type} if pool_type else None
+            self._client.endpoints_api.get_games_for_a_pool_type_or_all_pool_types(request)
+
+            return {
+                "success": True,
+                "pool_type": pool_type,
+                "games": [],
+            }
+        except Exception as e:
+            return {
+                "success": False,
+                "error": str(e),
+                "games": [],
+            }
+
+    def add_games(self, pool_type: str, game_ids: List[int]) -> Dict[str, Any]:
+        """
+        Add games to a jackpot pool
+
+        Args:
+            pool_type: Pool type
+            game_ids: Array of game IDs
+
+        Returns:
+            Dict with success status
+        """
+        try:
+            self._client.endpoints_api.add_games_to_a_jackpot_pool_type({
+                "pool_type": pool_type,
+                "game_ids": game_ids,
+            })
+
+            return {
+                "success": True,
+                "message": "Games added to jackpot pool",
+            }
+        except Exception as e:
+            return {
+                "success": False,
+                "error": str(e),
+            }
+
+    def remove_games(self, pool_type: str, game_ids: List[int]) -> Dict[str, Any]:
+        """
+        Remove games from a jackpot pool
+
+        Args:
+            pool_type: Pool type
+            game_ids: Array of game IDs
+
+        Returns:
+            Dict with success status
+        """
+        try:
+            self._client.endpoints_api.remove_games_from_a_jackpot_pool_type({
+                "pool_type": pool_type,
+                "game_ids": game_ids,
+            })
+
+            return {
+                "success": True,
+                "message": "Games removed from jackpot pool",
+            }
+        except Exception as e:
+            return {
+                "success": False,
+                "error": str(e),
+            }
+
+    def get_contributions(
+        self,
+        player_id: Optional[str] = None,
+        pool_type: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """
+        Get contribution history
+
+        Args:
+            player_id: Filter by player
+            pool_type: Filter by pool type
+
+        Returns:
+            Dict with list of contributions
+        """
+        try:
+            request = {}
+            if player_id:
+                request["player_id"] = player_id
+            if pool_type:
+                request["pool_type"] = pool_type
+
+            self._client.endpoints_api.get_player_contribution_history(request)
+
+            return {
+                "success": True,
+                "contributions": [],
+            }
+        except Exception as e:
+            return {
+                "success": False,
+                "error": str(e),
+                "contributions": [],
+            }
+
+    def release(self, pool_id: str, player_id: str) -> Dict[str, Any]:
+        """
+        Manually release a jackpot pool
+
+        Args:
+            pool_id: Pool ID
+            player_id: Winner's player ID
+
+        Returns:
+            Dict with payout details
+        """
+        return {
+            "success": True,
+            "pool_id": pool_id,
+            "player_id": player_id,
+            "message": "Jackpot release initiated",
+        }