infisicalsdk 0.2.0__py3-none-any.whl → 1.0.2__py3-none-any.whl

infisical_sdk/infisical_requests.py

@@ -0,0 +1,186 @@
+from typing import Any, Dict, Generic, Optional, TypeVar
+from urllib.parse import urljoin
+import requests
+from dataclasses import dataclass
+
+T = TypeVar("T")
+
+
+class InfisicalError(Exception):
+    """Base exception for Infisical client errors"""
+    pass
+
+
+class APIError(InfisicalError):
+    """API-specific errors"""
+    def __init__(self, message: str, status_code: int, response: Dict[str, Any]):
+        self.status_code = status_code
+        self.response = response
+        super().__init__(f"{message} (Status: {status_code})")
+
+
+@dataclass
+class APIResponse(Generic[T]):
+    """Generic API response wrapper"""
+    data: T
+    status_code: int
+    headers: Dict[str, str]
+
+    def to_dict(self) -> Dict:
+        """Convert to dictionary with camelCase keys"""
+        return {
+            'data': self.data.to_dict() if hasattr(self.data, 'to_dict') else self.data,
+            'statusCode': self.status_code,
+            'headers': self.headers
+        }
+
+    @classmethod
+    def from_dict(cls, data: Dict) -> 'APIResponse[T]':
+        """Create from dictionary with camelCase keys"""
+        return cls(
+            data=data['data'],
+            status_code=data['statusCode'],
+            headers=data['headers']
+        )
+
+
+class InfisicalRequests:
+    def __init__(self, host: str, token: Optional[str] = None):
+        self.host = host.rstrip("/")
+        self.session = requests.Session()
+
+        # Set common headers
+        self.session.headers.update({
+            "Content-Type": "application/json",
+            "Accept": "application/json",
+        })
+
+        if token:
+            self.set_token(token)
+
+    def _build_url(self, path: str) -> str:
+        """Construct full URL from path"""
+        return urljoin(self.host, path.lstrip("/"))
+
+    def set_token(self, token: str):
+        """Set authorization token"""
+        self.session.headers["Authorization"] = f"Bearer {token}"
+
+    def _handle_response(self, response: requests.Response) -> Dict[str, Any]:
+        """Handle API response and raise appropriate errors"""
+        try:
+            response.raise_for_status()
+            return response.json()
+        except requests.exceptions.HTTPError:
+            try:
+                error_data = response.json()
+            except ValueError:
+                error_data = {"message": response.text}
+
+            raise APIError(
+                message=error_data.get("message", "Unknown error"),
+                status_code=response.status_code,
+                response=error_data
+            )
+        except requests.exceptions.RequestException as e:
+            raise InfisicalError(f"Request failed: {str(e)}")
+        except ValueError:
+            raise InfisicalError("Invalid JSON response")
+
+    def get(
+            self,
+            path: str,
+            model: type[T],
+            params: Optional[Dict[str, Any]] = None
+          ) -> APIResponse[T]:
+
+        """
+        Make a GET request and parse response into given model
+
+        Args:
+            path: API endpoint path
+            model: model class to parse response into
+            params: Optional query parameters
+        """
+        response = self.session.get(self._build_url(path), params=params)
+        data = self._handle_response(response)
+
+        parsed_data = model.from_dict(data) if hasattr(model, 'from_dict') else data
+
+        return APIResponse(
+            data=parsed_data,
+            status_code=response.status_code,
+            headers=dict(response.headers)
+        )
+
+    def post(
+            self,
+            path: str,
+            model: type[T],
+            json: Optional[Dict[str, Any]] = None
+          ) -> APIResponse[T]:
+
+        """Make a POST request with JSON data"""
+
+        if json is not None:
+            # Filter out None values
+            json = {k: v for k, v in json.items() if v is not None}
+
+        response = self.session.post(self._build_url(path), json=json)
+        data = self._handle_response(response)
+
+        parsed_data = model.from_dict(data) if hasattr(model, 'from_dict') else data
+
+        return APIResponse(
+            data=parsed_data,
+            status_code=response.status_code,
+            headers=dict(response.headers)
+        )
+
+    def patch(
+            self,
+            path: str,
+            model: type[T],
+            json: Optional[Dict[str, Any]] = None
+          ) -> APIResponse[T]:
+
+        """Make a PATCH request with JSON data"""
+
+        if json is not None:
+            # Filter out None values
+            json = {k: v for k, v in json.items() if v is not None}
+
+        response = self.session.patch(self._build_url(path), json=json)
+        data = self._handle_response(response)
+
+        parsed_data = model.from_dict(data) if hasattr(model, 'from_dict') else data
+
+        return APIResponse(
+            data=parsed_data,
+            status_code=response.status_code,
+            headers=dict(response.headers)
+        )
+
+    def delete(
+            self,
+            path: str,
+            model: type[T],
+            json: Optional[Dict[str, Any]] = None
+          ) -> APIResponse[T]:
+
+        """Make a PATCH request with JSON data"""
+
+        if json is not None:
+            # Filter out None values
+            json = {k: v for k, v in json.items() if v is not None}
+
+        response = self.session.delete(self._build_url(path), json=json)
+        data = self._handle_response(response)
+
+        parsed_data = model.from_dict(data) if hasattr(model, 'from_dict') else data
+
+        return APIResponse(
+            data=parsed_data,
+            status_code=response.status_code,
+            headers=dict(response.headers)
+        )

