vortex-python-sdk 0.0.5__tar.gz → 0.1.0__tar.gz

{vortex_python_sdk-0.0.5 → vortex_python_sdk-0.1.0}/CHANGELOG.md

@@ -7,6 +7,43 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Changed
+
+- **JWT Payload Simplification**: Updated JWT structure to use simplified fields (backward compatible)
+  - **NEW (Preferred)**: Use `User` object with `id`, `email`, and `admin_scopes` for cleaner, more maintainable code
+  - `id` (string): User's ID in your system
+  - `email` (string): User's email address - replaces the `identifiers` array
+  - `admin_scopes` (list): List of admin scopes (e.g., `['autojoin']` for autojoin admin privileges)
+  - **DEPRECATED (Still Supported)**: `identifiers`, `groups`, and `role` fields maintained for backward compatibility
+  - Supports additional properties via Pydantic's `extra="allow"` configuration
+  - All existing integrations will continue to work without changes
+
+### Migration Guide (Optional - Backward Compatible)
+
+The old format still works, but we recommend migrating to the simpler structure:
+
+**New simplified format (recommended):**
+
+```python
+user = {
+    "id": "user-123",
+    "email": "user@example.com",
+    "admin_scopes": ["autojoin"]  # optional: grants autojoin admin privileges
+}
+jwt = vortex.generate_jwt(user=user)
+```
+
+**Old format (still supported):**
+
+```python
+jwt = vortex.generate_jwt({
+    "user_id": "user-123",
+    "identifiers": [{"type": "email", "value": "user@example.com"}],
+    "groups": [{"type": "team", "id": "team-1", "name": "Engineering"}],
+    "role": "admin"
+})
+```
+
 ## [0.0.5] - 2025-11-06
 
 ### Fixed

