shift-chat-server-client 0.2.0__tar.gz

shift_chat_server_client-0.2.0/PKG-INFO

@@ -0,0 +1,12 @@
+Metadata-Version: 2.4
+Name: shift-chat-server-client
+Version: 0.2.0
+Summary: A Python client for the Shift Chat Server
+Author: Lucas
+Author-email: Lucas <lucas@example.com>
+Requires-Python: >=3.7
+Requires-Dist: requests>=2.28.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Dynamic: author
+Dynamic: requires-python

shift_chat_server_client-0.2.0/README.md

@@ -0,0 +1,117 @@
+# Shift Chat Server Client
+
+Python client for interacting with the Shift Chat Server.
+
+## Installation
+
+```bash
+pip install .
+```
+
+## Usage
+
+### Initialization
+
+```python
+from shift_chat.client import ShiftChatClient
+
+# Initialize the client with your credentials
+client = ShiftChatClient(
+    base_url="http://localhost:3000",
+    client_id="your-client-id",
+    client_secret="your-client-secret"
+)
+
+# Authenticate (optional, methods will auto-authenticate if needed)
+client.authenticate()
+```
+
+### Managing Users
+
+You can create or update users using the `set_user` method. You must provide either an email address OR a phone number (or both).
+
+**Create user with Email:**
+
+```python
+user = client.set_user(
+    first_name="John",
+    last_name="Doe",
+    password="securePassword123",
+    email="john.doe@example.com"
+)
+print(f"Created user: {user['id']}")
+```
+
+**Create user with Phone Number:**
+
+```python
+user = client.set_user(
+    first_name="Jane",
+    last_name="Smith",
+    password="securePassword123",
+    phone_number="+15550123456"
+)
+print(f"Created user: {user['id']}")
+```
+
+**Create user with Both:**
+
+```python
+user = client.set_user(
+    first_name="Alice",
+    last_name="Wonder",
+    password="securePassword123",
+    email="alice@example.com",
+    phone_number="+15550198765"
+)
+```
+
+### Managing Workspaces and Channels
+
+You can add users to workspaces and channels using their IDs.
+
+**Add User to Workspace:**
+
+```python
+client.add_user_to_workspace(
+    user_id="user-uuid-123",
+    workspace_id="workspace-uuid-456"
+)
+```
+
+**Add User to Channel:**
+
+```python
+client.add_user_to_channel(
+    user_id="user-uuid-123",
+    channel_id="channel-uuid-789"
+)
+```
+
+**Get Workspaces with Channels (Formatted for Mobile):**
+
+```python
+# Returns workspaces with nested channels and channel members
+data = user_client.get_workspaces_with_channels()
+```
+
+### Acting on Behalf of a User
+
+Once a user exists, you can perform actions on their behalf using `authenticate_user`.
+
+```python
+# Get a user-specific client
+user_client = client.authenticate_user(user_id="user-uuid-123")
+
+# List workspaces the user belongs to
+workspaces = user_client.get_workspaces()
+for ws in workspaces:
+    print(f"Workspace: {ws['name']}")
+
+# Create a channel
+channel = user_client.set_channel(
+    workspace_id="workspace-uuid-123",
+    name="general-discussion",
+    is_public=True
+)
+```

shift_chat_server_client-0.2.0/pyproject.toml

@@ -0,0 +1,20 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "shift-chat-server-client"
+version = "0.2.0"
+description = "A Python client for the Shift Chat Server"
+authors = [
+  { name = "Lucas", email = "lucas@example.com" },
+]
+dependencies = [
+  "requests>=2.28.0",
+]
+requires-python = ">=3.7"
+
+[project.optional-dependencies]
+dev = [
+  "pytest>=7.0.0",
+]

shift_chat_server_client-0.2.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

shift_chat_server_client-0.2.0/setup.py

@@ -0,0 +1,23 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="shift-chat-server-client",
+    version="0.2.0",
+    description="A Python client for the Shift Chat Server",
+    author="Lucas",
+    author_email="lucas@example.com",
+    packages=find_packages(where="src"),
+    package_dir={"": "src"},
+    install_requires=[
+        "requests>=2.28.0",
+        "requests-toolbelt>=0.10.1", # useful for multipart uploads if we add file upload later
+    ],
+    extras_require={
+        "dev": [
+            "pytest>=7.0.0",
+            "flake8>=6.0.0",
+            "black>=23.0.0",
+        ],
+    },
+    python_requires=">=3.7",
+)

shift_chat_server_client-0.2.0/src/shift_chat/__init__.py

@@ -0,0 +1,9 @@
+from .client import ShiftChatClient
+from .exceptions import ShiftChatexception, AuthenticationError, APIError
+
+__all__ = [
+    "ShiftChatClient",
+    "ShiftChatexception",
+    "AuthenticationError",
+    "APIError",
+]

shift_chat_server_client-0.2.0/src/shift_chat/client.py

