chore: update SDK to v0.5.0

Author: github-actions[bot]

conf.py

@@ -21,8 +21,8 @@
 project = "X API SDK"
 copyright = "2024, X Developer Platform"
 author = "X Developer Platform"
-release = "0.4.6"
-version = "0.4.6"
+release = "0.5.0"
+version = "0.5.0"
 
 # -- General configuration ----------------------------------------------------
 

pyproject.toml

@@ -14,7 +14,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "xdk"
-version = "0.4.6"
+version = "0.5.0"
 description = "Python SDK for the X API"
 authors = [
     {name = "X Developer Platform", email = "[email protected]"},

scripts/process-for-mintlify.py

@@ -24,7 +24,22 @@ class TestAccountActivityGeneric:
 
     def setup_class(self):
         """Set up test fixtures."""
-        self.client = Client(base_url="https://api.example.com")
+        # Provide all authentication types for comprehensive test coverage
+        # Tests mock the session, so actual HTTP requests won't be made
+        from xdk.oauth1_auth import OAuth1
+        oauth1 = OAuth1(
+            api_key="test_api_key",
+            api_secret="test_api_secret",
+            callback="http://localhost:8080/callback",
+            access_token="test_access_token",
+            access_token_secret="test_access_token_secret",
+        )
+        self.client = Client(
+            base_url="https://api.example.com",
+            bearer_token="test_bearer_token",
+            access_token="test_access_token",
+            auth=oauth1,
+        )
         self.account_activity_client = getattr(self.client, "account_activity")
 
 

tests/account_activity/test_contracts.py

@@ -24,7 +24,22 @@ class TestActivityGeneric:
 
     def setup_class(self):
         """Set up test fixtures."""
-        self.client = Client(base_url="https://api.example.com")
+        # Provide all authentication types for comprehensive test coverage
+        # Tests mock the session, so actual HTTP requests won't be made
+        from xdk.oauth1_auth import OAuth1
+        oauth1 = OAuth1(
+            api_key="test_api_key",
+            api_secret="test_api_secret",
+            callback="http://localhost:8080/callback",
+            access_token="test_access_token",
+            access_token_secret="test_access_token_secret",
+        )
+        self.client = Client(
+            base_url="https://api.example.com",
+            bearer_token="test_bearer_token",
+            access_token="test_access_token",
+            auth=oauth1,
+        )
         self.activity_client = getattr(self.client, "activity")
 
 

tests/account_activity/test_generic.py

@@ -24,7 +24,22 @@ class TestActivityStructure:
 
     def setup_class(self):
         """Set up test fixtures."""
-        self.client = Client(base_url="https://api.example.com")
+        # Provide all authentication types for comprehensive test coverage
+        # Tests mock the session, so actual HTTP requests won't be made
+        from xdk.oauth1_auth import OAuth1
+        oauth1 = OAuth1(
+            api_key="test_api_key",
+            api_secret="test_api_secret",
+            callback="http://localhost:8080/callback",
+            access_token="test_access_token",
+            access_token_secret="test_access_token_secret",
+        )
+        self.client = Client(
+            base_url="https://api.example.com",
+            bearer_token="test_bearer_token",
+            access_token="test_access_token",
+            auth=oauth1,
+        )
         self.activity_client = getattr(self.client, "activity")
 
 
@@ -118,51 +133,6 @@ def test_create_subscription_return_annotation(self):
         ), f"Method create_subscription should have return type annotation"
 
 
-    def test_stream_exists(self):
-        """Test that stream method exists with correct signature."""
-        # Check method exists
-        method = getattr(ActivityClient, "stream", None)
-        assert method is not None, f"Method stream does not exist on ActivityClient"
-        # Check method is callable
-        assert callable(method), f"stream 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"stream 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 = []
-        for required_param in required_params:
-            assert (
-                required_param in params
-            ), f"Required parameter '{required_param}' missing from stream"
-        # Check optional parameters have defaults (excluding 'self')
-        optional_params = [
-            "backfill_minutes",
-            "start_time",
-            "end_time",
-        ]
-        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_stream_return_annotation(self):
-        """Test that stream has proper return type annotation."""
-        method = getattr(ActivityClient, "stream")
-        sig = inspect.signature(method)
-        # Check return annotation exists
-        assert (
-            sig.return_annotation is not inspect.Signature.empty
-        ), f"Method stream should have return type annotation"
-
-
     def test_update_subscription_exists(self):
         """Test that update_subscription method exists with correct signature."""
         # Check method exists
