Continuum / Client / get_code_issue_artifact

get_code_issue_artifact

Continuum.Client.get_code_issue_artifact(**kwargs)

Retrieves one immutable artifact attached to an issue, including its content.

See also: AWS API Documentation

Request Syntax

response = client.get_code_issue_artifact(
    environmentId='string',
    issueId='string',
    artifactId='string'
)

Parameters:

• environmentId (string) –

  [REQUIRED]

  The environment that owns the issue.

• issueId (string) –

  [REQUIRED]

  The issue the artifact is attached to.

• artifactId (string) –

  [REQUIRED]

  The unique identifier of the artifact to retrieve.

Return type:

dict

Returns:

Response Syntax

{
    'artifactId': 'string',
    'artifactType': 'EVIDENCE'|'AGENT_COMMUNICATION'|'VALIDATION_EVIDENCE'|'REMEDIATION_PROPOSAL'|'DECISION'|'PATCH',
    'mediaType': 'string',
    'body': {
        'validationEvidence': {
            'exploitable': 'EXPLOITABLE'|'NOT_EXPLOITABLE'|'UNCERTAIN',
            'terminalStatus': 'COMPLETED'|'FAILED'|'NO_SOURCE_AVAILABLE'|'PARTIAL',
            'flowVerdicts': [
                {
                    'flowId': 'string',
                    'verdict': 'CONFIRMED'|'DENIED'|'INCONCLUSIVE',
                    'confidence': 123.0,
                    'evidence': [
                        'string',
                    ]
                },
            ],
            'attackFlowsConfirmed': [
                'string',
            ],
            'exploitArtifact': {
                'payload': 'string',
                'targetUrl': 'string',
                'httpMethod': 'GET'|'HEAD'|'POST'|'PUT'|'PATCH'|'DELETE'|'OPTIONS',
                'headers': {
                    'string': 'string'
                },
                'responseStatus': 123,
                'responseSnippet': 'string',
                'effect': 'DATA_LEAKED'|'ERROR_REVEALED'|'BEHAVIOR_CHANGED'|'NO_EFFECT'
            },
            'executedProof': {
                'code': {
                    'proofCode': [
                        {
                            'content': 'string'
                        },
                    ]
                },
                'output': {
                    'consoleOutput': 'string'
                },
                'observedEffect': 'DATA_LEAKED'|'ERROR_REVEALED'|'BEHAVIOR_CHANGED'|'NO_EFFECT'
            },
            'sourceAnalysis': {
                'summary': 'string',
                'inferredEffect': 'DATA_LEAKED'|'ERROR_REVEALED'|'BEHAVIOR_CHANGED'|'NO_EFFECT'
            },
            'perFindingResults': [
                {
                    'findingId': 'string',
                    'exploitable': 'EXPLOITABLE'|'NOT_EXPLOITABLE'|'UNCERTAIN',
                    'confidence': 123.0,
                    'flowVerdicts': [
                        {
                            'flowId': 'string',
                            'verdict': 'CONFIRMED'|'DENIED'|'INCONCLUSIVE',
                            'confidence': 123.0,
                            'evidence': [
                                'string',
                            ]
                        },
                    ],
                    'reasoningChain': [
                        {
                            'step': 123,
                            'claim': 'string',
                            'source': 'string',
                            'confidence': 123.0
                        },
                    ],
                    'exploitArtifact': {
                        'payload': 'string',
                        'targetUrl': 'string',
                        'httpMethod': 'GET'|'HEAD'|'POST'|'PUT'|'PATCH'|'DELETE'|'OPTIONS',
                        'headers': {
                            'string': 'string'
                        },
                        'responseStatus': 123,
                        'responseSnippet': 'string',
                        'effect': 'DATA_LEAKED'|'ERROR_REVEALED'|'BEHAVIOR_CHANGED'|'NO_EFFECT'
                    }
                },
            ]
        },
        'prevalidationSignals': {
            'producedBy': 'string',
            'signals': [
                {
                    'subjectRef': 'string',
                    'dimension': 'EXPLOITABILITY'|'BLAST_RADIUS'|'NETWORK_EXPOSURE'|'PRECONDITION'|'CODE_CONTEXT'|'LIKELIHOOD_ASSESSMENT'|'IMPACT_ASSESSMENT',
                    'signalStrength': 'NONE'|'WEAK'|'MODERATE'|'STRONG',
                    'conclusion': 'string',
                    'producerId': 'string',
                    'producerVersion': 'string',
                    'confidence': 123.0,
                    'confidenceReasoning': {
                        'summary': 'string',
                        'factors': [
                            'string',
                        ]
                    },
                    'computed': {
                        'likelihoodBand': 'VERY_LOW'|'LOW'|'MODERATE'|'HIGH',
                        'impactBand': 'VERY_LOW'|'LOW'|'MODERATE'|'HIGH',
                        'barriers': 123
                    },
                    'preconditions': {
                        'reachableFromAttacker': {
                            'value': True|False,
                            'basis': 'CODE'|'GRAPH'|'FINDING'|'INFERRED'|'NO_EVIDENCE_DEFAULT',
                            'reason': 'string',
                            'missingInfo': 'string'
                        },
                        'configurationNeeded': {
                            'value': True|False,
                            'basis': 'CODE'|'GRAPH'|'FINDING'|'INFERRED'|'NO_EVIDENCE_DEFAULT',
                            'reason': 'string',
                            'missingInfo': 'string'
                        },
                        'accessLevel': {
                            'value': 'NONE'|'ANY_AUTHENTICATED'|'PRIVILEGED',
                            'basis': 'CODE'|'GRAPH'|'FINDING'|'INFERRED'|'NO_EVIDENCE_DEFAULT',
                            'reason': 'string',
                            'missingInfo': 'string'
                        },
                        'userInteractionRequired': {
                            'value': True|False,
                            'basis': 'CODE'|'GRAPH'|'FINDING'|'INFERRED'|'NO_EVIDENCE_DEFAULT',
                            'reason': 'string',
                            'missingInfo': 'string'
                        }
                    },
                    'impactDimensions': {
                        'attackerGains': {
                            'value': 'EXECUTE'|'MODIFY_PRIVILEGED'|'MODIFY_DATA'|'MODIFY_COSMETIC'|'READ'|'NEITHER',
                            'basis': 'CODE'|'GRAPH'|'FINDING'|'INFERRED'|'NO_EVIDENCE_DEFAULT',
                            'reason': 'string',
                            'missingInfo': 'string'
                        },
                        'blastRadius': {
                            'value': 'CROSS_TENANT'|'OTHER_USERS_IN_TENANT'|'OWN_SCOPE',
                            'basis': 'CODE'|'GRAPH'|'FINDING'|'INFERRED'|'NO_EVIDENCE_DEFAULT',
                            'reason': 'string',
                            'missingInfo': 'string'
                        },
                        'targetValue': {
                            'value': 'HIGH'|'MEDIUM'|'LOW',
                            'basis': 'CODE'|'GRAPH'|'FINDING'|'INFERRED'|'NO_EVIDENCE_DEFAULT',
                            'reason': 'string',
                            'missingInfo': 'string'
                        }
                    },
                    'exploitability': {
                        'verdict': 'EXPLOITABLE'|'NOT_EXPLOITABLE'|'UNCERTAIN',
                        'reachedCrownJewels': True|False,
                        'highestLayerReached': 123,
                        'confidenceTier': 'SOURCE_READ'|'STATIC_PROVEN'|'BUILD_PROVEN'|'RUNTIME_PROVEN',
                        'scriptable': True|False,
                        'sourceValidationArtifactId': 'string'
                    }
                },
            ]
        },
        'remediationProposal': {
            'patch': 'string',
            'format': 'GIT_MAILBOX_PATCH'|'GIT_BINARY_DIFF'|'GIT_DIFF',
            'filename': 'string',
            'patchSha256': 'string'
        },
        'patch': {
            'patch': 'string',
            'format': 'GIT_MAILBOX_PATCH'|'GIT_BINARY_DIFF'|'GIT_DIFF',
            'repositoryName': 'string',
            'patchSha256': 'string',
            'sizeBytes': 123,
            'delivery': {
                'status': 'PENDING'|'SUCCEEDED'|'FAILED'|'SKIPPED'|'ABANDONED',
                'target': {
                    's3': {
                        'bucket': 'string',
                        'key': 'string',
                        'version': 'string'
                    },
                    'github': {
                        'owner': 'string',
                        'repository': 'string',
                        'pullRequestNumber': 123,
                        'headSha': 'string'
                    }
                },
                'updatedAt': datetime(2015, 1, 1)
            }
        },
        'raw': 'string'
    },
    'metadata': {...}|[...]|123|123.4|'string'|True|None,
    'producer': {
        'agent': 'string'
    },
    'createdAt': datetime(2015, 1, 1)
}

