capo-codeguru-security 0.1.0__py3-none-any.whl

capo_codeguru_security/types/status.py

@@ -0,0 +1,18 @@
+"""Generated from Smithy shape ``com.amazonaws.codegurusecurity#Status``."""
+
+from typing import Literal, TypeAlias, cast
+
+Status: TypeAlias = Literal[
+    "Closed",
+    "Open",
+    "All",
+]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: Status) -> str:
+    return value
+
+
+def deserialize_json(data: str) -> Status:
+    return cast(Status, data)

capo_codeguru_security/types/suggested_fix.py

@@ -0,0 +1,29 @@
+"""Generated from Smithy shape ``com.amazonaws.codegurusecurity#SuggestedFix``."""
+
+from typing_extensions import NotRequired, TypedDict
+
+
+class SuggestedFix(TypedDict, closed=True):
+    description: NotRequired["str"]
+    """<p>A description of the suggested code fix and why it is being suggested. </p>"""
+    code: NotRequired["str"]
+    """<p>The suggested code fix. If applicable, includes code patch to replace your source code. </p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: SuggestedFix) -> dict:
+    out: dict = {}
+    if "description" in value:
+        out["description"] = value["description"]
+    if "code" in value:
+        out["code"] = value["code"]
+    return out
+
+
+def deserialize_json(data: dict) -> SuggestedFix:
+    out: SuggestedFix = {}  # type: ignore[typeddict-item]
+    if data.get("description") is not None:
+        out["description"] = data["description"]
+    if data.get("code") is not None:
+        out["code"] = data["code"]
+    return out

capo_codeguru_security/types/suggested_fixes.py

@@ -0,0 +1,31 @@
+"""Generated from Smithy shape ``com.amazonaws.codegurusecurity#SuggestedFixes``."""
+
+from typing import TYPE_CHECKING, TypeAlias
+
+if TYPE_CHECKING:
+    import capo_codeguru_security.types.suggested_fix
+
+SuggestedFixes: TypeAlias = list[
+    "capo_codeguru_security.types.suggested_fix.SuggestedFix"
+]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: SuggestedFixes) -> list:
+    import capo_codeguru_security.types.suggested_fix
+
+    out: list = []
+    for item in value:
+        out.append(capo_codeguru_security.types.suggested_fix.serialize_json(item))
+    return out
+
+
+def deserialize_json(data: list) -> SuggestedFixes:
+    import capo_codeguru_security.types.suggested_fix
+
+    out: SuggestedFixes = []
+    for item in data:
+        if item is None:
+            continue
+        out.append(capo_codeguru_security.types.suggested_fix.deserialize_json(item))
+    return out

capo_codeguru_security/types/tag_key.py

@@ -0,0 +1,5 @@
+"""Generated from Smithy shape ``com.amazonaws.codegurusecurity#TagKey``."""
+
+from typing import TypeAlias
+
+TagKey: TypeAlias = str

capo_codeguru_security/types/tag_key_list.py

@@ -0,0 +1,17 @@
+"""Generated from Smithy shape ``com.amazonaws.codegurusecurity#TagKeyList``."""
+
+from typing import TYPE_CHECKING, TypeAlias
+
+if TYPE_CHECKING:
+    import capo_codeguru_security.types.tag_key
+
+TagKeyList: TypeAlias = list["capo_codeguru_security.types.tag_key.TagKey"]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: TagKeyList) -> list:
+    return list(value)
+
+
+def deserialize_json(data: list) -> TagKeyList:
+    return [item for item in data if item is not None]

capo_codeguru_security/types/tag_map.py

@@ -0,0 +1,29 @@
+"""Generated from Smithy shape ``com.amazonaws.codegurusecurity#TagMap``."""
+
+from typing import TYPE_CHECKING, TypeAlias
+
+if TYPE_CHECKING:
+    import capo_codeguru_security.types.tag_key
+    import capo_codeguru_security.types.tag_value
+
+TagMap: TypeAlias = dict[
+    "capo_codeguru_security.types.tag_key.TagKey",
+    "capo_codeguru_security.types.tag_value.TagValue",
+]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(input_to_serialize: TagMap) -> dict:
+    out: dict = {}
+    for key, value in input_to_serialize.items():
+        out[key] = value
+    return out
+
+
+def deserialize_json(data: dict) -> TagMap:
+    out: TagMap = {}
+    for key, value in data.items():
+        if value is None:
+            continue
+        out[key] = value
+    return out

