briq 0.1.0__tar.gz

briq-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Briq Team
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

briq-0.1.0/PKG-INFO

@@ -0,0 +1,97 @@
+Metadata-Version: 2.4
+Name: briq
+Version: 0.1.0
+Summary: Python client for the Briq messaging platform API
+Home-page: https://github.com/BRIQ-BLOCK/BriqPythonSdk
+Author: Briq Team
+Author-email: Briq Team <info@briq.tz>
+License: MIT
+Project-URL: Homepage, https://github.com/briq/briq-python
+Project-URL: Bug Tracker, https://github.com/briq/briq-python/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.25.0
+Requires-Dist: python-dotenv>=0.15.0
+Dynamic: author
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
+
+# Briq Python Client
+
+A Python client library for the Briq messaging platform API.
+
+## Overview
+
+The Briq Python client provides a simple and intuitive interface to interact with the Briq messaging platform API. It allows you to manage workspaces, campaigns, and send messages programmatically from your Python applications.
+
+## Installation
+
+You can install the Briq client library using pip:
+
+```bash
+pip install briq
+```
+
+## Requirements
+
+- Python 3.7 or higher
+- requests
+- python-dotenv
+
+## Authentication
+
+The Briq client requires an API key for authentication. You can provide your API key in several ways:
+
+1. Set it in your environment as `BRIQ_API_KEY`
+2. Store it in a `.env` file in your project directory
+3. Pass it directly when initializing the client
+
+Example `.env` file:
+```
+BRIQ_API_KEY=your_api_key_here
+```
+
+## Quick Start
+
+```python
+import briq
+
+# Initialize the client (will load API key from environment or .env file)
+client = briq.Client()
+
+# Or set the API key manually
+client.set_api_key("your_api_key_here")
+
+# Create a workspace
+workspace = client.workspace.create(
+    name="My Workspace",
+    description="A workspace for my messaging campaigns"
+)
+
+# List all workspaces
+workspaces = client.workspace.list()
+
+# Send an instant message
+result = client.message.send_instant(
+    content="Hello from the Briq Python client!",
+    recipients=["255788344348"],
+    sender_id="my-sender-id"
+)
+```
+
+## Documentation
+
+For detailed documentation and examples, please refer to the [Usage Guide](docs/usage.md) and [API Reference](docs/api_reference.md).
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

briq-0.1.0/README.md

@@ -0,0 +1,70 @@
+# Briq Python Client
+
+A Python client library for the Briq messaging platform API.
+
+## Overview
+
+The Briq Python client provides a simple and intuitive interface to interact with the Briq messaging platform API. It allows you to manage workspaces, campaigns, and send messages programmatically from your Python applications.
+
+## Installation
+
+You can install the Briq client library using pip:
+
+```bash
+pip install briq
+```
+
+## Requirements
+
+- Python 3.7 or higher
+- requests
+- python-dotenv
+
+## Authentication
+
+The Briq client requires an API key for authentication. You can provide your API key in several ways:
+
+1. Set it in your environment as `BRIQ_API_KEY`
+2. Store it in a `.env` file in your project directory
+3. Pass it directly when initializing the client
+
+Example `.env` file:
+```
+BRIQ_API_KEY=your_api_key_here
+```
+
+## Quick Start
+
+```python
+import briq
+
+# Initialize the client (will load API key from environment or .env file)
+client = briq.Client()
+
+# Or set the API key manually
+client.set_api_key("your_api_key_here")
+
+# Create a workspace
+workspace = client.workspace.create(
+    name="My Workspace",
+    description="A workspace for my messaging campaigns"
+)
+
+# List all workspaces
+workspaces = client.workspace.list()
+
+# Send an instant message
+result = client.message.send_instant(
+    content="Hello from the Briq Python client!",
+    recipients=["255788344348"],
+    sender_id="my-sender-id"
+)
+```
+
+## Documentation
+
+For detailed documentation and examples, please refer to the [Usage Guide](docs/usage.md) and [API Reference](docs/api_reference.md).
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

briq-0.1.0/briq/__init__.py

@@ -0,0 +1,15 @@
+"""
+Briq Python Client Library
+
+A Python client for the Briq messaging platform API.
+"""
+
+__version__ = "0.1.0"
+
+from .client import Client
+from .config import Config
+
+# Create a default client instance that can be imported directly
+client = Client()
+
+__all__ = ["Client", "Config", "client"]

briq-0.1.0/briq/campaign/__init__.py

