vortex-python-sdk 0.0.1__py3-none-any.whl

vortex_python_sdk-0.0.1.dist-info/METADATA

@@ -0,0 +1,233 @@
+Metadata-Version: 2.4
+Name: vortex-python-sdk
+Version: 0.0.1
+Summary: Vortex Python SDK for invitation management and JWT generation
+Author-email: TeamVortexSoftware <support@vortexsoftware.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/teamvortexsoftware/vortex-python-sdk
+Project-URL: Repository, https://github.com/teamvortexsoftware/vortex-python-sdk.git
+Project-URL: Documentation, https://docs.vortexsoftware.com/python-sdk
+Project-URL: Changelog, https://github.com/teamvortexsoftware/vortex-python-sdk/blob/main/CHANGELOG.md
+Keywords: vortex,invitations,jwt,api,sdk
+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: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: pydantic>=2.8.0
+Requires-Dist: typing-extensions>=4.8.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.21.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
+Requires-Dist: black>=23.0.0; extra == "dev"
+Requires-Dist: isort>=5.12.0; extra == "dev"
+Requires-Dist: mypy>=1.0.0; extra == "dev"
+Requires-Dist: ruff>=0.1.0; extra == "dev"
+Dynamic: license-file
+
+# Vortex Python SDK
+
+A Python SDK for Vortex invitation management and JWT generation.
+
+## Installation
+
+```bash
+pip install vortex-python-sdk
+```
+
+> **Note**: The package will be available on PyPI once published. See [PUBLISHING.md](PUBLISHING.md) for publishing instructions.
+
+## Usage
+
+### Basic Setup
+
+```python
+from vortex_sdk import Vortex
+
+# Initialize the client
+vortex = Vortex(api_key="your-api-key")
+
+# Or with custom base URL
+vortex = Vortex(api_key="your-api-key", base_url="https://custom-api.example.com")
+```
+
+### JWT Generation
+
+```python
+# Generate JWT for a user
+jwt = vortex.generate_jwt({
+    "user_id": "user123",
+    "identifiers": {
+        "email": "user@example.com",
+        "username": "johndoe"
+    },
+    "groups": ["admin", "users"],
+    "role": "admin"
+})
+
+print(f"JWT: {jwt}")
+```
+
+### Invitation Management
+
+#### Get Invitations by Target
+
+```python
+import asyncio
+
+async def get_user_invitations():
+    # Async version
+    invitations = await vortex.get_invitations_by_target("email", "user@example.com")
+    for invitation in invitations:
+        print(f"Invitation ID: {invitation.id}, Status: {invitation.status}")
+
+# Sync version
+invitations = vortex.get_invitations_by_target_sync("email", "user@example.com")
+```
+
+#### Accept Invitations
+
+```python
+async def accept_user_invitations():
+    # Async version
+    result = await vortex.accept_invitations(
+        invitation_ids=["inv1", "inv2"],
+        target={"type": "email", "value": "user@example.com"}
+    )
+    print(f"Result: {result}")
+
+# Sync version
+result = vortex.accept_invitations_sync(
+    invitation_ids=["inv1", "inv2"],
+    target={"type": "email", "value": "user@example.com"}
+)
+```
+
+#### Get Specific Invitation
+
+```python
+async def get_invitation():
+    # Async version
+    invitation = await vortex.get_invitation("invitation-id")
+    print(f"Invitation: {invitation.id}")
+
+# Sync version
+invitation = vortex.get_invitation_sync("invitation-id")
+```
+
+#### Revoke Invitation
+
+```python
+async def revoke_invitation():
+    # Async version
+    result = await vortex.revoke_invitation("invitation-id")
+    print(f"Revoked: {result}")
+
+# Sync version
+result = vortex.revoke_invitation_sync("invitation-id")
+```
+
+### Group Operations
+
+#### Get Invitations by Group
+
+```python
+async def get_group_invitations():
+    # Async version
+    invitations = await vortex.get_invitations_by_group("organization", "org123")
+    print(f"Found {len(invitations)} invitations")
+
+# Sync version
+invitations = vortex.get_invitations_by_group_sync("organization", "org123")
+```
+
+#### Delete Invitations by Group
+
+```python
+async def delete_group_invitations():
+    # Async version
+    result = await vortex.delete_invitations_by_group("organization", "org123")
+    print(f"Deleted: {result}")
+
+# Sync version
+result = vortex.delete_invitations_by_group_sync("organization", "org123")
+```
+
+#### Reinvite
+
+```python
+async def reinvite_user():
+    # Async version
+    invitation = await vortex.reinvite("invitation-id")
+    print(f"Reinvited: {invitation.id}")
+
+# Sync version
+invitation = vortex.reinvite_sync("invitation-id")
+```
+
+### Context Manager Usage
+
+```python
+# Async context manager
+async with Vortex(api_key="your-api-key") as vortex:
+    invitations = await vortex.get_invitations_by_target("email", "user@example.com")
+
+# Sync context manager
+with Vortex(api_key="your-api-key") as vortex:
+    invitations = vortex.get_invitations_by_target_sync("email", "user@example.com")
+```
+
+### Error Handling
+
+```python
+from vortex_sdk import VortexApiError
+
+try:
+    invitation = vortex.get_invitation_sync("invalid-id")
+except VortexApiError as e:
+    print(f"API Error: {e.message} (Status: {e.status_code})")
+except Exception as e:
+    print(f"Unexpected error: {e}")
+```
+
+## Development
+
+### Installation
+
+```bash
+# Install development dependencies
+pip install -e ".[dev]"
+```
+
+### Running Tests
+
+```bash
+pytest
+```
+
+### Code Formatting
+
+```bash
+# Format code
+black src/ tests/
+isort src/ tests/
+
+# Lint code
+ruff check src/ tests/
+mypy src/
+```
+
+## License
+
+MIT

