vortex-python-sdk 0.0.3__tar.gz → 0.0.6__tar.gz

{vortex_python_sdk-0.0.3 → vortex_python_sdk-0.0.6}/CHANGELOG.md

@@ -7,9 +7,16 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.0.5] - 2025-11-06
+
+### Fixed
+
+- **CRITICAL FIX**: Updated api url & auth headers
+
 ## [0.0.3] - 2025-01-31
 
 ### Fixed
+
 - **CRITICAL FIX**: JWT generation now matches Node.js SDK implementation exactly
   - Improved JWT signing algorithm to match Node.js SDK
   - Added `iat` (issued at) and `expires` timestamp fields to JWT
@@ -18,12 +25,14 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Added comprehensive tests verifying JWT output matches Node.js SDK byte-for-byte
 
 ### Breaking Changes
+
 - JWT structure changed significantly - tokens from 0.0.2 are incompatible with 0.0.3
 - JWTs now include `iat` and `expires` fields for proper token lifecycle management
 
 ## [0.0.2] - 2025-01-31
 
 ### Fixed
+
 - **BREAKING FIX**: JWT payload format now matches TypeScript SDK
   - `identifiers` changed from `Dict[str, str]` to `List[Dict]` with `type` and `value` fields
   - `groups` structure now properly includes `type`, `id`/`groupId`, and `name` fields
@@ -32,9 +41,11 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Updated documentation with correct JWT generation examples
 
 ### Migration Guide
+
 If you're upgrading from 0.0.1, update your JWT generation code:
 
 **Before (0.0.1):**
+
 ```python
 jwt = vortex.generate_jwt({
     "user_id": "user-123",
@@ -44,6 +55,7 @@ jwt = vortex.generate_jwt({
 ```
 
 **After (0.0.2):**
