adaptsapi 0.1.7__tar.gz → 0.1.8__tar.gz

{adaptsapi-0.1.7/src/adaptsapi.egg-info → adaptsapi-0.1.8}/PKG-INFO

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: adaptsapi
-Version: 0.1.7
+Version: 0.1.8
 Summary: CLI to enqueue triggers via internal API Gateway → SNS
 Home-page: https://github.com/adaptsai/adaptsapi
 Author: adapts
 Author-email: "VerifyAI Inc." <dev@adapts.ai>
 License-Expression: LicenseRef-Proprietary
-Project-URL: Homepage, https://github.com/adaptsai/adaptsapi
-Project-URL: Source, https://github.com/adaptsai/adaptsapi
+Project-URL: Homepage, https://adapts.ai/
+Project-URL: Source, https://github.com/AdaptsAI/adapts_api_client
 Keywords: adapts,api,cli,sns
 Classifier: Programming Language :: Python :: 3
 Classifier: Operating System :: OS Independent

{adaptsapi-0.1.7 → adaptsapi-0.1.8}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "adaptsapi"
-version = "0.1.7"
+version = "0.1.8"
 description = "CLI to enqueue triggers via internal API Gateway → SNS"
 readme = { file = "README.md", content-type = "text/markdown" }
 
@@ -27,8 +27,8 @@ classifiers = [
 ]
 
 [project.urls]
-"Homepage"  = "https://github.com/adaptsai/adaptsapi"
-"Source"    = "https://github.com/adaptsai/adaptsapi"
+"Homepage"  = "https://adapts.ai/"
+"Source"    = "https://github.com/AdaptsAI/adapts_api_client"
 
 [project.scripts]
 adaptsapi = "adaptsapi.cli:main"
@@ -62,7 +62,7 @@ ensure_newline_before_comments = true
 skip = [".venv", "build", "dist", "*.egg-info"]
 
 [tool.mypy]
-python_version = "3.10"
+python_version = "0.1.8"
 warn_return_any = true
 warn_unused_configs = true
 disallow_untyped_defs = true

{adaptsapi-0.1.7 → adaptsapi-0.1.8}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name="adaptsapi",
-    version="0.1.7",
+    version="0.1.8",
     author="adapts",
     author_email="dev@adapts.ai",
     description="CLI to enqueue triggers via internal API Gateway → SNS",

{adaptsapi-0.1.7 → adaptsapi-0.1.8}/src/adaptsapi/cli.py

@@ -5,6 +5,7 @@ import json
 from adaptsapi.generate_docs import post
 from adaptsapi.config import load_token, load_default_endpoint
 
+
 def main():
     default_ep = load_default_endpoint()
     parser = argparse.ArgumentParser(prog="adaptsapi")
@@ -12,10 +13,13 @@ def main():
         "--endpoint",
         default=default_ep,
         required=(default_ep is None),
-        help="Full URL of the API endpoint (default from ./config.json)"
+        help="Full URL of the API endpoint (default from ./config.json)",
+    )
+    parser.add_argument(
+        "--payload-file",
+        type=argparse.FileType("r"),
+        help="Path to JSON payload file (overrides inline --data)",
     )
-    parser.add_argument("--payload-file", type=argparse.FileType('r'),
-                        help="Path to JSON payload file (overrides inline --data)")
     parser.add_argument("--data", help="Inline JSON payload string")
     parser.add_argument("--timeout", type=int, default=30)
     args = parser.parse_args()
@@ -36,5 +40,6 @@ def main():
         sys.exit(resp.status_code)
     print(resp.text)
 
+
 if __name__ == "__main__":
-    main()
+    main()

{adaptsapi-0.1.7 → adaptsapi-0.1.8}/src/adaptsapi/config.py

@@ -6,10 +6,13 @@ from pathlib import Path
 # Point at config.json in whatever directory you run the CLI from
 CONFIG_PATH = Path.cwd() / "config.json"
 
+
 class ConfigError(Exception):
     """Raised when no token can be found or loaded."""
+
     pass
 
+
 def load_token() -> str:
     # 1) ENV override
     token = os.getenv("ADAPTS_API_TOKEN")
@@ -35,6 +38,7 @@ def load_token() -> str:
     print(f"Saved token to {CONFIG_PATH}")
     return token
 
+
 def load_default_endpoint() -> str | None:
     """Return `endpoint` from ./config.json if present, else None."""
     if CONFIG_PATH.exists():
