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

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

@@ -7,9 +7,32 @@ 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
+  - Added `attributes` field support in JwtPayload for custom user attributes
+  - Fixed base64url encoding
+- 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
@@ -18,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",
@@ -30,6 +55,7 @@ jwt = vortex.generate_jwt({
 ```
 
 **After (0.0.2):**
+
 ```python
 jwt = vortex.generate_jwt({
     "user_id": "user-123",
@@ -41,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
@@ -51,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
@@ -60,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.2/src/vortex_python_sdk.egg-info → vortex_python_sdk-0.0.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vortex-python-sdk
-Version: 0.0.2
+Version: 0.0.5
 Summary: Vortex Python SDK for invitation management and JWT generation
 Author-email: TeamVortexSoftware <support@vortexsoftware.com>
 License-Expression: MIT
@@ -55,11 +55,11 @@ pip install vortex-python-sdk
 ```python
 from vortex_sdk import Vortex
 
-# Initialize the client
-vortex = Vortex(api_key="your-api-key")
+# Initialize the client with your Vortex API key
+vortex = Vortex(api_key="your-vortex-api-key")
 
 # Or with custom base URL
-vortex = Vortex(api_key="your-api-key", base_url="https://custom-api.example.com")
+vortex = Vortex(api_key="your-vortex-api-key", base_url="https://custom-api.example.com")
 ```
 
 ### JWT Generation

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

@@ -17,11 +17,11 @@ pip install vortex-python-sdk
 ```python
 from vortex_sdk import Vortex
 
-# Initialize the client
-vortex = Vortex(api_key="your-api-key")
+# Initialize the client with your Vortex API key
+vortex = Vortex(api_key="your-vortex-api-key")
 
 # Or with custom base URL
-vortex = Vortex(api_key="your-api-key", base_url="https://custom-api.example.com")
+vortex = Vortex(api_key="your-vortex-api-key", base_url="https://custom-api.example.com")
 ```
 
 ### JWT Generation

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "vortex-python-sdk"
-version = "0.0.2"
+version = "0.0.5"
 description = "Vortex Python SDK for invitation management and JWT generation"
 authors = [{name = "TeamVortexSoftware", email = "support@vortexsoftware.com"}]
 readme = "README.md"

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vortex-python-sdk
-Version: 0.0.2
+Version: 0.0.5
 Summary: Vortex Python SDK for invitation management and JWT generation
 Author-email: TeamVortexSoftware <support@vortexsoftware.com>
 License-Expression: MIT
@@ -55,11 +55,11 @@ pip install vortex-python-sdk
 ```python
 from vortex_sdk import Vortex
 
-# Initialize the client
-vortex = Vortex(api_key="your-api-key")
+# Initialize the client with your Vortex API key
+vortex = Vortex(api_key="your-vortex-api-key")
 
 # Or with custom base URL
-vortex = Vortex(api_key="your-api-key", base_url="https://custom-api.example.com")
+vortex = Vortex(api_key="your-vortex-api-key", base_url="https://custom-api.example.com")
 ```
 
 ### JWT Generation

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

@@ -4,21 +4,21 @@ Vortex Python SDK
 A Python SDK for Vortex invitation management and JWT generation.
 """
 
-from .vortex import Vortex
 from .types import (
+    AcceptInvitationsRequest,
+    ApiResponse,
     AuthenticatedUser,
-    JwtPayload,
-    IdentifierInput,
+    CreateInvitationRequest,
     GroupInput,
-    InvitationTarget,
+    IdentifierInput,
     Invitation,
-    CreateInvitationRequest,
-    AcceptInvitationsRequest,
-    ApiResponse,
-    VortexApiError
+    InvitationTarget,
+    JwtPayload,
+    VortexApiError,
 )
+from .vortex import Vortex
 
-__version__ = "0.0.2"
+__version__ = "0.0.5"
 __author__ = "TeamVortexSoftware"
 __email__ = "support@vortexsoftware.com"
 
@@ -34,4 +34,4 @@ __all__ = [
     "AcceptInvitationsRequest",
     "ApiResponse",
     "VortexApiError",
-]
+]

{vortex_python_sdk-0.0.2 → vortex_python_sdk-0.0.5}/src/vortex_sdk/types.py

@@ -1,18 +1,23 @@
-from typing import Dict, List, Optional, Union, Literal
+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
+    groupId: Optional[str] = Field(
+        None, alias="group_id", serialization_alias="groupId"
+    )  # Preferred: Customer's group ID
     name: str
 
     class Config:
@@ -24,12 +29,13 @@ 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)
+    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  # ISO 8601 timestamp (camelCase in JSON: createdAt)
+    created_at: str = Field(alias="createdAt")  # ISO 8601 timestamp
 
     class Config:
         # Allow both snake_case (Python) and camelCase (JSON) field names
@@ -41,7 +47,7 @@ class InvitationGroup(BaseModel):
                 "groupId": "workspace-123",
                 "type": "workspace",
                 "name": "My Workspace",
-                "createdAt": "2025-01-27T12:00:00.000Z"
+                "createdAt": "2025-01-27T12:00:00.000Z",
             }
         }
 
@@ -58,6 +64,7 @@ class JwtPayload(BaseModel):
     identifiers: List[IdentifierInput]
     groups: Optional[List[GroupInput]] = None
     role: Optional[str] = None
+    attributes: Optional[Dict[str, Any]] = None
 
 
 class InvitationTarget(BaseModel):
@@ -67,14 +74,17 @@ class InvitationTarget(BaseModel):
 
 class Invitation(BaseModel):
     id: str
-    target: InvitationTarget
-    groups: Optional[List[InvitationGroup]] = None  # Full group information
+    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: str
-    updated_at: Optional[str] = None
-    expires_at: Optional[str] = None
+    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
@@ -99,4 +109,4 @@ class VortexApiError(Exception):
     def __init__(self, message: str, status_code: int = 500):
         self.message = message
         self.status_code = status_code
-        super().__init__(message)
+        super().__init__(message)

{vortex_python_sdk-0.0.2 → vortex_python_sdk-0.0.5}/src/vortex_sdk/vortex.py

@@ -1,96 +1,155 @@
-import json
-import hmac
-import hashlib
 import base64
-from typing import Dict, List, Optional, Union, Literal
+import hashlib
+import hmac
+import json
+import time
+import uuid
+from typing import Dict, List, Literal, Optional, Union
 from urllib.parse import urlencode
+
 import httpx
+
 from .types import (
-    JwtPayload,
-    InvitationTarget,
-    Invitation,
-    CreateInvitationRequest,
     AcceptInvitationsRequest,
     ApiResponse,
-    VortexApiError
+    CreateInvitationRequest,
+    Invitation,
+    InvitationTarget,
+    JwtPayload,
+    VortexApiError,
 )
 
 
+def _get_version():
+    """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()
 
     def generate_jwt(self, payload: Union[JwtPayload, Dict]) -> str:
         """
-        Generate a JWT token for the given payload
+        Generate a JWT token for the given payload matching Node.js SDK implementation
 
         Args:
             payload: JWT payload containing user_id, identifiers, groups, and role
 
         Returns:
             JWT token string
+
+        Raises:
+            ValueError: If API key format is invalid
         """
         if isinstance(payload, dict):
             payload = JwtPayload(**payload)
 
-        # JWT Header
+        # Parse API key (format: VRTX.base64url(uuid).key)
+        parts = self.api_key.split(".")
+        if len(parts) != 3:
+            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")
+
+        # Decode UUID from base64url
+        # Add padding if needed
+        padding = 4 - len(encoded_id) % 4
+        if padding != 4:
+            encoded_id_padded = encoded_id + ("=" * padding)
+        else:
+            encoded_id_padded = encoded_id
+
+        try:
+            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}")
+
+        # 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()
+
+        # Step 2: Build header + payload
         header = {
+            "iat": iat,
             "alg": "HS256",
-            "typ": "JWT"
+            "typ": "JWT",
+            "kid": kid,
         }
 
-        # JWT Payload - serialize identifiers and groups to dicts
-        jwt_payload = {
-            "userId": payload.user_id,
-            "identifiers": [{"type": id.type, "value": id.value} for id in payload.identifiers],
-        }
+        # 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:
-            # Serialize groups, using model_dump to handle camelCase conversion
-            jwt_payload["groups"] = [
-                {k: v for k, v in group.model_dump(by_alias=True, exclude_none=True).items()}
+            groups_list = [
+                {
+                    k: v
+                    for k, v in group.model_dump(
+                        by_alias=True, exclude_none=True
+                    ).items()
+                }
                 for group in 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('=')
+        jwt_payload = {
+            "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
+
+        # Step 3: Base64URL encode (without padding)
+        header_json = json.dumps(header, separators=(",", ":"))
+        payload_json = json.dumps(jwt_payload, separators=(",", ":"))
 
-        payload_encoded = base64.urlsafe_b64encode(
-            json.dumps(jwt_payload, separators=(',', ':')).encode()
-        ).decode().rstrip('=')
+        header_b64 = base64.urlsafe_b64encode(header_json.encode()).decode().rstrip("=")
+        payload_b64 = (
+            base64.urlsafe_b64encode(payload_json.encode()).decode().rstrip("=")
+        )
 
-        # Create signature
-        message = f"{header_encoded}.{payload_encoded}"
-        signature = hmac.new(
-            self.api_key.encode(),
-            message.encode(),
-            hashlib.sha256
-        ).digest()
+        # Step 4: Sign
+        to_sign = f"{header_b64}.{payload_b64}"
+        signature = hmac.new(signing_key, to_sign.encode(), hashlib.sha256).digest()
 
-        signature_encoded = base64.urlsafe_b64encode(signature).decode().rstrip('=')
+        signature_b64 = base64.urlsafe_b64encode(signature).decode().rstrip("=")
 
-        return f"{message}.{signature_encoded}"
+        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
@@ -109,26 +168,27 @@ 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}')
+                    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 = (
+                        f"API request failed with status {response.status_code}"
+                    )
 
                 raise VortexApiError(error_message, response.status_code)
 
@@ -142,7 +202,7 @@ class Vortex:
         method: str,
         endpoint: str,
         data: Optional[Dict] = None,
-        params: Optional[Dict] = None
+        params: Optional[Dict] = None,
     ) -> Dict:
         """
         Make a synchronous API request to Vortex
@@ -161,26 +221,27 @@ 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}')
+                    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 = (
+                        f"API request failed with status {response.status_code}"
+                    )
 
                 raise VortexApiError(error_message, response.status_code)
 
@@ -192,7 +253,7 @@ class Vortex:
     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
@@ -204,18 +265,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)
@@ -227,12 +287,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:
@@ -245,7 +304,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:
@@ -262,9 +323,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
@@ -279,17 +338,12 @@ class Vortex:
         if isinstance(target, dict):
             target = InvitationTarget(**target)
 
-        data = {
-            "invitationIds": invitation_ids,
-            "target": target.model_dump()
-        }
+        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]]
+        self, invitation_ids: List[str], target: Union[InvitationTarget, Dict[str, str]]
     ) -> Dict:
         """
         Accept multiple invitations (synchronous)
@@ -304,10 +358,7 @@ class Vortex:
         if isinstance(target, dict):
             target = InvitationTarget(**target)
 
-        data = {
-            "invitationIds": invitation_ids,
-            "target": target.model_dump()
-        }
+        data = {"invitationIds": invitation_ids, "target": target.model_dump()}
 
         return self._vortex_api_request_sync("POST", "/invitations/accept", data=data)
 
@@ -336,9 +387,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
@@ -350,13 +399,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)
@@ -368,14 +417,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
 
@@ -386,13 +433,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)
 
@@ -403,7 +448,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:
         """
@@ -415,7 +462,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:
@@ -428,7 +477,9 @@ 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):
@@ -453,4 +504,4 @@ class Vortex:
 
     def __exit__(self, exc_type, exc_val, exc_tb):
         """Context manager exit"""
-        self.close_sync()
+        self.close_sync()