vortex_python_sdk-0.0.1.dist-info/RECORD

@@ -0,0 +1,9 @@
+vortex_python_sdk-0.0.1.dist-info/licenses/LICENSE,sha256=VndlWxbL4-w3YDf2yE5gJscj4zVXF0qlSq0LDtay3lo,1074
+vortex_sdk/__init__.py,sha256=mFLcyV2i5W7xuj25cThFWYBm6S0HpeOGtUIHDenzhBc,631
+vortex_sdk/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+vortex_sdk/types.py,sha256=whBfV7yVcrmk5K7ex1s4FCs92V9_bj-7KUsCRi5fmgk,1491
+vortex_sdk/vortex.py,sha256=_Ov62rzGdLecbID6LVQLMZgDc96xw7jY5qNqsfUjV3o,12963
+vortex_python_sdk-0.0.1.dist-info/METADATA,sha256=BH1AkI5SMi_mhRtttqLa5w1o2gk8ymwdzX3emM6U5iQ,5765
+vortex_python_sdk-0.0.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+vortex_python_sdk-0.0.1.dist-info/top_level.txt,sha256=xFDlEcXIIi_sBhkse0YfMnSdg2IlaYUd0oP2UCDc_Y0,11
+vortex_python_sdk-0.0.1.dist-info/RECORD,,

vortex_python_sdk-0.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

vortex_python_sdk-0.0.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 TeamVortexSoftware
+
+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.

vortex_python_sdk-0.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+vortex_sdk

vortex_sdk/__init__.py

@@ -0,0 +1,33 @@
+"""
+Vortex Python SDK
+
+A Python SDK for Vortex invitation management and JWT generation.
+"""
+
+from .vortex import Vortex
+from .types import (
+    AuthenticatedUser,
+    JwtPayload,
+    InvitationTarget,
+    Invitation,
+    CreateInvitationRequest,
+    AcceptInvitationsRequest,
+    ApiResponse,
+    VortexApiError
+)
+
+__version__ = "0.0.1"
+__author__ = "TeamVortexSoftware"
+__email__ = "support@vortexsoftware.com"
+
+__all__ = [
+    "Vortex",
+    "AuthenticatedUser",
+    "JwtPayload",
+    "InvitationTarget",
+    "Invitation",
+    "CreateInvitationRequest",
+    "AcceptInvitationsRequest",
+    "ApiResponse",
+    "VortexApiError",
+]

vortex_sdk/types.py