Response Structure

• (dict) –

  Contains the requested artifact and its content.

  • artifactId (string) –

    The unique identifier of the artifact.

  • artifactType (string) –

    Semantic category of the artifact.

  • mediaType (string) –

    MIME type the producer declared for its content.

  • body (dict) –

    The artifact body, projected against the shape defined for its artifactType. A type with a defined shape is returned as that structure, and anything else through IssueArtifactBody.raw.

    Note

    This is a Tagged Union structure. Only one of the following top level keys will be set: validationEvidence, prevalidationSignals, remediationProposal, patch, raw. If a client receives an unknown member it will set SDK_UNKNOWN_MEMBER as the top level key, which maps to the name or tag of the unknown member. The structure of SDK_UNKNOWN_MEMBER is as follows:

    'SDK_UNKNOWN_MEMBER': {'name': 'UnknownMemberName'}
    

    • validationEvidence (dict) –

      Projected VALIDATION_EVIDENCE content.

      • exploitable (string) –

        Exploitability verdict. Explicit UNCERTAIN replaces the producer’s tri-state exploitable: true | false | null, so an absent verdict is never confused with a negative one.

      • terminalStatus (string) –

        How the validation run ended. Absent when the producer reported a status with no mapping yet: the rest of the body still projects, so one unmapped enum never costs a customer the whole artifact.

      • flowVerdicts (list) –

        One verdict per attack flow assessed in the bundle.

        • (dict) –

          Validation’s verdict for one attack flow.

          • flowId (string) –

            Identifier of the attack flow assessed.

          • verdict (string) –

            Outcome for this flow.

          • confidence (float) –

            Confidence in this flow’s verdict. Absent when out of range.

          • evidence (list) –

            Citations supporting the verdict.

            • (string) –

              A citation supporting a claim: file:line, an HTTP response, or a graph node id.

              1024 rather than 512: validation agents cite a span of reasoning rather than a single location, reaching ~930 characters, and an over-long citation drops its entire ReasoningStep — claim included — rather than just the citation.

      • attackFlowsConfirmed (list) –

        Identifiers of attack flows upgraded to Confirmed provenance.

        • (string) –

          Identifier of an attack flow within a validation bundle.

      • exploitArtifact (dict) –

        Concrete payload and its observed effect, when validation produced one by sending an HTTP request.

        Only an HTTP proof projects here. A validation agent that proves exploitability by RUNNING code against the repository projects executedProof, and one that proves it by reading the source projects sourceAnalysis. All three are mutually exclusive: at most one is present.

        • payload (string) –

          The exact payload sent.

        • targetUrl (string) –

          Target the payload was sent to.

        • httpMethod (string) –

          HTTP method the payload was sent with.

        • headers (dict) –

          Headers sent with the payload.

          • (string) –

            A citation supporting a claim: file:line, an HTTP response, or a graph node id.

            1024 rather than 512: validation agents cite a span of reasoning rather than a single location, reaching ~930 characters, and an over-long citation drops its entire ReasoningStep — claim included — rather than just the citation.

            • (string) –

              A bounded free-text field in a projected artifact body.

              8192 rather than 4096: a validation agent’s reasoning claim runs to ~5.6K in practice, and a claim dropped on length takes its whole ReasoningStep with it. Deliberately NOT raised to the proof-body bound — this type is also the member of a 50-entry ReasoningSteps list and of ArtifactHeaders, so its bound multiplies into the worst-case response size.

              The product of these bounds is NOT what actually caps a response. Every projected body is read out of one IssueArtifactContent, itself bounded at 5 MiB, so no projection can exceed the size of the content it came from whatever the member bounds permit. Keeping this one modest is about not inflating a typical response, not about the ceiling.

        • responseStatus (integer) –

          HTTP status observed in the response.

        • responseSnippet (string) –

          Leading portion of the response body, bounded by the producer.

        • effect (string) –

          Effect observed from sending the payload.

      • executedProof (dict) –

        Proof the agent produced by executing code against the repository under test, with the output that execution produced.

        • code (dict) –

          The code that was run. Not a request payload: it imports the repository’s own modules and drives the vulnerable code path directly.

          • proofCode (list) –

            Proof program files, main file first, in their retained order.

            • (dict) –

              One proof program file. Further members, such as path and purpose, can be added later as optional details.

              • content (string) –

                The file’s non-blank text, exactly as retained.

        • output (dict) –

          What the execution printed, including the agent’s own PASS/FAIL assertions. Absent when the run printed nothing retained.

          • consoleOutput (string) –

            What the run printed: standard output and standard error merged, as retained. The text may be empty.

        • observedEffect (string) –

          Effect the execution actually produced. observedEffect rather than effect: this one was witnessed, and the name has to stay distinguishable from ValidationSourceAnalysis.inferredEffect, which was not.

      • sourceAnalysis (dict) –

        Proof the agent produced by reading the repository’s source, with nothing built or run.

        • summary (string) –

          The non-blank analysis as Markdown: the annotated entry-to-sink walk, its citations, and why the checked guards are absent or bypassed.

        • inferredEffect (string) –

          Effect the agent concluded WOULD occur. Deliberately not effect: nothing was executed, so this is reasoned from the source and must not be read as an observation. See ValidationExecutedProof.observedEffect.

      • perFindingResults (list) –

        Per-finding breakdown for a multi-finding bundle. Absent for a single-finding bundle.

        • (dict) –

          Validation’s result for one finding within a multi-finding bundle.

          • findingId (string) –

            The finding assessed.

          • exploitable (string) –

            Exploitability verdict for this finding.

          • confidence (float) –

            Confidence in this finding’s verdict. Absent when out of range.

          • flowVerdicts (list) –

            Per-flow verdicts recorded for this finding.

            • (dict) –

              Validation’s verdict for one attack flow.

              • flowId (string) –

                Identifier of the attack flow assessed.

              • verdict (string) –

                Outcome for this flow.

              • confidence (float) –

                Confidence in this flow’s verdict. Absent when out of range.

              • evidence (list) –

                Citations supporting the verdict.

                • (string) –

                  A citation supporting a claim: file:line, an HTTP response, or a graph node id.

                  1024 rather than 512: validation agents cite a span of reasoning rather than a single location, reaching ~930 characters, and an over-long citation drops its entire ReasoningStep — claim included — rather than just the citation.

          • reasoningChain (list) –

            Reasoning chain recorded for this finding.

            • (dict) –

              One step in the validation agent’s reasoning chain.

              • step (integer) –

                Position of this step in the chain.

              • claim (string) –

                The claim or conclusion reached at this step.

              • source (string) –

                Citation supporting the claim.

              • confidence (float) –

                Confidence in this individual claim, on the producer’s native 0-1 scale.

          • exploitArtifact (dict) –

            Exploit artifact produced for this finding, when there was one.

            • payload (string) –

              The exact payload sent.

            • targetUrl (string) –

              Target the payload was sent to.

            • httpMethod (string) –

              HTTP method the payload was sent with.

            • headers (dict) –

              Headers sent with the payload.

              • (string) –

                A citation supporting a claim: file:line, an HTTP response, or a graph node id.

                1024 rather than 512: validation agents cite a span of reasoning rather than a single location, reaching ~930 characters, and an over-long citation drops its entire ReasoningStep — claim included — rather than just the citation.

                • (string) –

                  A bounded free-text field in a projected artifact body.

                  8192 rather than 4096: a validation agent’s reasoning claim runs to ~5.6K in practice, and a claim dropped on length takes its whole ReasoningStep with it. Deliberately NOT raised to the proof-body bound — this type is also the member of a 50-entry ReasoningSteps list and of ArtifactHeaders, so its bound multiplies into the worst-case response size.

                  The product of these bounds is NOT what actually caps a response. Every projected body is read out of one IssueArtifactContent, itself bounded at 5 MiB, so no projection can exceed the size of the content it came from whatever the member bounds permit. Keeping this one modest is about not inflating a typical response, not about the ceiling.

            • responseStatus (integer) –

              HTTP status observed in the response.

            • responseSnippet (string) –

              Leading portion of the response body, bounded by the producer.

            • effect (string) –

              Effect observed from sending the payload.

    • prevalidationSignals (dict) –

      Projected EVIDENCE content whose stored envelope declares artifact_kind: prevalidation_signals — the severity signals prioritization uses.

      One artifactType can select different members here: EVIDENCE also carries the prioritization markdown narrative, which is not JSON and so returns through raw. The member is therefore chosen by artifactType AND, for a type that carries more than one payload kind, the content’s own discriminator.

      • producedBy (string) –

        The agent that produced this signal set.

      • signals (list) –

        The signals backing the Issue’s proposed severity.

        • (dict) –

          One producer’s conclusion about one subject on one scoring dimension.

          • subjectRef (string) –

            What this signal is about, such as a finding or issue reference.

          • dimension (string) –

            The axis this signal speaks to. Absent when the producer reported a dimension with no mapping yet.

          • signalStrength (string) –

            The signal’s own rating. This is an input to scoring and is NOT the finding’s severity.

          • conclusion (string) –

            The producer’s conclusion.

          • producerId (string) –

            Stable name of the producer that emitted this signal.

          • producerVersion (string) –

            Version of that producer.

          • confidence (float) –

            The producer’s confidence in this conclusion, on its native 0-1 scale. Absent when the stored value falls outside 0-1.

          • confidenceReasoning (dict) –

            Why the producer is or is not sure, kept structured rather than prose.

            • summary (string) –

              One-line rationale.

            • factors (list) –

              The individual factors behind it.

              • (string) –

                A citation supporting a claim: file:line, an HTTP response, or a graph node id.

                1024 rather than 512: validation agents cite a span of reasoning rather than a single location, reaching ~930 characters, and an over-long citation drops its entire ReasoningStep — claim included — rather than just the citation.

          • computed (dict) –

            The deterministic values the producer computed from its assessment.

            • likelihoodBand (string) –

              Computed likelihood band, on a likelihood signal.

            • impactBand (string) –

              Computed impact band, on an impact signal.

            • barriers (integer) –

              How many of the four exploit preconditions act as barriers (0-4).

          • preconditions (dict) –

            The four exploit preconditions a likelihood signal assessed, each with the basis the producer had for it.

            • reachableFromAttacker (dict) –

              Whether the vulnerable code path is reachable by an attacker.

              • value (boolean) –

                The producer’s determination.

                A Boolean rather than an enum, against the Common Terms preference for enums on extensibility grounds. The question each precondition answers is closed — is the code reachable, is configuration required, must a user other than the attacker interact — and the only third state, “not determined”, is already expressed by omitting this member, which the projection does whenever the stored value is not a bool. An enum would give two ways to say the same thing, while basis and missingInfo already qualify how firm the answer is.

              • basis (string) –

                Where the producer’s determination came from.

              • reason (string) –

                The producer’s explanation.

              • missingInfo (string) –

                What the producer could not determine, when anything was missing.

            • configurationNeeded (dict) –

              Whether exploitation depends on a non-default configuration.

              • value (boolean) –

                The producer’s determination.

                A Boolean rather than an enum, against the Common Terms preference for enums on extensibility grounds. The question each precondition answers is closed — is the code reachable, is configuration required, must a user other than the attacker interact — and the only third state, “not determined”, is already expressed by omitting this member, which the projection does whenever the stored value is not a bool. An enum would give two ways to say the same thing, while basis and missingInfo already qualify how firm the answer is.

              • basis (string) –

                Where the producer’s determination came from.

              • reason (string) –

                The producer’s explanation.

              • missingInfo (string) –

                What the producer could not determine, when anything was missing.

            • accessLevel (dict) –

              What level of access exploitation requires.

              • value (string) –

                The level of access exploitation requires. Absent when the producer reported a level with no mapping yet.

              • basis (string) –

                Where the producer’s determination came from.

              • reason (string) –

                The producer’s explanation.

              • missingInfo (string) –

                What the producer could not determine, when anything was missing.

            • userInteractionRequired (dict) –

              Whether exploitation requires a user other than the attacker to take part, for example by opening a link or a file (CVSS User Interaction).

              • value (boolean) –

                The producer’s determination.

                A Boolean rather than an enum, against the Common Terms preference for enums on extensibility grounds. The question each precondition answers is closed — is the code reachable, is configuration required, must a user other than the attacker interact — and the only third state, “not determined”, is already expressed by omitting this member, which the projection does whenever the stored value is not a bool. An enum would give two ways to say the same thing, while basis and missingInfo already qualify how firm the answer is.

              • basis (string) –

                Where the producer’s determination came from.

              • reason (string) –

                The producer’s explanation.

              • missingInfo (string) –

                What the producer could not determine, when anything was missing.

          • impactDimensions (dict) –

            The three impact dimensions an impact signal assessed, each with the basis the producer had for it. These are what the computed impact band is derived from.

            • attackerGains (dict) –

              What the attacker gains from exploitation.

              • value (string) –

                The capability exploitation grants. Absent when the producer reported a value with no mapping yet.

              • basis (string) –

                Where the producer’s determination came from.

              • reason (string) –

                The producer’s explanation.

              • missingInfo (string) –

                What the producer could not determine, when anything was missing.

            • blastRadius (dict) –

              How far the consequences reach.

              • value (string) –

                How far the consequences reach. Absent when the producer reported a value with no mapping yet.

              • basis (string) –

                Where the producer’s determination came from.

              • reason (string) –

                The producer’s explanation.

              • missingInfo (string) –

                What the producer could not determine, when anything was missing.

            • targetValue (dict) –

              How valuable the target is, which can shift the band off its base value.

              • value (string) –

                How valuable the target is. Absent when the producer reported a value with no mapping yet.

              • basis (string) –

                Where the producer’s determination came from.

              • reason (string) –

                The producer’s explanation.

              • missingInfo (string) –

                What the producer could not determine, when anything was missing.

          • exploitability (dict) –

            What validation established about exploitability, on an exploitability signal. This summarizes the verdict the signal was derived from; the proof itself is the VALIDATION_EVIDENCE artifact it cites.

            • verdict (string) –

              Validation’s verdict. UNCERTAIN covers a run that was inconclusive — out of budget, an ambiguous failure, or no decisive layer reached — and is never a refutation.

            • reachedCrownJewels (boolean) –

              Whether validation reached the high-value sink the attack path posited.

              A Boolean rather than an enum: the sink was either reached or it was not, and how far the walk got when it was not is already carried, with more precision, by highestLayerReached. An unknown is the absent member.

            • highestLayerReached (integer) –

              The highest impact layer validation reached, 1-5, as a measure of how far the attack path was walked.

            • confidenceTier (string) –

              How strong the evidence behind the verdict is.

            • scriptable (boolean) –

              Whether the proven exploit is automatable rather than one-off.

              A Boolean for the same reason as SignalPrecondition.value: validation records a bool, and an unknown is the absent member.

            • sourceValidationArtifactId (string) –

              The VALIDATION_EVIDENCE artifact on this same issue holding the proof this verdict summarizes. Fetch it with GetCodeIssueArtifact for the full reasoning chain and exploit artifact.

    • remediationProposal (dict) –

      Projected REMEDIATION_PROPOSAL content: a patch the remediation agent produced, with the descriptors needed to apply and verify it.

      REMEDIATION_PROPOSAL content that does not match this shape is returned through raw.

      • patch (string) –

        The patch exactly as the remediation agent produced it, unmodified.

      • format (string) –

        The patch’s wire format, which determines how to apply it. Absent when the producer recorded a format with no mapping yet.

      • filename (string) –

        Filename the producer suggests for the patch, when it named one.

      • patchSha256 (string) –

        SHA-256 of the patch bytes in lowercase hex, as recorded by the producer.

        Lets a caller confirm the patch it applies is byte-for-byte the one that was reviewed. Computed over the patch bytes, so it is verifiable against patch without trusting this value.

    • patch (dict) –

      Projected PATCH content: the remediation patch for one repository, with the descriptors needed to verify and apply it and the state of its delivery to the customer’s own bucket or repository.

      Every PATCH projects here. The descriptors come from members Control Plane computes or owns when it stores the patch, not from producer metadata, so this member is the whole PATCH contract and metadata is omitted for it.

      • patch (string) –

        The patch exactly as stored, unmodified. Control Plane accepted it only as a text unified diff, so git apply applies it.

      • format (string) –

        The patch’s wire format, read from the patch itself, which determines how to apply it. Absent when the patch starts with neither a git mailbox header nor a diff --git header.

      • repositoryName (string) –

        The repository the patch applies to, as named in the source snapshot it was generated against.

      • patchSha256 (string) –

        SHA-256 of the patch’s UTF-8 bytes in lowercase hex, computed by Control Plane when it stored the patch.

        Lets a caller confirm the patch it applies is byte-for-byte the one that was reviewed. Computed over the patch bytes, so it is verifiable against patch without trusting this value.

      • sizeBytes (integer) –

        Size of the patch in UTF-8 bytes, the unit the digest is computed over.

      • delivery (dict) –

        Delivery of the patch to the customer’s bucket or repository. Absent when the artifact has no delivery destination.

        • status (string) –

          How far delivery to the destination has progressed.

        • target (dict) –

          Where the patch was or will be delivered. Absent while the destination is still being resolved, or when delivery was skipped before a destination was known.

          Note

          This is a Tagged Union structure. Only one of the following top level keys will be set: s3, github. If a client receives an unknown member it will set SDK_UNKNOWN_MEMBER as the top level key, which maps to the name or tag of the unknown member. The structure of SDK_UNKNOWN_MEMBER is as follows:

          'SDK_UNKNOWN_MEMBER': {'name': 'UnknownMemberName'}
          

          • s3 (dict) –

            The S3 object the patch is delivered to.

            • bucket (string) –

              Customer-managed S3 bucket name.

            • key (string) –

              The object key of the delivered patch.

            • version (string) –

              The S3 version ID of the delivered object, when the bucket is versioned.

          • github (dict) –

            The GitHub repository the patch is delivered to, including the pull request once it is opened.

            • owner (string) –

              The GitHub user or organization that owns the repository.

            • repository (string) –

              The repository name.

            • pullRequestNumber (integer) –

              Repository-scoped pull request number assigned by GitHub.

            • headSha (string) –

              The head commit SHA of the pull request. Absent until the pull request is opened.

        • updatedAt (datetime) –

          When the delivery status last changed.

    • raw (string) –

      The producer’s content verbatim, for an artifactType with no defined shape or content that failed to parse against its shape.

  • metadata (document) –

    Producer-defined structured metadata, when the producer supplied any.

    Returned only for an artifactType whose content has no defined shape, so that the artifact stays inspectable. For an artifactType with a defined shape, body carries the content and this member is omitted.

  • producer (dict) –

    The agent that produced the artifact.

    • agent (string) –

      Stable producer name, such as ContinuumValidation.

  • createdAt (datetime) –

    The timestamp when the artifact was created.

Exceptions

• Continuum.Client.exceptions.ValidationException

• Continuum.Client.exceptions.InternalServerException

• Continuum.Client.exceptions.ResourceNotFoundException

• Continuum.Client.exceptions.ThrottlingException

• Continuum.Client.exceptions.AccessDeniedException