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

infisical_sdk/__init__.py

@@ -1 +1,3 @@
-from .client import InfisicalSDKClient
+from .client import InfisicalSDKClient # noqa
+from .infisical_requests import InfisicalError # noqa
+from .api_types import SingleSecretResponse, ListSecretsResponse, BaseSecret # noqa

infisical_sdk/api_types.py

@@ -0,0 +1,123 @@
+from dataclasses import dataclass, field
+from typing import Optional, List, Any, Dict
+from enum import Enum
+import json
+
+
+class ApprovalStatus(str, Enum):
+    """Enum for approval status"""
+    OPEN = "open"
+    APPROVED = "approved"
+    REJECTED = "rejected"
+
+
+class BaseModel:
+    """Base class for all models"""
+    def to_dict(self) -> Dict:
+        """Convert model to dictionary"""
+        result = {}
+        for key, value in self.__dict__.items():
+            if value is not None:  # Skip None values
+                if isinstance(value, BaseModel):
+                    result[key] = value.to_dict()
+                elif isinstance(value, list):
+                    result[key] = [
+                        item.to_dict() if isinstance(item, BaseModel) else item
+                        for item in value
+                    ]
+                elif isinstance(value, Enum):
+                    result[key] = value.value
+                else:
+                    result[key] = value
+        return result
+
+    @classmethod
+    def from_dict(cls, data: Dict) -> 'BaseModel':
+        """Create model from dictionary"""
+        return cls(**data)
+
+    def to_json(self) -> str:
+        """Convert model to JSON string"""
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> 'BaseModel':
+        """Create model from JSON string"""
+        data = json.loads(json_str)
+        return cls.from_dict(data)
+
+
+@dataclass(frozen=True)
+class SecretTag(BaseModel):
+    """Model for secret tags"""
+    id: str
+    slug: str
+    name: str
+    color: Optional[str] = None
+
+
+@dataclass
+class BaseSecret(BaseModel):
+    """Infisical Secret"""
+    id: str
+    _id: str
+    workspace: str
+    environment: str
+    version: int
+    type: str
+    secretKey: str
+    secretValue: str
+    secretComment: str
+    createdAt: str
+    updatedAt: str
+    secretReminderNote: Optional[str] = None
+    secretReminderRepeatDays: Optional[int] = None
+    skipMultilineEncoding: Optional[bool] = False
+    metadata: Optional[Any] = None
+    secretPath: Optional[str] = None
+    tags: List[SecretTag] = field(default_factory=list)
+
+
+@dataclass
+class Import(BaseModel):
+    """Model for imports section"""
+    secretPath: str
+    environment: str
+    folderId: Optional[str] = None
+    secrets: List[BaseSecret] = field(default_factory=list)
+
+
+@dataclass
+class ListSecretsResponse(BaseModel):
+    """Complete response model for secrets API"""
+    secrets: List[BaseSecret]
+    imports: List[Import] = field(default_factory=list)
+
+    @classmethod
+    def from_dict(cls, data: Dict) -> 'ListSecretsResponse':
+        """Create model from dictionary with camelCase keys, handling nested objects"""
+        return cls(
+            secrets=[BaseSecret.from_dict(secret) for secret in data['secrets']],
+            imports=[Import.from_dict(imp) for imp in data.get('imports', [])]
+        )
+
+
+@dataclass
+class SingleSecretResponse(BaseModel):
+    """Response model for get secret API"""
+    secret: BaseSecret
+
+    @classmethod
+    def from_dict(cls, data: Dict) -> 'ListSecretsResponse':
+        return cls(
+            secret=BaseSecret.from_dict(data['secret']),
+        )
+
+
+@dataclass
+class MachineIdentityLoginResponse(BaseModel):
+    """Response model for machine identity login API"""
+    accessToken: str
+    expiresIn: int
+    accessTokenMaxTTL: int
+    tokenType: str

infisical_sdk/client.py

@@ -2,8 +2,6 @@ import base64
 import json
 from typing import List, Union
 import os
-import json
-import base64
 import datetime
 from typing import Dict, Any
 