@@ -0,0 +1,92 @@
+"""
+Campaign management module for the Briq API.
+"""
+
+class CampaignAPI:
+    """
+    Campaign management API for Briq.
+    
+    Provides methods for creating, listing, retrieving, and updating campaigns.
+    """
+    
+    def __init__(self, client):
+        """
+        Initialize the Campaign API module.
+        
+        Args:
+            client: The Briq client instance
+        """
+        self.client = client
+    
+    def create(self, workspace_id, name, description=None, launch_date=None):
+        """
+        Create a new campaign.
+        
+        Args:
+            workspace_id (str): ID of the workspace to create the campaign in
+            name (str): Name of the campaign
+            description (str, optional): Description of the campaign
+            launch_date (str, optional): Launch date of the campaign in ISO format (e.g., "2023-12-01T00:00:00")
+            
+        Returns:
+            dict: Created campaign data
+        """
+        data = {
+            "workspace_id": workspace_id,
+            "name": name
+        }
+        
+        if description:
+            data["description"] = description
+            
+        if launch_date:
+            data["launch_date"] = launch_date
+            
+        return self.client.post("campaign/create/", data=data)
+    
+    def list(self):
+        """
+        List all campaigns.
+        
+        Returns:
+            list: List of campaigns
+        """
+        return self.client.get("campaign/all/")
+    
+    def get(self, campaign_id):
+        """
+        Get a campaign by ID.
+        
+        Args:
+            campaign_id (str): ID of the campaign to retrieve
+            
+        Returns:
+            dict: Campaign data
+        """
+        return self.client.get(f"campaign/{campaign_id}/")
+    
+    def update(self, campaign_id, name=None, description=None, launch_date=None):
+        """
+        Update a campaign.
+        
+        Args:
+            campaign_id (str): ID of the campaign to update
+            name (str, optional): New name for the campaign
+            description (str, optional): New description for the campaign
+            launch_date (str, optional): New launch date in ISO format
+            
+        Returns:
+            dict: Updated campaign data
+        """
+        data = {}
+        
+        if name:
+            data["name"] = name
+            
+        if description:
+            data["description"] = description
+            
+        if launch_date:
+            data["launch_date"] = launch_date
+            
+        return self.client.patch(f"campaign/update/{campaign_id}", data=data)

briq-0.1.0/briq/client.py

@@ -0,0 +1,104 @@
+"""
+Client implementation for the Briq API.
+"""
+
+import json
+import requests
+from .config import Config
+from .workspace import WorkspaceAPI
+from .campaign import CampaignAPI
+from .message import MessageAPI
+
+class Client:
+    """
+    Main client class for interacting with the Briq API.
+    
+    Provides access to all API endpoints through dedicated modules.
+    """
+    
+    def __init__(self, api_key=None, base_url=None):
+        """
+        Initialize the Briq client.
+        
+        Args:
+            api_key (str, optional): API key for authentication. If not provided,
+                                     will attempt to load from environment.
+            base_url (str, optional): Base URL for the API. If not provided,
+                                      will use the default URL.
+        """
+        self.config = Config(api_key=api_key, base_url=base_url)
+        self.session = requests.Session()
+        
+        # Initialize API modules
+        self.workspace = WorkspaceAPI(self)
+        self.campaign = CampaignAPI(self)
+        self.message = MessageAPI(self)
+    
+    def request(self, method, endpoint, data=None, params=None):
+        """
+        Make a request to the Briq API.
+        
+        Args:
+            method (str): HTTP method (GET, POST, PATCH, etc.)
+            endpoint (str): API endpoint path
+            data (dict, optional): Request body data
+            params (dict, optional): Query parameters
+            
+        Returns:
+            dict: Response data
+            
+        Raises:
+            BriqAPIError: If the API returns an error
+            BriqAuthError: If authentication fails
+            BriqRequestError: If the request fails
+        """
+        from .exceptions import BriqAPIError, BriqAuthError, BriqRequestError
+        
+        url = f"{self.config.base_url}/v1/{endpoint.lstrip('/')}"
+        
+        try:
+            response = self.session.request(
+                method=method,
+                url=url,
+                headers=self.config.headers,
+                json=data,
+                params=params
+            )
+            
+            response.raise_for_status()
+            
+            if response.content:
+                return response.json()
+            return {}
+            
+        except requests.exceptions.HTTPError as e:
+            if response.status_code == 401:
+                raise BriqAuthError("Authentication failed. Check your API key.")
+            elif response.status_code == 400:
+                error_data = response.json() if response.content else {"error": "Bad request"}
+                raise BriqAPIError(f"API error: {error_data}")
+            else:
+                raise BriqAPIError(f"API error: {str(e)}")
+        except requests.exceptions.RequestException as e:
+            raise BriqRequestError(f"Request failed: {str(e)}")
+    
+    def get(self, endpoint, params=None):
+        """Convenience method for GET requests."""
+        return self.request("GET", endpoint, params=params)
+    
+    def post(self, endpoint, data=None):
+        """Convenience method for POST requests."""
+        return self.request("POST", endpoint, data=data)
+    
+    def patch(self, endpoint, data=None):
+        """Convenience method for PATCH requests."""
+        return self.request("PATCH", endpoint, data=data)
+    
+    def set_api_key(self, api_key):
+        """
+        Set the API key for authentication.
+        
+        Args:
+            api_key (str): The API key to use
+        """
+        self.config.api_key = api_key