@@ -45,6 +49,7 @@ def load_default_endpoint() -> str | None:
             return None
     return None
 
+
 def _ensure_config_dir_and_write(obj: dict) -> None:
     """Helper to merge+write config.json in cwd."""
     # read existing if any
@@ -55,4 +60,4 @@ def _ensure_config_dir_and_write(obj: dict) -> None:
         except json.JSONDecodeError:
             existing = {}
     merged = {**existing, **obj}
-    CONFIG_PATH.write_text(json.dumps(merged, indent=2))
+    CONFIG_PATH.write_text(json.dumps(merged, indent=2))

{adaptsapi-0.1.7 → adaptsapi-0.1.8}/src/adaptsapi/generate_docs.py

@@ -3,19 +3,20 @@ import requests
 from typing import Dict, Any
 from datetime import date
 import uuid
+import os
 
 # regex for a very basic email validation
 _EMAIL_RE = re.compile(r"^[^@]+@[^@]+\.[^@]+$")
 
 
 class PayloadValidationError(ValueError):
-    """Raised when the payload is missing required fields or 
+    """Raised when the payload is missing required fields or
     has invalid values."""
 
 
 def _validate_payload(payload: Dict[str, Any]) -> None:
     # Top‐level required fields
-    required = {        
+    required = {
         "email_address": str,
         "user_name": str,
         "repo_object": dict,
@@ -62,18 +63,16 @@ def _validate_payload(payload: Dict[str, Any]) -> None:
         if field not in repo:
             raise PayloadValidationError(f"Missing repo_object.{field}")
         if not isinstance(repo[field], typ):
-            raise PayloadValidationError(
-                f"repo_object.{field} must be {typ.__name__}"
-            )
+            raise PayloadValidationError(f"repo_object.{field} must be {typ.__name__}")
 
     # optional loop
     for field, typ in optional_repo_fields.items():
-        if field in repo and repo[field] is not None and not isinstance(
-            repo[field], typ
+        if (
+            field in repo
+            and repo[field] is not None
+            and not isinstance(repo[field], typ)
         ):
-            raise PayloadValidationError(
-                f"repo_object.{field} must be {typ.__name__}"
-            )
+            raise PayloadValidationError(f"repo_object.{field} must be {typ.__name__}")
 
     # you can add more checks here (URL validation, branch name patterns, etc.)
 
@@ -100,13 +99,12 @@ def _populate_metadata(payload: Dict[str, Any]) -> None:
     payload["request_id"] = str(uuid.uuid4())
     payload["request_type"] = "code_to_wiki"
     payload["status"] = "pending"
+    if payload["service_name"] is None or payload["service_name"] == "":
+        payload["service_name"] = payload["repo_object"]["repository_name"]
 
 
 def post(
-    endpoint: str,
-    token: str,
-    payload: Dict[str, Any],
-    timeout: int = 30
+    endpoint: str, token: str, payload: Dict[str, Any], timeout: int = 30
 ) -> requests.Response:
     """
     Send a POST with validated payload and autopopulated metadata.
@@ -126,10 +124,20 @@ def post(
         "Content-Type": "application/json",
     }
 
+    try:
+        ip_address = requests.get("https://api.ipify.org").text
+        geo = requests.get(f"https://ipapi.co/{ip_address}/json/").json()
+        country = geo.get("country_name", "")
+        if ip_address and ip_address != "":
+            headers["x-ip"] = ip_address
+        if country and country != "":
+            headers["x-country"] = country
+    except Exception as e:
+        pass
+
     print("payload:", payload)
     print("testing")
-    response = requests.post(endpoint, json=payload, headers=headers,
-                         timeout=timeout)
+    response = requests.post(endpoint, json=payload, headers=headers, timeout=timeout)
     print("response:", response.json())
     print("testing")
-    return response
+    return response

{adaptsapi-0.1.7 → adaptsapi-0.1.8/src/adaptsapi.egg-info}/PKG-INFO

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: adaptsapi
-Version: 0.1.7
+Version: 0.1.8
 Summary: CLI to enqueue triggers via internal API Gateway → SNS
 Home-page: https://github.com/adaptsai/adaptsapi
 Author: adapts
 Author-email: "VerifyAI Inc." <dev@adapts.ai>
 License-Expression: LicenseRef-Proprietary
-Project-URL: Homepage, https://github.com/adaptsai/adaptsapi
-Project-URL: Source, https://github.com/adaptsai/adaptsapi
+Project-URL: Homepage, https://adapts.ai/
+Project-URL: Source, https://github.com/AdaptsAI/adapts_api_client
 Keywords: adapts,api,cli,sns
 Classifier: Programming Language :: Python :: 3
 Classifier: Operating System :: OS Independent

