chore: update SDK to v0.2.5-beta

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.2.4-beta"
-version = "0.2.4-beta"
+release = "0.2.5-beta"
+version = "0.2.5-beta"
 
 # -- General configuration ----------------------------------------------------
 

pyproject.toml

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

scripts/process-for-mintlify.py

@@ -24,9 +24,9 @@
 MINTLIFY_CONFIG = {
     "outputDir": "mintlify-docs",
     "baseUrl": "https://docs.x.com",
-    "title": "X API SDK v0.2.4-beta",
+    "title": "X API SDK v0.2.5-beta",
     "description": "Python SDK for the X API with comprehensive pagination, authentication, and streaming support.",
-    "version": "0.2.4-beta",
+    "version": "0.2.5-beta",
     "githubUrl": "https://github.com/xdevplatform/xdk",
 }
 

tests/account_activity/test_contracts.py

@@ -28,33 +28,35 @@ def setup_class(self):
         self.account_activity_client = getattr(self.client, "account_activity")
 
 
-    def test_get_subscriptions_exists(self):
-        """Test that get_subscriptions method exists with correct signature."""
+    def test_create_replay_job_exists(self):
+        """Test that create_replay_job method exists with correct signature."""
         # Check method exists
-        method = getattr(AccountActivityClient, "get_subscriptions", None)
+        method = getattr(AccountActivityClient, "create_replay_job", None)
         assert (
             method is not None
-        ), f"Method get_subscriptions does not exist on AccountActivityClient"
+        ), f"Method create_replay_job does not exist on AccountActivityClient"
         # Check method is callable
-        assert callable(method), f"get_subscriptions is not callable"
+        assert callable(method), f"create_replay_job 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"get_subscriptions should have at least 'self' parameter"
+        ), f"create_replay_job 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",
+            "from_date",
+            "to_date",
         ]
         for required_param in required_params:
             assert (
                 required_param in params
-            ), f"Required parameter '{required_param}' missing from get_subscriptions"
+            ), f"Required parameter '{required_param}' missing from create_replay_job"
         # Check optional parameters have defaults (excluding 'self')
         optional_params = []
         for optional_param in optional_params:
@@ -65,45 +67,43 @@ def test_get_subscriptions_exists(self):
                 ), f"Optional parameter '{optional_param}' should have a default value"
 
 
-    def test_get_subscriptions_return_annotation(self):
-        """Test that get_subscriptions has proper return type annotation."""
-        method = getattr(AccountActivityClient, "get_subscriptions")
+    def test_create_replay_job_return_annotation(self):
+        """Test that create_replay_job has proper return type annotation."""
+        method = getattr(AccountActivityClient, "create_replay_job")
         sig = inspect.signature(method)
         # Check return annotation exists
         assert (
             sig.return_annotation is not inspect.Signature.empty
-        ), f"Method get_subscriptions should have return type annotation"
+        ), f"Method create_replay_job should have return type annotation"
 
 
-    def test_create_replay_job_exists(self):
-        """Test that create_replay_job method exists with correct signature."""
+    def test_validate_subscription_exists(self):
+        """Test that validate_subscription method exists with correct signature."""
         # Check method exists
-        method = getattr(AccountActivityClient, "create_replay_job", None)
+        method = getattr(AccountActivityClient, "validate_subscription", None)
         assert (
             method is not None
-        ), f"Method create_replay_job does not exist on AccountActivityClient"
+        ), f"Method validate_subscription does not exist on AccountActivityClient"
         # Check method is callable
-        assert callable(method), f"create_replay_job is not callable"
+        assert callable(method), f"validate_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_replay_job should have at least 'self' parameter"
+        ), f"validate_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",
-            "from_date",
-            "to_date",
         ]
         for required_param in required_params:
             assert (
                 required_param in params
-            ), f"Required parameter '{required_param}' missing from create_replay_job"
+            ), f"Required parameter '{required_param}' missing from validate_subscription"
         # Check optional parameters have defaults (excluding 'self')
         optional_params = []
         for optional_param in optional_params:
@@ -114,32 +114,32 @@ def test_create_replay_job_exists(self):
                 ), f"Optional parameter '{optional_param}' should have a default value"
 
 
-    def test_create_replay_job_return_annotation(self):
-        """Test that create_replay_job has proper return type annotation."""
-        method = getattr(AccountActivityClient, "create_replay_job")
+    def test_validate_subscription_return_annotation(self):
+        """Test that validate_subscription has proper return type annotation."""
+        method = getattr(AccountActivityClient, "validate_subscription")
         sig = inspect.signature(method)
         # Check return annotation exists
         assert (
             sig.return_annotation is not inspect.Signature.empty
-        ), f"Method create_replay_job should have return type annotation"
+        ), f"Method validate_subscription should have return type annotation"
 
 
-    def test_validate_subscription_exists(self):
-        """Test that validate_subscription method exists with correct signature."""
+    def test_create_subscription_exists(self):
+        """Test that create_subscription method exists with correct signature."""
         # Check method exists
-        method = getattr(AccountActivityClient, "validate_subscription", None)
+        method = getattr(AccountActivityClient, "create_subscription", None)
         assert (
             method is not None
-        ), f"Method validate_subscription does not exist on AccountActivityClient"
+        ), f"Method create_subscription does not exist on AccountActivityClient"
         # Check method is callable