briq-0.1.0/briq/config.py

@@ -0,0 +1,72 @@
+"""
+Configuration management for the Briq client.
+"""
+
+import os
+from pathlib import Path
+from dotenv import load_dotenv
+
+class Config:
+    """
+    Configuration class for the Briq client.
+    
+    Handles API key management, loading from environment variables or .env files,
+    and allows manual setting of configuration values.
+    """
+    
+    def __init__(self, api_key=None, base_url=None):
+        """
+        Initialize the Config object.
+        
+        Args:
+            api_key (str, optional): API key for authentication. If not provided,
+                                     will attempt to load from environment.
+            base_url (str, optional): Base URL for the API. If not provided,
+                                      will use the default URL.
+        """
+        # Try to load from .env file if it exists
+        env_path = Path('.') / '.env'
+        if env_path.exists():
+            load_dotenv(dotenv_path=env_path)
+        
+        self._api_key = api_key or os.environ.get('BRIQ_API_KEY')
+        self._base_url = base_url or os.environ.get('BRIQ_BASE_URL', 'http://karibu.briq.tz')
+    
+    @property
+    def api_key(self):
+        """Get the API key."""
+        return self._api_key
+    
+    @api_key.setter
+    def api_key(self, value):
+        """Set the API key."""
+        self._api_key = value
+    
+    @property
+    def base_url(self):
+        """Get the base URL."""
+        return self._base_url
+    
+    @base_url.setter
+    def base_url(self, value):
+        """Set the base URL."""
+        self._base_url = value
+    
+    @property
+    def headers(self):
+        """
+        Get the headers for API requests.
+        
+        Returns:
+            dict: Headers including the API key.
+        
+        Raises:
+            ValueError: If API key is not set.
+        """
+        if not self._api_key:
+            raise ValueError("API key not set. Set it using client.config.api_key = 'your_api_key' or by setting the BRIQ_API_KEY environment variable.")
+        
+        return {
+            "X-API-Key": self._api_key,
+            "Content-Type": "application/json"
+        }

briq-0.1.0/briq/exceptions.py

@@ -0,0 +1,23 @@
+"""
+Exception classes for the Briq client.
+"""
+
+class BriqError(Exception):
+    """Base exception for all Briq-related errors."""
+    pass
+
+class BriqAuthError(BriqError):
+    """Raised when authentication fails."""
+    pass
+
+class BriqAPIError(BriqError):
+    """Raised when the API returns an error."""
+    pass
+
+class BriqRequestError(BriqError):
+    """Raised when a request to the API fails."""
+    pass
+
+class BriqConfigError(BriqError):
+    """Raised when there's a configuration error."""
+    pass

briq-0.1.0/briq/message/__init__.py

@@ -0,0 +1,83 @@
+"""
+Message management module for the Briq API.
+"""
+
+class MessageAPI:
+    """
+    Message management API for Briq.
+    
+    Provides methods for sending instant messages, campaign messages, and retrieving message logs.
+    """
+    
+    def __init__(self, client):
+        """
+        Initialize the Message API module.
+        
+        Args:
+            client: The Briq client instance
+        """
+        self.client = client
+    
+    def send_instant(self, content, recipients, sender_id, campaign_id=None):
+        """
+        Send an instant message.
+        
+        Args:
+            content (str): Message content
+            recipients (list): List of recipient phone numbers
+            sender_id (str): Registered sender ID name
+            campaign_id (str, optional): Campaign ID to associate the message with
+            
+        Returns:
+            dict: Message sending result
+        """
+        data = {
+            "content": content,
+            "recipients": recipients,
+            "sender_id": sender_id
+        }
+        
+        if campaign_id:
+            data["campaign_id"] = campaign_id
+            
+        return self.client.post("message/send-instant", data=data)
+    
+    def send_campaign(self, campaign_id, group_id, content, sender_id):
+        """
+        Send a campaign message.
+        
+        Args:
+            campaign_id (str): ID of the campaign
+            group_id (str): ID of the recipient group
+            content (str): Message content
+            sender_id (str): Registered sender ID name
+            
+        Returns:
+            dict: Message sending result
+        """
+        data = {
+            "campaign_id": campaign_id,
+            "group_id": group_id,
+            "content": content,
+            "sender_id": sender_id
+        }
+            
+        return self.client.post("message/send-campaign", data=data)
+    
+    def get_logs(self):
+        """
+        Get message logs.
+        
+        Returns:
+            list: Message logs
+        """
+        return self.client.get("message/logs")
+    
+    def get_history(self):
+        """
+        Get user message history.
+        
+        Returns:
+            list: Message history
+        """
+        return self.client.get("message/history")