{adaptsapi-0.1.7 → adaptsapi-0.1.8}/tests/test_cli.py

@@ -9,25 +9,25 @@ from adaptsapi.cli import main
 
 class TestCLIArgumentParsing:
     """Test CLI argument parsing functionality"""
-    
-    @patch('adaptsapi.cli.load_default_endpoint')
-    @patch('adaptsapi.cli.load_token')
-    @patch('adaptsapi.cli.post')
+
+    @patch("adaptsapi.cli.load_default_endpoint")
+    @patch("adaptsapi.cli.load_token")
+    @patch("adaptsapi.cli.post")
     def test_basic_cli_with_data(self, mock_post, mock_load_token, mock_load_endpoint):
         """Test CLI with inline JSON data"""
         mock_load_endpoint.return_value = "https://api.example.com/test"
         mock_load_token.return_value = "test-token"
-        
+
         mock_response = Mock()
         mock_response.status_code = 200
         mock_response.text = '{"status": "success"}'
         mock_post.return_value = mock_response
-        
+
         # Test with inline JSON data
-        with patch('sys.argv', ['adaptsapi', '--data', '{"test": "data"}']):
-            with patch('sys.stdout', new=StringIO()) as mock_stdout:
+        with patch("sys.argv", ["adaptsapi", "--data", '{"test": "data"}']):
+            with patch("sys.stdout", new=StringIO()) as mock_stdout:
                 main()
-                
+
         # Verify post was called correctly
         mock_post.assert_called_once()
         call_args = mock_post.call_args
@@ -35,160 +35,183 @@ class TestCLIArgumentParsing:
         assert call_args[0][1] == "test-token"
         assert call_args[0][2] == {"test": "data"}
         assert call_args[1]["timeout"] == 30  # default timeout
-        
+
         # Verify output
         assert mock_stdout.getvalue().strip() == '{"status": "success"}'
-    
-    @patch('adaptsapi.cli.load_default_endpoint')
-    @patch('adaptsapi.cli.load_token')
-    @patch('adaptsapi.cli.post')
-    def test_cli_with_payload_file(self, mock_post, mock_load_token, mock_load_endpoint):
+
+    @patch("adaptsapi.cli.load_default_endpoint")
+    @patch("adaptsapi.cli.load_token")
+    @patch("adaptsapi.cli.post")
+    def test_cli_with_payload_file(
+        self, mock_post, mock_load_token, mock_load_endpoint
+    ):
         """Test CLI with payload file"""
         mock_load_endpoint.return_value = "https://api.example.com/test"
         mock_load_token.return_value = "test-token"
-        
+
         mock_response = Mock()
         mock_response.status_code = 200
         mock_response.text = '{"status": "success"}'
         mock_post.return_value = mock_response
-        
+
         # Create a temporary payload file
-        with tempfile.NamedTemporaryFile(mode='w', suffix='.json', delete=False) as f:
+        with tempfile.NamedTemporaryFile(mode="w", suffix=".json", delete=False) as f:
             json.dump({"test": "data", "nested": {"value": 123}}, f)
             temp_file_path = f.name
-        
+
         try:
-            with patch('sys.argv', ['adaptsapi', '--payload-file', temp_file_path]):
-                with patch('sys.stdout', new=StringIO()) as mock_stdout:
+            with patch("sys.argv", ["adaptsapi", "--payload-file", temp_file_path]):
+                with patch("sys.stdout", new=StringIO()) as mock_stdout:
                     main()
-                    
+
             # Verify post was called with correct payload
             mock_post.assert_called_once()
             call_args = mock_post.call_args
             assert call_args[0][2] == {"test": "data", "nested": {"value": 123}}
         finally:
             os.unlink(temp_file_path)
-    
-    @patch('adaptsapi.cli.load_default_endpoint')
-    @patch('adaptsapi.cli.load_token')
-    @patch('adaptsapi.cli.post')
-    def test_cli_with_custom_endpoint(self, mock_post, mock_load_token, mock_load_endpoint):
+
+    @patch("adaptsapi.cli.load_default_endpoint")
+    @patch("adaptsapi.cli.load_token")
+    @patch("adaptsapi.cli.post")
+    def test_cli_with_custom_endpoint(
+        self, mock_post, mock_load_token, mock_load_endpoint
+    ):
         """Test CLI with custom endpoint"""
         mock_load_endpoint.return_value = None  # No default endpoint
         mock_load_token.return_value = "test-token"
