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

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

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

infisicalsdk-0.2.0.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+infisical_sdk
+infisicalapi_client

infisical_sdk/api_types.py

@@ -1,127 +0,0 @@
-from dataclasses import dataclass, field, fields
-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"""
-        # Get only the fields that exist in the dataclass
-        valid_fields = {f.name for f in fields(cls)}
-        filtered_data = {k: v for k, v in data.items() if k in valid_fields}
-        return cls(**filtered_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
-    secretMetadata: Optional[Dict[str, Any]] = None
-    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/infisical_requests.py

@@ -1,186 +0,0 @@
-from typing import Any, Dict, Generic, Optional, TypeVar, Type
-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.1.4.dist-info/RECORD

@@ -1,8 +0,0 @@
-infisical_sdk/__init__.py,sha256=UzssDXpMhK79mFBW4fpSea1bOVjoD_UILjvizFkLNz4,183
-infisical_sdk/api_types.py,sha256=FjyDQ71pOYiyYA9oGAPsW5jW7LGe5L7yDuOvCr4UxwQ,3651
-infisical_sdk/client.py,sha256=07IgDFDOnXrkTRoEeQ7idvCDBvZy72ELCzsgv9irpkg,10935
-infisical_sdk/infisical_requests.py,sha256=7y-0FS2BnlDRjfgZ4eRMXwPhA9-A7hLO3lCSOC63qt4,5661
-infisicalsdk-0.1.4.dist-info/METADATA,sha256=LEpbLrH3Ci6xoLS2FVyfN7PDriY9mMZAK7VP1e-hn3k,763
-infisicalsdk-0.1.4.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-infisicalsdk-0.1.4.dist-info/top_level.txt,sha256=FvJjMGD1FvxwipO_qFajdH20yNV8n3lJ7G3DkQoPJNU,14
-infisicalsdk-0.1.4.dist-info/RECORD,,

infisicalsdk-0.1.4.dist-info/top_level.txt

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