briq-0.1.0/briq/workspace/__init__.py

@@ -0,0 +1,82 @@
+"""
+Workspace management module for the Briq API.
+"""
+
+class WorkspaceAPI:
+    """
+    Workspace management API for Briq.
+    
+    Provides methods for creating, listing, retrieving, and updating workspaces.
+    """
+    
+    def __init__(self, client):
+        """
+        Initialize the Workspace API module.
+        
+        Args:
+            client: The Briq client instance
+        """
+        self.client = client
+    
+    def create(self, name, description=None):
+        """
+        Create a new workspace.
+        
+        Args:
+            name (str): Name of the workspace
+            description (str, optional): Description of the workspace
+            
+        Returns:
+            dict: Created workspace data
+        """
+        data = {
+            "name": name
+        }
+        
+        if description:
+            data["description"] = description
+            
+        return self.client.post("workspace/create/", data=data)
+    
+    def list(self):
+        """
+        List all workspaces.
+        
+        Returns:
+            list: List of workspaces
+        """
+        return self.client.get("workspace/all/")
+    
+    def get(self, workspace_id):
+        """
+        Get a workspace by ID.
+        
+        Args:
+            workspace_id (str): ID of the workspace to retrieve
+            
+        Returns:
+            dict: Workspace data
+        """
+        return self.client.get(f"workspace/{workspace_id}")
+    
+    def update(self, workspace_id, name=None, description=None):
+        """
+        Update a workspace.
+        
+        Args:
+            workspace_id (str): ID of the workspace to update
+            name (str, optional): New name for the workspace
+            description (str, optional): New description for the workspace
+            
+        Returns:
+            dict: Updated workspace data
+        """
+        data = {}
+        
+        if name:
+            data["name"] = name
+            
+        if description:
+            data["description"] = description
+            
+        return self.client.patch(f"workspace/update/{workspace_id}", data=data)

briq-0.1.0/briq.egg-info/PKG-INFO

@@ -0,0 +1,97 @@
+Metadata-Version: 2.4
+Name: briq
+Version: 0.1.0
+Summary: Python client for the Briq messaging platform API
+Home-page: https://github.com/BRIQ-BLOCK/BriqPythonSdk
+Author: Briq Team
+Author-email: Briq Team <info@briq.tz>
+License: MIT
+Project-URL: Homepage, https://github.com/briq/briq-python
+Project-URL: Bug Tracker, https://github.com/briq/briq-python/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.25.0
+Requires-Dist: python-dotenv>=0.15.0
+Dynamic: author
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
+
+# Briq Python Client
+
+A Python client library for the Briq messaging platform API.
+
+## Overview
+
+The Briq Python client provides a simple and intuitive interface to interact with the Briq messaging platform API. It allows you to manage workspaces, campaigns, and send messages programmatically from your Python applications.
+
+## Installation
+
+You can install the Briq client library using pip:
+
+```bash
+pip install briq
+```
+
+## Requirements
+
+- Python 3.7 or higher
+- requests
+- python-dotenv
+
+## Authentication
+
+The Briq client requires an API key for authentication. You can provide your API key in several ways:
+
+1. Set it in your environment as `BRIQ_API_KEY`
+2. Store it in a `.env` file in your project directory
+3. Pass it directly when initializing the client
+
+Example `.env` file:
+```
+BRIQ_API_KEY=your_api_key_here
+```
+
+## Quick Start
+
+```python
+import briq
+
+# Initialize the client (will load API key from environment or .env file)
+client = briq.Client()
+
+# Or set the API key manually
+client.set_api_key("your_api_key_here")
+
+# Create a workspace
+workspace = client.workspace.create(
+    name="My Workspace",
+    description="A workspace for my messaging campaigns"
+)
+
+# List all workspaces
+workspaces = client.workspace.list()
+
+# Send an instant message
+result = client.message.send_instant(
+    content="Hello from the Briq Python client!",
+    recipients=["255788344348"],
+    sender_id="my-sender-id"
+)
+```
+
+## Documentation
+
+For detailed documentation and examples, please refer to the [Usage Guide](docs/usage.md) and [API Reference](docs/api_reference.md).
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