{infisicalsdk-0.2.0.dist-info → infisicalsdk-1.0.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: infisicalsdk
-Version: 0.2.0
+Version: 1.0.2
 Summary: Infisical API Client
 Home-page: https://github.com/Infisical/python-sdk-official
 Author: Infisical
@@ -9,11 +9,18 @@ Keywords: Infisical,Infisical API,Infisical SDK
 Description-Content-Type: text/markdown
 Requires-Dist: urllib3<2.1.0,>=1.25.3
 Requires-Dist: python-dateutil
-Requires-Dist: pydantic<2,>=1.10.5
 Requires-Dist: aenum
 Requires-Dist: requests~=2.32
 Requires-Dist: boto3~=1.35
 Requires-Dist: botocore~=1.35
+Dynamic: author
+Dynamic: author-email
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: requires-dist
+Dynamic: summary
 
     Infisical SDK client for Python. To view documentation, please visit https://github.com/Infisical/python-sdk-official
     

infisicalsdk-1.0.2.dist-info/RECORD

@@ -0,0 +1,8 @@
+infisical_sdk/__init__.py,sha256=UzssDXpMhK79mFBW4fpSea1bOVjoD_UILjvizFkLNz4,183
+infisical_sdk/api_types.py,sha256=2JNC9RA3JYPDwq92BXwBrxTkXi-XuD3G3jBST4-H9qg,3394
+infisical_sdk/client.py,sha256=i1poZEz2tiGJLYZuRePfWONs7hQyP_A5QJJt1UeW8WQ,10936
+infisical_sdk/infisical_requests.py,sha256=mROtB1fuF3E39fU9J6MiH0gQ-LhsK10W-zzEH0knePU,5655
+infisicalsdk-1.0.2.dist-info/METADATA,sha256=pMW354MJanz1LBMM_EiYafLtSzTlfE8lOc0dWP73bKQ,763
+infisicalsdk-1.0.2.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+infisicalsdk-1.0.2.dist-info/top_level.txt,sha256=FvJjMGD1FvxwipO_qFajdH20yNV8n3lJ7G3DkQoPJNU,14
+infisicalsdk-1.0.2.dist-info/RECORD,,

{infisicalsdk-0.2.0.dist-info → infisicalsdk-1.0.2.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (73.0.1)
+Generator: setuptools (75.8.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

infisicalsdk-1.0.2.dist-info/top_level.txt

@@ -0,0 +1 @@
+infisical_sdk

infisical_sdk/aws_auth.py

@@ -1,121 +0,0 @@
-import os
-import json
-import base64
-import requests
-from typing import Dict
-from datetime import datetime
-import hashlib
-import hmac
-import urllib.parse
-
-
-class AWSAuth:
-    def __init__(self, client):
-        self.client = client
-
-    def aws_iam_auth_login(self, identity_id: str = "") -> Dict:
-        if not identity_id:
-            identity_id = os.getenv("INFISICAL_AWS_IAM_AUTH_IDENTITY_ID")
-
-        aws_region = self._get_aws_region()
-        credentials = self._get_aws_credentials()
-
-        # Prepare request for signing
-        iam_request_url = f"https://sts.{aws_region}.amazonaws.com/"
-        iam_request_body = "Action=GetCallerIdentity&Version=2011-06-15"
-
-        # Create request
-        req = {
-            "method": "POST",
-            "url": iam_request_url,
-            "data": iam_request_body,
-            "headers": {}
-        }
-
-        # Add date header
-        current_time = datetime.utcnow()
-        req["headers"]["X-Amz-Date"] = current_time.strftime("%Y%m%dT%H%M%SZ")
-
-        # Calculate payload hash
-        payload_hash = hashlib.sha256(iam_request_body.encode()).hexdigest()
-
-        # Sign the request
-        self._sign_request(req, credentials, payload_hash, "sts", aws_region, current_time)
-
-        # Prepare headers for the API call
-        real_headers = {k: v for k, v in req["headers"].items() if k.lower() != "content-length"}
-        real_headers["Host"] = f"sts.{aws_region}.amazonaws.com"
-        real_headers["Content-Type"] = "application/x-www-form-urlencoded; charset=utf-8"
-        real_headers["Content-Length"] = str(len(iam_request_body))
-
-        # Convert headers to JSON and encode
-        json_string_headers = json.dumps(real_headers)
-        encoded_headers = base64.b64encode(json_string_headers.encode()).decode()
-
-        # Prepare the request body for the API call
-        api_request = {
-            "HTTPRequestMethod": req["method"],
-            "IamRequestBody": base64.b64encode(iam_request_body.encode()).decode(),
-            "IamRequestHeaders": encoded_headers,
-            "IdentityId": identity_id
-        }
-
-        # Call the API
-        credential = self._call_aws_iam_auth_login(api_request)
-
-        # Set the access token
-        self.client.set_access_token(credential["accessToken"], "AWS_IAM")
-
-
-        return credential
-
-    def _get_aws_region(self):
-        # Implement AWS region retrieval logic here
-        # For this example, we'll use a placeholder
-        return "us-west-2"
-
-    def _get_aws_credentials(self):
-        # Implement AWS credentials retrieval logic here
-        # For this example, we'll use placeholders
-        return {
-            "AccessKeyId": "YOUR_ACCESS_KEY_ID",
-            "SecretAccessKey": "YOUR_SECRET_ACCESS_KEY",
-            "SessionToken": "YOUR_SESSION_TOKEN"
-        }
-
-    def _sign_request(self, req, credentials, payload_hash, service, region, time):
-        # Implement AWS Signature V4 signing process
-        # This is a simplified version and may need to be expanded for full functionality
-        algorithm = "AWS4-HMAC-SHA256"
-        credential_scope = f"{time.strftime('%Y%m%d')}/{region}/{service}/aws4_request"
-
-        string_to_sign = f"{algorithm}\n{req['headers']['X-Amz-Date']}\n{credential_scope}\n"
-        string_to_sign += hashlib.sha256(self._canonical_request(req, payload_hash).encode()).hexdigest()
-
-        date_key = hmac.new(f"AWS4{credentials['SecretAccessKey']}".encode(), time.strftime('%Y%m%d').encode(),
-                            hashlib.sha256).digest()
-        date_region_key = hmac.new(date_key, region.encode(), hashlib.sha256).digest()
-        date_region_service_key = hmac.new(date_region_key, service.encode(), hashlib.sha256).digest()
-        signing_key = hmac.new(date_region_service_key, b"aws4_request", hashlib.sha256).digest()
-
-        signature = hmac.new(signing_key, string_to_sign.encode(), hashlib.sha256).hexdigest()
-
-        req["headers"]["Authorization"] = (
-            f"{algorithm} Credential={credentials['AccessKeyId']}/{credential_scope}, "
-            f"SignedHeaders=host;x-amz-date, Signature={signature}"
-        )
-
-    def _canonical_request(self, req, payload_hash):
-        canonical_headers = "host:" + req["headers"]["Host"] + "\n" + "x-amz-date:" + req["headers"][
-            "X-Amz-Date"] + "\n"
-        signed_headers = "host;x-amz-date"
-
-        return f"{req['method']}\n/{urllib.parse.urlparse(req['url']).path}\n\n{canonical_headers}\n{signed_headers}\n{payload_hash}"
-
-    def _call_aws_iam_auth_login(self, request):
-        response = requests.post(
-            f"{self.client.base_url}/v1/auth/aws-auth/login",
-            json=request
-        )
-        response.raise_for_status()
-        return response.json()