capo_codeguru_security/types/tag_resource_request.py

@@ -0,0 +1,40 @@
+"""Generated from Smithy shape ``com.amazonaws.codegurusecurity#TagResourceRequest``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import TypedDict
+
+from capo_codeguru_security.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_codeguru_security.types.scan_name_arn
+    import capo_codeguru_security.types.tag_map
+
+
+class TagResourceRequest(TypedDict, closed=True):
+    resource_arn: "capo_codeguru_security.types.scan_name_arn.ScanNameArn"
+    """<p>The ARN of the <code>ScanName</code> object. You can retrieve this ARN by calling <code>CreateScan</code>, <code>ListScans</code>, or <code>GetScan</code>.</p>"""
+    tags: "capo_codeguru_security.types.tag_map.TagMap"
+    """<p>An array of key-value pairs used to tag an existing scan. A tag is a custom attribute label with two parts:</p> <ul> <li> <p>A tag key. For example, <code>CostCenter</code>, <code>Environment</code>, or <code>Secret</code>. Tag keys are case sensitive.</p> </li> <li> <p>An optional tag value field. For example, <code>111122223333</code>, <code>Production</code>, or a team name. Omitting the tag value is the same as using an empty string. Tag values are case sensitive.</p> </li> </ul>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: TagResourceRequest) -> dict:
+    out: dict = {}
+    import capo_codeguru_security.types.tag_map
+
+    out["tags"] = capo_codeguru_security.types.tag_map.serialize_json(value["tags"])
+    return out
+
+
+def deserialize_json(data: dict) -> TagResourceRequest:
+    out: TagResourceRequest = {}  # type: ignore[typeddict-item]
+    if data.get("tags") is not None:
+        import capo_codeguru_security.types.tag_map
+
+        out["tags"] = capo_codeguru_security.types.tag_map.deserialize_json(
+            data["tags"]
+        )
+    else:
+        raise DeserializationError("TagResourceRequest.tags required")
+    return out

capo_codeguru_security/types/tag_resource_response.py

@@ -0,0 +1,18 @@
+"""Generated from Smithy shape ``com.amazonaws.codegurusecurity#TagResourceResponse``."""
+
+from typing_extensions import TypedDict
+
+
+class TagResourceResponse(TypedDict, closed=True):
+    pass
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: TagResourceResponse) -> dict:
+    out: dict = {}
+    return out
+
+
+def deserialize_json(data: dict) -> TagResourceResponse:
+    out: TagResourceResponse = {}  # type: ignore[typeddict-item]
+    return out

capo_codeguru_security/types/tag_value.py

@@ -0,0 +1,5 @@
+"""Generated from Smithy shape ``com.amazonaws.codegurusecurity#TagValue``."""
+
+from typing import TypeAlias
+
+TagValue: TypeAlias = str

capo_codeguru_security/types/untag_resource_request.py

@@ -0,0 +1,27 @@
+"""Generated from Smithy shape ``com.amazonaws.codegurusecurity#UntagResourceRequest``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import TypedDict
+
+if TYPE_CHECKING:
+    import capo_codeguru_security.types.scan_name_arn
+    import capo_codeguru_security.types.tag_key_list
+
+
+class UntagResourceRequest(TypedDict, closed=True):
+    resource_arn: "capo_codeguru_security.types.scan_name_arn.ScanNameArn"
+    """<p>The ARN of the <code>ScanName</code> object. You can retrieve this ARN by calling <code>CreateScan</code>, <code>ListScans</code>, or <code>GetScan</code>.</p>"""
+    tag_keys: "capo_codeguru_security.types.tag_key_list.TagKeyList"
+    """<p>A list of keys for each tag you want to remove from a scan.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: UntagResourceRequest) -> dict:
+    out: dict = {}
+    return out
+
+
+def deserialize_json(data: dict) -> UntagResourceRequest:
+    out: UntagResourceRequest = {}  # type: ignore[typeddict-item]
+    return out

capo_codeguru_security/types/untag_resource_response.py

@@ -0,0 +1,18 @@
+"""Generated from Smithy shape ``com.amazonaws.codegurusecurity#UntagResourceResponse``."""
+
+from typing_extensions import TypedDict
+
+
+class UntagResourceResponse(TypedDict, closed=True):
+    pass
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: UntagResourceResponse) -> dict:
+    out: dict = {}
+    return out
+
+
+def deserialize_json(data: dict) -> UntagResourceResponse:
+    out: UntagResourceResponse = {}  # type: ignore[typeddict-item]
+    return out