briq-0.1.0/briq.egg-info/SOURCES.txt

@@ -0,0 +1,20 @@
+LICENSE
+README.md
+pyproject.toml
+setup.py
+briq/__init__.py
+briq/client.py
+briq/config.py
+briq/exceptions.py
+briq.egg-info/PKG-INFO
+briq.egg-info/SOURCES.txt
+briq.egg-info/dependency_links.txt
+briq.egg-info/requires.txt
+briq.egg-info/top_level.txt
+briq/campaign/__init__.py
+briq/message/__init__.py
+briq/workspace/__init__.py
+tests/test_campaign.py
+tests/test_client.py
+tests/test_message.py
+tests/test_workspace.py

briq-0.1.0/briq.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

briq-0.1.0/briq.egg-info/requires.txt

@@ -0,0 +1,2 @@
+requests>=2.25.0
+python-dotenv>=0.15.0

briq-0.1.0/briq.egg-info/top_level.txt

@@ -0,0 +1 @@
+briq

briq-0.1.0/pyproject.toml

@@ -0,0 +1,31 @@
+[build-system]
+requires = ["setuptools>=42", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "briq"
+version = "0.1.0"
+description = "Python client for the Briq messaging platform API"
+readme = "README.md"
+authors = [
+    {name = "Briq Team", email = "info@briq.tz"}
+]
+license = {text = "MIT"}
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.7",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+requires-python = ">=3.7"
+dependencies = [
+    "requests>=2.25.0",
+    "python-dotenv>=0.15.0",
+]
+
+[project.urls]
+"Homepage" = "https://github.com/briq/briq-python"
+"Bug Tracker" = "https://github.com/briq/briq-python/issues"

briq-0.1.0/setup.cfg

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

briq-0.1.0/setup.py

@@ -0,0 +1,30 @@
+from setuptools import setup, find_packages
+
+with open("README.md", "r", encoding="utf-8") as fh:
+    long_description = fh.read()
+
+setup(
+    name="briq",
+    version="0.0.7",
+    author="Briq Team",
+    author_email="sms@briq.tz",
+    description="Python client for the Briq messaging platform API",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    url="https://github.com/BRIQ-BLOCK/BriqPythonSdk",
+    packages=find_packages(),
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "Programming Language :: Python :: 3.7",
+        "Programming Language :: Python :: 3.8",
+        "Programming Language :: Python :: 3.9",
+        "Programming Language :: Python :: 3.10",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+    ],
+    python_requires=">=3.7",
+    install_requires=[
+        "requests>=2.25.0",
+        "python-dotenv>=0.15.0",
+    ],
+)

briq-0.1.0/tests/test_campaign.py