+
 ```python
 jwt = vortex.generate_jwt({
     "user_id": "user-123",
@@ -55,6 +67,7 @@ jwt = vortex.generate_jwt({
 ## [0.0.1] - 2024-10-10
 
 ### Added
+
 - Initial release of Vortex Python SDK
 - JWT generation with HMAC-SHA256 signing
 - Complete invitation management API
@@ -65,6 +78,7 @@ jwt = vortex.generate_jwt({
 - Full compatibility with Node.js SDK API
 
 ### Features
+
 - `generate_jwt()` - Generate Vortex JWT tokens
 - `get_invitations_by_target()` - Get invitations by email/username/phone
 - `accept_invitations()` - Accept multiple invitations
@@ -74,4 +88,4 @@ jwt = vortex.generate_jwt({
 - `delete_invitations_by_group()` - Delete all group invitations
 - `reinvite()` - Reinvite functionality
 - Both async and sync versions of all methods
-- Python 3.8+ support
+- Python 3.8+ support

{vortex_python_sdk-0.0.3/src/vortex_python_sdk.egg-info → vortex_python_sdk-0.0.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vortex-python-sdk
-Version: 0.0.3
+Version: 0.0.6
 Summary: Vortex Python SDK for invitation management and JWT generation
 Author-email: TeamVortexSoftware <support@vortexsoftware.com>
 License-Expression: MIT

{vortex_python_sdk-0.0.3 → vortex_python_sdk-0.0.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "vortex-python-sdk"
-version = "0.0.3"
+version = "0.0.6"
 description = "Vortex Python SDK for invitation management and JWT generation"
 authors = [{name = "TeamVortexSoftware", email = "support@vortexsoftware.com"}]
 readme = "README.md"
@@ -68,7 +68,7 @@ profile = "black"
 line_length = 88
 
 [tool.mypy]
-python_version = "3.8"
+python_version = "3.9"
 warn_return_any = true
 warn_unused_configs = true
 disallow_untyped_defs = true
@@ -83,6 +83,8 @@ warn_unreachable = true
 [tool.ruff]
 target-version = "py38"
 line-length = 88
+
+[tool.ruff.lint]
 select = [
     "E",  # pycodestyle errors
     "W",  # pycodestyle warnings

{vortex_python_sdk-0.0.3 → vortex_python_sdk-0.0.6/src/vortex_python_sdk.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vortex-python-sdk
-Version: 0.0.3
+Version: 0.0.6
 Summary: Vortex Python SDK for invitation management and JWT generation
 Author-email: TeamVortexSoftware <support@vortexsoftware.com>
 License-Expression: MIT

{vortex_python_sdk-0.0.3 → vortex_python_sdk-0.0.6}/src/vortex_sdk/__init__.py

@@ -4,21 +4,27 @@ Vortex Python SDK
 A Python SDK for Vortex invitation management and JWT generation.
 """
 
-from .vortex import Vortex
 from .types import (
+    AcceptInvitationRequest,
+    AcceptInvitationsRequest,
+    ApiRequestBody,
+    ApiResponse,
+    ApiResponseJson,
     AuthenticatedUser,
-    JwtPayload,
-    IdentifierInput,
+    CreateInvitationRequest,
     GroupInput,
-    InvitationTarget,
+    IdentifierInput,
     Invitation,
-    CreateInvitationRequest,
-    AcceptInvitationsRequest,
-    ApiResponse,
-    VortexApiError
+    InvitationAcceptance,
+    InvitationGroup,
+    InvitationResult,
+    InvitationTarget,
+    JwtPayload,
+    VortexApiError,
 )
+from .vortex import Vortex
 
-__version__ = "0.0.3"
+__version__ = "0.0.6"
 __author__ = "TeamVortexSoftware"
 __email__ = "support@vortexsoftware.com"
 
@@ -29,9 +35,15 @@ __all__ = [
     "IdentifierInput",
     "GroupInput",
     "InvitationTarget",
-    "Invitation",
+    "InvitationGroup",
+    "InvitationAcceptance",
+    "InvitationResult",
+    "Invitation",  # Alias for InvitationResult
     "CreateInvitationRequest",
-    "AcceptInvitationsRequest",
+    "AcceptInvitationRequest",
+    "AcceptInvitationsRequest",  # Alias for AcceptInvitationRequest
     "ApiResponse",
+    "ApiResponseJson",
+    "ApiRequestBody",
     "VortexApiError",
-]
+]

vortex_python_sdk-0.0.6/src/vortex_sdk/types.py

@@ -0,0 +1,173 @@
+from typing import Any, Dict, List, Literal, Optional, Union
+
+from pydantic import BaseModel, Field
+
+
+class IdentifierInput(BaseModel):
+    """Identifier structure for JWT generation"""
+
+    type: Literal["email", "sms"]
+    value: str
+
+
+class GroupInput(BaseModel):
+    """Group structure for JWT generation (input)"""
+
+    type: str
+    id: Optional[str] = None  # Legacy field (deprecated, use groupId)
+    groupId: Optional[str] = Field(
+        None, alias="group_id", serialization_alias="groupId"
+    )  # Preferred: Customer's group ID
+    name: str
+
+    class Config:
+        populate_by_name = True
+
+
+class InvitationGroup(BaseModel):
+    """
+    Invitation group from API responses
+    This matches the MemberGroups table structure from the API
+    """
+
+    id: str  # Vortex internal UUID
+    account_id: str = Field(alias="accountId")  # Vortex account ID
+    group_id: str = Field(alias="groupId")  # Customer's group ID
+    type: str  # Group type (e.g., "workspace", "team")
+    name: str  # Group name
+    created_at: str = Field(alias="createdAt")  # ISO 8601 timestamp
+
+    class Config:
+        # Allow both snake_case (Python) and camelCase (JSON) field names
+        populate_by_name = True
+        json_schema_extra = {
+            "example": {
+                "id": "550e8400-e29b-41d4-a716-446655440000",
+                "accountId": "6ba7b810-9dad-11d1-80b4-00c04fd430c8",
+                "groupId": "workspace-123",
+                "type": "workspace",
+                "name": "My Workspace",
+                "createdAt": "2025-01-27T12:00:00.000Z",
+            }
+        }
+
+
+class AuthenticatedUser(BaseModel):
+    user_id: str
+    identifiers: List[IdentifierInput]
+    groups: Optional[List[GroupInput]] = None
+    role: Optional[str] = None
+
+
+class JwtPayload(BaseModel):
+    user_id: str
+    identifiers: List[IdentifierInput]
+    groups: Optional[List[GroupInput]] = None
+    role: Optional[str] = None
+    attributes: Optional[Dict[str, Any]] = None
+
+
+class InvitationTarget(BaseModel):
+    type: Literal["email", "sms"]
+    value: str
+
+
+class InvitationAcceptance(BaseModel):
+    """Represents an acceptance of an invitation"""
+
+    id: str
+    account_id: str = Field(alias="accountId")
+    project_id: str = Field(alias="projectId")
+    accepted_at: str = Field(alias="acceptedAt")
+    target: InvitationTarget
+
+    class Config:
+        populate_by_name = True
+
+
+class InvitationResult(BaseModel):
+    """
+    Complete invitation result from API responses.
+    This is the exact port of the Node.js SDK's InvitationResult type.
+    """
+
+    id: str
+    account_id: str = Field(alias="accountId")
+    click_throughs: int = Field(alias="clickThroughs")
+    configuration_attributes: Optional[Dict[str, Any]] = Field(
+        None, alias="configurationAttributes"
+    )
+    attributes: Optional[Dict[str, Any]] = None
+    created_at: str = Field(alias="createdAt")
+    deactivated: bool
+    delivery_count: int = Field(alias="deliveryCount")
+    delivery_types: List[Literal["email", "sms", "share"]] = Field(
+        alias="deliveryTypes"
+    )
+    foreign_creator_id: str = Field(alias="foreignCreatorId")
+    invitation_type: Literal["single_use", "multi_use"] = Field(alias="invitationType")
+    modified_at: Optional[str] = Field(None, alias="modifiedAt")
+    status: Literal[
+        "queued",
+        "sending",
+        "delivered",
+        "accepted",
+        "shared",
+        "unfurled",
+        "accepted_elsewhere",
+    ]
+    target: List[InvitationTarget]
+    views: int
+    widget_configuration_id: str = Field(alias="widgetConfigurationId")
+    project_id: str = Field(alias="projectId")
+    groups: List[Optional[InvitationGroup]] = Field(default_factory=list)
+    accepts: List[InvitationAcceptance] = Field(default_factory=list)
+
+    class Config:
+        populate_by_name = True
+
+
+# Alias for backward compatibility
+Invitation = InvitationResult
+
+
+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 AcceptInvitationRequest(BaseModel):
+    """Request to accept one or more invitations"""
+
+    invitation_ids: List[str] = Field(alias="invitationIds")
+    target: InvitationTarget
+
+    class Config:
+        populate_by_name = True
+
+
+# Alias for backward compatibility
+AcceptInvitationsRequest = AcceptInvitationRequest
+
+
+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)
+
+
+# Type aliases to match Node.js SDK
+ApiResponseJson = Union[
+    InvitationResult, Dict[str, List[InvitationResult]], Dict[str, Any]
+]
+ApiRequestBody = Union[AcceptInvitationRequest, None]

{vortex_python_sdk-0.0.3 → vortex_python_sdk-0.0.6}/src/vortex_sdk/vortex.py

@@ -1,34 +1,41 @@
-import json
-import hmac
-import hashlib
 import base64
+import hashlib
+import hmac
+import json
 import time
 import uuid
-from typing import Dict, List, Optional, Union, Literal
-from urllib.parse import urlencode
+from typing import Any, Dict, List, Literal, Optional, Union
+
 import httpx
+
 from .types import (
-    JwtPayload,
-    InvitationTarget,
     Invitation,
-    CreateInvitationRequest,
-    AcceptInvitationsRequest,
-    ApiResponse,
-    VortexApiError
+    InvitationTarget,
+    JwtPayload,
+    VortexApiError,
 )
 
 
+def _get_version() -> str:
+    """Lazy import of version to avoid circular import"""
+    from . import __version__
+
+    return __version__
+
+
 class Vortex:
-    def __init__(self, api_key: str, base_url: str = "https://api.vortexsoftware.com"):
+    def __init__(
+        self, api_key: str, base_url: str = "https://api.vortexsoftware.com/api/v1"
+    ):
         """
         Initialize Vortex client
 
         Args:
             api_key: Your Vortex API key
-            base_url: Base URL for Vortex API (default: https://api.vortexsoftware.com)
+            base_url: Base URL for Vortex API (default: https://api.vortexsoftware.com/api/v1)
         """
         self.api_key = api_key
-        self.base_url = base_url.rstrip('/')
+        self.base_url = base_url.rstrip("/")
         self._client = httpx.AsyncClient()
         self._sync_client = httpx.Client()
 
@@ -49,20 +56,20 @@ class Vortex:
             payload = JwtPayload(**payload)
 
         # Parse API key (format: VRTX.base64url(uuid).key)
-        parts = self.api_key.split('.')
+        parts = self.api_key.split(".")
         if len(parts) != 3:
-            raise ValueError('Invalid API key format. Expected: VRTX.{encodedId}.{key}')
+            raise ValueError("Invalid API key format. Expected: VRTX.{encodedId}.{key}")
 
         prefix, encoded_id, key = parts
 
-        if prefix != 'VRTX':
-            raise ValueError('Invalid API key prefix. Expected: VRTX')
+        if prefix != "VRTX":
+            raise ValueError("Invalid API key prefix. Expected: VRTX")
 
         # Decode UUID from base64url
         # Add padding if needed
         padding = 4 - len(encoded_id) % 4
         if padding != 4:
-            encoded_id_padded = encoded_id + ('=' * padding)
+            encoded_id_padded = encoded_id + ("=" * padding)
         else:
             encoded_id_padded = encoded_id
 
@@ -70,75 +77,71 @@ class Vortex:
             uuid_bytes = base64.urlsafe_b64decode(encoded_id_padded)
             kid = str(uuid.UUID(bytes=uuid_bytes))
         except Exception as e:
-            raise ValueError(f'Invalid UUID in API key: {e}')
+            raise ValueError(f"Invalid UUID in API key: {e}") from e
 
         # Generate timestamps
         iat = int(time.time())
         expires = iat + 3600
 
         # Step 1: Derive signing key from API key + UUID
-        signing_key = hmac.new(
-            key.encode(),
-            kid.encode(),
-            hashlib.sha256
-        ).digest()
+        signing_key = hmac.new(key.encode(), kid.encode(), hashlib.sha256).digest()
 
         # Step 2: Build header + payload
         header = {
-            'iat': iat,
-            'alg': 'HS256',
-            'typ': 'JWT',
-            'kid': kid,
+            "iat": iat,
+            "alg": "HS256",
+            "typ": "JWT",
+            "kid": kid,
         }
 
         # Serialize identifiers
-        identifiers_list = [{"type": id.type, "value": id.value} for id in payload.identifiers]
+        identifiers_list = [
+            {"type": id.type, "value": id.value} for id in payload.identifiers
+        ]
 
         # Serialize groups
         groups_list = None
         if payload.groups is not None:
             groups_list = [
-                {k: v for k, v in group.model_dump(by_alias=True, exclude_none=True).items()}
+                group.model_dump(by_alias=True, exclude_none=True)
                 for group in payload.groups
             ]
 
-        jwt_payload = {
-            'userId': payload.user_id,
-            'groups': groups_list,
-            'role': payload.role,
-            'expires': expires,
-            'identifiers': identifiers_list,
+        jwt_payload: Dict[str, Any] = {
+            "userId": payload.user_id,
+            "groups": groups_list,
+            "role": payload.role,
+            "expires": expires,
+            "identifiers": identifiers_list,
         }
 
         # Add attributes if provided
-        if hasattr(payload, 'attributes') and payload.attributes:
-            jwt_payload['attributes'] = payload.attributes
+        if hasattr(payload, "attributes") and payload.attributes:
+            jwt_payload["attributes"] = payload.attributes
 
         # Step 3: Base64URL encode (without padding)
-        header_json = json.dumps(header, separators=(',', ':'))
-        payload_json = json.dumps(jwt_payload, separators=(',', ':'))
+        header_json = json.dumps(header, separators=(",", ":"))
+        payload_json = json.dumps(jwt_payload, separators=(",", ":"))
 
-        header_b64 = base64.urlsafe_b64encode(header_json.encode()).decode().rstrip('=')
-        payload_b64 = base64.urlsafe_b64encode(payload_json.encode()).decode().rstrip('=')
+        header_b64 = base64.urlsafe_b64encode(header_json.encode()).decode().rstrip("=")
+        payload_b64 = (
+            base64.urlsafe_b64encode(payload_json.encode()).decode().rstrip("=")
+        )
 
         # Step 4: Sign
-        to_sign = f'{header_b64}.{payload_b64}'
-        signature = hmac.new(
-            signing_key,
-            to_sign.encode(),
-            hashlib.sha256
-        ).digest()
+        to_sign = f"{header_b64}.{payload_b64}"
+        signature = hmac.new(signing_key, to_sign.encode(), hashlib.sha256).digest()
 
-        signature_b64 = base64.urlsafe_b64encode(signature).decode().rstrip('=')
+        signature_b64 = base64.urlsafe_b64encode(signature).decode().rstrip("=")
 
-        return f'{to_sign}.{signature_b64}'
+        return f"{to_sign}.{signature_b64}"
 
     async def _vortex_api_request(
         self,
         method: str,
         endpoint: str,
         data: Optional[Dict] = None,
-        params: Optional[Dict] = None
+        params: Optional[Dict] = None,
     ) -> Dict:
         """
         Make an API request to Vortex
@@ -157,40 +160,41 @@ class Vortex:
         """
         url = f"{self.base_url}{endpoint}"
         headers = {
-            "Authorization": f"Bearer {self.api_key}",
+            "x-api-key": f"{self.api_key}",
             "Content-Type": "application/json",
-            "User-Agent": "vortex-python-sdk/0.0.1"
+            "User-Agent": f"vortex-python-sdk/{_get_version()}",
         }
 
         try:
             response = await self._client.request(
-                method=method,
-                url=url,
-                json=data,
-                params=params,
-                headers=headers
+                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}'
+                    error_message = error_data.get(
+                        "error",
+                        f"API request failed with status {response.status_code}",
+                    )
+                except Exception:
+                    error_message = (
+                        f"API request failed with status {response.status_code}"
+                    )
 
                 raise VortexApiError(error_message, response.status_code)
 
-            return response.json()
+            return response.json()  # type: ignore[no-any-return]
 
         except httpx.RequestError as e:
-            raise VortexApiError(f"Request failed: {str(e)}")
+            raise VortexApiError(f"Request failed: {str(e)}") from e
 
     def _vortex_api_request_sync(
         self,
         method: str,
         endpoint: str,
         data: Optional[Dict] = None,
-        params: Optional[Dict] = None
+        params: Optional[Dict] = None,
     ) -> Dict:
         """
         Make a synchronous API request to Vortex
@@ -209,38 +213,39 @@ class Vortex:
         """
         url = f"{self.base_url}{endpoint}"
         headers = {
-            "Authorization": f"Bearer {self.api_key}",
+            "x-api-key": f"{self.api_key}",
             "Content-Type": "application/json",
-            "User-Agent": "vortex-python-sdk/0.0.1"
+            "User-Agent": f"vortex-python-sdk/{_get_version()}",
         }
 
         try:
             response = self._sync_client.request(
-                method=method,
-                url=url,
-                json=data,
-                params=params,
-                headers=headers
+                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}'
+                    error_message = error_data.get(
+                        "error",
+                        f"API request failed with status {response.status_code}",
+                    )
+                except Exception:
+                    error_message = (
+                        f"API request failed with status {response.status_code}"
+                    )
 
                 raise VortexApiError(error_message, response.status_code)
 
-            return response.json()
+            return response.json()  # type: ignore[no-any-return]
 
         except httpx.RequestError as e:
-            raise VortexApiError(f"Request failed: {str(e)}")
+            raise VortexApiError(f"Request failed: {str(e)}") from e
 
     async def get_invitations_by_target(
         self,
         target_type: Literal["email", "username", "phoneNumber"],
-        target_value: str
+        target_value: str,
     ) -> List[Invitation]:
         """
         Get invitations for a specific target
@@ -252,18 +257,17 @@ class Vortex:
         Returns:
             List of invitations
         """
-        params = {
-            "targetType": target_type,
-            "targetValue": target_value
-        }
+        params = {"targetType": target_type, "targetValue": target_value}
 
-        response = await self._vortex_api_request("GET", "/invitations/by-target", params=params)
+        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
+        target_value: str,
     ) -> List[Invitation]:
         """
         Get invitations for a specific target (synchronous)
@@ -275,12 +279,11 @@ class Vortex:
         Returns:
             List of invitations
         """
-        params = {
-            "targetType": target_type,
-            "targetValue": target_value
-        }
+        params = {"targetType": target_type, "targetValue": target_value}
 
-        response = self._vortex_api_request_sync("GET", "/invitations/by-target", params=params)
+        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:
@@ -293,7 +296,9 @@ class Vortex:
         Returns:
             Invitation object
         """
-        response = await self._vortex_api_request("GET", f"/invitations/{invitation_id}")
+        response = await self._vortex_api_request(
+            "GET", f"/invitations/{invitation_id}"
+        )
         return Invitation(**response)
 
     def get_invitation_sync(self, invitation_id: str) -> Invitation:
@@ -310,9 +315,7 @@ class Vortex:
         return Invitation(**response)
 
     async def accept_invitations(
-        self,
-        invitation_ids: List[str],
-        target: Union[InvitationTarget, Dict[str, str]]
+        self, invitation_ids: List[str], target: Union[InvitationTarget, Dict[str, str]]
     ) -> Dict:
         """
         Accept multiple invitations
@@ -324,20 +327,18 @@ class Vortex:
         Returns:
             API response
         """
+        target_obj: InvitationTarget
         if isinstance(target, dict):
-            target = InvitationTarget(**target)
+            target_obj = InvitationTarget(**target)  # type: ignore[arg-type]
+        else:
+            target_obj = target
 
-        data = {
-            "invitationIds": invitation_ids,
-            "target": target.model_dump()
-        }
+        data = {"invitationIds": invitation_ids, "target": target_obj.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]]
+        self, invitation_ids: List[str], target: Union[InvitationTarget, Dict[str, str]]
     ) -> Dict:
         """
         Accept multiple invitations (synchronous)
@@ -349,13 +350,13 @@ class Vortex:
         Returns:
             API response
         """
+        target_obj: InvitationTarget
         if isinstance(target, dict):
-            target = InvitationTarget(**target)
+            target_obj = InvitationTarget(**target)  # type: ignore[arg-type]
+        else:
+            target_obj = target
 
-        data = {
-            "invitationIds": invitation_ids,
-            "target": target.model_dump()
-        }
+        data = {"invitationIds": invitation_ids, "target": target_obj.model_dump()}
 
         return self._vortex_api_request_sync("POST", "/invitations/accept", data=data)
 
@@ -384,9 +385,7 @@ class Vortex:
         return self._vortex_api_request_sync("DELETE", f"/invitations/{invitation_id}")
 
     async def get_invitations_by_group(
-        self,
-        group_type: str,
-        group_id: str
+        self, group_type: str, group_id: str
     ) -> List[Invitation]:
         """
         Get invitations for a specific group
@@ -398,13 +397,13 @@ class Vortex:
         Returns:
             List of invitations
         """
-        response = await self._vortex_api_request("GET", f"/invitations/by-group/{group_type}/{group_id}")
+        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
+        self, group_type: str, group_id: str
     ) -> List[Invitation]:
         """
         Get invitations for a specific group (synchronous)
@@ -416,14 +415,12 @@ class Vortex:
         Returns:
             List of invitations
         """
-        response = self._vortex_api_request_sync("GET", f"/invitations/by-group/{group_type}/{group_id}")
+        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:
+    async def delete_invitations_by_group(self, group_type: str, group_id: str) -> Dict:
         """
         Delete all invitations for a specific group
 
@@ -434,13 +431,11 @@ class Vortex:
         Returns:
             API response
         """
-        return await self._vortex_api_request("DELETE", f"/invitations/by-group/{group_type}/{group_id}")
+        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:
+    def delete_invitations_by_group_sync(self, group_type: str, group_id: str) -> Dict:
         """
         Delete all invitations for a specific group (synchronous)
 
@@ -451,7 +446,9 @@ class Vortex:
         Returns:
             API response
         """
-        return self._vortex_api_request_sync("DELETE", f"/invitations/by-group/{group_type}/{group_id}")
+        return self._vortex_api_request_sync(
+            "DELETE", f"/invitations/by-group/{group_type}/{group_id}"
+        )
 
     async def reinvite(self, invitation_id: str) -> Invitation:
         """
@@ -463,7 +460,9 @@ class Vortex:
         Returns:
             Updated invitation object
         """
-        response = await self._vortex_api_request("POST", f"/invitations/{invitation_id}/reinvite")
+        response = await self._vortex_api_request(
+            "POST", f"/invitations/{invitation_id}/reinvite"
+        )
         return Invitation(**response)
 
     def reinvite_sync(self, invitation_id: str) -> Invitation:
@@ -476,29 +475,31 @@ class Vortex:
         Returns:
             Updated invitation object
         """
-        response = self._vortex_api_request_sync("POST", f"/invitations/{invitation_id}/reinvite")
+        response = self._vortex_api_request_sync(
+            "POST", f"/invitations/{invitation_id}/reinvite"
+        )
         return Invitation(**response)
 
-    async def close(self):
+    async def close(self) -> None:
         """Close the HTTP client"""
         await self._client.aclose()
 
-    def close_sync(self):
+    def close_sync(self) -> None:
         """Close the synchronous HTTP client"""
         self._sync_client.close()
 
-    async def __aenter__(self):
+    async def __aenter__(self) -> "Vortex":
         """Async context manager entry"""
         return self
 
-    async def __aexit__(self, exc_type, exc_val, exc_tb):
+    async def __aexit__(self, exc_type: Any, exc_val: Any, exc_tb: Any) -> None:
         """Async context manager exit"""
         await self.close()
 
-    def __enter__(self):
+    def __enter__(self) -> "Vortex":
         """Context manager entry"""
         return self
 
-    def __exit__(self, exc_type, exc_val, exc_tb):
+    def __exit__(self, exc_type: Any, exc_val: Any, exc_tb: Any) -> None:
         """Context manager exit"""
-        self.close_sync()
+        self.close_sync()

vortex_python_sdk-0.0.3/src/vortex_sdk/types.py

@@ -1,103 +0,0 @@
-from typing import Dict, List, Optional, Union, Literal, Any
-from pydantic import BaseModel, Field
-
-
-class IdentifierInput(BaseModel):
-    """Identifier structure for JWT generation"""
-    type: Literal["email", "sms"]
-    value: str
-
-
-class GroupInput(BaseModel):
-    """Group structure for JWT generation (input)"""
-    type: str
-    id: Optional[str] = None  # Legacy field (deprecated, use groupId)
-    groupId: Optional[str] = Field(None, alias="group_id", serialization_alias="groupId")  # Preferred: Customer's group ID
-    name: str
-
-    class Config:
-        populate_by_name = True
-
-
-class InvitationGroup(BaseModel):
-    """
-    Invitation group from API responses
-    This matches the MemberGroups table structure from the API
-    """
-    id: str  # Vortex internal UUID
-    account_id: str  # Vortex account ID (camelCase in JSON: accountId)
-    group_id: str  # Customer's group ID (camelCase in JSON: groupId)
-    type: str  # Group type (e.g., "workspace", "team")
-    name: str  # Group name
-    created_at: str  # ISO 8601 timestamp (camelCase in JSON: createdAt)
-
-    class Config:
-        # Allow both snake_case (Python) and camelCase (JSON) field names
-        populate_by_name = True
-        json_schema_extra = {
-            "example": {
-                "id": "550e8400-e29b-41d4-a716-446655440000",
-                "accountId": "6ba7b810-9dad-11d1-80b4-00c04fd430c8",
-                "groupId": "workspace-123",
-                "type": "workspace",
-                "name": "My Workspace",
-                "createdAt": "2025-01-27T12:00:00.000Z"
-            }
-        }
-
-
-class AuthenticatedUser(BaseModel):
-    user_id: str
-    identifiers: List[IdentifierInput]
-    groups: Optional[List[GroupInput]] = None
-    role: Optional[str] = None
-
-
-class JwtPayload(BaseModel):
-    user_id: str
-    identifiers: List[IdentifierInput]
-    groups: Optional[List[GroupInput]] = None
-    role: Optional[str] = None
-    attributes: Optional[Dict[str, Any]] = None
-
-
-class InvitationTarget(BaseModel):
-    type: Literal["email", "username", "phoneNumber"]
-    value: str
-
-
-class Invitation(BaseModel):
-    id: str
-    target: InvitationTarget
-    groups: Optional[List[InvitationGroup]] = None  # Full group information
-    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)