xdk 0.1.0__tar.gz

xdk-0.1.0/.gitignore

@@ -0,0 +1,4 @@
+/target
+.venv/
+test_output/
+__pycache__/

xdk-0.1.0/PKG-INFO

@@ -0,0 +1,80 @@
+Metadata-Version: 2.4
+Name: xdk
+Version: 0.1.0
+Summary: Python SDK for the X API
+Project-URL: Homepage, https://github.com/xdk/xdk-python
+Project-URL: Repository, https://github.com/xdk/xdk-python
+Author-email: XDK Team <info@xdk.com>
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.8
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: requests-oauthlib>=1.3.0
+Requires-Dist: requests>=2.25.0
+Provides-Extra: dev
+Requires-Dist: black; extra == 'dev'
+Requires-Dist: pytest; extra == 'dev'
+Requires-Dist: pytest-cov; extra == 'dev'
+Requires-Dist: ruff; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# XDK Python SDK
+
+A Python SDK for the X API.
+
+## Installation
+
+```bash
+uv add xdk
+```
+
+Or with pip:
+```bash
+pip install xdk
+```
+
+## Usage
+
+```python
+from xdk import Client
+
+# Initialize the client
+client = Client(
+    api_key="your_api_key",
+    api_secret="your_api_secret",
+    access_token="your_access_token",
+    access_token_secret="your_access_token_secret"
+)
+
+# Use the client to interact with the X API
+# For example, to get tweets:
+tweets = client.tweets.get_tweets(ids=["1234567890"])
+
+# To search for tweets:
+search_results = client.tweets.tweets_recent_search(query="python")
+
+# To post a tweet:
+tweet = client.tweets.post_tweets(tweet_data={"text": "Hello, world!"})
+```
+
+## Features
+
+- Full support for the X API v2
+- Simple and intuitive interface
+- Comprehensive documentation
+- Type hints for better IDE support
+
+## Documentation
+
+For more information, see the [documentation](https://xdk.com/docs/python).
+
+## License
+
+This project is licensed under the MIT License - see the LICENSE file for details. 

xdk-0.1.0/README.md

@@ -0,0 +1,53 @@
+# XDK Python SDK
+
+A Python SDK for the X API.
+
+## Installation
+
+```bash
+uv add xdk
+```
+
+Or with pip:
+```bash
+pip install xdk
+```
+
+## Usage
+
+```python
+from xdk import Client
+
+# Initialize the client
+client = Client(
+    api_key="your_api_key",
+    api_secret="your_api_secret",
+    access_token="your_access_token",
+    access_token_secret="your_access_token_secret"
+)
+
+# Use the client to interact with the X API
+# For example, to get tweets:
+tweets = client.tweets.get_tweets(ids=["1234567890"])
+
+# To search for tweets:
+search_results = client.tweets.tweets_recent_search(query="python")
+
+# To post a tweet:
+tweet = client.tweets.post_tweets(tweet_data={"text": "Hello, world!"})
+```
+
+## Features
+
+- Full support for the X API v2
+- Simple and intuitive interface
+- Comprehensive documentation
+- Type hints for better IDE support
+
+## Documentation
+
+For more information, see the [documentation](https://xdk.com/docs/python).
+
+## License
+
+This project is licensed under the MIT License - see the LICENSE file for details. 

xdk-0.1.0/pyproject.toml

@@ -0,0 +1,73 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "xdk"
+version = "0.1.0"
+description = "Python SDK for the X API"
+authors = [
+    {name = "XDK Team", email = "info@xdk.com"},
+]
+readme = "README.md"
+requires-python = ">=3.8"
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+]
+dependencies = [
+    "requests>=2.25.0",
+    "requests-oauthlib>=1.3.0",
+    "pydantic>=2.0.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/xdk/xdk-python"
+Repository = "https://github.com/xdk/xdk-python"
+
+[project.optional-dependencies]
+dev = [
+    "black",
+    "pytest",
+    "pytest-cov",
+    "ruff",
+]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+python_files = ["test_*.py"]
+python_classes = ["Test*"]
+python_functions = ["test_*"]
+
+[tool.black]
+line-length = 88
+target-version = ['py38']
+
+[tool.ruff]
+target-version = "py38"
+line-length = 88
+select = [
+    "E",  # pycodestyle errors
+    "W",  # pycodestyle warnings
+    "F",  # pyflakes
+    "I",  # isort
+    "B",  # flake8-bugbear
+    "C4", # flake8-comprehensions
+    "UP", # pyupgrade
+]
+ignore = []
+
+[tool.ruff.per-file-ignores]
+"__init__.py" = ["F401"]
+
+[dependency-groups]
+dev = [
+    "pytest>=8.3.5",
+]

xdk-0.1.0/tests/aaasubscriptions/test_contracts.py

@@ -0,0 +1,131 @@
+"""
+Auto-generated contract tests for AAASubscriptions client.
+
+This module contains tests that validate the request/response contracts
+of the AAASubscriptions client against the OpenAPI specification.
+
+Generated automatically - do not edit manually.
+"""
+
+import pytest
+import json
+from unittest.mock import Mock, patch
+from xdk.aaasubscriptions.client import AAASubscriptionsClient
+from xdk import Client
+
+
+class TestAAASubscriptionsContracts:
+    """Test the API contracts of AAASubscriptionsClient."""
+
+
+    def setup_class(self):
+        """Set up test fixtures."""
+        self.client = Client(base_url="https://api.example.com")
+        self.aaasubscriptions_client = getattr(self.client, "aaasubscriptions")
+
+
+    def test_create_account_activity_subscription_request_structure(self):
+        """Test create_account_activity_subscription request structure."""
+        # Mock the session to capture request details
+        with patch.object(self.client, "session") as mock_session:
+            mock_response = Mock()
+            mock_response.status_code = 200
+            mock_response.json.return_value = {
+                "data": None,
+            }
+            mock_response.raise_for_status.return_value = None
+            mock_session.post.return_value = mock_response
+            # Prepare test parameters
+            kwargs = {}
+            # Add required parameters
+            kwargs["webhook_id"] = "test_value"
+            # Add request body if required
+            # Import and create proper request model instance
+            from xdk.aaasubscriptions.models import (
+                CreateAccountActivitySubscriptionRequest,
+            )
+            # Create instance with minimal valid data (empty instance should work for most cases)
+            kwargs["body"] = CreateAccountActivitySubscriptionRequest()
+            # Call the method
+            try:
+                method = getattr(
+                    self.aaasubscriptions_client, "create_account_activity_subscription"
+                )
+                result = method(**kwargs)
+                # Verify the request was made
+                mock_session.post.assert_called_once()
+                # Verify request structure
+                call_args = mock_session.post.call_args
+                # Check URL structure
+                called_url = (
+                    call_args[0][0] if call_args[0] else call_args[1].get("url", "")
+                )
+                expected_path = (
+                    "/2/account_activity/webhooks/{webhook_id}/subscriptions/all"
+                )
+                assert expected_path.replace("{", "").replace(
+                    "}", ""
+                ) in called_url or any(
+                    param in called_url for param in ["test_", "42"]
+                ), f"URL should contain path template elements: {called_url}"
+                # Verify response structure
+                assert result is not None, "Method should return a result"
+            except Exception as e:
+                pytest.fail(
+                    f"Contract test failed for create_account_activity_subscription: {e}"
+                )
+
+
+    def test_create_account_activity_subscription_required_parameters(self):
+        """Test that create_account_activity_subscription handles parameters correctly."""
+        method = getattr(
+            self.aaasubscriptions_client, "create_account_activity_subscription"
+        )
+        # Test with missing required parameters - mock the request to avoid network calls
+        with patch.object(self.client, "session") as mock_session:
+            # Mock a 400 response (typical for missing required parameters)
+            mock_response = Mock()
+            mock_response.status_code = 400
+            mock_response.json.return_value = {"error": "Missing required parameters"}
+            mock_response.raise_for_status.side_effect = Exception("Bad Request")
+            mock_session.post.return_value = mock_response
+            # Call without required parameters should either raise locally or via server response
+            with pytest.raises((TypeError, ValueError, Exception)):
+                method()
+
+
+    def test_create_account_activity_subscription_response_structure(self):
+        """Test create_account_activity_subscription response structure validation."""
+        with patch.object(self.client, "session") as mock_session:
+            # Create mock response with expected structure
+            mock_response_data = {
+                "data": None,
+            }
+            mock_response = Mock()
+            mock_response.status_code = 200
+            mock_response.json.return_value = mock_response_data
+            mock_response.raise_for_status.return_value = None
+            mock_session.post.return_value = mock_response
+            # Prepare minimal valid parameters
+            kwargs = {}
+            kwargs["webhook_id"] = "test"
+            # Add request body if required
+            # Import and create proper request model instance
+            from xdk.aaasubscriptions.models import (
+                CreateAccountActivitySubscriptionRequest,
+            )
+            # Create instance with minimal valid data (empty instance should work for most cases)
+            kwargs["body"] = CreateAccountActivitySubscriptionRequest()
+            # Call method and verify response structure
+            method = getattr(
+                self.aaasubscriptions_client, "create_account_activity_subscription"
+            )
+            result = method(**kwargs)
+            # Verify response object has expected attributes
+            # Optional field - just check it doesn't cause errors if accessed
+            try:
+                getattr(result, "data", None)
+            except Exception as e:
+                pytest.fail(
+                    f"Accessing optional field 'data' should not cause errors: {e}"
+                )

xdk-0.1.0/tests/aaasubscriptions/test_generic.py

@@ -0,0 +1,125 @@
+"""
+Auto-generated generic tests for AAASubscriptions client.
+
+This module contains general tests that validate the overall client
+functionality, imports, and error handling that don't need to be
+repeated for each operation.
+
+Generated automatically - do not edit manually.
+"""
+
+import pytest
+import inspect
+from unittest.mock import Mock, patch
+from xdk.aaasubscriptions.client import AAASubscriptionsClient
+from xdk import Client
+
+
+class TestAAASubscriptionsGeneric:
+    """Generic tests for AAASubscriptionsClient."""
+
+
+    def setup_class(self):
+        """Set up test fixtures."""
+        self.client = Client(base_url="https://api.example.com")
+        self.aaasubscriptions_client = getattr(self.client, "aaasubscriptions")
+
+
+    def test_client_exists(self):
+        """Test that AAASubscriptionsClient class exists and is importable."""
+        assert AAASubscriptionsClient is not None
+        assert hasattr(AAASubscriptionsClient, "__name__")
+        assert AAASubscriptionsClient.__name__ == "AAASubscriptionsClient"
+
+
+    def test_client_initialization(self):
+        """Test that AAASubscriptionsClient can be initialized properly."""
+        assert self.aaasubscriptions_client is not None
+        assert isinstance(self.aaasubscriptions_client, AAASubscriptionsClient)
+
+
+    def test_imports_work(self):
+        """Test that all expected imports work correctly."""
+        expected_imports = ["typing", "requests", "pydantic"]
+        for import_name in expected_imports:
+            try:
+                __import__(import_name)
+            except ImportError as e:
+                pytest.fail(f"Expected import '{import_name}' failed: {e}")
+
+
+    def test_error_responses_handling(self):
+        """Test that error responses are handled correctly across all methods."""
+        with patch.object(self.client, "session") as mock_session:
+            # Test 404 response
+            mock_response = Mock()
+            mock_response.status_code = 404
+            mock_response.raise_for_status.side_effect = Exception("Not Found")
+            mock_session.get.return_value = mock_response
+            mock_session.post.return_value = mock_response
+            mock_session.put.return_value = mock_response
+            mock_session.delete.return_value = mock_response
+            # Get first available method for testing error handling
+            client_methods = [
+                name
+                for name in dir(AAASubscriptionsClient)
+                if not name.startswith("_")
+                and callable(getattr(AAASubscriptionsClient, name))
+            ]
+            if client_methods:
+                method_name = client_methods[0]
+                method = getattr(self.aaasubscriptions_client, method_name)
+                # Try calling the method and expect an exception
+                with pytest.raises(Exception):
+                    try:
+                        # Try with no args first
+                        method()
+                    except TypeError:
+                        # If it needs args, try with basic test args
+                        try:
+                            method("test_id")
+                        except TypeError:
+                            # If it needs more specific args, try with kwargs
+                            method(id="test_id", query="test")
+
+
+    def test_client_has_expected_base_functionality(self):
+        """Test that the client has expected base functionality."""
+        # Should be able to access the client through main Client
+        assert hasattr(self.client, "aaasubscriptions")
+        # Client should have standard Python object features
+        assert hasattr(self.aaasubscriptions_client, "__class__")
+        assert hasattr(self.aaasubscriptions_client, "__dict__")
+        # Should have at least one public method
+        public_methods = [
+            name
+            for name in dir(self.aaasubscriptions_client)
+            if not name.startswith("_")
+            and callable(getattr(self.aaasubscriptions_client, name))
+        ]
+        assert (
+            len(public_methods) > 0
+        ), f"AAASubscriptionsClient should have at least one public method"
+
+
+    def test_client_method_signatures_are_valid(self):
+        """Test that all client methods have valid Python signatures."""
+        public_methods = [
+            name
+            for name in dir(AAASubscriptionsClient)
+            if not name.startswith("_")
+            and callable(getattr(AAASubscriptionsClient, name))
+        ]
+        for method_name in public_methods:
+            method = getattr(AAASubscriptionsClient, method_name)
+            # Should be able to get signature without error
+            try:
+                sig = inspect.signature(method)
+                params = list(sig.parameters.keys())
+                # Should have 'self' as first parameter (if it's an instance method)
+                if params:
+                    assert (
+                        params[0] == "self"
+                    ), f"Method {method_name} should have 'self' as first parameter"
+            except (ValueError, TypeError) as e:
+                pytest.fail(f"Method {method_name} has invalid signature: {e}")

xdk-0.1.0/tests/aaasubscriptions/test_structure.py

@@ -0,0 +1,88 @@
+"""
+Auto-generated structural tests for AAASubscriptions client.
+
+This module contains tests that validate the structure and API surface
+of the AAASubscriptions client. These tests ensure that all expected methods
+exist and have the correct signatures.
+
+Generated automatically - do not edit manually.
+"""
+
+import pytest
+import inspect
+from typing import get_type_hints
+from xdk.aaasubscriptions.client import AAASubscriptionsClient
+from xdk import Client
+
+
+class TestAAASubscriptionsStructure:
+    """Test the structure of AAASubscriptionsClient."""
+
+
+    def setup_class(self):
+        """Set up test fixtures."""
+        self.client = Client(base_url="https://api.example.com")
+        self.aaasubscriptions_client = getattr(self.client, "aaasubscriptions")
+
+
+    def test_create_account_activity_subscription_exists(self):
+        """Test that create_account_activity_subscription method exists with correct signature."""
+        # Check method exists
+        method = getattr(
+            AAASubscriptionsClient, "create_account_activity_subscription", None
+        )
+        assert (
+            method is not None
+        ), f"Method create_account_activity_subscription does not exist on AAASubscriptionsClient"
+        # Check method is callable
+        assert callable(method), f"create_account_activity_subscription is not callable"
+        # Check method signature
+        sig = inspect.signature(method)
+        params = list(sig.parameters.keys())
+        # Should have 'self' as first parameter
+        assert (
+            len(params) >= 1
+        ), f"create_account_activity_subscription should have at least 'self' parameter"
+        assert (
+            params[0] == "self"
+        ), f"First parameter should be 'self', got '{params[0]}'"
+        # Check required parameters exist (excluding 'self')
+        required_params = [
+            "webhook_id",
+        ]
+        for required_param in required_params:
+            assert (
+                required_param in params
+            ), f"Required parameter '{required_param}' missing from create_account_activity_subscription"
+        # Check optional parameters have defaults (excluding 'self')
+        optional_params = []
+        for optional_param in optional_params:
+            if optional_param in params:
+                param_obj = sig.parameters[optional_param]
+                assert (
+                    param_obj.default is not inspect.Parameter.empty
+                ), f"Optional parameter '{optional_param}' should have a default value"
+
+
+    def test_create_account_activity_subscription_return_annotation(self):
+        """Test that create_account_activity_subscription has proper return type annotation."""
+        method = getattr(AAASubscriptionsClient, "create_account_activity_subscription")
+        sig = inspect.signature(method)
+        # Check return annotation exists
+        assert (
+            sig.return_annotation is not inspect.Signature.empty
+        ), f"Method create_account_activity_subscription should have return type annotation"
+
+
+    def test_all_expected_methods_exist(self):
+        """Test that all expected methods exist on the client."""
+        expected_methods = [
+            "create_account_activity_subscription",
+        ]
+        for expected_method in expected_methods:
+            assert hasattr(
+                AAASubscriptionsClient, expected_method
+            ), f"Expected method '{expected_method}' not found on AAASubscriptionsClient"
+            assert callable(
+                getattr(AAASubscriptionsClient, expected_method)
+            ), f"'{expected_method}' exists but is not callable"