capo_codeguru_security/types/update_account_configuration_request.py

@@ -0,0 +1,45 @@
+"""Generated from Smithy shape ``com.amazonaws.codegurusecurity#UpdateAccountConfigurationRequest``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import TypedDict
+
+from capo_codeguru_security.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_codeguru_security.types.encryption_config
+
+
+class UpdateAccountConfigurationRequest(TypedDict, closed=True):
+    encryption_config: "capo_codeguru_security.types.encryption_config.EncryptionConfig"
+    """<p>The customer-managed KMS key ARN you want to use for encryption. If not specified, CodeGuru Security will use an AWS-managed key for encryption. If you previously specified a customer-managed KMS key and want CodeGuru Security to use an AWS-managed key for encryption instead, pass nothing.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: UpdateAccountConfigurationRequest) -> dict:
+    out: dict = {}
+    import capo_codeguru_security.types.encryption_config
+
+    out["encryptionConfig"] = (
+        capo_codeguru_security.types.encryption_config.serialize_json(
+            value["encryption_config"]
+        )
+    )
+    return out
+
+
+def deserialize_json(data: dict) -> UpdateAccountConfigurationRequest:
+    out: UpdateAccountConfigurationRequest = {}  # type: ignore[typeddict-item]
+    if data.get("encryptionConfig") is not None:
+        import capo_codeguru_security.types.encryption_config
+
+        out["encryption_config"] = (
+            capo_codeguru_security.types.encryption_config.deserialize_json(
+                data["encryptionConfig"]
+            )
+        )
+    else:
+        raise DeserializationError(
+            "UpdateAccountConfigurationRequest.encryption_config required"
+        )
+    return out

capo_codeguru_security/types/update_account_configuration_response.py

@@ -0,0 +1,45 @@
+"""Generated from Smithy shape ``com.amazonaws.codegurusecurity#UpdateAccountConfigurationResponse``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import TypedDict
+
+from capo_codeguru_security.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_codeguru_security.types.encryption_config
+
+
+class UpdateAccountConfigurationResponse(TypedDict, closed=True):
+    encryption_config: "capo_codeguru_security.types.encryption_config.EncryptionConfig"
+    """<p>An <code>EncryptionConfig</code> object that contains the KMS key ARN that is used for encryption. If you did not specify a customer-managed KMS key in the request, returns empty. </p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: UpdateAccountConfigurationResponse) -> dict:
+    out: dict = {}
+    import capo_codeguru_security.types.encryption_config
+
+    out["encryptionConfig"] = (
+        capo_codeguru_security.types.encryption_config.serialize_json(
+            value["encryption_config"]
+        )
+    )
+    return out
+
+
+def deserialize_json(data: dict) -> UpdateAccountConfigurationResponse:
+    out: UpdateAccountConfigurationResponse = {}  # type: ignore[typeddict-item]
+    if data.get("encryptionConfig") is not None:
+        import capo_codeguru_security.types.encryption_config
+
+        out["encryption_config"] = (
+            capo_codeguru_security.types.encryption_config.deserialize_json(
+                data["encryptionConfig"]
+            )
+        )
+    else:
+        raise DeserializationError(
+            "UpdateAccountConfigurationResponse.encryption_config required"
+        )
+    return out

capo_codeguru_security/types/uuid.py

@@ -0,0 +1,5 @@
+"""Generated from Smithy shape ``com.amazonaws.codegurusecurity#Uuid``."""
+
+from typing import TypeAlias
+
+Uuid: TypeAlias = str

capo_codeguru_security/types/validation_exception_field.py

