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

capo_codeguru_security/types/metrics_summary.py

@@ -0,0 +1,121 @@
+"""Generated from Smithy shape ``com.amazonaws.codegurusecurity#MetricsSummary``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import datetime
+
+    import capo_codeguru_security.types.categories_with_most_findings
+    import capo_codeguru_security.types.finding_metrics_value_per_severity
+    import capo_codeguru_security.types.scans_with_most_open_critical_findings
+    import capo_codeguru_security.types.scans_with_most_open_findings
+
+
+class MetricsSummary(TypedDict, closed=True):
+    date: NotRequired["datetime.datetime"]
+    """<p>The date from which the metrics summary information was retrieved.</p>"""
+    open_findings: NotRequired[
+        "capo_codeguru_security.types.finding_metrics_value_per_severity.FindingMetricsValuePerSeverity"
+    ]
+    """<p>The number of open findings of each severity.</p>"""
+    categories_with_most_findings: NotRequired[
+        "capo_codeguru_security.types.categories_with_most_findings.CategoriesWithMostFindings"
+    ]
+    """<p>A list of <code>CategoryWithFindingNum</code> objects for the top 5 finding categories with the most findings.</p>"""
+    scans_with_most_open_findings: NotRequired[
+        "capo_codeguru_security.types.scans_with_most_open_findings.ScansWithMostOpenFindings"
+    ]
+    """<p>A list of <code>ScanNameWithFindingNum</code> objects for the top 3 scans with the most number of open findings.</p>"""
+    scans_with_most_open_critical_findings: NotRequired[
+        "capo_codeguru_security.types.scans_with_most_open_critical_findings.ScansWithMostOpenCriticalFindings"
+    ]
+    """<p>A list of <code>ScanNameWithFindingNum</code> objects for the top 3 scans with the most number of open critical findings.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: MetricsSummary) -> dict:
+    out: dict = {}
+    if "date" in value:
+        import capo_codeguru_security.types._prelude.timestamp
+
+        out["date"] = capo_codeguru_security.types._prelude.timestamp.serialize_json(
+            value["date"]
+        )
+    if "open_findings" in value:
+        import capo_codeguru_security.types.finding_metrics_value_per_severity
+
+        out["openFindings"] = (
+            capo_codeguru_security.types.finding_metrics_value_per_severity.serialize_json(
+                value["open_findings"]
+            )
+        )
+    if "categories_with_most_findings" in value:
+        import capo_codeguru_security.types.categories_with_most_findings
+
+        out["categoriesWithMostFindings"] = (
+            capo_codeguru_security.types.categories_with_most_findings.serialize_json(
+                value["categories_with_most_findings"]
+            )
+        )
+    if "scans_with_most_open_findings" in value:
+        import capo_codeguru_security.types.scans_with_most_open_findings
+
+        out["scansWithMostOpenFindings"] = (
+            capo_codeguru_security.types.scans_with_most_open_findings.serialize_json(
+                value["scans_with_most_open_findings"]
+            )
+        )
+    if "scans_with_most_open_critical_findings" in value:
+        import capo_codeguru_security.types.scans_with_most_open_critical_findings
+
+        out["scansWithMostOpenCriticalFindings"] = (
+            capo_codeguru_security.types.scans_with_most_open_critical_findings.serialize_json(
+                value["scans_with_most_open_critical_findings"]
+            )
+        )
+    return out
+
+
+def deserialize_json(data: dict) -> MetricsSummary:
+    out: MetricsSummary = {}  # type: ignore[typeddict-item]
+    if data.get("date") is not None:
+        import capo_codeguru_security.types._prelude.timestamp
+
+        out["date"] = capo_codeguru_security.types._prelude.timestamp.deserialize_json(
+            data["date"]
+        )
+    if data.get("openFindings") is not None:
+        import capo_codeguru_security.types.finding_metrics_value_per_severity
+
+        out["open_findings"] = (
+            capo_codeguru_security.types.finding_metrics_value_per_severity.deserialize_json(
+                data["openFindings"]
+            )
+        )
+    if data.get("categoriesWithMostFindings") is not None:
+        import capo_codeguru_security.types.categories_with_most_findings
+
+        out["categories_with_most_findings"] = (
+            capo_codeguru_security.types.categories_with_most_findings.deserialize_json(
+                data["categoriesWithMostFindings"]
+            )
+        )
+    if data.get("scansWithMostOpenFindings") is not None:
+        import capo_codeguru_security.types.scans_with_most_open_findings
+
+        out["scans_with_most_open_findings"] = (
+            capo_codeguru_security.types.scans_with_most_open_findings.deserialize_json(
+                data["scansWithMostOpenFindings"]
+            )
+        )
+    if data.get("scansWithMostOpenCriticalFindings") is not None:
+        import capo_codeguru_security.types.scans_with_most_open_critical_findings
+
+        out["scans_with_most_open_critical_findings"] = (
+            capo_codeguru_security.types.scans_with_most_open_critical_findings.deserialize_json(
+                data["scansWithMostOpenCriticalFindings"]
+            )
+        )
+    return out