@@ -0,0 +1,228 @@
+import requests
+from typing import Optional, Dict, List
+from .exceptions import AuthenticationError, APIError
+
+class ShiftChatClient:
+    def __init__(self, base_url: str, client_id: str, client_secret: str):
+        self.base_url = base_url.rstrip('/')
+        self.client_id = client_id
+        self.client_secret = client_secret
+        self._access_token: Optional[str] = None
+        self._session = requests.Session()
+
+    def authenticate(self) -> str:
+        """Authenticate as a client and get an access token."""
+        url = f"{self.base_url}/auth/client/login"
+        payload = {
+            "clientId": self.client_id,
+            "clientSecret": self.client_secret
+        }
+        
+        try:
+            response = self._session.post(url, json=payload)
+            response.raise_for_status()
+            data = response.json()
+            self._access_token = data.get("accessToken")
+            if not self._access_token:
+                raise AuthenticationError("No access token received")
+            return self._access_token
+        except requests.exceptions.HTTPError as e:
+            raise AuthenticationError(f"Authentication failed: {str(e)}") from e
+
+    def _get_headers(self, token: Optional[str] = None, impersonate_token: Optional[str] = None) -> Dict[str, str]:
+        headers = {
+            "Content-Type": "application/json"
+        }
+        
+        auth_token = impersonate_token or token or self._access_token
+        if auth_token:
+            headers["Authorization"] = f"Bearer {auth_token}"
+            
+        return headers
+
+    def authenticate_user(self, user_id: str) -> 'ShiftChatUserClient':
+        """Authenticate a user via client delegation and return a user client."""
+        if not self._access_token:
+            self.authenticate()
+            
+        url = f"{self.base_url}/auth/client/delegate"
+        payload = {"userId": user_id}
+        headers = self._get_headers()
+        
+        try:
+            response = self._session.post(url, json=payload, headers=headers)
+            response.raise_for_status()
+            data = response.json()
+            user_token = data.get("accessToken")
+            if not user_token:
+                raise AuthenticationError("No user token received")
+            
+            return ShiftChatUserClient(self.base_url, user_token)
+            
+        except requests.exceptions.HTTPError as e:
+            raise APIError(f"Failed to authenticate user: {str(e)}") from e
+
+    def set_user(self, 
+                 first_name: str, 
+                 last_name: str, 
+                 password: str,
+                 email: Optional[str] = None, 
+                 phone_number: Optional[str] = None) -> Dict:
+        """Create or update a user.
+        
+        Args:
+            first_name: User's first name
+            last_name: User's last name
+            password: User's password
+            email: User's email (optional if phone_number is provided)
+            phone_number: User's phone number (optional if email is provided)
+            
+        Returns:
+            Dict: The created or updated user data
+            
+        Raises:
+            ValueError: If neither email nor phone_number is provided
+            APIError: If the API request fails
+        """
+        if not email and not phone_number:
+            raise ValueError("At least one of email or phone_number must be provided")
+            
+        url = f"{self.base_url}/users"
+        payload = {
+            "firstName": first_name,
+            "lastName": last_name,
+            "password": password
+        }
+        
+        if email:
+            payload["email"] = email
+        if phone_number:
+            payload["phoneNumber"] = phone_number
+        
+        try:
+            response = self._session.post(url, json=payload)
+            if response.status_code == 201:
+                return response.json()
+            
+            # If 409 (Conflict) or similar, we might want to update? 
+            # But standard public register might not support update.
+            # Ideally we'd have a server-to-server endpoint for upserting users.
+            
+            response.raise_for_status()
+            return response.json()
+        except requests.exceptions.HTTPError as e:
+             raise APIError(f"Failed to create user: {str(e)}") from e
+
+class ShiftChatUserClient:
+    """Client for performing actions on behalf of a user."""
+    def __init__(self, base_url: str, access_token: str):
+        self.base_url = base_url
+        self._access_token = access_token
+        self._session = requests.Session()
+
+    def _get_headers(self) -> Dict[str, str]:
+        return {
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {self._access_token}"
+        }
+
+    def add_user_to_workspace(self, user_id: str, workspace_id: str) -> None:
+        """Add a user to a workspace."""
+        url = f"{self.base_url}/workspaces/invite"
+        payload = {
+            "userId": user_id,
+            "workspaceId": workspace_id
+        }
+        
+        try:
+            response = self._session.post(url, json=payload, headers=self._get_headers())
+            response.raise_for_status()
+        except requests.exceptions.HTTPError as e:
+            raise APIError(f"Failed to add user {user_id} to workspace {workspace_id}: {str(e)}") from e
+
+    def add_user_to_channel(self, user_id: str, channel_id: str) -> None:
+        """Add a user to a channel."""
+        url = f"{self.base_url}/channels/invite"
+        payload = {
+            "userId": user_id,
+            "channelId": channel_id
+        }
+        
+        try:
+            response = self._session.post(url, json=payload, headers=self._get_headers())
+            response.raise_for_status()
+        except requests.exceptions.HTTPError as e:
+             raise APIError(f"Failed to add user {user_id} to channel {channel_id}: {str(e)}") from e
+
+    def set_channel(self, workspace_id: str, name: str, is_public: bool = False, type: str = "GROUP") -> Dict:
+        """Create a channel."""
+        url = f"{self.base_url}/channels/group"
+        payload = {
+            "workspaceId": workspace_id,
+            "name": name,
+            "isPublic": is_public
+        }
+        
+        try:
+            response = self._session.post(url, json=payload, headers=self._get_headers())
+            response.raise_for_status()
+            return response.json()
+        except requests.exceptions.HTTPError as e:
+            raise APIError(f"Failed to create channel: {str(e)}") from e
+
+    def get_workspaces(self) -> List[Dict]:
+        """Get all workspaces the user is a member of."""
+        url = f"{self.base_url}/workspaces"
+        try:
+            response = self._session.get(url, headers=self._get_headers())
+            response.raise_for_status()
+            return response.json()
+        except requests.exceptions.HTTPError as e:
+            raise APIError(f"Failed to get workspaces: {str(e)}") from e
+
+    def get_workspace_channels(self, workspace_id: str) -> List[Dict]:
+        """Get all channels for a user in a specific workspace."""
+        url = f"{self.base_url}/channels/user"
+        params = {"workspaceId": workspace_id}
+        try:
+            response = self._session.get(url, headers=self._get_headers(), params=params)
+            response.raise_for_status()
+            return response.json()
+        except requests.exceptions.HTTPError as e:
+            raise APIError(f"Failed to get channels for workspace {workspace_id}: {str(e)}") from e
+
+    def get_workspaces_with_channels(self) -> List[Dict]:
+        """Get all workspaces with their channels and members, formatted for mobile app."""
+        workspaces = self.get_workspaces()
+        for workspace in workspaces:
+            workspace_id = workspace.get("id")
+            if workspace_id:
+                try:
+                    # fetch channels for the user in this workspace
+                    channels = self.get_workspace_channels(workspace_id)
+                    
+                    formatted_channels = []
+                    for channel in channels:
+                        # Extract basic info
+                        channel_data = {
+                            "channel": channel.get("name"),
+                            "id": channel.get("id"),
+                            "users": []
+                        }
+                        
+                        # Extract members if available (server should return them in members field)
+                        members = channel.get("members", [])
+                        users_list = []
+                        for member in members:
+                            # member structure from Prisma include usually has 'user' object inside
+                            user_obj = member.get("user")
+                            if user_obj:
+                                users_list.append(user_obj)
+                        
+                        channel_data["users"] = users_list
+                        formatted_channels.append(channel_data)
+
+                    workspace["channels"] = formatted_channels
+                except APIError:
+                    workspace["channels"] = []
+        return workspaces