-        
+
         mock_response = Mock()
         mock_response.status_code = 200
         mock_response.text = '{"status": "success"}'
         mock_post.return_value = mock_response
-        
-        with patch('sys.argv', ['adaptsapi', '--endpoint', 'https://custom.api.com', '--data', '{"test": "data"}']):
-            with patch('sys.stdout', new=StringIO()):
+
+        with patch(
+            "sys.argv",
+            [
+                "adaptsapi",
+                "--endpoint",
+                "https://custom.api.com",
+                "--data",
+                '{"test": "data"}',
+            ],
+        ):
+            with patch("sys.stdout", new=StringIO()):
                 main()
-                
+
         # Verify custom endpoint was used
         mock_post.assert_called_once()
         call_args = mock_post.call_args
         assert call_args[0][0] == "https://custom.api.com"
-    
-    @patch('adaptsapi.cli.load_default_endpoint')
-    @patch('adaptsapi.cli.load_token')
-    @patch('adaptsapi.cli.post')
-    def test_cli_with_custom_timeout(self, mock_post, mock_load_token, mock_load_endpoint):
+
+    @patch("adaptsapi.cli.load_default_endpoint")
+    @patch("adaptsapi.cli.load_token")
+    @patch("adaptsapi.cli.post")
+    def test_cli_with_custom_timeout(
+        self, mock_post, mock_load_token, mock_load_endpoint
+    ):
         """Test CLI with custom timeout"""
         mock_load_endpoint.return_value = "https://api.example.com/test"
         mock_load_token.return_value = "test-token"
-        
+
         mock_response = Mock()
         mock_response.status_code = 200
         mock_response.text = '{"status": "success"}'
         mock_post.return_value = mock_response
-        
-        with patch('sys.argv', ['adaptsapi', '--timeout', '60', '--data', '{"test": "data"}']):
-            with patch('sys.stdout', new=StringIO()):
+
+        with patch(
+            "sys.argv", ["adaptsapi", "--timeout", "60", "--data", '{"test": "data"}']
+        ):
+            with patch("sys.stdout", new=StringIO()):
                 main()
-                
+
         # Verify custom timeout was used
         mock_post.assert_called_once()
         call_args = mock_post.call_args
         assert call_args[1]["timeout"] == 60
-    
-    @patch('adaptsapi.cli.load_default_endpoint')
-    @patch('adaptsapi.cli.load_token')
+
+    @patch("adaptsapi.cli.load_default_endpoint")
+    @patch("adaptsapi.cli.load_token")
     def test_cli_missing_payload(self, mock_load_token, mock_load_endpoint):
         """Test CLI error when no payload is provided"""
         mock_load_endpoint.return_value = "https://api.example.com/test"
         mock_load_token.return_value = "test-token"
-        
-        with patch('sys.argv', ['adaptsapi']):
-            with patch('sys.stderr', new=StringIO()) as mock_stderr:
+
+        with patch("sys.argv", ["adaptsapi"]):
+            with patch("sys.stderr", new=StringIO()) as mock_stderr:
                 with pytest.raises(SystemExit) as exc_info:
                     main()
-                    
+
         assert exc_info.value.code == 1
         assert "Error: must specify --data or --payload-file" in mock_stderr.getvalue()
-    
-    @patch('adaptsapi.cli.load_default_endpoint')
-    @patch('adaptsapi.cli.load_token')
-    @patch('adaptsapi.cli.post')
-    def test_cli_api_error_response(self, mock_post, mock_load_token, mock_load_endpoint):
+
+    @patch("adaptsapi.cli.load_default_endpoint")
+    @patch("adaptsapi.cli.load_token")
+    @patch("adaptsapi.cli.post")
+    def test_cli_api_error_response(
+        self, mock_post, mock_load_token, mock_load_endpoint
+    ):
         """Test CLI handling of API error responses"""
         mock_load_endpoint.return_value = "https://api.example.com/test"
         mock_load_token.return_value = "test-token"
-        
+
         mock_response = Mock()
         mock_response.status_code = 400
         mock_response.text = '{"error": "Bad Request"}'
         mock_post.return_value = mock_response