@@ -0,0 +1,144 @@
+import unittest
+from unittest.mock import patch, MagicMock
+import os
+import sys
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
+
+from briq.campaign import CampaignAPI
+
+class TestCampaignAPI(unittest.TestCase):
+    def setUp(self):
+        # Create a mock client
+        self.mock_client = MagicMock()
+        self.campaign_api = CampaignAPI(self.mock_client)
+    
+    def test_init(self):
+        # Test initialization
+        self.assertIsNotNone(self.campaign_api)
+        self.assertEqual(self.campaign_api.client, self.mock_client)
+    
+    def test_create(self):
+        # Test create method with all parameters
+        self.campaign_api.create(
+            "workspace-1", 
+            "Test Campaign", 
+            "Test Description", 
+            "2023-12-01T00:00:00"
+        )
+        
+        # Verify client.post was called with correct arguments
+        self.mock_client.post.assert_called_once_with(
+            "campaign/create/",
+            data={
+                "workspace_id": "workspace-1",
+                "name": "Test Campaign",
+                "description": "Test Description",
+                "launch_date": "2023-12-01T00:00:00"
+            }
+        )
+        
+        # Test create with only required parameters
+        self.mock_client.post.reset_mock()
+        self.campaign_api.create("workspace-1", "Test Campaign")
+        
+        # Verify client.post was called with correct arguments
+        self.mock_client.post.assert_called_once_with(
+            "campaign/create/",
+            data={
+                "workspace_id": "workspace-1",
+                "name": "Test Campaign"
+            }
+        )
+    
+    def test_list(self):
+        # Mock response
+        mock_response = [
+            {"id": "campaign-1", "name": "Campaign 1"},
+            {"id": "campaign-2", "name": "Campaign 2"}
+        ]
+        self.mock_client.get.return_value = mock_response
+        
+        # Test list method
+        result = self.campaign_api.list()
+        
+        # Verify client.get was called with correct arguments
+        self.mock_client.get.assert_called_once_with("campaign/all/")
+        
+        # Verify result
+        self.assertEqual(result, mock_response)
+    
+    def test_get(self):
+        # Mock response
+        mock_response = {"id": "campaign-1", "name": "Campaign 1"}
+        self.mock_client.get.return_value = mock_response
+        
+        # Test get method
+        result = self.campaign_api.get("campaign-1")
+        
+        # Verify client.get was called with correct arguments
+        self.mock_client.get.assert_called_once_with("campaign/campaign-1/")
+        
+        # Verify result
+        self.assertEqual(result, mock_response)
+    
+    def test_update(self):
+        # Test update method with all parameters
+        self.campaign_api.update(
+            "campaign-1", 
+            "Updated Name", 
+            "Updated Description", 
+            "2023-12-15T00:00:00"
+        )
+        
+        # Verify client.patch was called with correct arguments
+        self.mock_client.patch.assert_called_once_with(
+            "campaign/update/campaign-1",
+            data={
+                "name": "Updated Name",
+                "description": "Updated Description",
+                "launch_date": "2023-12-15T00:00:00"
+            }
+        )
+        
+        # Test update with only name
+        self.mock_client.patch.reset_mock()
+        self.campaign_api.update("campaign-1", "Updated Name")
+        
+        # Verify client.patch was called with correct arguments
+        self.mock_client.patch.assert_called_once_with(
+            "campaign/update/campaign-1",
+            data={"name": "Updated Name"}
+        )
+        
+        # Test update with only description
+        self.mock_client.patch.reset_mock()
+        self.campaign_api.update("campaign-1", description="Updated Description")
+        
+        # Verify client.patch was called with correct arguments
+        self.mock_client.patch.assert_called_once_with(
+            "campaign/update/campaign-1",
+            data={"description": "Updated Description"}
+        )
+        
+        # Test update with only launch_date
+        self.mock_client.patch.reset_mock()
+        self.campaign_api.update("campaign-1", launch_date="2023-12-15T00:00:00")
+        
+        # Verify client.patch was called with correct arguments
+        self.mock_client.patch.assert_called_once_with(
+            "campaign/update/campaign-1",
+            data={"launch_date": "2023-12-15T00:00:00"}
+        )
+        
+        # Test update with no changes
+        self.mock_client.patch.reset_mock()
+        self.campaign_api.update("campaign-1")
+        
+        # Verify client.patch was called with correct arguments
+        self.mock_client.patch.assert_called_once_with(
+            "campaign/update/campaign-1",
+            data={}
+        )
+
+if __name__ == '__main__':
+    unittest.main()

briq-0.1.0/tests/test_client.py

