chore: update SDK to v0.4.1

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.0"
-version = "0.4.0"
+release = "0.4.1"
+version = "0.4.1"
 
 # -- General configuration ----------------------------------------------------
 

pyproject.toml

@@ -14,7 +14,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "xdk"
-version = "0.4.0"
+version = "0.4.1"
 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.4.0",
+    "title": "X API SDK v0.4.1",
     "description": "Python SDK for the X API with comprehensive pagination, authentication, and streaming support.",
-    "version": "0.4.0",
+    "version": "0.4.1",
     "githubUrl": "https://github.com/xdevplatform/xdk",
 }
 

tests/account_activity/test_contracts.py

@@ -28,6 +28,92 @@ def setup_class(self):
         self.community_notes_client = getattr(self.client, "community_notes")
 
 
+    def test_evaluate_exists(self):
+        """Test that evaluate method exists with correct signature."""
+        # Check method exists
+        method = getattr(CommunityNotesClient, "evaluate", None)
+        assert (
+            method is not None
+        ), f"Method evaluate does not exist on CommunityNotesClient"
+        # Check method is callable
+        assert callable(method), f"evaluate 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"evaluate 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 evaluate"
+        # 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_evaluate_return_annotation(self):
+        """Test that evaluate has proper return type annotation."""
+        method = getattr(CommunityNotesClient, "evaluate")
+        sig = inspect.signature(method)
+        # Check return annotation exists
+        assert (
+            sig.return_annotation is not inspect.Signature.empty
+        ), f"Method evaluate should have return type annotation"
+
+
+    def test_create_exists(self):
+        """Test that create method exists with correct signature."""
+        # Check method exists
+        method = getattr(CommunityNotesClient, "create", None)
+        assert (
+            method is not None
+        ), f"Method create does not exist on CommunityNotesClient"
+        # Check method is callable
+        assert callable(method), f"create 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 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 create"
+        # 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_return_annotation(self):
+        """Test that create has proper return type annotation."""
+        method = getattr(CommunityNotesClient, "create")
+        sig = inspect.signature(method)
+        # Check return annotation exists
+        assert (
+            sig.return_annotation is not inspect.Signature.empty
+        ), f"Method create should have return type annotation"
+
+
     def test_search_written_exists(self):
         """Test that search_written method exists with correct signature."""
         # Check method exists
@@ -172,49 +258,6 @@ def test_search_eligible_posts_pagination_params(self):
         ), f"Paginated method search_eligible_posts should have pagination parameters"
 
 
-    def test_evaluate_exists(self):
-        """Test that evaluate method exists with correct signature."""
-        # Check method exists
-        method = getattr(CommunityNotesClient, "evaluate", None)
-        assert (
-            method is not None
-        ), f"Method evaluate does not exist on CommunityNotesClient"
-        # Check method is callable
-        assert callable(method), f"evaluate 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"evaluate 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 evaluate"
-        # 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_evaluate_return_annotation(self):
-        """Test that evaluate has proper return type annotation."""
-        method = getattr(CommunityNotesClient, "evaluate")
-        sig = inspect.signature(method)
-        # Check return annotation exists
-        assert (
-            sig.return_annotation is not inspect.Signature.empty
-        ), f"Method evaluate should have return type annotation"
-
-
     def test_delete_exists(self):
         """Test that delete method exists with correct signature."""
         # Check method exists
@@ -260,57 +303,14 @@ def test_delete_return_annotation(self):
         ), f"Method delete should have return type annotation"
 
 
-    def test_create_exists(self):
-        """Test that create method exists with correct signature."""
-        # Check method exists
-        method = getattr(CommunityNotesClient, "create", None)
-        assert (
-            method is not None
-        ), f"Method create does not exist on CommunityNotesClient"
-        # Check method is callable
-        assert callable(method), f"create 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 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 create"
-        # 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_return_annotation(self):
-        """Test that create has proper return type annotation."""
-        method = getattr(CommunityNotesClient, "create")
-        sig = inspect.signature(method)
-        # Check return annotation exists
-        assert (
-            sig.return_annotation is not inspect.Signature.empty
-        ), f"Method create should have return type annotation"
-
-
     def test_all_expected_methods_exist(self):
         """Test that all expected methods exist on the client."""
         expected_methods = [
+            "evaluate",
+            "create",
             "search_written",
             "search_eligible_posts",
-            "evaluate",
             "delete",
-            "create",
         ]
         for expected_method in expected_methods:
             assert hasattr(