@@ -257,14 +227,59 @@ def test_delete_subscription_return_annotation(self):
         ), f"Method delete_subscription should have return type annotation"
 
 
+    def test_stream_exists(self):
+        """Test that stream method exists with correct signature."""
+        # Check method exists
+        method = getattr(ActivityClient, "stream", None)
+        assert method is not None, f"Method stream does not exist on ActivityClient"
+        # Check method is callable
+        assert callable(method), f"stream 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"stream 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 = []
+        for required_param in required_params:
+            assert (
+                required_param in params
+            ), f"Required parameter '{required_param}' missing from stream"
+        # Check optional parameters have defaults (excluding 'self')
+        optional_params = [
+            "backfill_minutes",
+            "start_time",
+            "end_time",
+        ]
+        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_stream_return_annotation(self):
+        """Test that stream has proper return type annotation."""
+        method = getattr(ActivityClient, "stream")
+        sig = inspect.signature(method)
+        # Check return annotation exists
+        assert (
+            sig.return_annotation is not inspect.Signature.empty
+        ), f"Method stream should have return type annotation"
+
+
     def test_all_expected_methods_exist(self):
         """Test that all expected methods exist on the client."""
         expected_methods = [
             "get_subscriptions",
             "create_subscription",
-            "stream",
             "update_subscription",
             "delete_subscription",
+            "stream",
         ]
         for expected_method in expected_methods:
             assert hasattr(

tests/account_activity/test_structure.py

@@ -24,12 +24,27 @@ class TestCommunitiesContracts:
 
     def setup_class(self):
         """Set up test fixtures."""
-        self.client = Client(base_url="https://api.example.com")
+        # Provide all authentication types for comprehensive test coverage
+        # Tests mock the session, so actual HTTP requests won't be made
+        from xdk.oauth1_auth import OAuth1
+        oauth1 = OAuth1(
+            api_key="test_api_key",
+            api_secret="test_api_secret",
+            callback="http://localhost:8080/callback",
+            access_token="test_access_token",
+            access_token_secret="test_access_token_secret",
+        )
+        self.client = Client(
+            base_url="https://api.example.com",
+            bearer_token="test_bearer_token",
+            access_token="test_access_token",
+            auth=oauth1,
+        )
         self.communities_client = getattr(self.client, "communities")
 
 
-    def test_search_request_structure(self):
-        """Test search request structure."""
+    def test_get_by_id_request_structure(self):
+        """Test get_by_id request structure."""
         # Mock the session to capture request details
         with patch.object(self.client, "session") as mock_session:
             mock_response = Mock()
@@ -42,11 +57,11 @@ def test_search_request_structure(self):
             # Prepare test parameters
             kwargs = {}
             # Add required parameters
-            kwargs["query"] = "test_query"
+            kwargs["id"] = "test_value"
             # Add request body if required
             # Call the method
             try:
-                method = getattr(self.communities_client, "search")
+                method = getattr(self.communities_client, "get_by_id")
                 # Check if this might be a streaming operation by inspecting return type
                 import types
                 import inspect
@@ -109,7 +124,7 @@ def test_search_request_structure(self):
                 called_url = (
                     call_args[0][0] if call_args[0] else call_args[1].get("url", "")
                 )
-                expected_path = "/2/communities/search"
+                expected_path = "/2/communities/{id}"
                 assert expected_path.replace("{", "").replace(
                     "}", ""
                 ) in called_url or any(
@@ -125,12 +140,12 @@ def test_search_request_structure(self):
                     # For regular operations, verify we got a result
                     assert result is not None, "Method should return a result"
             except Exception as e:
-                pytest.fail(f"Contract test failed for search: {e}")
+                pytest.fail(f"Contract test failed for get_by_id: {e}")
 
 
-    def test_search_required_parameters(self):
-        """Test that search handles parameters correctly."""
-        method = getattr(self.communities_client, "search")
+    def test_get_by_id_required_parameters(self):
+        """Test that get_by_id handles parameters correctly."""
+        method = getattr(self.communities_client, "get_by_id")
         # 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)
@@ -150,8 +165,8 @@ def test_search_required_parameters(self):
                     next(result)
 
 
-    def test_search_response_structure(self):
-        """Test search response structure validation."""
+    def test_get_by_id_response_structure(self):
+        """Test get_by_id response structure validation."""
         with patch.object(self.client, "session") as mock_session:
             # Create mock response with expected structure
             mock_response_data = {
@@ -164,10 +179,10 @@ def test_search_response_structure(self):
             mock_session.get.return_value = mock_response
             # Prepare minimal valid parameters
             kwargs = {}
-            kwargs["query"] = "test_value"
+            kwargs["id"] = "test"
             # Add request body if required
             # Call method and verify response structure
-            method = getattr(self.communities_client, "search")
+            method = getattr(self.communities_client, "get_by_id")
             result = method(**kwargs)
             # Verify response object has expected attributes
             # Optional field - just check it doesn't cause errors if accessed
@@ -179,8 +194,8 @@ def test_search_response_structure(self):
                 )
 
 
-    def test_get_by_id_request_structure(self):
-        """Test get_by_id request structure."""
+    def test_search_request_structure(self):
+        """Test search request structure."""
         # Mock the session to capture request details
         with patch.object(self.client, "session") as mock_session:
             mock_response = Mock()
@@ -193,11 +208,11 @@ def test_get_by_id_request_structure(self):
             # Prepare test parameters
             kwargs = {}
             # Add required parameters
-            kwargs["id"] = "test_value"
+            kwargs["query"] = "test_query"
             # Add request body if required
             # Call the method
             try:
-                method = getattr(self.communities_client, "get_by_id")
+                method = getattr(self.communities_client, "search")
                 # Check if this might be a streaming operation by inspecting return type
                 import types
                 import inspect
@@ -260,7 +275,7 @@ def test_get_by_id_request_structure(self):
                 called_url = (
                     call_args[0][0] if call_args[0] else call_args[1].get("url", "")
                 )
-                expected_path = "/2/communities/{id}"
+                expected_path = "/2/communities/search"
                 assert expected_path.replace("{", "").replace(
                     "}", ""
                 ) in called_url or any(
@@ -276,12 +291,12 @@ def test_get_by_id_request_structure(self):
                     # For regular operations, verify we got a result
                     assert result is not None, "Method should return a result"
             except Exception as e:
-                pytest.fail(f"Contract test failed for get_by_id: {e}")
+                pytest.fail(f"Contract test failed for search: {e}")
 
 
-    def test_get_by_id_required_parameters(self):
-        """Test that get_by_id handles parameters correctly."""
-        method = getattr(self.communities_client, "get_by_id")
+    def test_search_required_parameters(self):
+        """Test that search handles parameters correctly."""
+        method = getattr(self.communities_client, "search")
         # 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)
@@ -301,8 +316,8 @@ def test_get_by_id_required_parameters(self):
                     next(result)
 
 
-    def test_get_by_id_response_structure(self):
-        """Test get_by_id response structure validation."""
+    def test_search_response_structure(self):
+        """Test search response structure validation."""
         with patch.object(self.client, "session") as mock_session:
             # Create mock response with expected structure
             mock_response_data = {
@@ -315,10 +330,10 @@ def test_get_by_id_response_structure(self):
             mock_session.get.return_value = mock_response
             # Prepare minimal valid parameters
             kwargs = {}
-            kwargs["id"] = "test"
+            kwargs["query"] = "test_value"
             # Add request body if required
             # Call method and verify response structure
-            method = getattr(self.communities_client, "get_by_id")
+            method = getattr(self.communities_client, "search")
             result = method(**kwargs)
             # Verify response object has expected attributes
             # Optional field - just check it doesn't cause errors if accessed