@@ -0,0 +1,108 @@
+import unittest
+from unittest.mock import patch, MagicMock
+import os
+import sys
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
+
+from briq.client import Client
+from briq.exceptions import BriqAuthError, BriqAPIError, BriqRequestError
+
+class TestClient(unittest.TestCase):
+    def setUp(self):
+        # Create a client with a dummy API key for testing
+        self.client = Client(api_key="test_api_key")
+    
+    def test_init(self):
+        # Test client initialization
+        self.assertIsNotNone(self.client)
+        self.assertEqual(self.client.config.api_key, "test_api_key")
+        self.assertEqual(self.client.config.base_url, "http://karibu.briq.tz")
+        
+        # Test initialization with custom base URL
+        client = Client(api_key="test_api_key", base_url="http://custom-url")
+        self.assertEqual(client.config.base_url, "http://custom-url")
+    
+    def test_set_api_key(self):
+        # Test setting API key
+        self.client.set_api_key("new_api_key")
+        self.assertEqual(self.client.config.api_key, "new_api_key")
+    
+    @patch('requests.Session.request')
+    def test_request_success(self, mock_request):
+        # Mock successful response
+        mock_response = MagicMock()
+        mock_response.status_code = 200
+        mock_response.content = b'{"key": "value"}'
+        mock_response.json.return_value = {"key": "value"}
+        mock_request.return_value = mock_response
+        
+        # Test request method
+        result = self.client.request("GET", "test/endpoint")
+        
+        # Verify request was made correctly
+        mock_request.assert_called_once_with(
+            method="GET",
+            url="http://karibu.briq.tz/v1/test/endpoint",
+            headers=self.client.config.headers,
+            json=None,
+            params=None
+        )
+        
+        # Verify result
+        self.assertEqual(result, {"key": "value"})
+    
+    @patch('requests.Session.request')
+    def test_request_auth_error(self, mock_request):
+        # Mock 401 response
+        mock_response = MagicMock()
+        mock_response.status_code = 401
+        mock_response.raise_for_status.side_effect = Exception("401 Client Error")
+        mock_request.return_value = mock_response
+        
+        # Test request method with auth error
+        with self.assertRaises(BriqAuthError):
+            self.client.request("GET", "test/endpoint")
+    
+    @patch('requests.Session.request')
+    def test_request_api_error(self, mock_request):
+        # Mock 400 response
+        mock_response = MagicMock()
+        mock_response.status_code = 400
+        mock_response.content = b'{"error": "Bad request"}'
+        mock_response.json.return_value = {"error": "Bad request"}
+        mock_response.raise_for_status.side_effect = Exception("400 Client Error")
+        mock_request.return_value = mock_response
+        
+        # Test request method with API error
+        with self.assertRaises(BriqAPIError):
+            self.client.request("GET", "test/endpoint")
+    
+    @patch('requests.Session.request')
+    def test_request_network_error(self, mock_request):
+        # Mock network error
+        mock_request.side_effect = Exception("Connection error")
+        
+        # Test request method with network error
+        with self.assertRaises(BriqRequestError):
+            self.client.request("GET", "test/endpoint")
+    
+    @patch('briq.client.Client.request')
+    def test_get(self, mock_request):
+        # Test get method
+        self.client.get("test/endpoint", params={"param": "value"})
+        mock_request.assert_called_once_with("GET", "test/endpoint", params={"param": "value"})
+    
+    @patch('briq.client.Client.request')
+    def test_post(self, mock_request):
+        # Test post method
+        self.client.post("test/endpoint", data={"key": "value"})
+        mock_request.assert_called_once_with("POST", "test/endpoint", data={"key": "value"})
+    
+    @patch('briq.client.Client.request')
+    def test_patch(self, mock_request):
+        # Test patch method
+        self.client.patch("test/endpoint", data={"key": "value"})
+        mock_request.assert_called_once_with("PATCH", "test/endpoint", data={"key": "value"})
+
+if __name__ == '__main__':
+    unittest.main()

briq-0.1.0/tests/test_message.py

@@ -0,0 +1,113 @@
+import unittest
+from unittest.mock import patch, MagicMock
+import os
+import sys
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
+
+from briq.message import MessageAPI
+
+class TestMessageAPI(unittest.TestCase):
+    def setUp(self):
+        # Create a mock client
+        self.mock_client = MagicMock()
+        self.message_api = MessageAPI(self.mock_client)
+    
+    def test_init(self):
+        # Test initialization
+        self.assertIsNotNone(self.message_api)
+        self.assertEqual(self.message_api.client, self.mock_client)
+    
+    def test_send_instant(self):
+        # Test send_instant method with all parameters
+        self.message_api.send_instant(
+            "Hello, this is a test message",
+            ["255788344348", "255712345678"],
+            "test-sender",
+            "campaign-1"
+        )
+        
+        # Verify client.post was called with correct arguments
+        self.mock_client.post.assert_called_once_with(
+            "message/send-instant",
+            data={
+                "content": "Hello, this is a test message",
+                "recipients": ["255788344348", "255712345678"],
+                "sender_id": "test-sender",
+                "campaign_id": "campaign-1"
+            }
+        )
+        
+        # Test send_instant without campaign_id
+        self.mock_client.post.reset_mock()
+        self.message_api.send_instant(
+            "Hello, this is a test message",
+            ["255788344348"],
+            "test-sender"
+        )
+        
+        # Verify client.post was called with correct arguments
+        self.mock_client.post.assert_called_once_with(
+            "message/send-instant",
+            data={
+                "content": "Hello, this is a test message",
+                "recipients": ["255788344348"],
+                "sender_id": "test-sender"
+            }
+        )
+    
+    def test_send_campaign(self):
+        # Test send_campaign method
+        self.message_api.send_campaign(
+            "campaign-1",
+            "group-1",
+            "Campaign message content",
+            "test-sender"
+        )
+        
+        # Verify client.post was called with correct arguments
+        self.mock_client.post.assert_called_once_with(
+            "message/send-campaign",
+            data={
+                "campaign_id": "campaign-1",
+                "group_id": "group-1",
+                "content": "Campaign message content",
+                "sender_id": "test-sender"
+            }
+        )
+    
+    def test_get_logs(self):
+        # Mock response
+        mock_response = [
+            {"id": "message-1", "content": "Message 1", "status": "delivered"},
+            {"id": "message-2", "content": "Message 2", "status": "sent"}
+        ]
+        self.mock_client.get.return_value = mock_response
+        
+        # Test get_logs method
+        result = self.message_api.get_logs()
+        
+        # Verify client.get was called with correct arguments
+        self.mock_client.get.assert_called_once_with("message/logs")
+        
+        # Verify result
+        self.assertEqual(result, mock_response)
+    
+    def test_get_history(self):
+        # Mock response
+        mock_response = [
+            {"id": "message-1", "content": "Message 1", "sent_at": "2023-01-01T12:00:00"},
+            {"id": "message-2", "content": "Message 2", "sent_at": "2023-01-02T12:00:00"}
+        ]
+        self.mock_client.get.return_value = mock_response
+        
+        # Test get_history method
+        result = self.message_api.get_history()
+        
+        # Verify client.get was called with correct arguments
+        self.mock_client.get.assert_called_once_with("message/history")
+        
+        # Verify result
+        self.assertEqual(result, mock_response)
+
+if __name__ == '__main__':
+    unittest.main()