@@ -0,0 +1,33 @@
+"""Generated from Smithy shape ``com.amazonaws.codegurusecurity#ValidationExceptionField``."""
+
+from typing_extensions import TypedDict
+
+from capo_codeguru_security.errors import DeserializationError
+
+
+class ValidationExceptionField(TypedDict, closed=True):
+    name: "str"
+    """<p>The name of the exception.</p>"""
+    message: "str"
+    """<p>Describes the exception.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ValidationExceptionField) -> dict:
+    out: dict = {}
+    out["name"] = value["name"]
+    out["message"] = value["message"]
+    return out
+
+
+def deserialize_json(data: dict) -> ValidationExceptionField:
+    out: ValidationExceptionField = {}  # type: ignore[typeddict-item]
+    if data.get("name") is not None:
+        out["name"] = data["name"]
+    else:
+        raise DeserializationError("ValidationExceptionField.name required")
+    if data.get("message") is not None:
+        out["message"] = data["message"]
+    else:
+        raise DeserializationError("ValidationExceptionField.message required")
+    return out

capo_codeguru_security/types/validation_exception_field_list.py

@@ -0,0 +1,37 @@
+"""Generated from Smithy shape ``com.amazonaws.codegurusecurity#ValidationExceptionFieldList``."""
+
+from typing import TYPE_CHECKING, TypeAlias
+
+if TYPE_CHECKING:
+    import capo_codeguru_security.types.validation_exception_field
+
+ValidationExceptionFieldList: TypeAlias = list[
+    "capo_codeguru_security.types.validation_exception_field.ValidationExceptionField"
+]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ValidationExceptionFieldList) -> list:
+    import capo_codeguru_security.types.validation_exception_field
+
+    out: list = []
+    for item in value:
+        out.append(
+            capo_codeguru_security.types.validation_exception_field.serialize_json(item)
+        )
+    return out
+
+
+def deserialize_json(data: list) -> ValidationExceptionFieldList:
+    import capo_codeguru_security.types.validation_exception_field
+
+    out: ValidationExceptionFieldList = []
+    for item in data:
+        if item is None:
+            continue
+        out.append(
+            capo_codeguru_security.types.validation_exception_field.deserialize_json(
+                item
+            )
+        )
+    return out

capo_codeguru_security/types/validation_exception_reason.py

@@ -0,0 +1,20 @@
+"""Generated from Smithy shape ``com.amazonaws.codegurusecurity#ValidationExceptionReason``."""
+
+from typing import Literal, TypeAlias, cast
+
+ValidationExceptionReason: TypeAlias = Literal[
+    "unknownOperation",
+    "cannotParse",
+    "fieldValidationFailed",
+    "other",
+    "lambdaCodeShaMisMatch",
+]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ValidationExceptionReason) -> str:
+    return value
+
+
+def deserialize_json(data: str) -> ValidationExceptionReason:
+    return cast(ValidationExceptionReason, data)

capo_codeguru_security/types/vulnerability.py

@@ -0,0 +1,90 @@
+"""Generated from Smithy shape ``com.amazonaws.codegurusecurity#Vulnerability``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_codeguru_security.types.file_path
+    import capo_codeguru_security.types.reference_urls
+    import capo_codeguru_security.types.related_vulnerabilities
+
+
+class Vulnerability(TypedDict, closed=True):
+    reference_urls: NotRequired[
+        "capo_codeguru_security.types.reference_urls.ReferenceUrls"
+    ]
+    """<p>One or more URL addresses that contain details about a vulnerability.</p>"""
+    related_vulnerabilities: NotRequired[
+        "capo_codeguru_security.types.related_vulnerabilities.RelatedVulnerabilities"
+    ]
+    """<p>One or more vulnerabilities that are related to the vulnerability being described.</p>"""
+    id: NotRequired["str"]
+    """<p>The identifier for the vulnerability.</p>"""
+    file_path: NotRequired["capo_codeguru_security.types.file_path.FilePath"]
+    """<p> An object that describes the location of the detected security vulnerability in your code.</p>"""
+    item_count: NotRequired["int"]
+    """<p>The number of times the vulnerability appears in your code.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: Vulnerability) -> dict:
+    out: dict = {}
+    if "reference_urls" in value:
+        import capo_codeguru_security.types.reference_urls
+
+        out["referenceUrls"] = (
+            capo_codeguru_security.types.reference_urls.serialize_json(
+                value["reference_urls"]
+            )
+        )
+    if "related_vulnerabilities" in value:
+        import capo_codeguru_security.types.related_vulnerabilities
+
+        out["relatedVulnerabilities"] = (
+            capo_codeguru_security.types.related_vulnerabilities.serialize_json(
+                value["related_vulnerabilities"]
+            )
+        )
+    if "id" in value:
+        out["id"] = value["id"]
+    if "file_path" in value:
+        import capo_codeguru_security.types.file_path
+
+        out["filePath"] = capo_codeguru_security.types.file_path.serialize_json(
+            value["file_path"]
+        )
+    if "item_count" in value:
+        out["itemCount"] = value["item_count"]
+    return out
+
+
+def deserialize_json(data: dict) -> Vulnerability:
+    out: Vulnerability = {}  # type: ignore[typeddict-item]
+    if data.get("referenceUrls") is not None:
+        import capo_codeguru_security.types.reference_urls
+
+        out["reference_urls"] = (
+            capo_codeguru_security.types.reference_urls.deserialize_json(
+                data["referenceUrls"]
+            )
+        )
+    if data.get("relatedVulnerabilities") is not None:
+        import capo_codeguru_security.types.related_vulnerabilities
+
+        out["related_vulnerabilities"] = (
+            capo_codeguru_security.types.related_vulnerabilities.deserialize_json(
+                data["relatedVulnerabilities"]
+            )
+        )
+    if data.get("id") is not None:
+        out["id"] = data["id"]
+    if data.get("filePath") is not None:
+        import capo_codeguru_security.types.file_path
+
+        out["file_path"] = capo_codeguru_security.types.file_path.deserialize_json(
+            data["filePath"]
+        )
+    if data.get("itemCount") is not None:
+        out["item_count"] = data["itemCount"]
+    return out