shift_chat_server_client-0.2.0/src/shift_chat/exceptions.py

@@ -0,0 +1,11 @@
+class ShiftChatexception(Exception):
+    """Base exception for Shift Chat Client"""
+    pass
+
+class AuthenticationError(ShiftChatexception):
+    """Raised when authentication fails"""
+    pass
+
+class APIError(ShiftChatexception):
+    """Raised when API request fails"""
+    pass

shift_chat_server_client-0.2.0/src/shift_chat_server_client.egg-info/PKG-INFO

@@ -0,0 +1,12 @@
+Metadata-Version: 2.4
+Name: shift-chat-server-client
+Version: 0.2.0
+Summary: A Python client for the Shift Chat Server
+Author: Lucas
+Author-email: Lucas <lucas@example.com>
+Requires-Python: >=3.7
+Requires-Dist: requests>=2.28.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Dynamic: author
+Dynamic: requires-python

shift_chat_server_client-0.2.0/src/shift_chat_server_client.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+README.md
+pyproject.toml
+setup.py
+src/shift_chat/__init__.py
+src/shift_chat/client.py
+src/shift_chat/exceptions.py
+src/shift_chat_server_client.egg-info/PKG-INFO
+src/shift_chat_server_client.egg-info/SOURCES.txt
+src/shift_chat_server_client.egg-info/dependency_links.txt
+src/shift_chat_server_client.egg-info/requires.txt
+src/shift_chat_server_client.egg-info/top_level.txt

shift_chat_server_client-0.2.0/src/shift_chat_server_client.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

shift_chat_server_client-0.2.0/src/shift_chat_server_client.egg-info/requires.txt

@@ -0,0 +1,4 @@
+requests>=2.28.0
+
+[dev]
+pytest>=7.0.0

shift_chat_server_client-0.2.0/src/shift_chat_server_client.egg-info/top_level.txt

@@ -0,0 +1 @@
+shift_chat