databunkerpro 0.1.0__tar.gz

databunkerpro-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 securitybunker
+
+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.

databunkerpro-0.1.0/PKG-INFO

@@ -0,0 +1,143 @@
+Metadata-Version: 2.4
+Name: databunkerpro
+Version: 0.1.0
+Summary: Python client library for DatabunkerPro API
+Home-page: https://github.com/yourusername/databunkerpro-python
+Author: Your Name
+Author-email: your.email@example.com
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+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
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.25.1
+Provides-Extra: dev
+Requires-Dist: pytest>=6.0; extra == "dev"
+Requires-Dist: pytest-cov>=2.0; extra == "dev"
+Requires-Dist: black>=21.0; extra == "dev"
+Requires-Dist: isort>=5.0; extra == "dev"
+Requires-Dist: mypy>=0.910; extra == "dev"
+Requires-Dist: types-requests; extra == "dev"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# DatabunkerPro Python Client
+
+A Python client library for interacting with the DatabunkerPro API. This library provides a simple and intuitive interface for managing user data, tokens, and other DatabunkerPro features.
+
+## Installation
+
+You can install the package using pip:
+
+```bash
+pip install databunkerpro
+```
+
+Or install directly from GitHub:
+
+```bash
+pip install git+https://github.com/yourusername/databunkerpro-python.git
+```
+
+## Quick Start
+
+```python
+from databunkerpro import DatabunkerproAPI
+
+# Initialize the client
+api = DatabunkerproAPI(
+    base_url="https://pro.databunker.org",
+    x_bunker_token="your-api-token",
+    x_bunker_tenant="your-tenant-name"
+)
+
+# Create a new user
+user_data = {
+    "email": "user@example.com",
+    "name": "John Doe",
+    "phone": "+1234567890"
+}
+result = api.create_user(user_data)
+print(f"Created user with token: {result['token']}")
+
+# Get user information
+user = api.get_user("email", "user@example.com")
+print(f"User profile: {user['profile']}")
+
+# Update user information
+update_data = {
+    "name": "John Updated",
+    "phone": "+0987654321"
+}
+api.update_user("email", "user@example.com", update_data)
+
+# Create a token for sensitive data
+token_result = api.create_token("creditcard", "4111111111111111")
+print(f"Created token: {token_result['token']}")
+```
+
+## Features
+
+- User Management (create, read, update, delete)
+- Token Management
+- System Statistics
+- Type hints and comprehensive documentation
+- Error handling and validation
+
+## Development
+
+To set up the development environment:
+
+1. Clone the repository:
+```bash
+git clone https://github.com/yourusername/databunkerpro-python.git
+cd databunkerpro-python
+```
+
+2. Install development dependencies:
+```bash
+pip install -e ".[dev]"
+```
+
+3. Run tests:
+```bash
+pytest
+```
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+1. Fork the repository
+2. Create your feature branch (`git checkout -b feature/amazing-feature`)
+3. Commit your changes (`git commit -m 'Add some amazing feature'`)
+4. Push to the branch (`git push origin feature/amazing-feature`)
+5. Open a Pull Request
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+## Support
+
+If you encounter any issues or have questions, please [open an issue](https://github.com/yourusername/databunkerpro-python/issues) on GitHub.
+
+## API Documentation
+
+For detailed API documentation, please visit the [DatabunkerPro API Documentation](https://docs.databunker.org).

databunkerpro-0.1.0/README.md

@@ -0,0 +1,104 @@
+# DatabunkerPro Python Client
+
+A Python client library for interacting with the DatabunkerPro API. This library provides a simple and intuitive interface for managing user data, tokens, and other DatabunkerPro features.
+
+## Installation
+
+You can install the package using pip:
+
+```bash
+pip install databunkerpro
+```
+
+Or install directly from GitHub:
+
+```bash
+pip install git+https://github.com/yourusername/databunkerpro-python.git
+```
+
+## Quick Start
+
+```python
+from databunkerpro import DatabunkerproAPI
+
+# Initialize the client
+api = DatabunkerproAPI(
+    base_url="https://pro.databunker.org",
+    x_bunker_token="your-api-token",
+    x_bunker_tenant="your-tenant-name"
+)
+
+# Create a new user
+user_data = {
+    "email": "user@example.com",
+    "name": "John Doe",
+    "phone": "+1234567890"
+}
+result = api.create_user(user_data)
+print(f"Created user with token: {result['token']}")
+
+# Get user information
+user = api.get_user("email", "user@example.com")
+print(f"User profile: {user['profile']}")
+
+# Update user information
+update_data = {
+    "name": "John Updated",
+    "phone": "+0987654321"
+}
+api.update_user("email", "user@example.com", update_data)
+
+# Create a token for sensitive data
+token_result = api.create_token("creditcard", "4111111111111111")
+print(f"Created token: {token_result['token']}")
+```
+
+## Features
+
+- User Management (create, read, update, delete)
+- Token Management
+- System Statistics
+- Type hints and comprehensive documentation
+- Error handling and validation
+
+## Development
+
+To set up the development environment:
+
+1. Clone the repository:
+```bash
+git clone https://github.com/yourusername/databunkerpro-python.git
+cd databunkerpro-python
+```
+
+2. Install development dependencies:
+```bash
+pip install -e ".[dev]"
+```
+
+3. Run tests:
+```bash
+pytest
+```
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+1. Fork the repository
+2. Create your feature branch (`git checkout -b feature/amazing-feature`)
+3. Commit your changes (`git commit -m 'Add some amazing feature'`)
+4. Push to the branch (`git push origin feature/amazing-feature`)
+5. Open a Pull Request
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+## Support
+
+If you encounter any issues or have questions, please [open an issue](https://github.com/yourusername/databunkerpro-python/issues) on GitHub.
+
+## API Documentation
+
+For detailed API documentation, please visit the [DatabunkerPro API Documentation](https://docs.databunker.org).

databunkerpro-0.1.0/databunkerpro/__init__.py

@@ -0,0 +1,9 @@
+"""
+DatabunkerPro Python Client Library
+A Python client library for interacting with the DatabunkerPro API.
+"""
+
+from .api import DatabunkerproAPI
+
+__version__ = "0.1.0"
+__all__ = ["DatabunkerproAPI"]

databunkerpro-0.1.0/databunkerpro/api.py

@@ -0,0 +1,250 @@
+"""
+DatabunkerPro API Client
+Main implementation of the DatabunkerPro API client.
+"""
+
+import json
+from datetime import datetime
+from typing import Any, Dict, List, Optional, Union
+
+import requests
+
+
+class DatabunkerproAPI:
+    """Main client class for interacting with the DatabunkerPro API."""
+
+    def __init__(
+        self, base_url: str, x_bunker_token: str = "", x_bunker_tenant: str = ""
+    ):
+        """
+        Initialize the DatabunkerPro API client.
+
+        Args:
+            base_url (str): The base URL of the DatabunkerPro API
+            x_bunker_token (str, optional): The X-Bunker-Token for authentication
+            x_bunker_tenant (str, optional): The X-Bunker-Tenant identifier
+        """
+        self.base_url = base_url.rstrip("/")
+        self.x_bunker_token = x_bunker_token
+        self.x_bunker_tenant = x_bunker_tenant
+
+    def _make_request(
+        self,
+        endpoint: str,
+        method: str = "POST",
+        data: Optional[Dict[str, Any]] = None,
+        request_metadata: Optional[Dict[str, Any]] = None,
+    ) -> Dict[str, Any]:
+        """
+        Make a request to the DatabunkerPro API.
+
+        Args:
+            endpoint (str): The API endpoint to call
+            method (str, optional): The HTTP method to use. Defaults to "POST"
+            data (Dict[str, Any], optional): The data to send in the request body
+            request_metadata (Dict[str, Any], optional): Additional metadata to include in the request
+
+        Returns:
+            Dict[str, Any]: The API response
+
+        Raises:
+            Exception: If the API request fails
+        """
+        headers = {"Content-Type": "application/json"}
+
+        if self.x_bunker_token:
+            headers["X-Bunker-Token"] = self.x_bunker_token
+        if self.x_bunker_tenant:
+            headers["X-Bunker-Tenant"] = self.x_bunker_tenant
+
+        url = f"{self.base_url}/v2/{endpoint}"
+
+        if data or request_metadata:
+            body_data = data.copy() if data else {}
+            if request_metadata:
+                body_data["request_metadata"] = request_metadata
+            body = json.dumps(body_data)
+        else:
+            body = None
+
+        try:
+            response = requests.request(method, url, headers=headers, data=body)
+            response.raise_for_status()
+            result: Dict[str, Any] = response.json()
+
+            if not response.ok:
+                if result.get("status"):
+                    return result
+                else:
+                    return {
+                        "status": "error",
+                        "message": result.get("message", "API request failed"),
+                    }
+
+            return result
+        except requests.exceptions.RequestException as e:
+            return {"status": "error", "message": f"Error making request: {str(e)}"}
+
+    def create_user(
+        self,
+        profile: Dict[str, Any],
+        options: Optional[Dict[str, Any]] = None,
+        request_metadata: Optional[Dict[str, Any]] = None,
+    ) -> Dict[str, Any]:
+        """
+        Create a new user in DatabunkerPro.
+
+        Args:
+            profile (Dict[str, Any]): User profile data
+            options (Dict[str, Any], optional): Additional options for user creation
+            request_metadata (Dict[str, Any], optional): Additional metadata for the request
+
+        Returns:
+            Dict[str, Any]: The API response
+        """
+        data = {"profile": profile}
+        if options:
+            data.update(options)
+        return self._make_request("UserCreate", "POST", data, request_metadata)
+
+    def get_user(
+        self,
+        mode: str,
+        identity: str,
+        request_metadata: Optional[Dict[str, Any]] = None,
+    ) -> Dict[str, Any]:
+        """
+        Get user information from DatabunkerPro.
+
+        Args:
+            mode (str): The identification mode (e.g., 'email', 'phone', 'token')
+            identity (str): The user's identifier
+            request_metadata (Dict[str, Any], optional): Additional metadata for the request
+
+        Returns:
+            Dict[str, Any]: The API response
+        """
+        return self._make_request(
+            "UserGet", "POST", {"mode": mode, "identity": identity}, request_metadata
+        )
+
+    def update_user(
+        self,
+        mode: str,
+        identity: str,
+        profile: Dict[str, Any],
+        request_metadata: Optional[Dict[str, Any]] = None,
+    ) -> Dict[str, Any]:
+        """
+        Update user information in DatabunkerPro.
+
+        Args:
+            mode (str): The identification mode (e.g., 'email', 'phone', 'token')
+            identity (str): The user's identifier
+            profile (Dict[str, Any]): Updated user profile data
+            request_metadata (Dict[str, Any], optional): Additional metadata for the request
+
+        Returns:
+            Dict[str, Any]: The API response
+        """
+        return self._make_request(
+            "UserUpdate",
+            "POST",
+            {"mode": mode, "identity": identity, "profile": profile},
+            request_metadata,
+        )
+
+    def delete_user(
+        self,
+        mode: str,
+        identity: str,
+        request_metadata: Optional[Dict[str, Any]] = None,
+    ) -> Dict[str, Any]:
+        """
+        Delete a user from DatabunkerPro.
+
+        Args:
+            mode (str): The identification mode (e.g., 'email', 'phone', 'token')
+            identity (str): The user's identifier
+            request_metadata (Dict[str, Any], optional): Additional metadata for the request
+
+        Returns:
+            Dict[str, Any]: The API response
+        """
+        return self._make_request(
+            "UserDelete", "POST", {"mode": mode, "identity": identity}, request_metadata
+        )
+
+    def get_system_stats(
+        self, request_metadata: Optional[Dict[str, Any]] = None
+    ) -> Dict[str, Any]:
+        """
+        Get system statistics from DatabunkerPro.
+
+        Args:
+            request_metadata (Dict[str, Any], optional): Additional metadata for the request
+
+        Returns:
+            Dict[str, Any]: The API response containing system statistics
+        """
+        return self._make_request(
+            "SystemGetSystemStats", "POST", None, request_metadata
+        )
+
+    def create_token(
+        self,
+        token_type: str,
+        record: str,
+        options: Optional[Dict[str, Any]] = None,
+        request_metadata: Optional[Dict[str, Any]] = None,
+    ) -> Dict[str, Any]:
+        """
+        Create a token for sensitive data.
+
+        Args:
+            token_type (str): Type of token (e.g., 'creditcard')
+            record (str): The sensitive data to tokenize
+            options (Dict[str, Any], optional): Additional options for token creation
+            request_metadata (Dict[str, Any], optional): Additional metadata for the request
+
+        Returns:
+            Dict[str, Any]: The API response
+        """
+        data = {"tokentype": token_type, "record": record}
+        if options:
+            data.update(options)
+        return self._make_request("TokenCreate", "POST", data, request_metadata)
+
+    def get_token(
+        self, token: str, request_metadata: Optional[Dict[str, Any]] = None
+    ) -> Dict[str, Any]:
+        """
+        Get token information from DatabunkerPro.
+
+        Args:
+            token (str): The token to retrieve
+            request_metadata (Dict[str, Any], optional): Additional metadata for the request
+
+        Returns:
+            Dict[str, Any]: The API response
+        """
+        return self._make_request(
+            "TokenGet", "POST", {"token": token}, request_metadata
+        )
+
+    def delete_token(
+        self, token: str, request_metadata: Optional[Dict[str, Any]] = None
+    ) -> Dict[str, Any]:
+        """
+        Delete a token from DatabunkerPro.
+
+        Args:
+            token (str): The token to delete
+            request_metadata (Dict[str, Any], optional): Additional metadata for the request
+
+        Returns:
+            Dict[str, Any]: The API response
+        """
+        return self._make_request(
+            "TokenDelete", "POST", {"token": token}, request_metadata
+        )

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

@@ -0,0 +1,143 @@
+Metadata-Version: 2.4
+Name: databunkerpro
+Version: 0.1.0
+Summary: Python client library for DatabunkerPro API
+Home-page: https://github.com/yourusername/databunkerpro-python
+Author: Your Name
+Author-email: your.email@example.com
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+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
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.25.1
+Provides-Extra: dev
+Requires-Dist: pytest>=6.0; extra == "dev"
+Requires-Dist: pytest-cov>=2.0; extra == "dev"
+Requires-Dist: black>=21.0; extra == "dev"
+Requires-Dist: isort>=5.0; extra == "dev"
+Requires-Dist: mypy>=0.910; extra == "dev"
+Requires-Dist: types-requests; extra == "dev"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# DatabunkerPro Python Client
+
+A Python client library for interacting with the DatabunkerPro API. This library provides a simple and intuitive interface for managing user data, tokens, and other DatabunkerPro features.
+
+## Installation
+
+You can install the package using pip:
+
+```bash
+pip install databunkerpro
+```
+
+Or install directly from GitHub:
+
+```bash
+pip install git+https://github.com/yourusername/databunkerpro-python.git
+```
+
+## Quick Start
+
+```python
+from databunkerpro import DatabunkerproAPI
+
+# Initialize the client
+api = DatabunkerproAPI(
+    base_url="https://pro.databunker.org",
+    x_bunker_token="your-api-token",
+    x_bunker_tenant="your-tenant-name"
+)
+
+# Create a new user
+user_data = {
+    "email": "user@example.com",
+    "name": "John Doe",
+    "phone": "+1234567890"
+}
+result = api.create_user(user_data)
+print(f"Created user with token: {result['token']}")
+
+# Get user information
+user = api.get_user("email", "user@example.com")
+print(f"User profile: {user['profile']}")
+
+# Update user information
+update_data = {
+    "name": "John Updated",
+    "phone": "+0987654321"
+}
+api.update_user("email", "user@example.com", update_data)
+
+# Create a token for sensitive data
+token_result = api.create_token("creditcard", "4111111111111111")
+print(f"Created token: {token_result['token']}")
+```
+
+## Features
+
+- User Management (create, read, update, delete)
+- Token Management
+- System Statistics
+- Type hints and comprehensive documentation
+- Error handling and validation
+
+## Development
+
+To set up the development environment:
+
+1. Clone the repository:
+```bash
+git clone https://github.com/yourusername/databunkerpro-python.git
+cd databunkerpro-python
+```
+
+2. Install development dependencies:
+```bash
+pip install -e ".[dev]"
+```
+
+3. Run tests:
+```bash
+pytest
+```
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+1. Fork the repository
+2. Create your feature branch (`git checkout -b feature/amazing-feature`)
+3. Commit your changes (`git commit -m 'Add some amazing feature'`)
+4. Push to the branch (`git push origin feature/amazing-feature`)
+5. Open a Pull Request
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+## Support
+
+If you encounter any issues or have questions, please [open an issue](https://github.com/yourusername/databunkerpro-python/issues) on GitHub.
+
+## API Documentation
+
+For detailed API documentation, please visit the [DatabunkerPro API Documentation](https://docs.databunker.org).

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

@@ -0,0 +1,12 @@
+LICENSE
+README.md
+pyproject.toml
+setup.py
+databunkerpro/__init__.py
+databunkerpro/api.py
+databunkerpro.egg-info/PKG-INFO
+databunkerpro.egg-info/SOURCES.txt
+databunkerpro.egg-info/dependency_links.txt
+databunkerpro.egg-info/requires.txt
+databunkerpro.egg-info/top_level.txt
+tests/test_api.py

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

@@ -0,0 +1 @@
+

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

@@ -0,0 +1,9 @@
+requests>=2.25.1
+
+[dev]
+pytest>=6.0
+pytest-cov>=2.0
+black>=21.0
+isort>=5.0
+mypy>=0.910
+types-requests

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

@@ -0,0 +1 @@
+databunkerpro

databunkerpro-0.1.0/pyproject.toml

@@ -0,0 +1,35 @@
+[build-system]
+requires = ["setuptools>=42", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[tool.black]
+line-length = 88
+target-version = ['py37', 'py38', 'py39', 'py310']
+include = '\.pyi?$'
+
+[tool.isort]
+profile = "black"
+multi_line_output = 3
+include_trailing_comma = true
+force_grid_wrap = 0
+use_parentheses = true
+line_length = 88
+
+[tool.mypy]
+python_version = "3.8"
+warn_return_any = true
+warn_unused_configs = true
+disallow_untyped_defs = true
+disallow_incomplete_defs = true
+check_untyped_defs = true
+disallow_untyped_decorators = true
+no_implicit_optional = true
+warn_redundant_casts = true
+warn_unused_ignores = true
+warn_no_return = true
+warn_unreachable = true
+
+[[tool.mypy.overrides]]
+module = ["tests.*"]
+disallow_untyped_defs = false
+disallow_incomplete_defs = false 

databunkerpro-0.1.0/setup.cfg

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

databunkerpro-0.1.0/setup.py

@@ -0,0 +1,41 @@
+from setuptools import find_packages, setup
+
+with open("README.md", "r", encoding="utf-8") as fh:
+    long_description = fh.read()
+
+setup(
+    name="databunkerpro",
+    version="0.1.0",
+    author="Your Name",
+    author_email="your.email@example.com",
+    description="Python client library for DatabunkerPro API",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    url="https://github.com/yourusername/databunkerpro-python",
+    packages=find_packages(),
+    classifiers=[
+        "Development Status :: 3 - Alpha",
+        "Intended Audience :: Developers",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+        "Programming Language :: Python :: 3",
+        "Programming Language :: Python :: 3.7",
+        "Programming Language :: Python :: 3.8",
+        "Programming Language :: Python :: 3.9",
+        "Programming Language :: Python :: 3.10",
+    ],
+    python_requires=">=3.7",
+    install_requires=[
+        "requests>=2.25.1",
+    ],
+    extras_require={
+        "dev": [
+            "pytest>=6.0",
+            "pytest-cov>=2.0",
+            "black>=21.0",
+            "isort>=5.0",
+            "mypy>=0.910",
+            "types-requests",
+        ],
+    },
+)

databunkerpro-0.1.0/tests/test_api.py

@@ -0,0 +1,114 @@
+"""
+Tests for the DatabunkerPro API client.
+"""
+
+import os
+import random
+import unittest
+
+import requests
+
+from databunkerpro import DatabunkerproAPI
+
+
+class TestDatabunkerproAPI(unittest.TestCase):
+    """Test cases for the DatabunkerPro API client."""
+
+    @classmethod
+    def setUpClass(cls):
+        """Set up test environment before running tests."""
+        # Try to get credentials from environment first
+        cls.api_url = os.getenv("DATABUNKER_API_URL", "https://pro.databunker.org")
+        cls.api_token = os.getenv("DATABUNKER_API_TOKEN", "")
+        cls.tenant_name = os.getenv("DATABUNKER_TENANT_NAME", "")
+
+        # If credentials are not in environment, try to get them from sandbox server
+        if not all([cls.api_token, cls.tenant_name]):
+            try:
+                response = requests.get(
+                    "https://databunker.org/api/newtenant.php", verify=False
+                )
+                if response.ok:
+                    data = response.json()
+                    if data and data.get("status") == "ok":
+                        cls.tenant_name = data["tenantname"]
+                        cls.api_token = data["xtoken"]
+                        print(
+                            "\nSuccessfully connected to DatabunkerPro sandbox server"
+                        )
+                        print(f"Tenant: {cls.tenant_name}")
+                        print(f"API URL: {cls.api_url}")
+                    else:
+                        raise unittest.SkipTest(
+                            "Failed to get credentials from sandbox server"
+                        )
+                else:
+                    raise unittest.SkipTest("Failed to connect to sandbox server")
+            except Exception as e:
+                raise unittest.SkipTest(f"Failed to get credentials: {str(e)}")
+
+        # Initialize API client
+        cls.api = DatabunkerproAPI(cls.api_url, cls.api_token, cls.tenant_name)
+
+        # Test connection
+        try:
+            result = cls.api.get_system_stats()
+            if not (isinstance(result, dict) and result.get("status") == "ok"):
+                raise unittest.SkipTest("Failed to connect to DatabunkerPro server")
+        except Exception as e:
+            raise unittest.SkipTest(
+                f"Failed to connect to DatabunkerPro server: {str(e)}"
+            )
+
+    def test_create_user(self):
+        """Test user creation."""
+        user_data = {
+            "email": f"test{random.randint(1000, 999999)}@example.com",
+            "name": f"Test User {random.randint(1000, 999999)}",
+            "phone": str(random.randint(1000, 999999)),
+        }
+        result = self.api.create_user(user_data)
+        self.assertIsInstance(result, dict)
+        self.assertEqual(result.get("status"), "ok")
+        self.assertIn("token", result)
+        return user_data["email"]
+
+    def test_get_user(self):
+        """Test user retrieval."""
+        email = self.test_create_user()
+        result = self.api.get_user("email", email)
+        self.assertIsInstance(result, dict)
+        self.assertEqual(result.get("status"), "ok")
+        self.assertIn("profile", result)
+        return email
+
+    def test_update_user(self):
+        """Test user update."""
+        email = self.test_get_user()
+        update_data = {"name": "Updated Test User", "phone": "+9876543210"}
+        result = self.api.update_user("email", email, update_data)
+        self.assertIsInstance(result, dict)
+        self.assertEqual(result.get("status"), "ok")
+
+        # Verify the update
+        updated_user = self.api.get_user("email", email)
+        self.assertEqual(updated_user["profile"]["name"], update_data["name"])
+        self.assertEqual(updated_user["profile"]["phone"], update_data["phone"])
+
+    def test_delete_user(self):
+        """Test user deletion."""
+        email = self.test_create_user()
+        result = self.api.delete_user("email", email)
+        self.assertIsInstance(result, dict)
+        self.assertEqual(result.get("status"), "ok")
+
+    def test_get_system_stats(self):
+        """Test getting system statistics."""
+        result = self.api.get_system_stats()
+        self.assertIsInstance(result, dict)
+        self.assertEqual(result.get("status"), "ok")
+        self.assertIn("stats", result)
+
+
+if __name__ == "__main__":
+    unittest.main()