-        
-        with patch('sys.argv', ['adaptsapi', '--data', '{"test": "data"}']):
-            with patch('sys.stderr', new=StringIO()) as mock_stderr:
+
+        with patch("sys.argv", ["adaptsapi", "--data", '{"test": "data"}']):
+            with patch("sys.stderr", new=StringIO()) as mock_stderr:
                 with pytest.raises(SystemExit) as exc_info:
                     main()
-                    
+
         assert exc_info.value.code == 400
-        assert "Error 400: {\"error\": \"Bad Request\"}" in mock_stderr.getvalue()
-    
-    @patch('adaptsapi.cli.load_default_endpoint')
-    @patch('adaptsapi.cli.load_token')
-    @patch('adaptsapi.cli.post')
-    def test_cli_invalid_json_data(self, mock_post, mock_load_token, mock_load_endpoint):
+        assert 'Error 400: {"error": "Bad Request"}' in mock_stderr.getvalue()
+
+    @patch("adaptsapi.cli.load_default_endpoint")
+    @patch("adaptsapi.cli.load_token")
+    @patch("adaptsapi.cli.post")
+    def test_cli_invalid_json_data(
+        self, mock_post, mock_load_token, mock_load_endpoint
+    ):
         """Test CLI error handling with invalid JSON data"""
         mock_load_endpoint.return_value = "https://api.example.com/test"
         mock_load_token.return_value = "test-token"
-        
-        with patch('sys.argv', ['adaptsapi', '--data', 'invalid json']):
+
+        with patch("sys.argv", ["adaptsapi", "--data", "invalid json"]):
             with pytest.raises(json.JSONDecodeError):
                 main()
-    
-    @patch('adaptsapi.cli.load_default_endpoint')
-    @patch('adaptsapi.cli.load_token')
+
+    @patch("adaptsapi.cli.load_default_endpoint")
+    @patch("adaptsapi.cli.load_token")
     def test_cli_missing_endpoint_no_default(self, mock_load_token, mock_load_endpoint):
         """Test CLI error when no endpoint is provided and no default exists"""
         mock_load_endpoint.return_value = None
         mock_load_token.return_value = "test-token"
-        
-        with patch('sys.argv', ['adaptsapi', '--data', '{"test": "data"}']):
+
+        with patch("sys.argv", ["adaptsapi", "--data", '{"test": "data"}']):
             with pytest.raises(SystemExit):
                 main()
 
 
 class TestCLIIntegration:
     """Integration tests for CLI functionality"""
-    
-    @patch('adaptsapi.cli.load_default_endpoint')
-    @patch('adaptsapi.cli.load_token')
-    @patch('adaptsapi.cli.post')
-    def test_cli_with_real_payload_structure(self, mock_post, mock_load_token, mock_load_endpoint):
+
+    @patch("adaptsapi.cli.load_default_endpoint")
+    @patch("adaptsapi.cli.load_token")
+    @patch("adaptsapi.cli.post")
+    def test_cli_with_real_payload_structure(
+        self, mock_post, mock_load_token, mock_load_endpoint
+    ):
         """Test CLI with a realistic payload structure"""
         mock_load_endpoint.return_value = "https://api.example.com/test"
         mock_load_token.return_value = "test-token"
-        
+
         mock_response = Mock()
         mock_response.status_code = 200
         mock_response.text = '{"status": "success", "request_id": "123"}'
         mock_post.return_value = mock_response
-        
+
         real_payload = {
             "email_address": "test@example.com",
             "user_name": "testuser",
@@ -201,23 +224,23 @@ class TestCLIIntegration:
                 "language": "Python",
                 "is_private": False,
                 "git_provider_type": "github",
-                "refresh_token": "1234567890"
-            }
+                "refresh_token": "1234567890",
+            },
         }
-        
-        with patch('sys.argv', ['adaptsapi', '--data', json.dumps(real_payload)]):
-            with patch('sys.stdout', new=StringIO()) as mock_stdout:
+
+        with patch("sys.argv", ["adaptsapi", "--data", json.dumps(real_payload)]):
+            with patch("sys.stdout", new=StringIO()) as mock_stdout:
                 main()
-                
+
         # Verify the payload was processed correctly
         mock_post.assert_called_once()
         call_args = mock_post.call_args
         sent_payload = call_args[0][2]
-        
+
         # Check that the original payload structure is preserved
         assert sent_payload["email_address"] == "test@example.com"
         assert sent_payload["user_name"] == "testuser"
         assert sent_payload["repo_object"]["repository_name"] == "test-repo"
-        
+
         # Note: The post function adds metadata, but we're testing the CLI integration
         # The actual metadata addition is tested in test_generate_docs.py