@@ -0,0 +1,59 @@
+from typing import Dict, List, Optional, Union, Literal
+from pydantic import BaseModel
+
+
+class AuthenticatedUser(BaseModel):
+    user_id: str
+    identifiers: Dict[str, str]
+    groups: Optional[List[str]] = None
+    role: Optional[str] = None
+
+
+class JwtPayload(BaseModel):
+    user_id: str
+    identifiers: Dict[str, str]
+    groups: Optional[List[str]] = None
+    role: Optional[str] = None
+
+
+class InvitationTarget(BaseModel):
+    type: Literal["email", "username", "phoneNumber"]
+    value: str
+
+
+class Invitation(BaseModel):
+    id: str
+    target: InvitationTarget
+    group_type: Optional[str] = None
+    group_id: Optional[str] = None
+    status: str
+    created_at: str
+    updated_at: Optional[str] = None
+    expires_at: Optional[str] = None
+    metadata: Optional[Dict[str, Union[str, int, bool]]] = None
+
+
+class CreateInvitationRequest(BaseModel):
+    target: InvitationTarget
+    group_type: Optional[str] = None
+    group_id: Optional[str] = None
+    expires_at: Optional[str] = None
+    metadata: Optional[Dict[str, Union[str, int, bool]]] = None
+
+
+class AcceptInvitationsRequest(BaseModel):
+    invitation_ids: List[str]
+    target: InvitationTarget
+
+
+class ApiResponse(BaseModel):
+    data: Optional[Dict] = None
+    error: Optional[str] = None
+    status_code: int = 200
+
+
+class VortexApiError(Exception):
+    def __init__(self, message: str, status_code: int = 500):
+        self.message = message
+        self.status_code = status_code
+        super().__init__(message)

vortex_sdk/vortex.py

