Session Validator (session-validator)
Overview
The Session Validator gear checks that a Flywheel session container, including its acquisitions and files, meets the criteria defined in a user-provided 2020-12 JSONSchema. It records a PASS or FAIL QC result on the session, tags the session accordingly, and can export the full list of validation errors as a JSON file and/or a human-readable PDF report. Data managers and study coordinators use it to confirm that each session is complete (for example, that all expected scans are present and correctly classified) before downstream processing. Part of the Utility suite.
[[TOC]]
Summary
Validates a Flywheel session container, including its acquisitions and files, against a user-provided 2020-12 JSON Schema, writing a PASS or FAIL QC result to the session's metadata. Must be launched at the session level. Optionally saves the full error report as a JSON or PDF file, and can force re-validation of a session that already passed.
Cite
N/A
License
MIT
Classification
Category: analysis
Gear Level:
- Project
- Subject
- Session
- Acquisition
- Analysis
Inputs
- validation_schema
- Name: validation_schema
- Type: file
- Optional: False
- Classification: JSON
- Description: The schema file to validate the session against
- Notes: Must be a valid 2020-12 JSONSchema. See File Specifications.
Config
-
save_validation_report
- Name: save_validation_report
- Type: boolean
- Description: Save the validation report
- Default: false
-
save_pdf_report
- Name: save_pdf_report
- Type: boolean
- Description: Export validation errors to a PDF summary report
- Default: false
-
force_rerun
- Name: force_rerun
- Type: boolean
- Description: Force re-validation even if the session has already passed validation
- Default: false
-
debug
- Name: debug
- Type: boolean
- Description: Log debug messages
- Default: false
Outputs
Files
All output files are saved to the session-level analysis container created by the gear run.
-
validation_report.json
- Name: validation_report.json
- Type: file
- Optional: True
- Classification: JSON
- Description: JSON file including the full error report from validation.
- Notes: Only created when
save_validation_reportistrue. Contains an empty list ([]) if validation passes. See Understanding Error Structure.
-
validation_report.pdf
- Name: validation_report.pdf
- Type: file
- Optional: True
- Classification: PDF
- Description: Human-readable PDF summary of the validation result and errors.
- Notes: Only created when
save_pdf_reportistrue. Created for both PASS and FAIL results. See PDF Report.
Metadata
The gear writes two things back to the session container:
- Tag: the session is tagged
session-qc-PASSorsession-qc-FAIL. On a re-run, the previous QC tag is removed before the new one is added. - QC result: a session-level QC metadata object named
session-validator. It holds information on the gear run (job_info: configuration, input file, job ID and gear version) and the validation result (jsonschema-validation). Thejsonschema-validationobject holds the overall state of the validation (PASSorFAIL) and adatalist with one entry per error reported by the JSONSchema validator.
The QC metadata object has the below structure:
qc:
session-validator:
job_info:
config:
debug: <boolean>
force_rerun: <boolean>
save_pdf_report: <boolean>
save_validation_report: <boolean>
inputs:
validation_schema:
file_id: <string>
file_name: <string>
parent: <string>
version: <integer>
job_id: <string>
version: <string>
jsonschema-validation:
state: <PASS|FAIL>
data: ["<list of error objects>"]
Each error object in the data list has the same fields as an entry in
validation_report.json. See
Understanding Error Structure.
Pre-requisites
The gear technically has no prerequisites, as validation can be performed entirely
on container labels and file names. However, run both file-metadata-importer and
file-classifier first if the schema validates container metadata (for example, file
classification or DICOM header values).
Prerequisite Gear Runs
A list of gears, in the order they need to be run, when the schema validates file metadata:
- File Metadata Importer
- Level: File
- File Classifier
- Level: File
Prerequisite Files
This gear has no prerequisite files beyond the user-provided JSONSchema input file.
Prerequisite Metadata
This gear has no prerequisite metadata. However, users may wish to include metadata
fields created by the file-metadata-importer and file-classifier gears in their
JSONSchema.
Usage
Description
This gear validates a Flywheel session container against a JSONSchema. The
JSONSchema file is a required input to the gear and can include validation criteria
on session, acquisition and/or file level metadata. Validation criteria can be
general (for example, age is populated with a number) or specific (for example,
the session contains files with specific classifications or header values).
Before validating, the gear builds a nested dictionary of the session: the session
fields at the root, an acquisitions list holding each acquisition's fields, and a
files list inside each acquisition holding each file's fields (including modality,
classification and info). The schema is evaluated against this dictionary.
The gear skips sessions that already passed validation (tagged session-qc-PASS)
unless force_rerun is enabled. Sessions tagged session-qc-FAIL are always
re-validated.
When save_pdf_report is enabled, the gear also produces a PDF report that
summarizes the result for reviewers who do not want to read raw JSON. See
PDF Report.
For practical examples, see the examples documentation, which includes:
- Sample JSONSchema files for common use cases
- Example validation error outputs
File Specifications
validation_schema
The validation schema must be a 2020-12 compatible JSONSchema. The gear checks the
schema itself at the start of the run and fails if it is invalid. The schema must
assume the Flywheel hierarchy: the root is the session container, the acquisitions
array holds the session's acquisitions, and each acquisition's files array holds
its files.
Add a description to each rule in the schema. The gear attaches the nearest
description found along the failing rule's schema path to each error. This makes
the JSON report, the QC metadata and the PDF report much easier to read.
See the Use Cases below for example JSONSchemas.
Workflow
flowchart LR
A[validation_schema]:::input --> B{Session level?}
B -->|No| X[Fail: must run at session level]:::container
B -->|Yes| C{Already tagged PASS?}
C -->|Yes, no force_rerun| Z[Exit: already validated]:::container
C -->|No, or force_rerun| D{Schema valid?}
D -->|No| Y[Fail: invalid schema]:::container
D -->|Yes| E[Validate session against schema]:::container
E --> F[Save JSON report]:::output
E --> G[Save PDF report]:::output
E --> H[Tag session PASS/FAIL]:::container
H --> I[Write QC metadata]:::container
classDef container fill:#57d,color:#fff
classDef input fill:#7a9,color:#fff
classDef output fill:#659,color:#fff
Description of workflow:
- Upload the JSONSchema file to the project attachments (assuming the same JSONSchema applies to all sessions in the project).
- Select the file as the
validation_schemainput and launch the gear at the session level. - The gear checks that it runs at the session level.
- The gear checks the session's existing QC tags. If the session is tagged
session-qc-PASSandforce_rerunis disabled (default), the gear exits without re-validating. Otherwise, the previous QC tag is removed. - The gear checks that the input JSONSchema is valid.
- The gear validates the session, its acquisitions and their files against the schema.
- If
save_validation_reportis enabled, the gear savesvalidation_report.json. - If
save_pdf_reportis enabled, the gear savesvalidation_report.pdf. - The gear tags the session
session-qc-PASSorsession-qc-FAILand writes the QC metadata object to the session.
Use Cases
The conditions listed for each use case are not mutually exclusive, as the various validation criteria shown in the below use case examples can be combined. Rather, the conditions listed for each use case indicate what container properties are used in the example schemas.
While, there are several ways of setting up a valid JSONSchema (2020-12) for validating the session container, Flywheel recommends the framework shown below separating the rule definitions for file and acquisition containers from the validation logic block. This framework should generally make the JSONSchema file easier to maintain.
Use Case 1: Validate against acquisition labels
Conditions:
- Validate using session container properties
- Validate using acquisition container properties
- Validate using file level properties
For well-behaved studies, it is possible to validate against acquisition container labels to quickly determine if a session is missing a required acquisition.
In the below, example jsonschema, we are checking that a session has at minimum one
acquisition with label exactly equal to "T1" and one acquisition with label that
contains the string "T2". To make maintaining the jsonschema a bit easier, the example
adopts the framework of defining rules in the "$defs" section and then leverage the
definitions when creating the validation logic in the subsequent block starting with
"type": "object".
In the two definitions, the example uses "const" to require that the acquisition label
be exactly "T1" in the first definition, and "pattern" to require that the acquisition
label contain the string "T2" somewhere in the second definition. In the case of
"pattern", regular expressions can also be used. For example, regular expressions can
be leveraged to require the acquisition label to start with a string (e.g., "^T2") or
end with a string (e.g., "T2$").
The validation block uses "allOf" to require that the session container being
validated must meet all of the rules in the list. This is more rigid than
"anyOf", where the session container would be considered valid if it met at least
one of the rules in the list. The validation block also leverages "minContains" and
"maxContains" to require a session only has one acquisition that satisfies each rule.
{
"$schema": "https://json-schema.org/draft/2020-12/schema",
"description": "Schema to validate acquisition labels within a session object",
"$defs": {
"acquisition_with_label_T1": {
"description": "An acquisition whose label must be exactly 'T1'",
"type": "object",
"properties": {
"label": { "const": "T1" }
},
"required": ["label"]
},
"acquisition_with_label_T2": {
"description": "An acquisition whose label contains 'T2'",
"type": "object",
"properties": {
"label": { "pattern": "T2" }
},
"required": ["label"]
}
},
"type": "object",
"properties": {
"acquisitions": {
"description": "List of acquisitions in this session",
"type": "array",
"items": { "type": "object" },
"allOf": [
{
"description": "Require exactly one acquisition with label 'T1'",
"contains": { "$ref": "#/$defs/acquisition_with_label_T1" },
"minContains": 1,
"maxContains": 1
},
{
"description": "Require exactly one acquisition with label 'T2'",
"contains": { "$ref": "#/$defs/acquisition_with_label_T2" },
"minContains": 1,
"maxContains": 1
}
]
}
},
"required": ["acquisitions"]
}
Use Case 2: Validate against file modality and classification
Conditions:
- Validate using session container properties
- Validate using acquisition container properties
- Validate using file level properties
To validate that a session has files with expected modalities and/or classifications, it
is possible to leverage the output metadata from the file-metadata-importer and
file-classifier gears.
Using the framework of having rule definitions separate, means that as validation criteria are added to the rules, the overall validation block stays relatively fixed.
In the below example, now each acquisition is required to have at least one file with the specified modality and classification. Using the rules framework means that we can make one-to-one matches between the file and acquisition rules.
Note that as validation criteria are added to the "properties", the values for the
respective "required" keys need to be updated to ensure that the schema first checks
that the properties exist in the data object being validated before assessing the rules.
In this way, the error for a required property not existing will be separate from a
session that is missing a file or acquisition without the properties defined in the
rules.
Also, note that this example removes the "label" requirement from the acquisition
rules. This schema will simply check if there is an acquisition whose file(s) meets the
file rules without imposing the requirement that the acquisition label be something
specific. It is easy enough to combine the logic from the previous use case to add the
acquisition label requirement back in if desired.
{
"$schema": "https://json-schema.org/draft/2020-12/schema",
"description": "Schema to validate acquisition labels and require files with modality and classification",
"$defs": {
"T1_file": {
"description": "A T1 file with required modality and classification",
"type": "object",
"properties": {
"modality": { "const": "MR" },
"classification": {
"type": "object",
"properties": {
"Measurement": {
"description": "Measurment array must contain the value 'T1'",
"type": "array",
"items": { "const": "T1" },
"minItems": 1,
"maxItems": 1
},
"Intent": {
"description": "Intent array must contain the value 'Structural'",
"type": "array",
"items": { "const": "Structural" },
"minItems": 1,
"maxItems": 1
},
"Features": {
"description": "Features array must contain both 'MPRAGE' and '3D'",
"type": "array",
"minItems": 2,
"items": { "type": "string" },
"allOf": [
{ "contains": { "const": "MPRAGE" } },
{ "contains": { "const": "3D" } }
]
}
},
"required": ["Measurement", "Intent", "Features"]
}
},
"required": ["modality", "classification"]
},
"T2_file": {
"description": "A T2 file with required modality and classification",
"type": "object",
"properties": {
"modality": { "const": "MR" },
"classification": {
"type": "object",
"properties": {
"Measurement": {
"description": "Measurment array must contain the value 'T2'",
"type": "array",
"items": { "const": "T2" },
"minItems": 1,
"maxItems": 1
},
"Intent": {
"description": "Intent array must contain the value 'Structural'",
"type": "array",
"items": { "const": "Structural" },
"minItems": 1,
"maxItems": 1
},
"Features": {
"description": "Features array must contain 'Spin-Echo'",
"type": "array",
"items": { "const": "Spin-Echo" },
"minItems": 1
}
},
"required": ["Measurement", "Intent", "Features"]
}
},
"required": ["modality", "classification"]
},
"acquisition_with_label_T1": {
"description": "An acquisition that contains at least one T1 file",
"type": "object",
"properties": {
"files": {
"type": "array",
"contains": { "$ref": "#/$defs/T1_file" },
"minContains": 1
}
},
"required": ["files"]
},
"acquisition_with_label_T2": {
"description": "An acquisition that contains at least one T2 file",
"type": "object",
"properties": {
"files": {
"type": "array",
"contains": { "$ref": "#/$defs/T2_file" },
"minContains": 1
}
},
"required": ["files"]
}
},
"type": "object",
"properties": {
"acquisitions": {
"description": "List of acquisitions in this session",
"type": "array",
"items": { "type": "object" },
"allOf": [
{
"description": "Require exactly one acquisition with label 'T1' containing at least one MR file",
"contains": { "$ref": "#/$defs/acquisition_with_label_T1" },
"minContains": 1,
"maxContains": 1
},
{
"description": "Require exactly one acquisition with label 'T2' containing at least one MR file",
"contains": { "$ref": "#/$defs/acquisition_with_label_T2" },
"minContains": 1,
"maxContains": 1
}
]
}
},
"required": ["acquisitions"]
}
Use Case 3: Validate against file metadata
Conditions:
- Validate using session container properties
- Validate using acquisition container properties
- Validate using file level properties
While the dicom-qc
gear is specifically suited to validate the full header extracted by
file-metadata-importer, it is possible to validate a session against file metadata to
determine if it contains files with the desired imaging parameters or header
information.
In the below partial jsonschema example, we show how to specify a file rule to check
that certain properties of the file.info.header.dicom metadata object are the
specified types or values. Again, since the framework used in these examples separates
out the file and acquisition validation criteria into separate, defined rules, no
additional changes would need to be made to the acquisition rule associated with this
file rule or to the overall jsonschema validation block.
For the added criteria of checking against file.info.header.dicom key-value pairs, the
below example shows how to check if the "SeriesDescription" is a non-empty string. The
combination of "minLength": 1 and "pattern": "\\S" tells the jsonschema to make sure
that "SeriesDescription" contains at least one visible character. For "Columns", the
schema simply checks that the value is an integer. And, finally, "ImageType" is checked
to make sure that the string "ORIGINAL" is contained somewhere in the array. As with
the examples in Use Cases 1 and 2, it is also possible to validate against specific
values (const) or patterns (pattern) in file.info.header.dicom key-value pairs.
{
"$schema": "https://json-schema.org/draft/2020-12/schema",
"$defs": {
"CT_file": {
"type": "object",
"properties": {
"modality": { "const": "CT" },
"classification": {
"type": "object",
"properties": {
"Contrast": {
"type": "array",
"items": { "const": "No Contrast" },
"minItems": 1,
"maxItems": 1
},
"Scan Orientation": {
"type": "array",
"items": { "const": "Axial" },
"minItems": 1,
"maxItems": 1
}
},
"required": ["Contrast", "Scan Orientation"]
},
"info": {
"type": "object",
"properties": {
"header": {
"type": "object",
"properties": {
"dicom": {
"type": "object",
"properties": {
"SeriesDescription": {
"description": "Must be string and have at least one character",
"type": "string",
"minLength": 1,
"pattern": "\\S"
},
"Columns": {
"description": "Must be an integer",
"type": "integer"
},
"ImageType": {
"description": "Must contain 'ORIGINAL'",
"type": "array",
"contains": { "const": "ORIGINAL" }
}
},
"required": ["SeriesDescription", "Columns", "ImageType"]
}
},
"required": ["dicom"]
}
},
"required": ["header"]
}
},
"required": ["modality", "classification", "info"]
},
...
}
}
Use Case 4: Validate different sessions with different criteria
Conditions:
- Validate using session container properties
- Validate using acquisition container properties
- Validate using file level properties
For projects that include multi-session data, it is possible to create a single JSONSchema that includes conditional logic to assess different sessions against different validation criteria.
This example schema shows how to add conditional logic to first check the session label,
and then based on the session label call specific rules. So, for this artificial
example, we assume that each subject has two sessions, "T1_session" and "T2_session".
Since, we are not updating the file or acquisition rules, all of the changes are in the
schema validation block. First, we add this: "label": { "type": "string" } to the
session properties. Then, inside of the "allOf" block, we first add an "if"
statement to check what the session label is; a "then" block is then added to specify
which acquisition rule(s) should be used for validating the session.
{
"$schema": "https://json-schema.org/draft/2020-12/schema",
"description": "Schema to validate acquisition labels and require files with modality and classification in specific sessions",
"$defs": {
...
},
"type": "object",
"properties": {
"label": { "type": "string" },
"acquisitions": {
"type": "array",
"items": { "type": "object" }
}
},
"allOf": [
{
"if": { "properties": { "label": { "const": "T1_session" } } },
"then": {
"properties": {
"acquisitions": {
"type": "array",
"contains": { "$ref": "#/$defs/acquisition_with_T1_file" },
"minContains": 1,
"maxContains": 1
}
},
"required": ["acquisitions"]
}
},
{
"if": { "properties": { "label": { "const": "T2_session" } } },
"then": {
"properties": {
"acquisitions": {
"type": "array",
"contains": { "$ref": "#/$defs/acquisition_with_T2_file" },
"minContains": 1,
"maxContains": 1
}
},
"required": ["acquisitions"]
}
}
],
"required": ["label", "acquisitions"]
}
Use Case 5: Validate against session metadata
Conditions:
- Validate using session container properties
- Validate using acquisition container properties
- Validate using file level properties
It is also possible to include more general validation criteria for session-level metadata to validate whether the value is of the correct type (e.g., string, number, boolean, etc.). Unlike the previous use cases, where the schema imposes required values and/or patterns of values, with session-level metadata like age and weight, it is more useful to just check that the metadata exists and is of a specific type.
In the below example jsonschema, we extend the first use case to add a requirement in
the validation block that in addition to the session having the required acquisitions,
the age metadata object is also of type number and has a minimum value of 0. The schema
could have also leveraged "maximum" to set a maximum value.
{
"$schema": "https://json-schema.org/draft/2020-12/schema",
"description": "Schema to validate acquisition labels and session-level metadata",
"$defs": {
...
},
"type": "object",
"properties": {
"age": {
"description": "Age of the subject at time of session in years",
"type": "number",
"minimum": 0
},
"acquisitions": {
"description": "List of acquisitions in this session",
"type": "array",
"items": { "type": "object" },
"allOf": [
{
"description": "Require exactly one acquisition with label 'T1'",
"contains": { "$ref": "#/$defs/acquisition_with_label_T1" },
"minContains": 1,
"maxContains": 1
},
{
"description": "Require exactly one acquisition with label 'T2'",
"contains": { "$ref": "#/$defs/acquisition_with_label_T2" },
"minContains": 1,
"maxContains": 1
}
]
}
},
"required": ["age", "acquisitions"]
}
Use Case 6: Share a PDF validation summary with reviewers
Conditions:
- Validate using session container properties
- Validate using acquisition container properties
- Validate using file level properties
Study coordinators or site monitors often need to review why a session failed
without reading raw JSON or browsing the session's QC metadata. Run the gear with
any of the schemas above and enable save_pdf_report. The gear saves
validation_report.pdf to the analysis container. Reviewers can download it, follow
its links to the job, the session and the schema file in Flywheel, and read each
error with the rule description taken from the schema. Enable
save_validation_report as well to keep a machine-readable copy of the same errors.
Interpreting Validation Results
Where to Find Validation Errors
After running the Session Validator gear, validation errors are available in up to three places.
1. Session QC Metadata (always)
Errors are always stored in the session's QC metadata at:
session.info.qc.session-validator.jsonschema-validation.data
Structure:
qc:
session-validator:
jsonschema-validation:
state: "FAIL"
data:
- error_message: "..."
instance_path: "..."
...
2. validation_report.json (optional output file)
If save_validation_report is enabled, the full error report is saved as
validation_report.json in the analysis container.
Structure:
[
{
"error_message": "...",
"instance_path": "...",
...
}
]
3. validation_report.pdf (optional output file)
If save_pdf_report is enabled, a PDF summary is saved as validation_report.pdf
in the analysis container. See PDF Report.
PDF Report
The PDF report is intended for human review. It contains:
- Header: the report title, the creation timestamp (UTC) and the job ID, linked to the job page in Flywheel.
- Summary table:
- Number of Errors
- Status:
PASS(green) orFAIL(red) - Session Location: the
fw://group/project/subject/sessionpath, linked to the session page in Flywheel - Schema Filename: the name of the
validation_schemainput file, linked to the container that holds it - Schema File Version: the version of the
validation_schemainput file
- List of Errors: one card per validation error, with:
- Error Number
- Description: the nearest
descriptionfrom the schema, or "No description available" - Schema Definition: the
$defsrule name, or "N/A" - Schema Path
- Error Message
If the session passes, the report shows the summary table followed by "No validation errors found. The session passed all validation checks."
Understanding Error Structure
Each validation error has the following fields:
{
"error_message": "Human-readable description of what failed",
"instance_path": "Location in your data where the error occurred",
"label": "Short identifier for the failing item",
"schema_path": "Location in your schema where the rule is defined",
"validator_type": {
"type": "Type of validation that failed",
"details": {
"validator-specific": "Additional context"
}
},
"validator_value": "The constraint value from your schema",
"schema_definition": "Optional: $ref definition name if applicable",
"description": "Optional: nearest description found in your schema"
}
Tips for Debugging Validation Errors
1. Start with instance_path
This tells you exactly where in your session the problem is:
root→ Session levelacquisitions.0→ First acquisition of the sessionacquisitions.0.files.1→ Second file in the first acquisitionacquisitions.0.files.1.modality→ The modality property of that file
2. Check description and schema_definition for complex errors
description holds the nearest description found along the failing rule's schema
path. schema_definition, when present, tells you which rule in your $defs section
failed:
{
"schema_definition": "acquisition_with_label_T1"
}
Go to your schema's $defs section and find acquisition_with_label_T1 to see
exactly what it requires.
3. Use the label field
The label field is a short identifier for the failing item:
- The
$defsrule name, when the failing rule references one - Otherwise, the last element of
instance_path(for example,modalityorage) - Otherwise, a fallback based on the validator type (for example,
missing_age)
4. Review validator_type.details
This provides validator-specific context that varies by error type:
| Validator Type | Details Fields | What They Mean |
|---|---|---|
required |
missing |
Which fields are missing |
type |
expected, found |
Expected vs actual data type |
pattern |
pattern, preview |
Required regex and actual value |
const |
expected, found |
Expected vs actual value |
enum |
allowed_values, found |
Allowed values vs actual value |
contains |
found, minContains |
Items checked vs required |
minimum / maximum |
other constraints of the rule | Sibling constraints (for example, maximum) |
5. Understand the schema_path
This shows where in your JSONSchema the validation rule is defined, as a dot-separated path:
$defs.T1_file.properties.modality.const
This path tells you: "Go to the $defs section, find T1_file, look in
properties, then modality, and you will see a const constraint."
For concrete examples of validation errors and how to interpret them, see the examples documentation.
Logging
This gear uses standard Python logging via the fw-gear library. It logs at the
info level as it starts and completes each workflow step, including whether the
session was skipped, validated, and which reports were saved. Warnings and errors
are also logged. Set the debug config option to true for verbose debug output.
FAQ
Q: Why did the gear exit without validating my session?
A: The session is already tagged session-qc-PASS. Enable force_rerun to
re-validate it, for example after updating the schema.
Q: Why did the gear fail with "Cannot run at ... level"?
A: The gear must be launched at the session level. Launch it from the session container you want to validate.
Q: Why did the gear fail with "Invalid JSON schema"?
A: The validation_schema input is not a valid 2020-12 JSONSchema. Check the job log
for the exact schema error.
See also FAQ.md.
Contributing
For information on how to contribute to this gear, please see CONTRIBUTING.md.
Metadata
Release files for fw-gear-session-validator 0.2.4
For a detailed explanation of source distributions (sdists) and built distributions (wheels), please see the package formats documentation.
Built distribution (wheel)
| File | Interpreter | ABI | Platform | Actions Reset |
|---|---|---|---|---|
| fw_gear_session_validator-0.2.4-py3-none-any.whl | Python 3 | none | any | Details for fw_gear_session_validator-0.2.4-py3-none-any.whl |
Release files / fw_gear_session_validator-0.2.4-py3-none-any.whl
| Download URL | fw_gear_session_validator-0.2.4-py3-none-any.whl |
|---|---|
| Size | 22.7 kB |
| Tags | Python 3 |
|
SHA-256 checksum How to use checksums |
530ee3c8f74899641bef18306a0dd058964bcdb30fa6b273d9497653cb34d8bd
|
|
BLAKE2b-256 checksum How to use checksums |
f8a5d227733debda9d48cfa83d787dcc3f5617a4cfb379ed398e9ebcb0949012
|
| Upload date | |
|
Uploaded using Trusted Publishing? What is trusted publishing? |
No |
| Uploaded via |
uv/0.12.23 {"installer":{"name":"uv","version":"0.12.23","subcommand":["publish"]},"python":null,"implementation":{"name":null,"version":null},"distro":{"name":"Alpine Linux","version":"3.25.0_alpha20260805","id":null,"libc":null},"system":{"name":null,"release":null},"cpu":null,"openssl_version":null,"setuptools_version":null,"rustc_version":null,"ci":true}
|
Security for fw-gear-session-validator 0.2.4
Provenance
Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.
No provenance found
None of the files in this release were uploaded with provenance metadata.
A note on package security
PyPI is a repository for distributing packages, not a service for auditing them. While third-party security researchers and our staff do their best to detect and remove malicious packages, PyPI cannot guarantee the quality, security or suitability of any given package.
To learn more about protecting yourself from malicious actors, visit our package security documentation.