capo_codeguru_security/types/next_token.py

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

capo_codeguru_security/types/recommendation.py

@@ -0,0 +1,29 @@
+"""Generated from Smithy shape ``com.amazonaws.codegurusecurity#Recommendation``."""
+
+from typing_extensions import NotRequired, TypedDict
+
+
+class Recommendation(TypedDict, closed=True):
+    text: NotRequired["str"]
+    """<p>The recommended course of action to remediate the finding.</p>"""
+    url: NotRequired["str"]
+    """<p>The URL address to the recommendation for remediating the finding. </p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: Recommendation) -> dict:
+    out: dict = {}
+    if "text" in value:
+        out["text"] = value["text"]
+    if "url" in value:
+        out["url"] = value["url"]
+    return out
+
+
+def deserialize_json(data: dict) -> Recommendation:
+    out: Recommendation = {}  # type: ignore[typeddict-item]
+    if data.get("text") is not None:
+        out["text"] = data["text"]
+    if data.get("url") is not None:
+        out["url"] = data["url"]
+    return out

capo_codeguru_security/types/reference_urls.py

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

capo_codeguru_security/types/related_vulnerabilities.py

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

capo_codeguru_security/types/remediation.py

@@ -0,0 +1,63 @@
+"""Generated from Smithy shape ``com.amazonaws.codegurusecurity#Remediation``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_codeguru_security.types.recommendation
+    import capo_codeguru_security.types.suggested_fixes
+
+
+class Remediation(TypedDict, closed=True):
+    recommendation: NotRequired[
+        "capo_codeguru_security.types.recommendation.Recommendation"
+    ]
+    """<p>An object that contains information about the recommended course of action to remediate a finding.</p>"""
+    suggested_fixes: NotRequired[
+        "capo_codeguru_security.types.suggested_fixes.SuggestedFixes"
+    ]
+    """<p>A list of <code>SuggestedFix</code> objects. Each object contains information about a suggested code fix to remediate the finding.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: Remediation) -> dict:
+    out: dict = {}
+    if "recommendation" in value:
+        import capo_codeguru_security.types.recommendation
+
+        out["recommendation"] = (
+            capo_codeguru_security.types.recommendation.serialize_json(
+                value["recommendation"]
+            )
+        )
+    if "suggested_fixes" in value:
+        import capo_codeguru_security.types.suggested_fixes
+
+        out["suggestedFixes"] = (
+            capo_codeguru_security.types.suggested_fixes.serialize_json(
+                value["suggested_fixes"]
+            )
+        )
+    return out
+
+
+def deserialize_json(data: dict) -> Remediation:
+    out: Remediation = {}  # type: ignore[typeddict-item]
+    if data.get("recommendation") is not None:
+        import capo_codeguru_security.types.recommendation
+
+        out["recommendation"] = (
+            capo_codeguru_security.types.recommendation.deserialize_json(
+                data["recommendation"]
+            )
+        )
+    if data.get("suggestedFixes") is not None:
+        import capo_codeguru_security.types.suggested_fixes
+
+        out["suggested_fixes"] = (
+            capo_codeguru_security.types.suggested_fixes.deserialize_json(
+                data["suggestedFixes"]
+            )
+        )
+    return out

capo_codeguru_security/types/request_header_map.py

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

capo_codeguru_security/types/resource.py

@@ -0,0 +1,29 @@
+"""Generated from Smithy shape ``com.amazonaws.codegurusecurity#Resource``."""
+
+from typing_extensions import NotRequired, TypedDict
+
+
+class Resource(TypedDict, closed=True):
+    id: NotRequired["str"]
+    """<p>The <code>scanName</code> of the scan that was run on the resource.</p>"""
+    sub_resource_id: NotRequired["str"]
+    """<p>The identifier for a section of the resource.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: Resource) -> dict:
+    out: dict = {}
+    if "id" in value:
+        out["id"] = value["id"]
+    if "sub_resource_id" in value:
+        out["subResourceId"] = value["sub_resource_id"]
+    return out
+
+
+def deserialize_json(data: dict) -> Resource:
+    out: Resource = {}  # type: ignore[typeddict-item]
+    if data.get("id") is not None:
+        out["id"] = data["id"]
+    if data.get("subResourceId") is not None:
+        out["sub_resource_id"] = data["subResourceId"]
+    return out

capo_codeguru_security/types/resource_id.py

@@ -0,0 +1,32 @@
+"""Generated from Smithy shape ``com.amazonaws.codegurusecurity#ResourceId``."""
+
+from typing import TYPE_CHECKING, TypeAlias
+
+from typing_extensions import TypedDict
+
+from capo_codeguru_security.errors import DeserializationError, SerializationError
+
+if TYPE_CHECKING:
+    import capo_codeguru_security.types.uuid
+
+
+class _ResourceId_codeArtifactId(TypedDict, closed=True):
+    codeArtifactId: "capo_codeguru_security.types.uuid.Uuid"
+
+
+ResourceId: TypeAlias = _ResourceId_codeArtifactId
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ResourceId) -> dict:
+    if "codeArtifactId" in value:
+        return {"codeArtifactId": value["codeArtifactId"]}
+    else:
+        raise SerializationError("ResourceId: no variant present")
+
+
+def deserialize_json(data: dict) -> ResourceId:
+    if data.get("codeArtifactId") is not None:
+        return {"codeArtifactId": data["codeArtifactId"]}
+    else:
+        raise DeserializationError("ResourceId: no recognized variant key")