@@ -13,28 +11,17 @@ from botocore.auth import SigV4Auth
 from botocore.awsrequest import AWSRequest
 from botocore.exceptions import NoCredentialsError
 
+from .infisical_requests import InfisicalRequests
+from .api_types import ListSecretsResponse, MachineIdentityLoginResponse
+from .api_types import SingleSecretResponse, BaseSecret
 
-import infisicalapi_client 
-from infisicalapi_client.models.api_v1_auth_aws_auth_login_post_request import ApiV1AuthAwsAuthLoginPostRequest
-from infisicalapi_client.models.api_v1_auth_token_auth_identities_identity_id_tokens_post200_response import ApiV1AuthTokenAuthIdentitiesIdentityIdTokensPost200Response
-from infisicalapi_client.models.api_v1_auth_universal_auth_login_post_request import ApiV1AuthUniversalAuthLoginPostRequest
-from infisicalapi_client.models.api_v3_secrets_raw_get200_response import ApiV3SecretsRawGet200Response
-from infisicalapi_client.models.api_v3_secrets_raw_secret_name_delete_request import ApiV3SecretsRawSecretNameDeleteRequest
-from infisicalapi_client.models.api_v3_secrets_raw_secret_name_get200_response import ApiV3SecretsRawSecretNameGet200Response
-from infisicalapi_client.models.api_v3_secrets_raw_secret_name_patch_request import ApiV3SecretsRawSecretNamePatchRequest
-from infisicalapi_client.models.api_v3_secrets_raw_secret_name_post200_response import ApiV3SecretsRawSecretNamePost200Response
-from infisicalapi_client.models.api_v3_secrets_raw_secret_name_post_request import ApiV3SecretsRawSecretNamePostRequest
 
 class InfisicalSDKClient:
-    def __init__(self, host: str, token: str  = None):
+    def __init__(self, host: str, token: str = None):
         self.host = host
-        self.token_type = None
-        self.expires_in = None
+        self.access_token = token
 
-        self._api_config = infisicalapi_client.Configuration(host=host, access_token=token)
-        self._api_client = infisicalapi_client.ApiClient(self._api_config)
-        self._api_instance = infisicalapi_client.DefaultApi(self._api_client)
-        self.rest = self._api_instance
+        self.api = InfisicalRequests(host=host, token=token)
 
         self.auth = Auth(self)
         self.secrets = V3RawSecrets(self)
@@ -43,20 +30,21 @@ class InfisicalSDKClient:
         """
         Set the access token for future requests.
         """
-        self._api_config.access_token = token
+        self.api.set_token(token)
+        self.access_token = token
 
     def get_token(self):
         """
         Set the access token for future requests.
         """
-        return self.token
+        return self.access_token
 
 
 class UniversalAuth:
     def __init__(self, client: InfisicalSDKClient):
         self.client = client
 
-    def login(self, client_id: str, client_secret: str) -> ApiV1AuthTokenAuthIdentitiesIdentityIdTokensPost200Response:
+    def login(self, client_id: str, client_secret: str) -> MachineIdentityLoginResponse:
         """
         Login with Universal Auth.
 
@@ -68,23 +56,29 @@ class UniversalAuth:
             Dict: A dictionary containing the access token and related information.
         """
 
-        response = self.client._api_instance.api_v1_auth_universal_auth_login_post(ApiV1AuthUniversalAuthLoginPostRequest(
-            client_id = client_id,
-            client_secret = client_secret
-        ))
+        requestBody = {
+            "clientId": client_id,
+            "clientSecret": client_secret
+        }
+
+        result = self.client.api.post(
+          path="/api/v1/auth/universal-auth/login",
+          json=requestBody,
+          model=MachineIdentityLoginResponse
+        )
 
-        self.client.set_token(response.access_token)
+        self.client.set_token(result.data.accessToken)
+
+        return result.data
 
-        return response
-    
 
 class AWSAuth:
     def __init__(self, client: InfisicalSDKClient) -> None:
         self.client = client
 