briq-0.1.0/tests/test_workspace.py

@@ -0,0 +1,112 @@
+import unittest
+from unittest.mock import patch, MagicMock
+import os
+import sys
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
+
+from briq.workspace import WorkspaceAPI
+
+class TestWorkspaceAPI(unittest.TestCase):
+    def setUp(self):
+        # Create a mock client
+        self.mock_client = MagicMock()
+        self.workspace_api = WorkspaceAPI(self.mock_client)
+    
+    def test_init(self):
+        # Test initialization
+        self.assertIsNotNone(self.workspace_api)
+        self.assertEqual(self.workspace_api.client, self.mock_client)
+    
+    def test_create(self):
+        # Test create method
+        self.workspace_api.create("Test Workspace", "Test Description")
+        
+        # Verify client.post was called with correct arguments
+        self.mock_client.post.assert_called_once_with(
+            "workspace/create/",
+            data={"name": "Test Workspace", "description": "Test Description"}
+        )
+        
+        # Test create with only name
+        self.mock_client.post.reset_mock()
+        self.workspace_api.create("Test Workspace")
+        
+        # Verify client.post was called with correct arguments
+        self.mock_client.post.assert_called_once_with(
+            "workspace/create/",
+            data={"name": "Test Workspace"}
+        )
+    
+    def test_list(self):
+        # Mock response
+        mock_response = [
+            {"id": "workspace-1", "name": "Workspace 1"},
+            {"id": "workspace-2", "name": "Workspace 2"}
+        ]
+        self.mock_client.get.return_value = mock_response
+        
+        # Test list method
+        result = self.workspace_api.list()
+        
+        # Verify client.get was called with correct arguments
+        self.mock_client.get.assert_called_once_with("workspace/all/")
+        
+        # Verify result
+        self.assertEqual(result, mock_response)
+    
+    def test_get(self):
+        # Mock response
+        mock_response = {"id": "workspace-1", "name": "Workspace 1"}
+        self.mock_client.get.return_value = mock_response
+        
+        # Test get method
+        result = self.workspace_api.get("workspace-1")
+        
+        # Verify client.get was called with correct arguments
+        self.mock_client.get.assert_called_once_with("workspace/workspace-1")
+        
+        # Verify result
+        self.assertEqual(result, mock_response)
+    
+    def test_update(self):
+        # Test update method with both name and description
+        self.workspace_api.update("workspace-1", "Updated Name", "Updated Description")
+        
+        # Verify client.patch was called with correct arguments
+        self.mock_client.patch.assert_called_once_with(
+            "workspace/update/workspace-1",
+            data={"name": "Updated Name", "description": "Updated Description"}
+        )
+        
+        # Test update with only name
+        self.mock_client.patch.reset_mock()
+        self.workspace_api.update("workspace-1", "Updated Name")
+        
+        # Verify client.patch was called with correct arguments
+        self.mock_client.patch.assert_called_once_with(
+            "workspace/update/workspace-1",
+            data={"name": "Updated Name"}
+        )
+        
+        # Test update with only description
+        self.mock_client.patch.reset_mock()
+        self.workspace_api.update("workspace-1", description="Updated Description")
+        
+        # Verify client.patch was called with correct arguments
+        self.mock_client.patch.assert_called_once_with(
+            "workspace/update/workspace-1",
+            data={"description": "Updated Description"}
+        )
+        
+        # Test update with no changes
+        self.mock_client.patch.reset_mock()
+        self.workspace_api.update("workspace-1")
+        
+        # Verify client.patch was called with correct arguments
+        self.mock_client.patch.assert_called_once_with(
+            "workspace/update/workspace-1",
+            data={}
+        )
+
+if __name__ == '__main__':
+    unittest.main()