@@ -0,0 +1,452 @@
+import json
+import hmac
+import hashlib
+import base64
+from typing import Dict, List, Optional, Union, Literal
+from urllib.parse import urlencode
+import httpx
+from .types import (
+    JwtPayload,
+    InvitationTarget,
+    Invitation,
+    CreateInvitationRequest,
+    AcceptInvitationsRequest,
+    ApiResponse,
+    VortexApiError
+)
+
+
+class Vortex:
+    def __init__(self, api_key: str, base_url: str = "https://api.vortexsoftware.com"):
+        """
+        Initialize Vortex client
+
+        Args:
+            api_key: Your Vortex API key
+            base_url: Base URL for Vortex API (default: https://api.vortexsoftware.com)
+        """
+        self.api_key = api_key
+        self.base_url = base_url.rstrip('/')
+        self._client = httpx.AsyncClient()
+        self._sync_client = httpx.Client()
+
+    def generate_jwt(self, payload: Union[JwtPayload, Dict]) -> str:
+        """
+        Generate a JWT token for the given payload
+
+        Args:
+            payload: JWT payload containing user_id, identifiers, groups, and role
+
+        Returns:
+            JWT token string
+        """
+        if isinstance(payload, dict):
+            payload = JwtPayload(**payload)
+
+        # JWT Header
+        header = {
+            "alg": "HS256",
+            "typ": "JWT"
+        }
+
+        # JWT Payload
+        jwt_payload = {
+            "userId": payload.user_id,
+            "identifiers": payload.identifiers,
+        }
+
+        if payload.groups is not None:
+            jwt_payload["groups"] = payload.groups
+        if payload.role is not None:
+            jwt_payload["role"] = payload.role
+
+        # Encode header and payload
+        header_encoded = base64.urlsafe_b64encode(
+            json.dumps(header, separators=(',', ':')).encode()
+        ).decode().rstrip('=')
+
+        payload_encoded = base64.urlsafe_b64encode(
+            json.dumps(jwt_payload, separators=(',', ':')).encode()
+        ).decode().rstrip('=')
+
+        # Create signature
+        message = f"{header_encoded}.{payload_encoded}"
+        signature = hmac.new(
+            self.api_key.encode(),
+            message.encode(),
+            hashlib.sha256
+        ).digest()
+
+        signature_encoded = base64.urlsafe_b64encode(signature).decode().rstrip('=')
+
+        return f"{message}.{signature_encoded}"
+
+    async def _vortex_api_request(
+        self,
+        method: str,
+        endpoint: str,
+        data: Optional[Dict] = None,
+        params: Optional[Dict] = None
+    ) -> Dict:
+        """
+        Make an API request to Vortex
+
+        Args:
+            method: HTTP method (GET, POST, DELETE, etc.)
+            endpoint: API endpoint path
+            data: Request body data
+            params: Query parameters
+
+        Returns:
+            API response data
+
+        Raises:
+            VortexApiError: If the API request fails
+        """
+        url = f"{self.base_url}{endpoint}"
+        headers = {
+            "Authorization": f"Bearer {self.api_key}",
+            "Content-Type": "application/json",
+            "User-Agent": "vortex-python-sdk/0.0.1"
+        }
+
+        try:
+            response = await self._client.request(
+                method=method,
+                url=url,
+                json=data,
+                params=params,
+                headers=headers
+            )
+
+            if response.status_code >= 400:
+                try:
+                    error_data = response.json()
+                    error_message = error_data.get('error', f'API request failed with status {response.status_code}')
+                except:
+                    error_message = f'API request failed with status {response.status_code}'
+
+                raise VortexApiError(error_message, response.status_code)
+
+            return response.json()
+
+        except httpx.RequestError as e:
+            raise VortexApiError(f"Request failed: {str(e)}")
+
+    def _vortex_api_request_sync(
+        self,
+        method: str,
+        endpoint: str,
+        data: Optional[Dict] = None,
+        params: Optional[Dict] = None
+    ) -> Dict:
+        """
+        Make a synchronous API request to Vortex
+
+        Args:
+            method: HTTP method (GET, POST, DELETE, etc.)
+            endpoint: API endpoint path
+            data: Request body data
+            params: Query parameters
+
+        Returns:
+            API response data
+
+        Raises:
+            VortexApiError: If the API request fails
+        """
+        url = f"{self.base_url}{endpoint}"
+        headers = {
+            "Authorization": f"Bearer {self.api_key}",
+            "Content-Type": "application/json",
+            "User-Agent": "vortex-python-sdk/0.0.1"
+        }
+
+        try:
+            response = self._sync_client.request(
+                method=method,
+                url=url,
+                json=data,
+                params=params,
+                headers=headers
+            )
+
+            if response.status_code >= 400:
+                try:
+                    error_data = response.json()
+                    error_message = error_data.get('error', f'API request failed with status {response.status_code}')
+                except:
+                    error_message = f'API request failed with status {response.status_code}'
+
+                raise VortexApiError(error_message, response.status_code)
+
+            return response.json()
+
+        except httpx.RequestError as e:
+            raise VortexApiError(f"Request failed: {str(e)}")
+
+    async def get_invitations_by_target(
+        self,
+        target_type: Literal["email", "username", "phoneNumber"],
+        target_value: str
+    ) -> List[Invitation]:
+        """
+        Get invitations for a specific target
+
+        Args:
+            target_type: Type of target (email, username, or phoneNumber)
+            target_value: Target value
+
+        Returns:
+            List of invitations
+        """
+        params = {
+            "targetType": target_type,
+            "targetValue": target_value
+        }
+
+        response = await self._vortex_api_request("GET", "/invitations/by-target", params=params)
+        return [Invitation(**inv) for inv in response.get("invitations", [])]
+
+    def get_invitations_by_target_sync(
+        self,
+        target_type: Literal["email", "username", "phoneNumber"],
+        target_value: str
+    ) -> List[Invitation]:
+        """
+        Get invitations for a specific target (synchronous)
+
+        Args:
+            target_type: Type of target (email, username, or phoneNumber)
+            target_value: Target value
+
+        Returns:
+            List of invitations
+        """
+        params = {
+            "targetType": target_type,
+            "targetValue": target_value
+        }
+
+        response = self._vortex_api_request_sync("GET", "/invitations/by-target", params=params)
+        return [Invitation(**inv) for inv in response.get("invitations", [])]
+
+    async def get_invitation(self, invitation_id: str) -> Invitation:
+        """
+        Get a specific invitation by ID
+
+        Args:
+            invitation_id: Invitation ID
+
+        Returns:
+            Invitation object
+        """
+        response = await self._vortex_api_request("GET", f"/invitations/{invitation_id}")
+        return Invitation(**response)
+
+    def get_invitation_sync(self, invitation_id: str) -> Invitation:
+        """
+        Get a specific invitation by ID (synchronous)
+
+        Args:
+            invitation_id: Invitation ID
+
+        Returns:
+            Invitation object
+        """
+        response = self._vortex_api_request_sync("GET", f"/invitations/{invitation_id}")
+        return Invitation(**response)
+
+    async def accept_invitations(
+        self,
+        invitation_ids: List[str],
+        target: Union[InvitationTarget, Dict[str, str]]
+    ) -> Dict:
+        """
+        Accept multiple invitations
+
+        Args:
+            invitation_ids: List of invitation IDs to accept
+            target: Target information (type and value)
+
+        Returns:
+            API response
+        """
+        if isinstance(target, dict):
+            target = InvitationTarget(**target)
+
+        data = {
+            "invitationIds": invitation_ids,
+            "target": target.model_dump()
+        }
+
+        return await self._vortex_api_request("POST", "/invitations/accept", data=data)
+
+    def accept_invitations_sync(
+        self,
+        invitation_ids: List[str],
+        target: Union[InvitationTarget, Dict[str, str]]
+    ) -> Dict:
+        """
+        Accept multiple invitations (synchronous)
+
+        Args:
+            invitation_ids: List of invitation IDs to accept
+            target: Target information (type and value)
+
+        Returns:
+            API response
+        """
+        if isinstance(target, dict):
+            target = InvitationTarget(**target)
+
+        data = {
+            "invitationIds": invitation_ids,
+            "target": target.model_dump()
+        }
+
+        return self._vortex_api_request_sync("POST", "/invitations/accept", data=data)
+
+    async def revoke_invitation(self, invitation_id: str) -> Dict:
+        """
+        Revoke an invitation
+
+        Args:
+            invitation_id: Invitation ID to revoke
+
+        Returns:
+            API response
+        """
+        return await self._vortex_api_request("DELETE", f"/invitations/{invitation_id}")
+
+    def revoke_invitation_sync(self, invitation_id: str) -> Dict:
+        """
+        Revoke an invitation (synchronous)
+
+        Args:
+            invitation_id: Invitation ID to revoke
+
+        Returns:
+            API response
+        """
+        return self._vortex_api_request_sync("DELETE", f"/invitations/{invitation_id}")
+
+    async def get_invitations_by_group(
+        self,
+        group_type: str,
+        group_id: str
+    ) -> List[Invitation]:
+        """
+        Get invitations for a specific group
+
+        Args:
+            group_type: Type of group
+            group_id: Group ID
+
+        Returns:
+            List of invitations
+        """
+        response = await self._vortex_api_request("GET", f"/invitations/by-group/{group_type}/{group_id}")
+        return [Invitation(**inv) for inv in response.get("invitations", [])]
+
+    def get_invitations_by_group_sync(
+        self,
+        group_type: str,
+        group_id: str
+    ) -> List[Invitation]:
+        """
+        Get invitations for a specific group (synchronous)
+
+        Args:
+            group_type: Type of group
+            group_id: Group ID
+
+        Returns:
+            List of invitations
+        """
+        response = self._vortex_api_request_sync("GET", f"/invitations/by-group/{group_type}/{group_id}")
+        return [Invitation(**inv) for inv in response.get("invitations", [])]
+
+    async def delete_invitations_by_group(
+        self,
+        group_type: str,
+        group_id: str
+    ) -> Dict:
+        """
+        Delete all invitations for a specific group
+
+        Args:
+            group_type: Type of group
+            group_id: Group ID
+
+        Returns:
+            API response
+        """
+        return await self._vortex_api_request("DELETE", f"/invitations/by-group/{group_type}/{group_id}")
+
+    def delete_invitations_by_group_sync(
+        self,
+        group_type: str,
+        group_id: str
+    ) -> Dict:
+        """
+        Delete all invitations for a specific group (synchronous)
+
+        Args:
+            group_type: Type of group
+            group_id: Group ID
+
+        Returns:
+            API response
+        """
+        return self._vortex_api_request_sync("DELETE", f"/invitations/by-group/{group_type}/{group_id}")
+
+    async def reinvite(self, invitation_id: str) -> Invitation:
+        """
+        Reinvite for a specific invitation
+
+        Args:
+            invitation_id: Invitation ID to reinvite
+
+        Returns:
+            Updated invitation object
+        """
+        response = await self._vortex_api_request("POST", f"/invitations/{invitation_id}/reinvite")
+        return Invitation(**response)
+
+    def reinvite_sync(self, invitation_id: str) -> Invitation:
+        """
+        Reinvite for a specific invitation (synchronous)
+
+        Args:
+            invitation_id: Invitation ID to reinvite
+
+        Returns:
+            Updated invitation object
+        """
+        response = self._vortex_api_request_sync("POST", f"/invitations/{invitation_id}/reinvite")
+        return Invitation(**response)
+
+    async def close(self):
+        """Close the HTTP client"""
+        await self._client.aclose()
+
+    def close_sync(self):
+        """Close the synchronous HTTP client"""
+        self._sync_client.close()
+
+    async def __aenter__(self):
+        """Async context manager entry"""
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        """Async context manager exit"""
+        await self.close()
+
+    def __enter__(self):
+        """Context manager entry"""
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        """Context manager exit"""
+        self.close_sync()