-    def login(self, identity_id: str) -> ApiV1AuthTokenAuthIdentitiesIdentityIdTokensPost200Response:
+    def login(self, identity_id: str) -> MachineIdentityLoginResponse:
         """
-        Login with AWS Authentication. 
+        Login with AWS Authentication.
 
         Args:
             identity_id (str): Your Machine Identity ID that has AWS Auth configured.
@@ -95,7 +89,10 @@ class AWSAuth:
 
         identity_id = identity_id or os.getenv("INFISICAL_AWS_IAM_AUTH_IDENTITY_ID")
         if not identity_id:
-            raise ValueError("Identity ID must be provided or set in the environment variable INFISICAL_AWS_IAM_AUTH_IDENTITY_ID.")
+            raise ValueError(
+              "Identity ID must be provided or set in the environment variable" +
+              "INFISICAL_AWS_IAM_AUTH_IDENTITY_ID."
+            )
 
         aws_region = self.get_aws_region()
         session = boto3.Session(region_name=aws_region)
@@ -104,19 +101,30 @@ class AWSAuth:
 
         iam_request_url = f"https://sts.{aws_region}.amazonaws.com/"
         iam_request_body = "Action=GetCallerIdentity&Version=2011-06-15"
-        request_headers = self._prepare_aws_request(iam_request_url, iam_request_body, credentials, aws_region)
 
-        login_request = ApiV1AuthAwsAuthLoginPostRequest(
-            identityId=identity_id,
-            iamRequestBody=base64.b64encode(iam_request_body.encode()).decode(),
-            iamRequestHeaders=base64.b64encode(json.dumps(request_headers).encode()).decode(),
-            iamHttpRequestMethod="POST"
+        request_headers = self._prepare_aws_request(
+          iam_request_url,
+          iam_request_body,
+          credentials,
+          aws_region
+        )
+
+        requestBody = {
+          "identityId": identity_id,
+          "iamRequestBody": base64.b64encode(iam_request_body.encode()).decode(),
+          "iamRequestHeaders": base64.b64encode(json.dumps(request_headers).encode()).decode(),
+          "iamHttpRequestMethod": "POST"
+        }
+
+        result = self.client.api.post(
+          path="/api/v1/auth/aws-auth/login",
+          json=requestBody,
+          model=MachineIdentityLoginResponse
         )
 
-        response = self.client._api_instance.api_v1_auth_aws_auth_login_post(login_request)
-        self.client.set_token(response.access_token)
+        self.client.set_token(result.data.accessToken)
 
-        return response
+        return result.data
 
     def _get_aws_credentials(self, session: boto3.Session) -> Any:
         try:
@@ -127,10 +135,16 @@ class AWSAuth:
         except NoCredentialsError as e:
             raise RuntimeError(f"AWS IAM Auth Login failed: {str(e)}")
 
-    def _prepare_aws_request(self, url: str, body: str, credentials: Any, region: str) -> Dict[str, str]:
+    def _prepare_aws_request(
+      self,
+      url: str,
+      body: str,
+      credentials: Any,
+      region: str) -> Dict[str, str]:
+
         current_time = datetime.datetime.now(datetime.timezone.utc)
         amz_date = current_time.strftime('%Y%m%dT%H%M%SZ')
-        
+
         request = AWSRequest(method="POST", url=url, data=body)
         request.headers["X-Amz-Date"] = amz_date
         request.headers["Host"] = f"sts.{region}.amazonaws.com"
@@ -139,12 +153,12 @@ class AWSAuth:
 
         signer = SigV4Auth(credentials, "sts", region)
         signer.add_auth(request)
-        
+
         return {k: v for k, v in request.headers.items() if k.lower() != "content-length"}
 
     @staticmethod
     def get_aws_region() -> str:
-        region = os.getenv("AWS_REGION") # Typically found in lambda runtime environment
+        region = os.getenv("AWS_REGION")  # Typically found in lambda runtime environment
         if region:
             return region
 
@@ -180,72 +194,152 @@ class Auth:
         self.aws_auth = AWSAuth(client)
         self.universal_auth = UniversalAuth(client)
 
+
 class V3RawSecrets:
     def __init__(self, client: InfisicalSDKClient) -> None:
         self.client = client
 
-    def list_secrets(self, project_id: str, environment_slug: str, secret_path: str, expand_secret_references: bool = True, recursive: bool = False, include_imports : bool = True, tag_filters: List[str] = []) -> ApiV3SecretsRawGet200Response:
-        return self.client._api_instance.api_v3_secrets_raw_get(
-            workspace_id=project_id, 
-            environment=environment_slug, 
-            secret_path=secret_path, 
-            expand_secret_references=str(expand_secret_references).lower(), 
-            recursive=str(recursive).lower(), 
-            tag_slugs=",".join(tag_filters), 
-            include_imports=str(include_imports).lower())
-
-    def create_secret_by_name(self, secret_name: str, project_id: str, secret_path: str, environment_slug: str, secret_value: str = None, secret_comment: str = None, skip_multiline_encoding: bool = False, secret_reminder_repeat_days: Union[float, int] = None, secret_reminder_note: str = None) -> ApiV3SecretsRawSecretNamePost200Response:
-        secret_request = ApiV3SecretsRawSecretNamePostRequest(
-            workspaceId = project_id,
-            environment = environment_slug,
-            secretPath= secret_path,
-            secretValue = secret_value,
-            secretComment = secret_comment,
-            tagIds = None,
-            skipMultilineEncoding = skip_multiline_encoding,
-            type = "shared",
-            secretReminderRepeatDays = secret_reminder_repeat_days,
-            secretReminderNote = secret_reminder_note
+    def list_secrets(
+            self,
+            project_id: str,
+            environment_slug: str,
+            secret_path: str,
+            expand_secret_references: bool = True,
+            recursive: bool = False,
+            include_imports: bool = True,
+            tag_filters: List[str] = []) -> ListSecretsResponse:
+
+        params = {
+            "workspaceId": project_id,
+            "environment": environment_slug,
+            "secretPath": secret_path,
+            "expandSecretReferences": str(expand_secret_references).lower(),
+            "recursive": str(recursive).lower(),
+            "include_imports": str(include_imports).lower(),
+        }
+
+        if tag_filters:
+            params["tag_slugs"] = ",".join(tag_filters)
+
+        result = self.client.api.get(
+            path="/api/v3/secrets/raw",
+            params=params,
+            model=ListSecretsResponse
         )
 
-        return self.client._api_instance.api_v3_secrets_raw_secret_name_post(secret_name, secret_request)
-         
-
-    def update_secret_by_name(self, current_secret_name: str, project_id: str, secret_path: str, environment_slug: str, secret_value: str = None, secret_comment: str = None, skip_multiline_encoding: bool = False, secret_reminder_repeat_days: Union[float, int] = None, secret_reminder_note: str = None, new_secret_name: str = None) -> ApiV3SecretsRawSecretNamePost200Response:
-        secret_request = ApiV3SecretsRawSecretNamePatchRequest(
-            workspaceId = project_id,
-            environment = environment_slug,
-            secretPath= secret_path,
-            secretValue = secret_value,
-            secretComment = secret_comment,
-            new_secret_name=new_secret_name,
-            tagIds = None,
-            skipMultilineEncoding = skip_multiline_encoding,
-            type = "shared",
-            secretReminderRepeatDays = secret_reminder_repeat_days,
-            secretReminderNote = secret_reminder_note
+        return result.data
+
+    def get_secret_by_name(
+            self,
+            secret_name: str,
+            project_id: str,
+            environment_slug: str,
+            secret_path: str,
+            expand_secret_references: bool = True,
+            include_imports: bool = True,
+            version: str = None) -> BaseSecret:
+
+        params = {
+          "workspaceId": project_id,
+          "environment": environment_slug,
+          "secretPath": secret_path,
+          "expandSecretReferences": str(expand_secret_references).lower(),
+          "include_imports": str(include_imports).lower(),
+          "version": version
+        }
+
+        result = self.client.api.get(
+            path=f"/api/v3/secrets/raw/{secret_name}",
+            params=params,
+            model=SingleSecretResponse
         )
 
-        return self.client._api_instance.api_v3_secrets_raw_secret_name_patch(current_secret_name, secret_request) 
-
-    def delete_secret_by_name(self, secret_name: str, project_id: str, secret_path: str, environment_slug: str) -> ApiV3SecretsRawSecretNamePost200Response:
-        secret_delete_request = ApiV3SecretsRawSecretNameDeleteRequest(
-            workspaceId = project_id,
-            environment = environment_slug,
-            secretPath= secret_path,
-            type = "shared",
+        return result.data.secret
+
+    def create_secret_by_name(
+            self,
+            secret_name: str,
+            project_id: str,
+            secret_path: str,
+            environment_slug: str,
+            secret_value: str = None,
+            secret_comment: str = None,
+            skip_multiline_encoding: bool = False,
+            secret_reminder_repeat_days: Union[float, int] = None,
+            secret_reminder_note: str = None) -> BaseSecret:
+
+        requestBody = {
+          "workspaceId": project_id,
+          "environment": environment_slug,
+          "secretPath": secret_path,
+          "secretValue": secret_value,
+          "secretComment": secret_comment,
+          "tagIds": None,
+          "skipMultilineEncoding": skip_multiline_encoding,
+          "type": "shared",
+          "secretReminderRepeatDays": secret_reminder_repeat_days,
+          "secretReminderNote": secret_reminder_note
+        }
+        result = self.client.api.post(
+            path=f"/api/v3/secrets/raw/{secret_name}",
+            json=requestBody,
+            model=SingleSecretResponse
         )
 
-        return self.client._api_instance.api_v3_secrets_raw_secret_name_delete(secret_name, secret_delete_request)
-
-    def get_secret_by_name(self, secret_name: str, project_id: str, environment_slug: str, secret_path: str, expand_secret_references: bool = True, include_imports : bool = True, version: str = None) -> ApiV3SecretsRawSecretNameGet200Response:
-        return self.client._api_instance.api_v3_secrets_raw_secret_name_get(
-            secret_name=secret_name,
-            workspace_id=project_id, 
-            environment=environment_slug, 
-            secret_path=secret_path,
-            version=version, 
-            type="shared",
-            expand_secret_references=str(expand_secret_references).lower(), 
-            include_imports=str(include_imports).lower()
+        return result.data.secret
+
+    def update_secret_by_name(
+            self,
+            current_secret_name: str,
+            project_id: str,
+            secret_path: str,
+            environment_slug: str,
+            secret_value: str = None,
+            secret_comment: str = None,
+            skip_multiline_encoding: bool = False,
+            secret_reminder_repeat_days: Union[float, int] = None,
+            secret_reminder_note: str = None,
+            new_secret_name: str = None) -> BaseSecret:
+
+        requestBody = {
+          "workspaceId": project_id,
+          "environment": environment_slug,
+          "secretPath": secret_path,
+          "secretValue": secret_value,
+          "secretComment": secret_comment,
+          "new_secret_name": new_secret_name,
+          "tagIds": None,
+          "skipMultilineEncoding": skip_multiline_encoding,
+          "type": "shared",
+          "secretReminderRepeatDays": secret_reminder_repeat_days,
+          "secretReminderNote": secret_reminder_note
+        }
+
+        result = self.client.api.patch(
+            path=f"/api/v3/secrets/raw/{current_secret_name}",
+            json=requestBody,
+            model=SingleSecretResponse
+        )
+        return result.data.secret
+
+    def delete_secret_by_name(
+            self,
+            secret_name: str,
+            project_id: str,
+            secret_path: str,
+            environment_slug: str) -> BaseSecret:
+
+        requestBody = {
+          "workspaceId": project_id,
+          "environment": environment_slug,
+          "secretPath": secret_path,
+          "type": "shared",
+        }
+
+        result = self.client.api.delete(
+            path=f"/api/v3/secrets/raw/{secret_name}",
+            json=requestBody,
+            model=SingleSecretResponse
         )
+
+        return result.data.secret