{vortex_python_sdk-0.0.5/src/vortex_python_sdk.egg-info → vortex_python_sdk-0.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vortex-python-sdk
-Version: 0.0.5
+Version: 0.1.0
 Summary: Vortex Python SDK for invitation management and JWT generation
 Author-email: TeamVortexSoftware <support@vortexsoftware.com>
 License-Expression: MIT
@@ -66,34 +66,32 @@ vortex = Vortex(api_key="your-vortex-api-key", base_url="https://custom-api.exam
 
 ```python
 # Generate JWT for a user
-jwt = vortex.generate_jwt({
-    "user_id": "user-123",
-    "identifiers": [
-        {"type": "email", "value": "user@example.com"}
-    ],
-    "groups": [
-        {"type": "team", "id": "team-1", "name": "Engineering"}
-    ],
-    "role": "admin"
-})
+user = {
+    "id": "user-123",
+    "email": "user@example.com",
+    "admin_scopes": ["autojoin"]  # Optional - included as adminScopes array in JWT
+}
 
+jwt = vortex.generate_jwt(user=user)
 print(f"JWT: {jwt}")
 
+# With additional properties
+jwt = vortex.generate_jwt(
+    user=user,
+    role="admin",
+    department="Engineering"
+)
+
 # Or using type-safe models
-from vortex_sdk import JwtPayload, IdentifierInput, GroupInput
+from vortex_sdk import User
 
-jwt = vortex.generate_jwt(
-    JwtPayload(
-        user_id="user-123",
-        identifiers=[
-            IdentifierInput(type="email", value="user@example.com")
-        ],
-        groups=[
-            GroupInput(type="team", id="team-1", name="Engineering")
-        ],
-        role="admin"
-    )
+user = User(
+    id="user-123",
+    email="user@example.com",
+    admin_scopes=["autojoin"]
 )
+
+jwt = vortex.generate_jwt(user=user)
 ```
 
 ### Invitation Management

{vortex_python_sdk-0.0.5 → vortex_python_sdk-0.1.0}/README.md

@@ -28,34 +28,32 @@ vortex = Vortex(api_key="your-vortex-api-key", base_url="https://custom-api.exam
 
 ```python
 # Generate JWT for a user
-jwt = vortex.generate_jwt({
-    "user_id": "user-123",
-    "identifiers": [
-        {"type": "email", "value": "user@example.com"}
-    ],
-    "groups": [
-        {"type": "team", "id": "team-1", "name": "Engineering"}
-    ],
-    "role": "admin"
-})
+user = {
+    "id": "user-123",
+    "email": "user@example.com",
+    "admin_scopes": ["autojoin"]  # Optional - included as adminScopes array in JWT
+}
 
+jwt = vortex.generate_jwt(user=user)
 print(f"JWT: {jwt}")
 
+# With additional properties
+jwt = vortex.generate_jwt(
+    user=user,
+    role="admin",
+    department="Engineering"
+)
+
 # Or using type-safe models
-from vortex_sdk import JwtPayload, IdentifierInput, GroupInput
+from vortex_sdk import User
 
-jwt = vortex.generate_jwt(
-    JwtPayload(
-        user_id="user-123",
-        identifiers=[
-            IdentifierInput(type="email", value="user@example.com")
-        ],
-        groups=[
-            GroupInput(type="team", id="team-1", name="Engineering")
-        ],
-        role="admin"
-    )
+user = User(
+    id="user-123",
+    email="user@example.com",
+    admin_scopes=["autojoin"]
 )
+
+jwt = vortex.generate_jwt(user=user)
 ```
 
 ### Invitation Management
@@ -209,4 +207,4 @@ mypy src/
 
 ## License
 
-MIT
+MIT

{vortex_python_sdk-0.0.5 → vortex_python_sdk-0.1.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "vortex-python-sdk"
-version = "0.0.5"
+version = "0.1.0"
 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
@@ -81,8 +81,10 @@ warn_no_return = true
 warn_unreachable = true
 
 [tool.ruff]
-target-version = "py38"
+target-version = "py39"
 line-length = 88
+
+[tool.ruff.lint]
 select = [
     "E",  # pycodestyle errors
     "W",  # pycodestyle warnings

{vortex_python_sdk-0.0.5 → vortex_python_sdk-0.1.0/src/vortex_python_sdk.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vortex-python-sdk
-Version: 0.0.5
+Version: 0.1.0
 Summary: Vortex Python SDK for invitation management and JWT generation
 Author-email: TeamVortexSoftware <support@vortexsoftware.com>
 License-Expression: MIT
@@ -66,34 +66,32 @@ vortex = Vortex(api_key="your-vortex-api-key", base_url="https://custom-api.exam
 
 ```python
 # Generate JWT for a user
-jwt = vortex.generate_jwt({
-    "user_id": "user-123",
-    "identifiers": [
-        {"type": "email", "value": "user@example.com"}
-    ],
-    "groups": [
-        {"type": "team", "id": "team-1", "name": "Engineering"}
-    ],
-    "role": "admin"
-})
+user = {
+    "id": "user-123",
+    "email": "user@example.com",
+    "admin_scopes": ["autojoin"]  # Optional - included as adminScopes array in JWT
+}
 
+jwt = vortex.generate_jwt(user=user)
 print(f"JWT: {jwt}")
 
+# With additional properties
+jwt = vortex.generate_jwt(
+    user=user,
+    role="admin",
+    department="Engineering"
+)
+
 # Or using type-safe models
-from vortex_sdk import JwtPayload, IdentifierInput, GroupInput
+from vortex_sdk import User
 
-jwt = vortex.generate_jwt(
-    JwtPayload(
-        user_id="user-123",
-        identifiers=[
-            IdentifierInput(type="email", value="user@example.com")
-        ],
-        groups=[
-            GroupInput(type="team", id="team-1", name="Engineering")
-        ],
-        role="admin"
-    )
+user = User(
+    id="user-123",
+    email="user@example.com",
+    admin_scopes=["autojoin"]
 )
+
+jwt = vortex.generate_jwt(user=user)
 ```
 
 ### Invitation Management

{vortex_python_sdk-0.0.5 → vortex_python_sdk-0.1.0}/src/vortex_sdk/__init__.py

@@ -5,20 +5,26 @@ A Python SDK for Vortex invitation management and JWT generation.
 """
 
 from .types import (
+    AcceptInvitationRequest,
     AcceptInvitationsRequest,
+    ApiRequestBody,
     ApiResponse,
+    ApiResponseJson,
     AuthenticatedUser,
     CreateInvitationRequest,
     GroupInput,
     IdentifierInput,
     Invitation,
+    InvitationAcceptance,
+    InvitationGroup,
+    InvitationResult,
     InvitationTarget,
     JwtPayload,
     VortexApiError,
 )
 from .vortex import Vortex
 
-__version__ = "0.0.5"
+__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.1.0/src/vortex_sdk/types.py

@@ -0,0 +1,232 @@
+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 User(BaseModel):
+    """
+    User data for JWT generation
+
+    Required fields:
+    - id: User's ID in their system
+    - email: User's email address
+
+    Optional fields:
+    - admin_scopes: List of admin scopes (e.g., ['autojoin'])
+
+    Additional fields are allowed via extra parameter
+    """
+    id: str
+    email: str
+    admin_scopes: Optional[List[str]] = None
+
+    class Config:
+        extra = "allow"  # Allow additional fields
+
+
+class AuthenticatedUser(BaseModel):
+    """
+    User data for JWT generation (simplified structure)
+
+    Note: identifiers, groups, and role are maintained for backward compatibility
+    but are deprecated in favor of the User object with admin_scopes.
+    """
+    user_id: str
+    user_email: Optional[str] = None
+    admin_scopes: Optional[List[str]] = None
+
+    # Deprecated fields (maintained for backward compatibility)
+    identifiers: Optional[List[IdentifierInput]] = None
+    groups: Optional[List[GroupInput]] = None
+    role: Optional[str] = None
+
+
+class JwtPayload(BaseModel):
+    """
+    JWT payload structure (simplified)
+
+    Required fields:
+    - user_id: User's ID in their system
+    - user_email: User's email address (preferred)
+
+    Optional fields:
+    - admin_scopes: List of admin scopes (e.g., ['autojoin'] for autojoin admin privileges)
+    - attributes: Additional custom attributes
+
+    Deprecated fields (maintained for backward compatibility):
+    - identifiers: Use user_email instead
+    - groups: No longer required
+    - role: No longer required
+
+    Additional fields are allowed via [key: string]: any pattern
+    """
+    user_id: str
+    user_email: Optional[str] = None
+    admin_scopes: Optional[List[str]] = None
+
+    # Deprecated fields (maintained for backward compatibility)
+    identifiers: Optional[List[IdentifierInput]] = None
+    groups: Optional[List[GroupInput]] = None
+    role: Optional[str] = None
+
+    attributes: Optional[Dict[str, Any]] = None
+
+    class Config:
+        extra = "allow"  # Allow additional fields [key: string]: any
+
+
+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] = Field(default_factory=list)
+    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)
+    expired: bool
+    expires: Optional[str] = None
+
+    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.5 → vortex_python_sdk-0.1.0}/src/vortex_sdk/vortex.py

@@ -4,25 +4,22 @@ import hmac
 import json
 import time
 import uuid
-from typing import Dict, List, Literal, Optional, Union
-from urllib.parse import urlencode
+from typing import Any, Dict, List, Literal, Optional, Union
 
 import httpx
 
 from .types import (
-    AcceptInvitationsRequest,
-    ApiResponse,
-    CreateInvitationRequest,
     Invitation,
     InvitationTarget,
-    JwtPayload,
+    User,
     VortexApiError,
 )
 
 
-def _get_version():
+def _get_version() -> str:
     """Lazy import of version to avoid circular import"""
     from . import __version__
+
     return __version__
 
 
@@ -42,21 +39,30 @@ class Vortex:
         self._client = httpx.AsyncClient()
         self._sync_client = httpx.Client()
 
-    def generate_jwt(self, payload: Union[JwtPayload, Dict]) -> str:
+    def generate_jwt(self, user: Union[User, Dict], **extra: Any) -> str:
         """
-        Generate a JWT token for the given payload matching Node.js SDK implementation
+        Generate a JWT token for a user
 
         Args:
-            payload: JWT payload containing user_id, identifiers, groups, and role
+            user: User object or dict with 'id', 'email', and optional 'admin_scopes'
+            **extra: Additional properties to include in JWT payload
 
         Returns:
             JWT token string
 
         Raises:
-            ValueError: If API key format is invalid
+            ValueError: If API key format is invalid or required fields are missing
+
+        Example:
+            user = {'id': 'user-123', 'email': 'user@example.com', 'admin_scopes': ['autojoin']}
+            jwt = vortex.generate_jwt(user=user)
+
+            # With additional properties
+            jwt = vortex.generate_jwt(user=user, role='admin', department='Engineering')
         """
-        if isinstance(payload, dict):
-            payload = JwtPayload(**payload)
+        # Convert dict to User if needed
+        if isinstance(user, dict):
+            user = User(**user)
 
         # Parse API key (format: VRTX.base64url(uuid).key)
         parts = self.api_key.split(".")
@@ -80,7 +86,7 @@ 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())
@@ -97,35 +103,24 @@ class Vortex:
             "kid": kid,
         }
 
-        # Serialize 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()
-                }
-                for group in payload.groups
-            ]
-
-        jwt_payload = {
-            "userId": payload.user_id,
-            "groups": groups_list,
-            "role": payload.role,
+        # Build JWT payload
+        jwt_payload: Dict[str, Any] = {
+            "userId": user.id,
+            "userEmail": user.email,
             "expires": expires,
-            "identifiers": identifiers_list,
         }
 
-        # Add attributes if provided
-        if hasattr(payload, "attributes") and payload.attributes:
-            jwt_payload["attributes"] = payload.attributes
+        # Add adminScopes if present
+        if user.admin_scopes:
+            jwt_payload["adminScopes"] = user.admin_scopes
+
+        # Add any additional properties from user.model_extra
+        if hasattr(user, "model_extra") and user.model_extra:
+            jwt_payload.update(user.model_extra)
+
+        # Add any additional properties from **extra
+        if extra:
+            jwt_payload.update(extra)
 
         # Step 3: Base64URL encode (without padding)
         header_json = json.dumps(header, separators=(",", ":"))
@@ -185,17 +180,21 @@ class Vortex:
                         "error",
                         f"API request failed with status {response.status_code}",
                     )
-                except:
+                except Exception:
                     error_message = (
                         f"API request failed with status {response.status_code}"
                     )
 
                 raise VortexApiError(error_message, response.status_code)
 
-            return response.json()
+            # Handle empty responses (e.g., DELETE requests may return 204 or empty 200)
+            if response.status_code == 204 or not response.content:
+                return {}  # type: ignore[return-value]
+
+            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,
@@ -238,17 +237,21 @@ class Vortex:
                         "error",
                         f"API request failed with status {response.status_code}",
                     )
-                except:
+                except Exception:
                     error_message = (
                         f"API request failed with status {response.status_code}"
                     )
 
                 raise VortexApiError(error_message, response.status_code)
 
-            return response.json()
+            # Handle empty responses (e.g., DELETE requests may return 204 or empty 200)
+            if response.status_code == 204 or not response.content:
+                return {}  # type: ignore[return-value]
+
+            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,
@@ -268,7 +271,7 @@ class Vortex:
         params = {"targetType": target_type, "targetValue": target_value}
 
         response = await self._vortex_api_request(
-            "GET", "/invitations/by-target", params=params
+            "GET", "/invitations", params=params
         )
         return [Invitation(**inv) for inv in response.get("invitations", [])]
 
@@ -290,7 +293,7 @@ class Vortex:
         params = {"targetType": target_type, "targetValue": target_value}
 
         response = self._vortex_api_request_sync(
-            "GET", "/invitations/by-target", params=params
+            "GET", "/invitations", params=params
         )
         return [Invitation(**inv) for inv in response.get("invitations", [])]
 
@@ -335,10 +338,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 await self._vortex_api_request("POST", "/invitations/accept", data=data)
 
@@ -355,10 +361,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)
 
@@ -482,26 +491,26 @@ class Vortex:
         )
         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()

vortex_python_sdk-0.0.5/src/vortex_sdk/types.py

@@ -1,112 +0,0 @@
-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", "username", "phoneNumber"]
-    value: str
-
-
-class Invitation(BaseModel):
-    id: str
-    target: Union[InvitationTarget, List[InvitationTarget]]  # API returns list or single
-    groups: Optional[List[Optional[InvitationGroup]]] = None  # Full group information, can contain None
-    status: str
-    created_at: Optional[str] = Field(None, alias="createdAt")  # API uses camelCase
-    updated_at: Optional[str] = Field(None, alias="updatedAt")
-    expires_at: Optional[str] = Field(None, alias="expiresAt")
-    metadata: Optional[Dict[str, Union[str, int, bool]]] = None
-
-    class Config:
-        populate_by_name = True
-
-
-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)