capo_codeguru_security-0.1.0.dist-info/METADATA

@@ -0,0 +1,101 @@
+Metadata-Version: 2.4
+Name: capo-codeguru-security
+Version: 0.1.0
+Summary: Python SDK for Codeguru Security.
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Software Development :: Code Generators
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: zapros>=0.13.0
+Provides-Extra: sso
+Requires-Dist: capo-sso>=0.2.0; extra == "sso"
+Requires-Dist: capo-sso-oidc>=0.2.0; extra == "sso"
+Requires-Dist: capo-sts>=0.3.0; extra == "sso"
+Dynamic: license-file
+
+# Getting Started
+
+## Installation
+
+```
+pip install capo-codeguru-security
+```
+
+## Usage
+
+```python
+from capo_codeguru_security import AsyncCodeGuruSecurityClient
+
+
+async def main():
+    async with AsyncCodeGuruSecurityClient() as code_guru_security:
+        # Example: call the batch_get_findings operation
+        response = await code_guru_security.batch_get_findings()
+        print(response["findings"])
+```
+
+## Pagination
+
+Some operations in this SDK support pagination. If the operation supports pagination it will have an `iter_` prefixed method that returns an async iterator.
+
+```python
+from capo_codeguru_security import AsyncCodeGuruSecurityClient
+
+
+async def main():
+    async with AsyncCodeGuruSecurityClient() as code_guru_security:
+        # Example: paginate over get_findings
+        async for item in code_guru_security.iter_get_findings():
+            print(item)
+```
+
+## Error Handling
+
+The SDK raises exceptions for errors returned by the API. Catch them to handle failures gracefully.
+
+```python
+from capo_codeguru_security import AsyncCodeGuruSecurityClient
+from capo_codeguru_security.error import AccessDeniedException
+
+
+async def main():
+    async with AsyncCodeGuruSecurityClient() as code_guru_security:
+        try:
+            await code_guru_security.batch_get_findings()
+        except AccessDeniedException as e:
+            print(f"Error: {e}")
+            print(e.data)  # additional error data
+```
+
+## Retrying
+
+The SDK retries failed operations automatically. Retry behaviour follows the Smithy specification: errors are retried based on their `is_retryable` and `is_throttling_error` attributes. Throttling errors use a longer base delay. Network-level failures (connection errors and timeouts) are also retried. Non-retryable errors, such as client errors without the `@retryable` trait, are raised immediately without further attempts.
+
+The number of attempts defaults to 3 and can be changed at the client level via `retry_max_attempts`, or per call via `config_overrides`.
+
+```python
+from capo_codeguru_security import AsyncCodeGuruSecurityClient
+
+
+async def main():
+    async with AsyncCodeGuruSecurityClient() as code_guru_security:
+        # Default: 3 attempts for every operation
+        response = await code_guru_security.batch_get_findings()
+
+        # Override per operation
+        response = await code_guru_security.batch_get_findings(config_overrides={"retry_max_attempts": 5})
+
+        # Disable retries for this call
+        response = await code_guru_security.batch_get_findings(config_overrides={"retry_max_attempts": 1})
+```