capo_codeguru_security/types/s3_url.py

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

capo_codeguru_security/types/scan_name.py

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

capo_codeguru_security/types/scan_name_arn.py

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

capo_codeguru_security/types/scan_name_with_finding_num.py

@@ -0,0 +1,29 @@
+"""Generated from Smithy shape ``com.amazonaws.codegurusecurity#ScanNameWithFindingNum``."""
+
+from typing_extensions import NotRequired, TypedDict
+
+
+class ScanNameWithFindingNum(TypedDict, closed=True):
+    scan_name: NotRequired["str"]
+    """<p>The name of the scan.</p>"""
+    finding_number: NotRequired["int"]
+    """<p>The number of findings generated by a scan.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ScanNameWithFindingNum) -> dict:
+    out: dict = {}
+    if "scan_name" in value:
+        out["scanName"] = value["scan_name"]
+    if "finding_number" in value:
+        out["findingNumber"] = value["finding_number"]
+    return out
+
+
+def deserialize_json(data: dict) -> ScanNameWithFindingNum:
+    out: ScanNameWithFindingNum = {}  # type: ignore[typeddict-item]
+    if data.get("scanName") is not None:
+        out["scan_name"] = data["scanName"]
+    if data.get("findingNumber") is not None:
+        out["finding_number"] = data["findingNumber"]
+    return out

capo_codeguru_security/types/scan_state.py

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

capo_codeguru_security/types/scan_summaries.py

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

capo_codeguru_security/types/scan_summary.py

@@ -0,0 +1,99 @@
+"""Generated from Smithy shape ``com.amazonaws.codegurusecurity#ScanSummary``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_codeguru_security.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import datetime
+
+    import capo_codeguru_security.types.scan_name
+    import capo_codeguru_security.types.scan_name_arn
+    import capo_codeguru_security.types.scan_state
+    import capo_codeguru_security.types.uuid
+
+
+class ScanSummary(TypedDict, closed=True):
+    scan_state: "capo_codeguru_security.types.scan_state.ScanState"
+    """<p>The state of the scan. A scan can be <code>In Progress</code>, <code>Complete</code>, or <code>Failed</code>. </p>"""
+    created_at: "datetime.datetime"
+    """<p> The time when the scan was created. </p>"""
+    updated_at: NotRequired["datetime.datetime"]
+    """<p>The time the scan was last updated. A scan is updated when it is re-run.</p>"""
+    scan_name: "capo_codeguru_security.types.scan_name.ScanName"
+    """<p>The name of the scan. </p>"""
+    run_id: "capo_codeguru_security.types.uuid.Uuid"
+    """<p>The identifier for the scan run. </p>"""
+    scan_name_arn: NotRequired["capo_codeguru_security.types.scan_name_arn.ScanNameArn"]
+    """<p>The ARN for the scan name.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ScanSummary) -> dict:
+    out: dict = {}
+    import capo_codeguru_security.types.scan_state
+
+    out["scanState"] = capo_codeguru_security.types.scan_state.serialize_json(
+        value["scan_state"]
+    )
+    import capo_codeguru_security.types._prelude.timestamp
+
+    out["createdAt"] = capo_codeguru_security.types._prelude.timestamp.serialize_json(
+        value["created_at"]
+    )
+    if "updated_at" in value:
+        import capo_codeguru_security.types._prelude.timestamp
+
+        out["updatedAt"] = (
+            capo_codeguru_security.types._prelude.timestamp.serialize_json(
+                value["updated_at"]
+            )
+        )
+    out["scanName"] = value["scan_name"]
+    out["runId"] = value["run_id"]
+    if "scan_name_arn" in value:
+        out["scanNameArn"] = value["scan_name_arn"]
+    return out
+
+
+def deserialize_json(data: dict) -> ScanSummary:
+    out: ScanSummary = {}  # type: ignore[typeddict-item]
+    if data.get("scanState") is not None:
+        import capo_codeguru_security.types.scan_state
+
+        out["scan_state"] = capo_codeguru_security.types.scan_state.deserialize_json(
+            data["scanState"]
+        )
+    else:
+        raise DeserializationError("ScanSummary.scan_state required")
+    if data.get("createdAt") is not None:
+        import capo_codeguru_security.types._prelude.timestamp
+
+        out["created_at"] = (
+            capo_codeguru_security.types._prelude.timestamp.deserialize_json(
+                data["createdAt"]
+            )
+        )
+    else:
+        raise DeserializationError("ScanSummary.created_at required")
+    if data.get("updatedAt") is not None:
+        import capo_codeguru_security.types._prelude.timestamp
+
+        out["updated_at"] = (
+            capo_codeguru_security.types._prelude.timestamp.deserialize_json(
+                data["updatedAt"]
+            )
+        )
+    if data.get("scanName") is not None:
+        out["scan_name"] = data["scanName"]
+    else:
+        raise DeserializationError("ScanSummary.scan_name required")
+    if data.get("runId") is not None:
+        out["run_id"] = data["runId"]
+    else:
+        raise DeserializationError("ScanSummary.run_id required")
+    if data.get("scanNameArn") is not None:
+        out["scan_name_arn"] = data["scanNameArn"]
+    return out

capo_codeguru_security/types/scan_type.py

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

capo_codeguru_security/types/scans_with_most_open_critical_findings.py

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

capo_codeguru_security/types/scans_with_most_open_findings.py

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

capo_codeguru_security/types/severity.py

@@ -0,0 +1,20 @@
+"""Generated from Smithy shape ``com.amazonaws.codegurusecurity#Severity``."""
+
+from typing import Literal, TypeAlias, cast
+
+Severity: TypeAlias = Literal[
+    "Critical",
+    "High",
+    "Medium",
+    "Low",
+    "Info",
+]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: Severity) -> str:
+    return value
+
+
+def deserialize_json(data: str) -> Severity:
+    return cast(Severity, data)