-        assert callable(method), f"validate_subscription is not callable"
+        assert callable(method), f"create_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"validate_subscription should have at least 'self' parameter"
+        ), f"create_subscription should have at least 'self' parameter"
         assert (
             params[0] == "self"
         ), f"First parameter should be 'self', got '{params[0]}'"
@@ -150,7 +150,7 @@ def test_validate_subscription_exists(self):
         for required_param in required_params:
             assert (
                 required_param in params
-            ), f"Required parameter '{required_param}' missing from validate_subscription"
+            ), f"Required parameter '{required_param}' missing from create_subscription"
         # Check optional parameters have defaults (excluding 'self')
         optional_params = []
         for optional_param in optional_params:
@@ -161,43 +161,44 @@ def test_validate_subscription_exists(self):
                 ), f"Optional parameter '{optional_param}' should have a default value"
 
 
-    def test_validate_subscription_return_annotation(self):
-        """Test that validate_subscription has proper return type annotation."""
-        method = getattr(AccountActivityClient, "validate_subscription")
+    def test_create_subscription_return_annotation(self):
+        """Test that create_subscription has proper return type annotation."""
+        method = getattr(AccountActivityClient, "create_subscription")
         sig = inspect.signature(method)
         # Check return annotation exists
         assert (
             sig.return_annotation is not inspect.Signature.empty
-        ), f"Method validate_subscription should have return type annotation"
+        ), f"Method create_subscription should have return type annotation"
 
 
-    def test_create_subscription_exists(self):
-        """Test that create_subscription method exists with correct signature."""
+    def test_delete_subscription_exists(self):
+        """Test that delete_subscription method exists with correct signature."""
         # Check method exists
-        method = getattr(AccountActivityClient, "create_subscription", None)
+        method = getattr(AccountActivityClient, "delete_subscription", None)
         assert (
             method is not None
-        ), f"Method create_subscription does not exist on AccountActivityClient"
+        ), f"Method delete_subscription does not exist on AccountActivityClient"
         # Check method is callable
-        assert callable(method), f"create_subscription is not callable"
+        assert callable(method), f"delete_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_subscription should have at least 'self' parameter"
+        ), f"delete_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",
+            "user_id",
         ]
         for required_param in required_params:
             assert (
                 required_param in params
-            ), f"Required parameter '{required_param}' missing from create_subscription"
+            ), f"Required parameter '{required_param}' missing from delete_subscription"
         # Check optional parameters have defaults (excluding 'self')
         optional_params = []
         for optional_param in optional_params:
@@ -208,14 +209,14 @@ def test_create_subscription_exists(self):
                 ), f"Optional parameter '{optional_param}' should have a default value"
 
 
-    def test_create_subscription_return_annotation(self):
-        """Test that create_subscription has proper return type annotation."""
-        method = getattr(AccountActivityClient, "create_subscription")
+    def test_delete_subscription_return_annotation(self):
+        """Test that delete_subscription has proper return type annotation."""
+        method = getattr(AccountActivityClient, "delete_subscription")
         sig = inspect.signature(method)
         # Check return annotation exists
         assert (
             sig.return_annotation is not inspect.Signature.empty
-        ), f"Method create_subscription should have return type annotation"
+        ), f"Method delete_subscription should have return type annotation"
 
 
     def test_get_subscription_count_exists(self):
@@ -263,34 +264,33 @@ def test_get_subscription_count_return_annotation(self):
         ), f"Method get_subscription_count should have return type annotation"
 
 
-    def test_delete_subscription_exists(self):
-        """Test that delete_subscription method exists with correct signature."""
+    def test_get_subscriptions_exists(self):
+        """Test that get_subscriptions method exists with correct signature."""
         # Check method exists
-        method = getattr(AccountActivityClient, "delete_subscription", None)
+        method = getattr(AccountActivityClient, "get_subscriptions", None)
         assert (
             method is not None
-        ), f"Method delete_subscription does not exist on AccountActivityClient"
+        ), f"Method get_subscriptions does not exist on AccountActivityClient"
         # Check method is callable
-        assert callable(method), f"delete_subscription is not callable"
+        assert callable(method), f"get_subscriptions 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"delete_subscription should have at least 'self' parameter"
+        ), f"get_subscriptions 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",
-            "user_id",
         ]
         for required_param in required_params:
             assert (
                 required_param in params
-            ), f"Required parameter '{required_param}' missing from delete_subscription"
+            ), f"Required parameter '{required_param}' missing from get_subscriptions"
         # Check optional parameters have defaults (excluding 'self')
         optional_params = []
         for optional_param in optional_params:
@@ -301,25 +301,25 @@ def test_delete_subscription_exists(self):
                 ), f"Optional parameter '{optional_param}' should have a default value"
 
 
-    def test_delete_subscription_return_annotation(self):
-        """Test that delete_subscription has proper return type annotation."""
-        method = getattr(AccountActivityClient, "delete_subscription")
+    def test_get_subscriptions_return_annotation(self):
+        """Test that get_subscriptions has proper return type annotation."""
+        method = getattr(AccountActivityClient, "get_subscriptions")
         sig = inspect.signature(method)
         # Check return annotation exists
         assert (
             sig.return_annotation is not inspect.Signature.empty
-        ), f"Method delete_subscription should have return type annotation"
+        ), f"Method get_subscriptions 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_replay_job",
             "validate_subscription",
             "create_subscription",
-            "get_subscription_count",
             "delete_subscription",
+            "get_subscription_count",
+            "get_subscriptions",
         ]
         for expected_method in expected_methods:
             assert hasattr(