From a0dadda53e3d179152bbe0b976f20cbffd2d17d1 Mon Sep 17 00:00:00 2001 From: Don Jayamanne Date: Mon, 3 Jun 2024 16:54:06 +1000 Subject: [PATCH 1/3] Initial commit with skeletal code --- cargo.toml | 4 + crates/pet-conda/Cargo.toml | 12 + crates/pet-conda/src/conda_rc.rs | 152 + crates/pet-conda/src/environment_locations.rs | 229 + crates/pet-conda/src/environments.rs | 174 + crates/pet-conda/src/lib.rs | 23 + crates/pet-conda/src/manager.rs | 136 + crates/pet-conda/src/mod.rs | 245 + crates/pet-conda/src/package.rs | 182 + crates/pet-conda/src/utils.rs | 19 + crates/pet-conda/tests/common.rs | 52 + .../tests/environment_locations_test.rs | 138 + crates/pet-conda/tests/package_test.rs | 87 + .../bin/conda | 0 .../bin/python | 0 .../bin/python3 | 0 .../bin/python3.1 | 0 .../bin/python3.10 | 0 .../conda-23.1.0-py310hca03da5_0.json | 575 + .../conda-build-3.23.3-py310hca03da5_0.json | 292 + .../pytest-7.1.2-py310hca03da5_0.json | 209 + .../conda-meta/python-3.10.9-hc0d8a6c_1.json | 2222 +++ .../python-dateutil-2.8.2-pyhd3eb1b0_0.json | 159 + ...fastjsonschema-2.16.2-py310hca03da5_0.json | 66 + .../condabin/conda | 0 .../tests/unix/anaconda3-2023.03/bin/conda | 0 .../tests/unix/anaconda3-2023.03/bin/python | 0 .../tests/unix/anaconda3-2023.03/bin/python3 | 0 .../unix/anaconda3-2023.03/bin/python3.1 | 0 .../unix/anaconda3-2023.03/bin/python3.10 | 0 .../conda-23.1.0-py310hca03da5_0.json | 575 + .../conda-build-3.23.3-py310hca03da5_0.json | 292 + .../unix/anaconda3-2023.03/conda-meta/history | 428 + .../pytest-7.1.2-py310hca03da5_0.json | 209 + .../conda-meta/python-3.10.9-hc0d8a6c_1.json | 2222 +++ .../python-dateutil-2.8.2-pyhd3eb1b0_0.json | 159 + ...fastjsonschema-2.16.2-py310hca03da5_0.json | 66 + .../unix/anaconda3-2023.03/condabin/conda | 0 .../envs/env_python_3/bin/conda | 0 .../envs/env_python_3/bin/python | 0 .../envs/env_python_3/bin/python3 | 0 .../envs/env_python_3/bin/python3.1 | 0 .../envs/env_python_3/bin/python3.12 | 0 .../envs/env_python_3/conda-meta/history | 62 + .../pygments-2.17.2-pyhd8ed1ab_0.json | 4285 ++++ .../python-3.12.2-hdf0ec26_0_cpython.json | 15444 +++++++++++++++ .../python-dateutil-2.8.2-pyhd8ed1ab_0.json | 350 + .../conda-meta/python_abi-3.12-4_cp312.json | 31 + .../anaconda3-2023.03/envs/myenv/bin/python | 0 .../anaconda3-2023.03/envs/myenv/bin/python3 | 0 .../envs/myenv/bin/python3.1 | 0 .../envs/myenv/bin/python3.10 | 0 .../envs/myenv/conda-meta/history | 19 + .../conda-meta/pip-24.0-py310hca03da5_0.json | 8143 ++++++++ .../conda-meta/python-3.10.14-hb885b13_1.json | 16514 ++++++++++++++++ .../conda-meta/readline-8.2-h1a28f6b_0.json | 241 + .../envs/without_python/conda-meta/history | 3 + .../.conda/environments.txt | 22 + crates/pet-conda/tests/utils_test.rs | 53 + crates/pet-core/Cargo.toml | 7 + crates/pet-core/src/arch.rs | 12 + crates/pet-core/src/lib.rs | 7 + crates/pet-core/src/manager.rs | 32 + crates/pet-core/src/os_environment.rs | 113 + crates/pet-core/src/python_environment.rs | 188 + crates/pet-env-var-path/Cargo.toml | 6 + crates/pet-env-var-path/src/lib.rs | 14 + crates/pet-hatch/Cargo.toml | 6 + crates/pet-hatch/src/lib.rs | 14 + crates/pet-homebrew/Cargo.toml | 6 + crates/pet-homebrew/src/lib.rs | 14 + crates/pet-jsonrpc/Cargo.toml | 6 + crates/pet-jsonrpc/src/lib.rs | 14 + crates/pet-pipenv/Cargo.toml | 6 + crates/pet-pipenv/src/lib.rs | 14 + crates/pet-poetry/Cargo.toml | 6 + crates/pet-poetry/src/lib.rs | 14 + crates/pet-pyenv/Cargo.toml | 6 + crates/pet-pyenv/src/lib.rs | 14 + crates/pet-utils/Cargo.toml | 9 + crates/pet-utils/src/env.rs | 21 + crates/pet-utils/src/executable.rs | 222 + crates/pet-utils/src/headers.rs | 50 + crates/pet-utils/src/lib.rs | 8 + crates/pet-utils/src/pyvenv_cfg.rs | 92 + crates/pet-utils/src/sys_prefix.rs | 17 + crates/pet-utils/tests/common.rs | 166 + crates/pet-utils/tests/executable_test.rs | 49 + crates/pet-utils/tests/sys_prefix_test.rs | 72 + .../tests/unix/executables/.venv/bin/python | 0 .../tests/unix/executables/.venv/bin/python3 | 0 .../tests/unix/executables/.venv/pyvenv.cfg | 5 + .../conda_without_python/conda-meta/history | 3 + .../unix/executables/python3.9.9/bin/python3 | 0 .../executables/python3.9.9/bin/python3.9.9 | 0 .../python3.9.9/include/patchlevel.h | 35 + .../unix/headers/python3.9.9/bin/python3 | 0 .../unix/headers/python3.9.9/bin/python3.9.9 | 0 .../headers/python3.9.9/include/patchlevel.h | 35 + .../tests/unix/pyvenv_cfg/.venv/bin/python | 0 .../tests/unix/pyvenv_cfg/.venv/bin/python3 | 0 .../tests/unix/pyvenv_cfg/.venv/pyvenv.cfg | 5 + .../unix/pyvenv_cfg/hatch_env/bin/python | 0 .../unix/pyvenv_cfg/hatch_env/pyvenv.cfg | 8 + .../python3.9.9_without_headers/bin/python | 0 crates/pet-venv/Cargo.toml | 6 + crates/pet-venv/src/lib.rs | 14 + crates/pet-virtualenv/Cargo.toml | 6 + crates/pet-virtualenv/src/lib.rs | 14 + crates/pet-virtualenvwrapper/Cargo.toml | 6 + crates/pet-virtualenvwrapper/src/lib.rs | 14 + crates/pet-windows-registry/Cargo.toml | 6 + crates/pet-windows-registry/src/lib.rs | 14 + crates/pet-windows-store/Cargo.toml | 6 + crates/pet-windows-store/src/lib.rs | 14 + crates/pet/Cargo.toml | 6 + crates/pet/src/lib.rs | 0 crates/pet/src/main.rs | 3 + 118 files changed, 55499 insertions(+) create mode 100644 cargo.toml create mode 100644 crates/pet-conda/Cargo.toml create mode 100644 crates/pet-conda/src/conda_rc.rs create mode 100644 crates/pet-conda/src/environment_locations.rs create mode 100644 crates/pet-conda/src/environments.rs create mode 100644 crates/pet-conda/src/lib.rs create mode 100644 crates/pet-conda/src/manager.rs create mode 100644 crates/pet-conda/src/mod.rs create mode 100644 crates/pet-conda/src/package.rs create mode 100644 crates/pet-conda/src/utils.rs create mode 100644 crates/pet-conda/tests/common.rs create mode 100644 crates/pet-conda/tests/environment_locations_test.rs create mode 100644 crates/pet-conda/tests/package_test.rs create mode 100644 crates/pet-conda/tests/unix/anaconda3-2023.03-without-history/bin/conda create mode 100644 crates/pet-conda/tests/unix/anaconda3-2023.03-without-history/bin/python create mode 100644 crates/pet-conda/tests/unix/anaconda3-2023.03-without-history/bin/python3 create mode 100644 crates/pet-conda/tests/unix/anaconda3-2023.03-without-history/bin/python3.1 create mode 100644 crates/pet-conda/tests/unix/anaconda3-2023.03-without-history/bin/python3.10 create mode 100644 crates/pet-conda/tests/unix/anaconda3-2023.03-without-history/conda-meta/conda-23.1.0-py310hca03da5_0.json create mode 100644 crates/pet-conda/tests/unix/anaconda3-2023.03-without-history/conda-meta/conda-build-3.23.3-py310hca03da5_0.json create mode 100644 crates/pet-conda/tests/unix/anaconda3-2023.03-without-history/conda-meta/pytest-7.1.2-py310hca03da5_0.json create mode 100644 crates/pet-conda/tests/unix/anaconda3-2023.03-without-history/conda-meta/python-3.10.9-hc0d8a6c_1.json create mode 100644 crates/pet-conda/tests/unix/anaconda3-2023.03-without-history/conda-meta/python-dateutil-2.8.2-pyhd3eb1b0_0.json create mode 100644 crates/pet-conda/tests/unix/anaconda3-2023.03-without-history/conda-meta/python-fastjsonschema-2.16.2-py310hca03da5_0.json create mode 100644 crates/pet-conda/tests/unix/anaconda3-2023.03-without-history/condabin/conda create mode 100644 crates/pet-conda/tests/unix/anaconda3-2023.03/bin/conda create mode 100644 crates/pet-conda/tests/unix/anaconda3-2023.03/bin/python create mode 100644 crates/pet-conda/tests/unix/anaconda3-2023.03/bin/python3 create mode 100644 crates/pet-conda/tests/unix/anaconda3-2023.03/bin/python3.1 create mode 100644 crates/pet-conda/tests/unix/anaconda3-2023.03/bin/python3.10 create mode 100644 crates/pet-conda/tests/unix/anaconda3-2023.03/conda-meta/conda-23.1.0-py310hca03da5_0.json create mode 100644 crates/pet-conda/tests/unix/anaconda3-2023.03/conda-meta/conda-build-3.23.3-py310hca03da5_0.json create mode 100644 crates/pet-conda/tests/unix/anaconda3-2023.03/conda-meta/history create mode 100644 crates/pet-conda/tests/unix/anaconda3-2023.03/conda-meta/pytest-7.1.2-py310hca03da5_0.json create mode 100644 crates/pet-conda/tests/unix/anaconda3-2023.03/conda-meta/python-3.10.9-hc0d8a6c_1.json create mode 100644 crates/pet-conda/tests/unix/anaconda3-2023.03/conda-meta/python-dateutil-2.8.2-pyhd3eb1b0_0.json create mode 100644 crates/pet-conda/tests/unix/anaconda3-2023.03/conda-meta/python-fastjsonschema-2.16.2-py310hca03da5_0.json create mode 100644 crates/pet-conda/tests/unix/anaconda3-2023.03/condabin/conda create mode 100644 crates/pet-conda/tests/unix/anaconda3-2023.03/envs/env_python_3/bin/conda create mode 100644 crates/pet-conda/tests/unix/anaconda3-2023.03/envs/env_python_3/bin/python create mode 100644 crates/pet-conda/tests/unix/anaconda3-2023.03/envs/env_python_3/bin/python3 create mode 100644 crates/pet-conda/tests/unix/anaconda3-2023.03/envs/env_python_3/bin/python3.1 create mode 100644 crates/pet-conda/tests/unix/anaconda3-2023.03/envs/env_python_3/bin/python3.12 create mode 100644 crates/pet-conda/tests/unix/anaconda3-2023.03/envs/env_python_3/conda-meta/history create mode 100644 crates/pet-conda/tests/unix/anaconda3-2023.03/envs/env_python_3/conda-meta/pygments-2.17.2-pyhd8ed1ab_0.json create mode 100644 crates/pet-conda/tests/unix/anaconda3-2023.03/envs/env_python_3/conda-meta/python-3.12.2-hdf0ec26_0_cpython.json create mode 100644 crates/pet-conda/tests/unix/anaconda3-2023.03/envs/env_python_3/conda-meta/python-dateutil-2.8.2-pyhd8ed1ab_0.json create mode 100644 crates/pet-conda/tests/unix/anaconda3-2023.03/envs/env_python_3/conda-meta/python_abi-3.12-4_cp312.json create mode 100644 crates/pet-conda/tests/unix/anaconda3-2023.03/envs/myenv/bin/python create mode 100644 crates/pet-conda/tests/unix/anaconda3-2023.03/envs/myenv/bin/python3 create mode 100644 crates/pet-conda/tests/unix/anaconda3-2023.03/envs/myenv/bin/python3.1 create mode 100644 crates/pet-conda/tests/unix/anaconda3-2023.03/envs/myenv/bin/python3.10 create mode 100644 crates/pet-conda/tests/unix/anaconda3-2023.03/envs/myenv/conda-meta/history create mode 100644 crates/pet-conda/tests/unix/anaconda3-2023.03/envs/myenv/conda-meta/pip-24.0-py310hca03da5_0.json create mode 100644 crates/pet-conda/tests/unix/anaconda3-2023.03/envs/myenv/conda-meta/python-3.10.14-hb885b13_1.json create mode 100644 crates/pet-conda/tests/unix/anaconda3-2023.03/envs/myenv/conda-meta/readline-8.2-h1a28f6b_0.json create mode 100644 crates/pet-conda/tests/unix/anaconda3-2023.03/envs/without_python/conda-meta/history create mode 100644 crates/pet-conda/tests/unix/user_home_with_environments_txt/.conda/environments.txt create mode 100644 crates/pet-conda/tests/utils_test.rs create mode 100644 crates/pet-core/Cargo.toml create mode 100644 crates/pet-core/src/arch.rs create mode 100644 crates/pet-core/src/lib.rs create mode 100644 crates/pet-core/src/manager.rs create mode 100644 crates/pet-core/src/os_environment.rs create mode 100644 crates/pet-core/src/python_environment.rs create mode 100644 crates/pet-env-var-path/Cargo.toml create mode 100644 crates/pet-env-var-path/src/lib.rs create mode 100644 crates/pet-hatch/Cargo.toml create mode 100644 crates/pet-hatch/src/lib.rs create mode 100644 crates/pet-homebrew/Cargo.toml create mode 100644 crates/pet-homebrew/src/lib.rs create mode 100644 crates/pet-jsonrpc/Cargo.toml create mode 100644 crates/pet-jsonrpc/src/lib.rs create mode 100644 crates/pet-pipenv/Cargo.toml create mode 100644 crates/pet-pipenv/src/lib.rs create mode 100644 crates/pet-poetry/Cargo.toml create mode 100644 crates/pet-poetry/src/lib.rs create mode 100644 crates/pet-pyenv/Cargo.toml create mode 100644 crates/pet-pyenv/src/lib.rs create mode 100644 crates/pet-utils/Cargo.toml create mode 100644 crates/pet-utils/src/env.rs create mode 100644 crates/pet-utils/src/executable.rs create mode 100644 crates/pet-utils/src/headers.rs create mode 100644 crates/pet-utils/src/lib.rs create mode 100644 crates/pet-utils/src/pyvenv_cfg.rs create mode 100644 crates/pet-utils/src/sys_prefix.rs create mode 100644 crates/pet-utils/tests/common.rs create mode 100644 crates/pet-utils/tests/executable_test.rs create mode 100644 crates/pet-utils/tests/sys_prefix_test.rs create mode 100644 crates/pet-utils/tests/unix/executables/.venv/bin/python create mode 100644 crates/pet-utils/tests/unix/executables/.venv/bin/python3 create mode 100644 crates/pet-utils/tests/unix/executables/.venv/pyvenv.cfg create mode 100644 crates/pet-utils/tests/unix/executables/conda_without_python/conda-meta/history create mode 100644 crates/pet-utils/tests/unix/executables/python3.9.9/bin/python3 create mode 100644 crates/pet-utils/tests/unix/executables/python3.9.9/bin/python3.9.9 create mode 100644 crates/pet-utils/tests/unix/executables/python3.9.9/include/patchlevel.h create mode 100644 crates/pet-utils/tests/unix/headers/python3.9.9/bin/python3 create mode 100644 crates/pet-utils/tests/unix/headers/python3.9.9/bin/python3.9.9 create mode 100644 crates/pet-utils/tests/unix/headers/python3.9.9/include/patchlevel.h create mode 100644 crates/pet-utils/tests/unix/pyvenv_cfg/.venv/bin/python create mode 100644 crates/pet-utils/tests/unix/pyvenv_cfg/.venv/bin/python3 create mode 100644 crates/pet-utils/tests/unix/pyvenv_cfg/.venv/pyvenv.cfg create mode 100644 crates/pet-utils/tests/unix/pyvenv_cfg/hatch_env/bin/python create mode 100644 crates/pet-utils/tests/unix/pyvenv_cfg/hatch_env/pyvenv.cfg create mode 100644 crates/pet-utils/tests/unix/pyvenv_cfg/python3.9.9_without_headers/bin/python create mode 100644 crates/pet-venv/Cargo.toml create mode 100644 crates/pet-venv/src/lib.rs create mode 100644 crates/pet-virtualenv/Cargo.toml create mode 100644 crates/pet-virtualenv/src/lib.rs create mode 100644 crates/pet-virtualenvwrapper/Cargo.toml create mode 100644 crates/pet-virtualenvwrapper/src/lib.rs create mode 100644 crates/pet-windows-registry/Cargo.toml create mode 100644 crates/pet-windows-registry/src/lib.rs create mode 100644 crates/pet-windows-store/Cargo.toml create mode 100644 crates/pet-windows-store/src/lib.rs create mode 100644 crates/pet/Cargo.toml create mode 100644 crates/pet/src/lib.rs create mode 100644 crates/pet/src/main.rs diff --git a/cargo.toml b/cargo.toml new file mode 100644 index 00000000..cadbb46c --- /dev/null +++ b/cargo.toml @@ -0,0 +1,4 @@ +[workspace] + +members = ["crates/*"] +resolver = "2" diff --git a/crates/pet-conda/Cargo.toml b/crates/pet-conda/Cargo.toml new file mode 100644 index 00000000..6b1a06aa --- /dev/null +++ b/crates/pet-conda/Cargo.toml @@ -0,0 +1,12 @@ +[package] +name = "pet-conda" +version = "0.1.0" +edition = "2021" + +[dependencies] +serde = { version = "1.0.152", features = ["derive"] } +serde_json = "1.0.93" +lazy_static = "1.4.0" +pet-core = { path = "../pet-core" } +log = "0.4.21" +regex = "1.10.4" diff --git a/crates/pet-conda/src/conda_rc.rs b/crates/pet-conda/src/conda_rc.rs new file mode 100644 index 00000000..9a426194 --- /dev/null +++ b/crates/pet-conda/src/conda_rc.rs @@ -0,0 +1,152 @@ +// Copyright (c) Microsoft Corporation. All rights reserved. +// Licensed under the MIT License. + +use log::trace; +use pet_core::os_environment::Environment; +use std::{fs, path::PathBuf}; + +#[derive(Debug)] +pub struct Condarc { + pub env_dirs: Vec, +} + +#[cfg(windows)] +fn get_conda_rc_search_paths(environment: &dyn Environment) -> Vec { + let mut search_paths: Vec = vec![ + "C:\\ProgramData\\conda\\.condarc", + "C:\\ProgramData\\conda\\condarc", + "C:\\ProgramData\\conda\\condarc.d", + ] + .iter() + .map(|p| PathBuf::from(p)) + .collect(); + + if let Some(conda_root) = environment.get_env_var("CONDA_ROOT".to_string()) { + search_paths.append(&mut vec![ + PathBuf::from(conda_root.clone()).join(".condarc"), + PathBuf::from(conda_root.clone()).join("condarc"), + PathBuf::from(conda_root.clone()).join(".condarc.d"), + ]); + } + if let Some(home) = environment.get_user_home() { + search_paths.append(&mut vec![ + home.join(".config").join("conda").join(".condarc"), + home.join(".config").join("conda").join("condarc"), + home.join(".config").join("conda").join("condarc.d"), + home.join(".conda").join(".condarc"), + home.join(".conda").join("condarc"), + home.join(".conda").join("condarc.d"), + home.join(".condarc"), + ]); + } + if let Some(conda_prefix) = environment.get_env_var("CONDA_PREFIX".to_string()) { + search_paths.append(&mut vec![ + PathBuf::from(conda_prefix.clone()).join(".condarc"), + PathBuf::from(conda_prefix.clone()).join("condarc"), + PathBuf::from(conda_prefix.clone()).join(".condarc.d"), + ]); + } + if let Some(condarc) = environment.get_env_var("CONDARC".to_string()) { + search_paths.append(&mut vec![PathBuf::from(condarc)]); + } + + search_paths +} +#[cfg(unix)] +fn get_conda_rc_search_paths(environment: &dyn Environment) -> Vec { + let mut search_paths: Vec = vec![ + "/etc/conda/.condarc", + "/etc/conda/condarc", + "/etc/conda/condarc.d/", + "/var/lib/conda/.condarc", + "/var/lib/conda/condarc", + "/var/lib/conda/condarc.d/", + ] + .iter() + .map(|p| PathBuf::from(p)) + .map(|p| { + // This only applies in tests. + // We need this, as the root folder cannot be mocked. + if let Some(root) = environment.get_root() { + root.join(p.to_string_lossy()[1..].to_string()) + } else { + p + } + }) + .collect(); + + if let Some(conda_root) = environment.get_env_var("CONDA_ROOT".to_string()) { + search_paths.append(&mut vec![ + PathBuf::from(conda_root.clone()).join(".condarc"), + PathBuf::from(conda_root.clone()).join("condarc"), + PathBuf::from(conda_root.clone()).join(".condarc.d"), + ]); + } + if let Some(xdg_config_home) = environment.get_env_var("XDG_CONFIG_HOME".to_string()) { + search_paths.append(&mut vec![ + PathBuf::from(xdg_config_home.clone()).join(".condarc"), + PathBuf::from(xdg_config_home.clone()).join("condarc"), + PathBuf::from(xdg_config_home.clone()).join(".condarc.d"), + ]); + } + if let Some(home) = environment.get_user_home() { + search_paths.append(&mut vec![ + home.join(".config").join("conda").join(".condarc"), + home.join(".config").join("conda").join("condarc"), + home.join(".config").join("conda").join("condarc.d"), + home.join(".conda").join(".condarc"), + home.join(".conda").join("condarc"), + home.join(".conda").join("condarc.d"), + home.join(".condarc"), + ]); + } + if let Some(conda_prefix) = environment.get_env_var("CONDA_PREFIX".to_string()) { + search_paths.append(&mut vec![ + PathBuf::from(conda_prefix.clone()).join(".condarc"), + PathBuf::from(conda_prefix.clone()).join("condarc"), + PathBuf::from(conda_prefix.clone()).join(".condarc.d"), + ]); + } + if let Some(condarc) = environment.get_env_var("CONDARC".to_string()) { + search_paths.append(&mut vec![PathBuf::from(condarc)]); + } + + search_paths +} + +/** + * The .condarc file contains a list of directories where conda environments are created. + * https://conda.io/projects/conda/en/latest/configuration.html#envs-dirs + * + * TODO: Search for the .condarc file in the following locations: + * https://conda.io/projects/conda/en/latest/user-guide/configuration/use-condarc.html#searching-for-condarc + */ +pub fn get_conda_conda_rc(environment: &dyn Environment) -> Option { + let conda_rc = get_conda_rc_search_paths(environment) + .into_iter() + .find(|p| p.exists())?; + let mut start_consuming_values = false; + trace!("conda_rc: {:?}", conda_rc); + let reader = fs::read_to_string(conda_rc).ok()?; + let mut env_dirs = vec![]; + for line in reader.lines() { + if line.starts_with("envs_dirs:") && !start_consuming_values { + start_consuming_values = true; + continue; + } + if start_consuming_values { + if line.trim().starts_with("-") { + if let Some(env_dir) = line.splitn(2, '-').nth(1) { + let env_dir = PathBuf::from(env_dir.trim()).join("envs"); + if fs::metadata(&env_dir).is_ok() { + env_dirs.push(env_dir); + } + } + continue; + } else { + break; + } + } + } + return Some(Condarc { env_dirs }); +} diff --git a/crates/pet-conda/src/environment_locations.rs b/crates/pet-conda/src/environment_locations.rs new file mode 100644 index 00000000..9e740ce1 --- /dev/null +++ b/crates/pet-conda/src/environment_locations.rs @@ -0,0 +1,229 @@ +// Copyright (c) Microsoft Corporation. All rights reserved. +// Licensed under the MIT License. + +use crate::{ + conda_rc::get_conda_conda_rc, + utils::{is_conda_env, is_conda_install}, +}; +use log::trace; +use pet_core::os_environment::Environment; +use std::{ + fs, + path::{Path, PathBuf}, +}; + +// use super::conda_rc::get_conda_conda_rc; +// use crate::{ +// conda::{is_conda_env_location, is_conda_install_location}, +// known::Environment, +// }; +// use log::trace; +// use std::{ +// collections::HashSet, +// path::{Path, PathBuf}, +// }; + +pub fn get_conda_environment_paths(environment: &dyn Environment) -> Vec { + let mut env_paths = get_conda_envs_from_environment_txt(environment) + .iter() + .map(|e| PathBuf::from(e)) + .collect::>(); + + let mut env_paths_from_conda_rc = get_conda_environment_paths_from_conda_rc(environment); + env_paths.append(&mut env_paths_from_conda_rc); + + let mut envs_from_known_paths = get_conda_environment_paths_from_known_paths(environment); + env_paths.append(&mut envs_from_known_paths); + + let mut envs_from_known_paths = get_known_conda_install_locations(environment); + env_paths.append(&mut envs_from_known_paths); + + // For each env, check if we have a conda install directory in them and + // & then iterate through the list of envs in the envs directory. + for env_path in env_paths.clone().iter().filter(|e| is_conda_env(e)) { + let envs = get_environments_in_conda_dir(&env_path); + env_paths.extend(envs); + } + + // Remove duplicates. + env_paths.dedup(); + env_paths +} + +/** + * Get the list of conda environments found in other locations such as + * /.conda/envs + * /AppData/Local/conda/conda/envs + */ +pub fn get_conda_environment_paths_from_conda_rc(environment: &dyn Environment) -> Vec { + if let Some(paths) = get_conda_conda_rc(environment) { + paths.env_dirs + } else { + vec![] + } +} + +pub fn get_conda_environment_paths_from_known_paths(environment: &dyn Environment) -> Vec { + let mut env_paths: Vec = vec![]; + if let Some(home) = environment.get_user_home() { + let known_conda_paths = [ + PathBuf::from(".conda").join("envs"), + PathBuf::from("AppData") + .join("Local") + .join("conda") + .join("conda") + .join("envs"), + ]; + for path in known_conda_paths { + // We prefix with home only for testing purposes. + let full_path = home.join(path); + if let Ok(entries) = fs::read_dir(full_path) { + for entry in entries.filter_map(Result::ok) { + let path = entry.path(); + if let Some(meta) = fs::metadata(&path).ok() { + if meta.is_dir() { + env_paths.push(path); + } + } + } + } + } + } + return env_paths; +} + +pub fn get_environments_in_conda_dir(conda_dir: &Path) -> Vec { + let mut envs: Vec = vec![]; + + if is_conda_install(conda_dir) { + envs.push(conda_dir.to_path_buf()); + + if let Ok(entries) = fs::read_dir(conda_dir.join("envs")) { + for entry in entries.filter_map(Result::ok) { + let path = entry.path(); + if is_conda_env(&path) { + envs.push(path); + } + } + } + } else if is_conda_env(conda_dir) { + envs.push(conda_dir.to_path_buf()); + } + + envs.dedup(); + envs +} + +pub fn get_conda_envs_from_environment_txt(environment: &dyn Environment) -> Vec { + let mut envs: Vec = vec![]; + if let Some(home) = environment.get_user_home() { + let home = Path::new(&home); + let environment_txt = home.join(".conda").join("environments.txt"); + if let Ok(reader) = fs::read_to_string(environment_txt.clone()) { + trace!("Found environments.txt file {:?}", environment_txt); + for line in reader.lines() { + envs.push(PathBuf::from(line.to_string())); + } + } + } + + envs +} + +#[cfg(windows)] +pub fn get_known_conda_install_locations(environment: &dyn Environment) -> Vec { + let user_profile = environment.get_env_var("USERPROFILE".to_string()).unwrap(); + let program_data = environment.get_env_var("PROGRAMDATA".to_string()).unwrap(); + let all_user_profile = environment + .get_env_var("ALLUSERSPROFILE".to_string()) + .unwrap(); + let home_drive = environment.get_env_var("HOMEDRIVE".to_string()).unwrap(); + let mut known_paths = vec![ + Path::new(&user_profile).join("Anaconda3"), + Path::new(&program_data).join("Anaconda3"), + Path::new(&all_user_profile).join("Anaconda3"), + Path::new(&home_drive).join("Anaconda3"), + Path::new(&user_profile).join("Miniconda3"), + Path::new(&program_data).join("Miniconda3"), + Path::new(&all_user_profile).join("Miniconda3"), + Path::new(&home_drive).join("Miniconda3"), + Path::new(&all_user_profile).join("miniforge3"), + Path::new(&home_drive).join("miniforge3"), + ]; + if let Some(home) = environment.get_user_home() { + known_paths.push(PathBuf::from(home.clone()).join("anaconda3")); + known_paths.push(PathBuf::from(home.clone()).join("miniconda3")); + known_paths.push(PathBuf::from(home.clone()).join("miniforge3")); + known_paths.push(PathBuf::from(home).join(".conda")); + } + known_paths +} + +#[cfg(unix)] +pub fn get_known_conda_install_locations(environment: &dyn Environment) -> Vec { + let mut known_paths = vec![ + PathBuf::from("/opt/anaconda3"), + PathBuf::from("/opt/miniconda3"), + PathBuf::from("/usr/local/anaconda3"), + PathBuf::from("/usr/local/miniconda3"), + PathBuf::from("/usr/anaconda3"), + PathBuf::from("/usr/miniconda3"), + PathBuf::from("/home/anaconda3"), + PathBuf::from("/home/miniconda3"), + PathBuf::from("/anaconda3"), + PathBuf::from("/miniconda3"), + PathBuf::from("/miniforge3"), + PathBuf::from("/miniforge3"), + ]; + if let Some(home) = environment.get_user_home() { + known_paths.push(PathBuf::from(home.clone()).join("anaconda3")); + known_paths.push(PathBuf::from(home.clone()).join("miniconda3")); + known_paths.push(PathBuf::from(home.clone()).join("miniforge3")); + known_paths.push(PathBuf::from(home).join(".conda")); + } + known_paths +} + +#[cfg(windows)] +pub fn get_known_conda_locations(environment: &dyn Environment) -> Vec { + let user_profile = environment.get_env_var("USERPROFILE".to_string()).unwrap(); + let program_data = environment.get_env_var("PROGRAMDATA".to_string()).unwrap(); + let all_user_profile = environment + .get_env_var("ALLUSERSPROFILE".to_string()) + .unwrap(); + let home_drive = environment.get_env_var("HOMEDRIVE".to_string()).unwrap(); + let mut known_paths = vec![ + Path::new(&user_profile).join("Anaconda3\\Scripts"), + Path::new(&program_data).join("Anaconda3\\Scripts"), + Path::new(&all_user_profile).join("Anaconda3\\Scripts"), + Path::new(&home_drive).join("Anaconda3\\Scripts"), + Path::new(&user_profile).join("Miniconda3\\Scripts"), + Path::new(&program_data).join("Miniconda3\\Scripts"), + Path::new(&all_user_profile).join("Miniconda3\\Scripts"), + Path::new(&home_drive).join("Miniconda3\\Scripts"), + ]; + known_paths.append(&mut environment.get_know_global_search_locations()); + known_paths +} + +#[cfg(unix)] +pub fn get_known_conda_locations(environment: &dyn Environment) -> Vec { + let mut known_paths = vec![ + PathBuf::from("/opt/anaconda3/bin"), + PathBuf::from("/opt/miniconda3/bin"), + PathBuf::from("/usr/local/anaconda3/bin"), + PathBuf::from("/usr/local/miniconda3/bin"), + PathBuf::from("/usr/anaconda3/bin"), + PathBuf::from("/usr/miniconda3/bin"), + PathBuf::from("/home/anaconda3/bin"), + PathBuf::from("/home/miniconda3/bin"), + PathBuf::from("/anaconda3/bin"), + PathBuf::from("/miniconda3/bin"), + ]; + if let Some(home) = environment.get_user_home() { + known_paths.push(PathBuf::from(home.clone()).join("anaconda3/bin")); + known_paths.push(PathBuf::from(home).join("miniconda3/bin")); + } + known_paths.append(&mut environment.get_know_global_search_locations()); + known_paths +} diff --git a/crates/pet-conda/src/environments.rs b/crates/pet-conda/src/environments.rs new file mode 100644 index 00000000..9d12ef0d --- /dev/null +++ b/crates/pet-conda/src/environments.rs @@ -0,0 +1,174 @@ +// Copyright (c) Microsoft Corporation. All rights reserved. +// Licensed under the MIT License. + +use super::{is_conda_env_location, is_conda_install_location, utils::get_conda_package_info}; +use crate::{ + messaging::{ + Architecture, EnvManager, PythonEnvironment, PythonEnvironmentBuilder, + PythonEnvironmentCategory, + }, + utils::find_python_binary_path, +}; +use std::path::PathBuf; + +#[derive(Debug, Clone)] +pub struct CondaEnvironment { + pub env_path: PathBuf, + pub python_executable_path: Option, + pub version: Option, + pub conda_install_folder: Option, + pub arch: Option, +} + +impl CondaEnvironment { + pub fn to_python_environment( + &self, + conda_manager: EnvManager, + conda_manager_dir: &PathBuf, + ) -> PythonEnvironment { + #[allow(unused_assignments)] + let mut name: Option = None; + if is_conda_install_location(&self.env_path) { + name = Some("base".to_string()); + } else { + name = match self.env_path.file_name() { + Some(name) => Some(name.to_str().unwrap_or_default().to_string()), + None => None, + }; + } + // if the conda install folder is parent of the env folder, then we can use named activation. + // E.g. conda env is = /envs/ + // Then we can use `/bin/conda activate -n ` + if !self.env_path.starts_with(&conda_manager_dir) { + name = None; + } + // This is a root env. + let builder = PythonEnvironmentBuilder::new(PythonEnvironmentCategory::Conda) + .python_executable_path(self.python_executable_path.clone()) + .version(self.version.clone()) + .env_path(Some(self.env_path.clone())) + .arch(self.arch.clone()) + .env_manager(Some(conda_manager.clone())) + .python_run_command(get_activation_command(self, &conda_manager, name.clone())); + + if let Some(name) = name { + builder.name(name).build() + } else { + builder.build() + } + } +} +pub fn get_conda_environment_info(env_path: &PathBuf) -> Option { + if is_conda_env_location(env_path) { + let conda_install_folder = get_conda_installation_used_to_create_conda_env(env_path); + let env_path = env_path.clone(); + if let Some(python_binary) = find_python_binary_path(&env_path) { + if let Some(package_info) = get_conda_package_info(&env_path, "python") { + return Some(CondaEnvironment { + env_path, + python_executable_path: Some(python_binary), + version: Some(package_info.version), + conda_install_folder, + arch: package_info.arch, + }); + } else { + return Some(CondaEnvironment { + env_path, + python_executable_path: Some(python_binary), + version: None, + conda_install_folder, + arch: None, + }); + } + } else { + return Some(CondaEnvironment { + env_path, + python_executable_path: None, + version: None, + conda_install_folder, + arch: None, + }); + } + } + + None +} + +/** + * The conda-meta/history file in conda environments contain the command used to create the conda environment. + * And example is `# cmd: \Scripts\conda-script.py create -n sample`` + * And example is `# cmd: conda create -n sample`` + * + * Sometimes the cmd line contains the fully qualified path to the conda install folder. + * This function returns the path to the conda installation that was used to create the environment. + */ +pub fn get_conda_installation_used_to_create_conda_env(env_path: &PathBuf) -> Option { + // Possible the env_path is the root conda install folder. + if is_conda_install_location(env_path) { + return Some(env_path.to_path_buf()); + } + + // If this environment is in a folder named `envs`, then the parent directory of `envs` is the root conda install folder. + if let Some(parent) = env_path.ancestors().nth(2) { + if is_conda_install_location(parent) { + return Some(parent.to_path_buf()); + } + } + + let conda_meta_history = env_path.join("conda-meta").join("history"); + if let Ok(reader) = std::fs::read_to_string(conda_meta_history.clone()) { + if let Some(line) = reader.lines().map(|l| l.trim()).find(|l| { + l.to_lowercase().starts_with("# cmd:") && l.to_lowercase().contains(" create -") + }) { + // Sample lines + // # cmd: \Scripts\conda-script.py create -n samlpe1 + // # cmd: \Scripts\conda-script.py create -p + // # cmd: /Users/donjayamanne/miniconda3/bin/conda create -n conda1 + let start_index = line.to_lowercase().find("# cmd:")? + "# cmd:".len(); + let end_index = line.to_lowercase().find(" create -")?; + let cmd_line = PathBuf::from(line[start_index..end_index].trim().to_string()); + if let Some(cmd_line) = cmd_line.parent() { + if let Some(conda_dir) = cmd_line.file_name() { + if conda_dir.to_ascii_lowercase() == "bin" + || conda_dir.to_ascii_lowercase() == "scripts" + { + if let Some(conda_dir) = cmd_line.parent() { + return Some(conda_dir.to_path_buf()); + } + } + return Some(cmd_line.to_path_buf()); + } + } + } + } + + None +} + +pub fn get_activation_command( + env: &CondaEnvironment, + manager: &EnvManager, + name: Option, +) -> Option> { + if env.python_executable_path.is_none() { + return None; + } + let conda_exe = manager.executable_path.to_str().unwrap().to_string(); + if let Some(name) = name { + Some(vec![ + conda_exe, + "run".to_string(), + "-n".to_string(), + name, + "python".to_string(), + ]) + } else { + Some(vec![ + conda_exe, + "run".to_string(), + "-p".to_string(), + env.env_path.to_str().unwrap().to_string(), + "python".to_string(), + ]) + } +} diff --git a/crates/pet-conda/src/lib.rs b/crates/pet-conda/src/lib.rs new file mode 100644 index 00000000..76b1dab8 --- /dev/null +++ b/crates/pet-conda/src/lib.rs @@ -0,0 +1,23 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +pub mod conda_rc; +pub mod environment_locations; +pub mod package; +pub mod manager; +pub mod utils; + +pub fn add(left: usize, right: usize) -> usize { + left + right +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn it_works() { + let result = add(2, 2); + assert_eq!(result, 4); + } +} diff --git a/crates/pet-conda/src/manager.rs b/crates/pet-conda/src/manager.rs new file mode 100644 index 00000000..9a4ff150 --- /dev/null +++ b/crates/pet-conda/src/manager.rs @@ -0,0 +1,136 @@ +// Copyright (c) Microsoft Corporation. All rights reserved. +// Licensed under the MIT License. + +use log::warn; +use pet_core::{manager::EnvManager, manager::EnvManagerType, os_environment::Environment}; +use std::{ + env, + path::{Path, PathBuf}, +}; + +use crate::{environment_locations::get_known_conda_locations, package::CondaPackageInfo}; + +fn get_conda_executable(path: &Path) -> Option { + #[cfg(windows)] + let relative_path_to_conda_exe = vec![ + PathBuf::from("Scripts").join("conda.exe"), + PathBuf::from("Scripts").join("conda.bat"), + ]; + #[cfg(unix)] + let relative_path_to_conda_exe = vec![PathBuf::from("bin").join("conda")]; + + for relative_path in relative_path_to_conda_exe { + let exe = path.join(&relative_path); + if exe.metadata().is_ok() { + return Some(exe); + } + } + + None +} + +/// Specifically returns the file names that are valid for 'conda' on windows +#[cfg(windows)] +fn get_conda_bin_names() -> Vec<&'static str> { + vec!["conda.exe", "conda.bat"] +} + +/// Specifically returns the file names that are valid for 'conda' on linux/Mac +#[cfg(unix)] +fn get_conda_bin_names() -> Vec<&'static str> { + vec!["conda"] +} + +/// Find the conda binary on the PATH environment variable +pub fn find_conda_binary_on_path(environment: &dyn Environment) -> Option { + let paths = environment.get_env_var("PATH".to_string())?; + for path in env::split_paths(&paths) { + for bin in get_conda_bin_names() { + let conda_path = path.join(bin); + if let Ok(metadata) = std::fs::metadata(&conda_path) { + if metadata.is_file() || metadata.is_symlink() { + return Some(conda_path); + } + } + } + } + None +} + +/// Find conda binary in known locations +fn find_conda_binary_in_known_locations(environment: &dyn Environment) -> Option { + let conda_bin_names = get_conda_bin_names(); + let known_locations = get_known_conda_locations(environment); + for location in known_locations { + for bin in &conda_bin_names { + let conda_path = location.join(bin); + if let Some(metadata) = std::fs::metadata(&conda_path).ok() { + if metadata.is_file() || metadata.is_symlink() { + return Some(conda_path); + } + } + } + } + None +} + +/// Find the conda binary on the system +pub fn find_conda_binary(environment: &dyn Environment) -> Option { + let conda_binary_on_path = find_conda_binary_on_path(environment); + match conda_binary_on_path { + Some(conda_binary_on_path) => Some(conda_binary_on_path), + None => find_conda_binary_in_known_locations(environment), + } +} + +#[derive(Debug, Clone)] +pub struct CondaManager { + pub executable: PathBuf, + pub version: Option, + pub company: Option, + pub company_display_name: Option, + pub conda_dir: PathBuf, +} + +impl CondaManager { + pub fn to_manager(&self) -> EnvManager { + EnvManager { + tool: EnvManagerType::Conda, + executable: self.executable.clone(), + version: self.version.clone(), + } + } +} + +pub fn get_conda_manager(path: &Path) -> Option { + let conda_exe = get_conda_executable(path)?; + if let Some(conda_pkg) = CondaPackageInfo::from(path, &crate::package::Package::Conda) { + Some(CondaManager { + executable: conda_exe, + version: Some(conda_pkg.version), + company: None, + company_display_name: None, + conda_dir: path.to_path_buf(), + }) + } else { + warn!("Could not get conda package info from {:?}", path); + None + } +} + +// pub fn get_conda_version(conda_binary: &PathBuf) -> Option { +// let mut parent = conda_binary.parent()?; +// if parent.ends_with("bin") { +// parent = parent.parent()?; +// } +// if parent.ends_with("Library") { +// parent = parent.parent()?; +// } +// match get_conda_package_info(&parent, "conda") { +// Some(result) => Some(result.version), +// None => match get_conda_package_info(&parent.parent()?, "conda") { +// Some(result) => Some(result.version), +// None => None, +// }, +// } +// } diff --git a/crates/pet-conda/src/mod.rs b/crates/pet-conda/src/mod.rs new file mode 100644 index 00000000..939946ef --- /dev/null +++ b/crates/pet-conda/src/mod.rs @@ -0,0 +1,245 @@ +// Copyright (c) Microsoft Corporation. All rights reserved. +// Licensed under the MIT License. + +mod environment_locations; +mod environments; +mod lib; +mod manager; +mod utils; + +use crate::known::Environment; +use crate::locator::Locator; +use crate::locator::LocatorResult; +use crate::messaging::EnvManager; +use crate::messaging::PythonEnvironment; +use crate::messaging::PythonEnvironmentBuilder; +use crate::messaging::PythonEnvironmentCategory; +use crate::utils::PythonEnv; +use environment_locations::get_conda_environment_paths; +#[allow(unused_imports)] +pub use environment_locations::get_conda_environment_paths_from_conda_rc; +use environment_locations::get_environments_in_conda_dir; +use environments::get_activation_command; +use environments::get_conda_environment_info; +use environments::get_conda_installation_used_to_create_conda_env; +use environments::CondaEnvironment; +use log::error; +use manager::get_conda_manager; +use manager::CondaManager; +use std::collections::HashMap; +use std::collections::HashSet; +use std::path::{Path, PathBuf}; +use std::sync::Mutex; +#[allow(unused_imports)] +pub use utils::get_conda_package_info; +pub use utils::is_conda_env_location; +pub use utils::is_conda_install_location; +#[allow(unused_imports)] +pub use utils::CondaPackage; + +fn get_conda_manager_from_env(env_path: &Path) -> Option { + // Lets see if we've been given the base env. + if let Some(manager) = get_conda_manager(env_path) { + return Some(manager); + } + + // Possible we've been given an env thats in the `/envs` folder. + if let Some(parent) = env_path.parent() { + if parent.file_name().unwrap_or_default() == "envs" { + return get_conda_manager(parent.parent()?); + } + } + + // We've been given an env thats been created using the -p flag. + // Get the conda install folder from the history file. + if let Some(conda_install_folder) = + get_conda_installation_used_to_create_conda_env(&env_path.to_path_buf()) + { + return get_conda_manager(&conda_install_folder); + } + None +} + +fn get_known_conda_envs_from_various_locations( + environment: &dyn Environment, +) -> Vec { + get_conda_environment_paths(environment) + .iter() + .map(|path| get_conda_environment_info(&path)) + .filter(Option::is_some) + .map(Option::unwrap) + .into_iter() + .collect::>() +} + +pub struct Conda<'a> { + pub environments: Mutex>, + pub managers: Mutex>, + pub environment: &'a dyn Environment, +} + +pub trait CondaLocator { + fn find_in(&mut self, possible_conda_folder: &Path) -> Option; +} + +impl Conda<'_> { + pub fn with<'a>(environment: &'a impl Environment) -> Conda { + Conda { + environment, + environments: Mutex::new(HashMap::new()), + managers: Mutex::new(HashMap::new()), + } + } +} + +impl CondaLocator for Conda<'_> { + fn find_in(&mut self, conda_dir: &Path) -> Option { + if !is_conda_install_location(conda_dir) { + return None; + } + if let Some(manager) = get_conda_manager(&conda_dir) { + let mut managers = self.managers.lock().unwrap(); + let mut environments = self.environments.lock().unwrap(); + + // Keep track to search again later. + // Possible we'll find environments in other directories created using this manager + managers.insert(conda_dir.to_path_buf(), manager.clone()); + + let mut new_environments = vec![]; + + // Find all the environments in the conda install folder. (under `envs` folder) + get_environments_in_conda_dir(conda_dir) + .iter() + .map(|path| get_conda_environment_info(path)) + .filter(Option::is_some) + .map(Option::unwrap) + .for_each(|env| { + let env = env.to_python_environment(manager.to_manager(), &manager.conda_dir); + if let Some(path) = env.env_path.clone() { + if environments.contains_key(&path) { + return; + } + environments.insert(path, env.clone()); + new_environments.push(env); + } + }); + + return Some(LocatorResult { + environments: new_environments, + managers: vec![manager.to_manager()], + }); + } + return None; + } +} + +impl Locator for Conda<'_> { + fn resolve(&self, env: &PythonEnv) -> Option { + if let Some(ref path) = env.path { + let mut managers = self.managers.lock().unwrap(); + let mut environments = self.environments.lock().unwrap(); + + // Do we already have an env for this. + if let Some(env) = environments.get(path) { + return Some(env.clone()); + } + if let Some(env) = get_conda_environment_info(path) { + if let Some(conda_dir) = &env.conda_install_folder { + // Use existing manager if we have one. + if let Some(manager) = managers.get(conda_dir) { + let env = env.to_python_environment(manager.to_manager(), &conda_dir); + environments.insert(path.clone(), env.clone()); + return Some(env); + } + + if let Some(manager) = get_conda_manager(conda_dir) { + let env = env.to_python_environment(manager.to_manager(), &conda_dir); + managers.insert(path.clone(), manager.clone()); + environments.insert(path.clone(), env.clone()); + return Some(env); + } + } else { + error!("Unable to find conda Install folder conda install folder env: {:?}", env); + } + } + } + None + } + + fn find(&mut self) -> Option { + let mut managers = self.managers.lock().unwrap(); + let mut environments = self.environments.lock().unwrap(); + + let mut discovered_environments: Vec = vec![]; + // 1. Get a list of all know conda environments + let known_conda_envs = get_known_conda_envs_from_various_locations(self.environment); + + // 2. Go through all conda dirs and build the conda managers. + for env in &known_conda_envs { + if let Some(conda_dir) = &env.conda_install_folder { + if managers.contains_key(conda_dir) { + continue; + } + if let Some(manager) = get_conda_manager(&conda_dir) { + managers.insert(conda_dir.clone(), manager); + } + } + } + + fn get_manager( + known_env: &CondaEnvironment, + discovered_managers: &mut HashMap, + ) -> Option { + if let Some(ref path) = known_env.conda_install_folder { + return discovered_managers.get(path).cloned(); + } + // If we have a conda install folder, then use that to get the manager. + if let Some(ref conda_dir) = known_env.conda_install_folder { + if let Some(mgr) = discovered_managers.get(conda_dir) { + return Some(mgr.clone()); + } + if let Some(manager) = get_conda_manager(&conda_dir) { + discovered_managers.insert(conda_dir.clone(), manager.clone()); + return Some(manager); + } + + // We could not find the manager, this is an error. + error!( + "Manager not found for conda env: {:?}, known managers include {:?}", + known_env, + discovered_managers.values() + ); + } + // If we do not have the conda install folder, then use the env path to get the manager. + if let Some(mgr) = discovered_managers.values().next() { + return Some(mgr.clone()); + } else { + error!("No conda manager, hence unable to report any environment"); + return None; + } + } + + // 5. Go through each environment we know of and build the python environments. + for known_env in &known_conda_envs { + // We should not hit this condition, see above. + if let Some(manager) = get_manager(known_env, &mut managers) { + let env = known_env.to_python_environment(manager.to_manager(), &manager.conda_dir); + environments.insert(known_env.env_path.clone(), env.clone()); + discovered_environments.push(env); + } + } + + if managers.is_empty() && discovered_environments.is_empty() { + return None; + } + + Some(LocatorResult { + managers: managers + .values() + .into_iter() + .map(|m| m.to_manager()) + .collect::>(), + environments: discovered_environments, + }) + } +} diff --git a/crates/pet-conda/src/package.rs b/crates/pet-conda/src/package.rs new file mode 100644 index 00000000..a2dc26a7 --- /dev/null +++ b/crates/pet-conda/src/package.rs @@ -0,0 +1,182 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +use lazy_static::lazy_static; +use log::warn; +use pet_core::arch::Architecture; +use regex::Regex; +use serde::Deserialize; +use std::fs::read_to_string; +use std::path::{Path, PathBuf}; + +lazy_static! { + static ref PYTHON_VERSION: Regex = Regex::new("^python-((\\d+\\.*)*)-.*.json$") + .expect("error parsing Version regex for Python Package Version in conda"); + static ref CONDA_VERSION: Regex = Regex::new("^conda-((\\d+\\.*)*)-.*.json$") + .expect("error parsing Version regex for Conda Package Version in conda"); +} + +use std::{fmt, fs}; + +#[derive(Debug, Clone, PartialEq)] +pub enum Package { + Conda, + Python, +} + +impl Package { + pub fn to_name(&self) -> &str { + match self { + Package::Conda => "conda", + Package::Python => "python", + } + } +} + +impl fmt::Display for Package { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + match self { + Package::Conda => write!(f, "Conda"), + Package::Python => write!(f, "Python"), + } + } +} + +#[derive(Debug, PartialEq)] +pub struct CondaPackageInfo { + pub package: Package, + #[allow(dead_code)] + pub path: PathBuf, + pub version: String, + pub arch: Option, +} + +impl CondaPackageInfo { + pub fn from(path: &Path, package: &Package) -> Option { + get_conda_package_info(path, package) + } +} + +#[derive(Deserialize, Debug)] +struct CondaMetaPackageStructure { + channel: Option, + version: Option, +} + +/// Get the details of a conda package from the 'conda-meta' directory. +fn get_conda_package_info(path: &Path, name: &Package) -> Option { + // conda-meta is in the root of the conda installation folder + let path = path.join("conda-meta"); + + let history = path.join("history"); + let package_entry = format!(":{}", name.to_name()); + if let Some(history_contents) = fs::read_to_string(&history).ok() { + for line in history_contents + .lines() + .filter(|l| l.contains(&package_entry)) + { + // Sample entry in the history file + // +conda-forge/osx-arm64::psutil-5.9.8-py312he37b823_0 + // +conda-forge/osx-arm64::python-3.12.2-hdf0ec26_0_cpython + // +conda-forge/osx-arm64::python_abi-3.12-4_cp312 + if let Some(package_path) = line.split(&package_entry).nth(1) { + let package_path = path.join(format!("{}{}.json", name.to_name(), package_path)); + let mut arch: Option = None; + // Sample contents + // { + // "build": "h966fe2a_2", + // "build_number": 2, + // "channel": "https://repo.anaconda.com/pkgs/main/win-64", + // "constrains": [], + // } + // 32bit channel is https://repo.anaconda.com/pkgs/main/win-32/ + // 64bit channel is "channel": "https://repo.anaconda.com/pkgs/main/osx-arm64", + if let Some(contents) = read_to_string(&package_path).ok() { + if let Some(js) = + serde_json::from_str::(&contents).ok() + { + if let Some(channel) = js.channel { + if channel.ends_with("64") { + arch = Some(Architecture::X64); + } else if channel.ends_with("32") { + arch = Some(Architecture::X86); + } + } + if let Some(version) = js.version { + return Some(CondaPackageInfo { + package: name.clone(), + path: package_path, + version, + arch, + }); + } else { + warn!( + "Unable to find version for package {} in {:?}", + name, package_path + ); + } + } + } + } + } + } + + warn!( + "Unable to find conda package {} in {:?}, trying slower approach", + name, path + ); + + let package_name = format!("{}-", name.to_name()); + let regex = get_package_version_regex(&name); + + // Fallback, slower approach of enumerating all files. + if let Ok(entries) = fs::read_dir(path) { + for entry in entries.filter_map(Result::ok) { + let path = entry.path(); + let file_name = path.file_name()?.to_string_lossy(); + if file_name.starts_with(&package_name) && file_name.ends_with(".json") { + if let Some(captures) = regex.captures(&file_name) { + if let Some(version) = captures.get(1) { + let mut arch: Option = None; + // Sample contents + // { + // "build": "h966fe2a_2", + // "build_number": 2, + // "channel": "https://repo.anaconda.com/pkgs/main/win-64", + // "constrains": [], + // } + // 32bit channel is https://repo.anaconda.com/pkgs/main/win-32/ + // 64bit channel is "channel": "https://repo.anaconda.com/pkgs/main/osx-arm64", + if let Some(contents) = read_to_string(&path).ok() { + if let Some(js) = + serde_json::from_str::(&contents).ok() + { + if let Some(channel) = js.channel { + if channel.ends_with("64") { + arch = Some(Architecture::X64); + } else if channel.ends_with("32") { + arch = Some(Architecture::X86); + } + } + } + } + return Some(CondaPackageInfo { + package: name.clone(), + path: path.clone(), + version: version.as_str().to_string(), + arch, + }); + } + } + } + } + } + None +} + +fn get_package_version_regex(package: &Package) -> &Regex { + match package { + Package::Conda => &CONDA_VERSION, + Package::Python => &PYTHON_VERSION, + } +} diff --git a/crates/pet-conda/src/utils.rs b/crates/pet-conda/src/utils.rs new file mode 100644 index 00000000..4f824258 --- /dev/null +++ b/crates/pet-conda/src/utils.rs @@ -0,0 +1,19 @@ +// Copyright (c) Microsoft Corporation. All rights reserved. +// Licensed under the MIT License. + +use std::{fs, path::Path}; + +// conda-meta must exist as this contains a mandatory `history` file. +pub fn is_conda_install(path: &Path) -> bool { + path.join("envs").metadata().is_ok() && path.join("conda-meta").metadata().is_ok() +} + +// conda-meta must exist as this contains a mandatory `history` file. +// The root conda installation folder is also a conda environment (its the base environment). +pub fn is_conda_env(path: &Path) -> bool { + if let Some(metadata) = fs::metadata(path.join("conda-meta")).ok() { + metadata.is_dir() + } else { + false + } +} diff --git a/crates/pet-conda/tests/common.rs b/crates/pet-conda/tests/common.rs new file mode 100644 index 00000000..d9804384 --- /dev/null +++ b/crates/pet-conda/tests/common.rs @@ -0,0 +1,52 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +use std::{collections::HashMap, path::PathBuf}; + +use pet_core::os_environment::Environment; + +#[allow(dead_code)] +pub fn resolve_test_path(paths: &[&str]) -> PathBuf { + let mut root = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("tests"); + + paths.iter().for_each(|p| root.push(p)); + + root +} + +#[allow(dead_code)] +#[derive(Debug)] +pub struct TestEnvironment { + vars: HashMap, + home: Option, + root: Option, + globals_locations: Vec, +} +#[allow(dead_code)] +pub fn create_test_environment( + root: Option, + home: Option, + vars: HashMap, + globals_locations: Vec, +) -> TestEnvironment { + impl Environment for TestEnvironment { + fn get_env_var(&self, key: String) -> Option { + self.vars.get(&key).cloned() + } + fn get_root(&self) -> Option { + self.root.clone() + } + fn get_user_home(&self) -> Option { + self.home.clone() + } + fn get_know_global_search_locations(&self) -> Vec { + self.globals_locations.clone() + } + } + TestEnvironment { + vars, + home, + root, + globals_locations, + } +} diff --git a/crates/pet-conda/tests/environment_locations_test.rs b/crates/pet-conda/tests/environment_locations_test.rs new file mode 100644 index 00000000..8218d5a6 --- /dev/null +++ b/crates/pet-conda/tests/environment_locations_test.rs @@ -0,0 +1,138 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +mod common; +use common::{create_test_environment, resolve_test_path}; +use pet_conda::environment_locations::{ + get_conda_envs_from_environment_txt, get_environments_in_conda_dir, get_known_conda_locations, +}; +use std::{collections::HashMap, path::PathBuf}; + +#[test] +fn read_environment_txt() { + let root = resolve_test_path(&["unix", "root_empty"]).into(); + let home = resolve_test_path(&["unix", "user_home_with_environments_txt"]).into(); + let env = create_test_environment(root, home, HashMap::new(), vec![]); + + let mut environments = get_conda_envs_from_environment_txt(&env); + environments.sort(); + + let mut expected = vec![ + "/Users/username/miniconda3", + "/Users/username/miniconda3/envs/xyz", + "/Users/username/miniconda3/envs/conda1", + "/Users/username/miniconda3/envs/conda2", + "/Users/username/miniconda3/envs/conda3", + "/Users/username/miniconda3/envs/conda4", + "/Users/username/miniconda3/envs/conda5", + "/Users/username/miniconda3/envs/conda6", + "/Users/username/miniconda3/envs/conda7", + "/Users/username/miniconda3/envs/conda8", + "/Users/username/.pyenv/versions/miniconda3-latest", + "/Users/username/.pyenv/versions/miniconda3-latest/envs/myenv", + "/Users/username/.pyenv/versions/miniforge3-4.10.1-1", + "/Users/username/.pyenv/versions/anaconda3-2023.03", + "/Users/username/miniforge3/envs/sample1", + "/Users/username/temp/conda_work_folder", + "/Users/username/temp/conda_work_folder_3.12", + "/Users/username/temp/conda_work_folder__no_python", + "/Users/username/temp/conda_work_folder_from_root", + "/Users/username/temp/sample-conda-envs-folder/hello_world", + "/Users/username/temp/sample-conda-envs-folder2/another", + "/Users/username/temp/sample-conda-envs-folder2/xyz", + ] + .iter() + .map(PathBuf::from) + .collect::>(); + expected.sort(); + + assert_eq!(environments, expected); +} + +#[test] +fn non_existent_envrionments_txt() { + let root = resolve_test_path(&["unix", "root_empty"]).into(); + let home = resolve_test_path(&["unix", "bogus directory"]).into(); + let env = create_test_environment(root, home, HashMap::new(), vec![]); + + let environments = get_conda_envs_from_environment_txt(&env); + + assert_eq!(environments.len(), 0); +} + +#[test] +fn known_install_locations() { + let root = resolve_test_path(&["unix", "root_empty"]).into(); + let home = resolve_test_path(&["unix", "user_home"]).into(); + let env = create_test_environment(root, home, HashMap::new(), vec![]); + + let mut locations = get_known_conda_locations(&env); + locations.sort(); + + let mut expected = [ + vec![ + "/opt/anaconda3/bin", + "/opt/miniconda3/bin", + "/usr/local/anaconda3/bin", + "/usr/local/miniconda3/bin", + "/usr/anaconda3/bin", + "/usr/miniconda3/bin", + "/home/anaconda3/bin", + "/home/miniconda3/bin", + "/anaconda3/bin", + "/miniconda3/bin", + ] + .iter() + .map(PathBuf::from) + .collect::>(), + vec![ + resolve_test_path(&["unix", "user_home", "anaconda3", "bin"]), + resolve_test_path(&["unix", "user_home", "miniconda3", "bin"]), + ], + ] + .concat(); + expected.sort(); + + assert_eq!(locations, expected); +} + +#[test] +fn list_conda_envs_in_install_location() { + let path = resolve_test_path(&["unix", "anaconda3-2023.03"]); + + let mut locations = get_environments_in_conda_dir(&path); + locations.sort(); + + assert_eq!( + locations, + vec![ + resolve_test_path(&["unix", "anaconda3-2023.03"]), + resolve_test_path(&["unix", "anaconda3-2023.03", "envs", "env_python_3"]), + resolve_test_path(&["unix", "anaconda3-2023.03", "envs", "myenv"]), + resolve_test_path(&["unix", "anaconda3-2023.03", "envs", "without_python"]), + ] + ); +} + +// #[test] +// fn get_conda_environment_paths_test() { +// let now = SystemTime::now(); + +// let env = EnvironmentApi {}; +// let envs = get_conda_environment_paths(&env); +// println!("{:?}", envs); +// println!("{:?}", envs); +// println!("{:?}", envs); +// println!("{:?}", envs); +// println!("{:?}", envs); +// match now.elapsed() { +// Ok(elapsed) => { +// println!("Native Locator took {} milliseconds.", elapsed.as_millis()); +// println!("Native Locator took {} milliseconds.", elapsed.as_millis()); +// println!("Native Locator took {} milliseconds.", elapsed.as_millis()); +// } +// Err(e) => { +// log::error!("Error getting elapsed time: {:?}", e); +// } +// } +// } diff --git a/crates/pet-conda/tests/package_test.rs b/crates/pet-conda/tests/package_test.rs new file mode 100644 index 00000000..25a65cfc --- /dev/null +++ b/crates/pet-conda/tests/package_test.rs @@ -0,0 +1,87 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +mod common; +use pet_conda::package::{self, CondaPackageInfo}; +use std::path::PathBuf; + +use common::resolve_test_path; + +#[test] +fn empty_result_for_bogus_paths() { + let path: PathBuf = resolve_test_path(&["unix", "bogus_path"]).into(); + let pkg = CondaPackageInfo::from(&path, &package::Package::Conda); + + assert!(pkg.is_none()); +} + +#[test] +fn get_conda_package_info() { + let path: PathBuf = resolve_test_path(&["unix", "anaconda3-2023.03"]).into(); + let pkg = CondaPackageInfo::from(&path, &package::Package::Conda).unwrap(); + + assert_eq!(pkg.package, package::Package::Conda); + assert_eq!(pkg.version, "23.1.0".to_string()); + assert_eq!( + pkg.path, + resolve_test_path(&[ + "unix", + "anaconda3-2023.03", + "conda-meta", + "conda-23.1.0-py310hca03da5_0.json" + ]) + ); +} + +#[test] +fn get_python_package_info() { + let path: PathBuf = resolve_test_path(&["unix", "anaconda3-2023.03"]).into(); + let pkg = CondaPackageInfo::from(&path, &package::Package::Python).unwrap(); + + assert_eq!(pkg.package, package::Package::Python); + assert_eq!(pkg.version, "3.10.9".to_string()); + assert_eq!( + pkg.path, + resolve_test_path(&[ + "unix", + "anaconda3-2023.03", + "conda-meta", + "python-3.10.9-hc0d8a6c_1.json" + ]) + ); +} +#[test] +fn get_conda_package_info_without_history() { + let path: PathBuf = resolve_test_path(&["unix", "anaconda3-2023.03-without-history"]).into(); + let pkg = CondaPackageInfo::from(&path, &package::Package::Conda).unwrap(); + + assert_eq!(pkg.package, package::Package::Conda); + assert_eq!(pkg.version, "23.1.0".to_string()); + assert_eq!( + pkg.path, + resolve_test_path(&[ + "unix", + "anaconda3-2023.03-without-history", + "conda-meta", + "conda-23.1.0-py310hca03da5_0.json" + ]) + ); +} + +#[test] +fn get_python_package_info_without_history() { + let path: PathBuf = resolve_test_path(&["unix", "anaconda3-2023.03-without-history"]).into(); + let pkg = CondaPackageInfo::from(&path, &package::Package::Python).unwrap(); + + assert_eq!(pkg.package, package::Package::Python); + assert_eq!(pkg.version, "3.10.9".to_string()); + assert_eq!( + pkg.path, + resolve_test_path(&[ + "unix", + "anaconda3-2023.03-without-history", + "conda-meta", + "python-3.10.9-hc0d8a6c_1.json" + ]) + ); +} diff --git a/crates/pet-conda/tests/unix/anaconda3-2023.03-without-history/bin/conda b/crates/pet-conda/tests/unix/anaconda3-2023.03-without-history/bin/conda new file mode 100644 index 00000000..e69de29b diff --git a/crates/pet-conda/tests/unix/anaconda3-2023.03-without-history/bin/python b/crates/pet-conda/tests/unix/anaconda3-2023.03-without-history/bin/python new file mode 100644 index 00000000..e69de29b diff --git a/crates/pet-conda/tests/unix/anaconda3-2023.03-without-history/bin/python3 b/crates/pet-conda/tests/unix/anaconda3-2023.03-without-history/bin/python3 new file mode 100644 index 00000000..e69de29b diff --git a/crates/pet-conda/tests/unix/anaconda3-2023.03-without-history/bin/python3.1 b/crates/pet-conda/tests/unix/anaconda3-2023.03-without-history/bin/python3.1 new file mode 100644 index 00000000..e69de29b diff --git a/crates/pet-conda/tests/unix/anaconda3-2023.03-without-history/bin/python3.10 b/crates/pet-conda/tests/unix/anaconda3-2023.03-without-history/bin/python3.10 new file mode 100644 index 00000000..e69de29b diff --git a/crates/pet-conda/tests/unix/anaconda3-2023.03-without-history/conda-meta/conda-23.1.0-py310hca03da5_0.json b/crates/pet-conda/tests/unix/anaconda3-2023.03-without-history/conda-meta/conda-23.1.0-py310hca03da5_0.json new file mode 100644 index 00000000..0ab7e321 --- /dev/null +++ b/crates/pet-conda/tests/unix/anaconda3-2023.03-without-history/conda-meta/conda-23.1.0-py310hca03da5_0.json @@ -0,0 +1,575 @@ +{ + "build": "py310hca03da5_0", + "build_number": 0, + "channel": "https://repo.anaconda.com/pkgs/main/osx-arm64", + "constrains": [ + "conda-content-trust >=0.1.1", + "cytoolz >=0.8.1", + "conda-env >=2.6", + "conda-libmamba-solver >=22.12.0", + "conda-build >=3" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pluggy >=1.0.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.10,<3.11.0a0", + "requests >=2.20.1,<3", + "ruamel.yaml >=0.11.14,<0.18", + "setuptools >=31.0.1", + "toolz >=0.8.1", + "tqdm >=4" + ], + "extracted_package_dir": "/Users/donjayamanne/.pyenv/versions/anaconda3-2023.03/pkgs/conda-23.1.0-py310hca03da5_0", + "features": "", + "files": [ + "bin/activate", + "bin/conda", + "bin/conda-env", + "bin/deactivate", + "condabin/conda", + "etc/fish/conf.d/conda.fish", + "etc/profile.d/conda.csh", + "etc/profile.d/conda.sh", + "lib/python3.10/site-packages/conda-23.1.0-py3.10.egg-info/PKG-INFO", + "lib/python3.10/site-packages/conda-23.1.0-py3.10.egg-info/SOURCES.txt", + "lib/python3.10/site-packages/conda-23.1.0-py3.10.egg-info/dependency_links.txt", + "lib/python3.10/site-packages/conda-23.1.0-py3.10.egg-info/entry_points.txt", + "lib/python3.10/site-packages/conda-23.1.0-py3.10.egg-info/not-zip-safe", + "lib/python3.10/site-packages/conda-23.1.0-py3.10.egg-info/requires.txt", + "lib/python3.10/site-packages/conda-23.1.0-py3.10.egg-info/top_level.txt", + "lib/python3.10/site-packages/conda/.version", + "lib/python3.10/site-packages/conda/__init__.py", + "lib/python3.10/site-packages/conda/__main__.py", + "lib/python3.10/site-packages/conda/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/conda/__pycache__/__main__.cpython-310.pyc", + "lib/python3.10/site-packages/conda/__pycache__/activate.cpython-310.pyc", + "lib/python3.10/site-packages/conda/__pycache__/api.cpython-310.pyc", + "lib/python3.10/site-packages/conda/__pycache__/exceptions.cpython-310.pyc", + "lib/python3.10/site-packages/conda/__pycache__/exports.cpython-310.pyc", + "lib/python3.10/site-packages/conda/__pycache__/history.cpython-310.pyc", + "lib/python3.10/site-packages/conda/__pycache__/instructions.cpython-310.pyc", + "lib/python3.10/site-packages/conda/__pycache__/lock.cpython-310.pyc", + "lib/python3.10/site-packages/conda/__pycache__/misc.cpython-310.pyc", + "lib/python3.10/site-packages/conda/__pycache__/plan.cpython-310.pyc", + "lib/python3.10/site-packages/conda/__pycache__/resolve.cpython-310.pyc", + "lib/python3.10/site-packages/conda/__pycache__/utils.cpython-310.pyc", + "lib/python3.10/site-packages/conda/_vendor/__init__.py", + "lib/python3.10/site-packages/conda/_vendor/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/conda/_vendor/__pycache__/appdirs.cpython-310.pyc", + "lib/python3.10/site-packages/conda/_vendor/__pycache__/distro.cpython-310.pyc", + "lib/python3.10/site-packages/conda/_vendor/appdirs.py", + "lib/python3.10/site-packages/conda/_vendor/boltons/LICENSE", + "lib/python3.10/site-packages/conda/_vendor/boltons/__init__.py", + "lib/python3.10/site-packages/conda/_vendor/boltons/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/conda/_vendor/boltons/__pycache__/setutils.cpython-310.pyc", + "lib/python3.10/site-packages/conda/_vendor/boltons/__pycache__/timeutils.cpython-310.pyc", + "lib/python3.10/site-packages/conda/_vendor/boltons/setutils.py", + "lib/python3.10/site-packages/conda/_vendor/boltons/timeutils.py", + "lib/python3.10/site-packages/conda/_vendor/cpuinfo/__init__.py", + "lib/python3.10/site-packages/conda/_vendor/cpuinfo/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/conda/_vendor/cpuinfo/__pycache__/cpuinfo.cpython-310.pyc", + "lib/python3.10/site-packages/conda/_vendor/cpuinfo/cpuinfo.py", + "lib/python3.10/site-packages/conda/_vendor/distro.py", + "lib/python3.10/site-packages/conda/_vendor/frozendict/__init__.py", + "lib/python3.10/site-packages/conda/_vendor/frozendict/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/conda/_vendor/toolz/__init__.py", + "lib/python3.10/site-packages/conda/_vendor/toolz/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/conda/_vendor/toolz/__pycache__/compatibility.cpython-310.pyc", + "lib/python3.10/site-packages/conda/_vendor/toolz/__pycache__/dicttoolz.cpython-310.pyc", + "lib/python3.10/site-packages/conda/_vendor/toolz/__pycache__/itertoolz.cpython-310.pyc", + "lib/python3.10/site-packages/conda/_vendor/toolz/__pycache__/recipes.cpython-310.pyc", + "lib/python3.10/site-packages/conda/_vendor/toolz/__pycache__/utils.cpython-310.pyc", + "lib/python3.10/site-packages/conda/_vendor/toolz/compatibility.py", + "lib/python3.10/site-packages/conda/_vendor/toolz/dicttoolz.py", + "lib/python3.10/site-packages/conda/_vendor/toolz/itertoolz.py", + "lib/python3.10/site-packages/conda/_vendor/toolz/recipes.py", + "lib/python3.10/site-packages/conda/_vendor/toolz/utils.py", + "lib/python3.10/site-packages/conda/_vendor/tqdm/__init__.py", + "lib/python3.10/site-packages/conda/_vendor/tqdm/__main__.py", + "lib/python3.10/site-packages/conda/_vendor/tqdm/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/conda/_vendor/tqdm/__pycache__/__main__.cpython-310.pyc", + "lib/python3.10/site-packages/conda/_vendor/tqdm/__pycache__/_main.cpython-310.pyc", + "lib/python3.10/site-packages/conda/_vendor/tqdm/__pycache__/_monitor.cpython-310.pyc", + "lib/python3.10/site-packages/conda/_vendor/tqdm/__pycache__/_tqdm.cpython-310.pyc", + "lib/python3.10/site-packages/conda/_vendor/tqdm/__pycache__/_utils.cpython-310.pyc", + "lib/python3.10/site-packages/conda/_vendor/tqdm/__pycache__/asyncio.cpython-310.pyc", + "lib/python3.10/site-packages/conda/_vendor/tqdm/__pycache__/auto.cpython-310.pyc", + "lib/python3.10/site-packages/conda/_vendor/tqdm/__pycache__/cli.cpython-310.pyc", + "lib/python3.10/site-packages/conda/_vendor/tqdm/__pycache__/std.cpython-310.pyc", + "lib/python3.10/site-packages/conda/_vendor/tqdm/__pycache__/utils.cpython-310.pyc", + "lib/python3.10/site-packages/conda/_vendor/tqdm/__pycache__/version.cpython-310.pyc", + "lib/python3.10/site-packages/conda/_vendor/tqdm/_main.py", + "lib/python3.10/site-packages/conda/_vendor/tqdm/_monitor.py", + "lib/python3.10/site-packages/conda/_vendor/tqdm/_tqdm.py", + "lib/python3.10/site-packages/conda/_vendor/tqdm/_utils.py", + "lib/python3.10/site-packages/conda/_vendor/tqdm/asyncio.py", + "lib/python3.10/site-packages/conda/_vendor/tqdm/auto.py", + "lib/python3.10/site-packages/conda/_vendor/tqdm/cli.py", + "lib/python3.10/site-packages/conda/_vendor/tqdm/std.py", + "lib/python3.10/site-packages/conda/_vendor/tqdm/utils.py", + "lib/python3.10/site-packages/conda/_vendor/tqdm/version.py", + "lib/python3.10/site-packages/conda/activate.py", + "lib/python3.10/site-packages/conda/api.py", + "lib/python3.10/site-packages/conda/auxlib/LICENSE", + "lib/python3.10/site-packages/conda/auxlib/__init__.py", + "lib/python3.10/site-packages/conda/auxlib/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/conda/auxlib/__pycache__/collection.cpython-310.pyc", + "lib/python3.10/site-packages/conda/auxlib/__pycache__/compat.cpython-310.pyc", + "lib/python3.10/site-packages/conda/auxlib/__pycache__/decorators.cpython-310.pyc", + "lib/python3.10/site-packages/conda/auxlib/__pycache__/entity.cpython-310.pyc", + "lib/python3.10/site-packages/conda/auxlib/__pycache__/exceptions.cpython-310.pyc", + "lib/python3.10/site-packages/conda/auxlib/__pycache__/ish.cpython-310.pyc", + "lib/python3.10/site-packages/conda/auxlib/__pycache__/logz.cpython-310.pyc", + "lib/python3.10/site-packages/conda/auxlib/__pycache__/packaging.cpython-310.pyc", + "lib/python3.10/site-packages/conda/auxlib/__pycache__/type_coercion.cpython-310.pyc", + "lib/python3.10/site-packages/conda/auxlib/collection.py", + "lib/python3.10/site-packages/conda/auxlib/compat.py", + "lib/python3.10/site-packages/conda/auxlib/decorators.py", + "lib/python3.10/site-packages/conda/auxlib/entity.py", + "lib/python3.10/site-packages/conda/auxlib/exceptions.py", + "lib/python3.10/site-packages/conda/auxlib/ish.py", + "lib/python3.10/site-packages/conda/auxlib/logz.py", + "lib/python3.10/site-packages/conda/auxlib/packaging.py", + "lib/python3.10/site-packages/conda/auxlib/type_coercion.py", + "lib/python3.10/site-packages/conda/base/__init__.py", + "lib/python3.10/site-packages/conda/base/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/conda/base/__pycache__/constants.cpython-310.pyc", + "lib/python3.10/site-packages/conda/base/__pycache__/context.cpython-310.pyc", + "lib/python3.10/site-packages/conda/base/__pycache__/exceptions.cpython-310.pyc", + "lib/python3.10/site-packages/conda/base/constants.py", + "lib/python3.10/site-packages/conda/base/context.py", + "lib/python3.10/site-packages/conda/base/exceptions.py", + "lib/python3.10/site-packages/conda/cli/__init__.py", + "lib/python3.10/site-packages/conda/cli/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/conda/cli/__pycache__/common.cpython-310.pyc", + "lib/python3.10/site-packages/conda/cli/__pycache__/conda_argparse.cpython-310.pyc", + "lib/python3.10/site-packages/conda/cli/__pycache__/find_commands.cpython-310.pyc", + "lib/python3.10/site-packages/conda/cli/__pycache__/install.cpython-310.pyc", + "lib/python3.10/site-packages/conda/cli/__pycache__/main.cpython-310.pyc", + "lib/python3.10/site-packages/conda/cli/__pycache__/main_clean.cpython-310.pyc", + "lib/python3.10/site-packages/conda/cli/__pycache__/main_compare.cpython-310.pyc", + "lib/python3.10/site-packages/conda/cli/__pycache__/main_config.cpython-310.pyc", + "lib/python3.10/site-packages/conda/cli/__pycache__/main_create.cpython-310.pyc", + "lib/python3.10/site-packages/conda/cli/__pycache__/main_info.cpython-310.pyc", + "lib/python3.10/site-packages/conda/cli/__pycache__/main_init.cpython-310.pyc", + "lib/python3.10/site-packages/conda/cli/__pycache__/main_install.cpython-310.pyc", + "lib/python3.10/site-packages/conda/cli/__pycache__/main_list.cpython-310.pyc", + "lib/python3.10/site-packages/conda/cli/__pycache__/main_notices.cpython-310.pyc", + "lib/python3.10/site-packages/conda/cli/__pycache__/main_package.cpython-310.pyc", + "lib/python3.10/site-packages/conda/cli/__pycache__/main_pip.cpython-310.pyc", + "lib/python3.10/site-packages/conda/cli/__pycache__/main_remove.cpython-310.pyc", + "lib/python3.10/site-packages/conda/cli/__pycache__/main_rename.cpython-310.pyc", + "lib/python3.10/site-packages/conda/cli/__pycache__/main_run.cpython-310.pyc", + "lib/python3.10/site-packages/conda/cli/__pycache__/main_search.cpython-310.pyc", + "lib/python3.10/site-packages/conda/cli/__pycache__/main_update.cpython-310.pyc", + "lib/python3.10/site-packages/conda/cli/__pycache__/python_api.cpython-310.pyc", + "lib/python3.10/site-packages/conda/cli/common.py", + "lib/python3.10/site-packages/conda/cli/conda_argparse.py", + "lib/python3.10/site-packages/conda/cli/find_commands.py", + "lib/python3.10/site-packages/conda/cli/install.py", + "lib/python3.10/site-packages/conda/cli/main.py", + "lib/python3.10/site-packages/conda/cli/main_clean.py", + "lib/python3.10/site-packages/conda/cli/main_compare.py", + "lib/python3.10/site-packages/conda/cli/main_config.py", + "lib/python3.10/site-packages/conda/cli/main_create.py", + "lib/python3.10/site-packages/conda/cli/main_info.py", + "lib/python3.10/site-packages/conda/cli/main_init.py", + "lib/python3.10/site-packages/conda/cli/main_install.py", + "lib/python3.10/site-packages/conda/cli/main_list.py", + "lib/python3.10/site-packages/conda/cli/main_notices.py", + "lib/python3.10/site-packages/conda/cli/main_package.py", + "lib/python3.10/site-packages/conda/cli/main_pip.py", + "lib/python3.10/site-packages/conda/cli/main_remove.py", + "lib/python3.10/site-packages/conda/cli/main_rename.py", + "lib/python3.10/site-packages/conda/cli/main_run.py", + "lib/python3.10/site-packages/conda/cli/main_search.py", + "lib/python3.10/site-packages/conda/cli/main_update.py", + "lib/python3.10/site-packages/conda/cli/python_api.py", + "lib/python3.10/site-packages/conda/common/__init__.py", + "lib/python3.10/site-packages/conda/common/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/conda/common/__pycache__/_logic.cpython-310.pyc", + "lib/python3.10/site-packages/conda/common/__pycache__/compat.cpython-310.pyc", + "lib/python3.10/site-packages/conda/common/__pycache__/configuration.cpython-310.pyc", + "lib/python3.10/site-packages/conda/common/__pycache__/constants.cpython-310.pyc", + "lib/python3.10/site-packages/conda/common/__pycache__/cuda.cpython-310.pyc", + "lib/python3.10/site-packages/conda/common/__pycache__/decorators.cpython-310.pyc", + "lib/python3.10/site-packages/conda/common/__pycache__/disk.cpython-310.pyc", + "lib/python3.10/site-packages/conda/common/__pycache__/io.cpython-310.pyc", + "lib/python3.10/site-packages/conda/common/__pycache__/iterators.cpython-310.pyc", + "lib/python3.10/site-packages/conda/common/__pycache__/logic.cpython-310.pyc", + "lib/python3.10/site-packages/conda/common/__pycache__/path.cpython-310.pyc", + "lib/python3.10/site-packages/conda/common/__pycache__/serialize.cpython-310.pyc", + "lib/python3.10/site-packages/conda/common/__pycache__/signals.cpython-310.pyc", + "lib/python3.10/site-packages/conda/common/__pycache__/toposort.cpython-310.pyc", + "lib/python3.10/site-packages/conda/common/__pycache__/url.cpython-310.pyc", + "lib/python3.10/site-packages/conda/common/_logic.py", + "lib/python3.10/site-packages/conda/common/_os/__init__.py", + "lib/python3.10/site-packages/conda/common/_os/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/conda/common/_os/__pycache__/linux.cpython-310.pyc", + "lib/python3.10/site-packages/conda/common/_os/__pycache__/unix.cpython-310.pyc", + "lib/python3.10/site-packages/conda/common/_os/__pycache__/windows.cpython-310.pyc", + "lib/python3.10/site-packages/conda/common/_os/linux.py", + "lib/python3.10/site-packages/conda/common/_os/unix.py", + "lib/python3.10/site-packages/conda/common/_os/windows.py", + "lib/python3.10/site-packages/conda/common/compat.py", + "lib/python3.10/site-packages/conda/common/configuration.py", + "lib/python3.10/site-packages/conda/common/constants.py", + "lib/python3.10/site-packages/conda/common/cuda.py", + "lib/python3.10/site-packages/conda/common/decorators.py", + "lib/python3.10/site-packages/conda/common/disk.py", + "lib/python3.10/site-packages/conda/common/io.py", + "lib/python3.10/site-packages/conda/common/iterators.py", + "lib/python3.10/site-packages/conda/common/logic.py", + "lib/python3.10/site-packages/conda/common/path.py", + "lib/python3.10/site-packages/conda/common/pkg_formats/__init__.py", + "lib/python3.10/site-packages/conda/common/pkg_formats/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/conda/common/pkg_formats/__pycache__/python.cpython-310.pyc", + "lib/python3.10/site-packages/conda/common/pkg_formats/python.py", + "lib/python3.10/site-packages/conda/common/serialize.py", + "lib/python3.10/site-packages/conda/common/signals.py", + "lib/python3.10/site-packages/conda/common/toposort.py", + "lib/python3.10/site-packages/conda/common/url.py", + "lib/python3.10/site-packages/conda/core/__init__.py", + "lib/python3.10/site-packages/conda/core/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/conda/core/__pycache__/envs_manager.cpython-310.pyc", + "lib/python3.10/site-packages/conda/core/__pycache__/index.cpython-310.pyc", + "lib/python3.10/site-packages/conda/core/__pycache__/initialize.cpython-310.pyc", + "lib/python3.10/site-packages/conda/core/__pycache__/link.cpython-310.pyc", + "lib/python3.10/site-packages/conda/core/__pycache__/package_cache.cpython-310.pyc", + "lib/python3.10/site-packages/conda/core/__pycache__/package_cache_data.cpython-310.pyc", + "lib/python3.10/site-packages/conda/core/__pycache__/path_actions.cpython-310.pyc", + "lib/python3.10/site-packages/conda/core/__pycache__/portability.cpython-310.pyc", + "lib/python3.10/site-packages/conda/core/__pycache__/prefix_data.cpython-310.pyc", + "lib/python3.10/site-packages/conda/core/__pycache__/solve.cpython-310.pyc", + "lib/python3.10/site-packages/conda/core/__pycache__/subdir_data.cpython-310.pyc", + "lib/python3.10/site-packages/conda/core/envs_manager.py", + "lib/python3.10/site-packages/conda/core/index.py", + "lib/python3.10/site-packages/conda/core/initialize.py", + "lib/python3.10/site-packages/conda/core/link.py", + "lib/python3.10/site-packages/conda/core/package_cache.py", + "lib/python3.10/site-packages/conda/core/package_cache_data.py", + "lib/python3.10/site-packages/conda/core/path_actions.py", + "lib/python3.10/site-packages/conda/core/portability.py", + "lib/python3.10/site-packages/conda/core/prefix_data.py", + "lib/python3.10/site-packages/conda/core/solve.py", + "lib/python3.10/site-packages/conda/core/subdir_data.py", + "lib/python3.10/site-packages/conda/exceptions.py", + "lib/python3.10/site-packages/conda/exports.py", + "lib/python3.10/site-packages/conda/gateways/__init__.py", + "lib/python3.10/site-packages/conda/gateways/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/conda/gateways/__pycache__/anaconda_client.cpython-310.pyc", + "lib/python3.10/site-packages/conda/gateways/__pycache__/logging.cpython-310.pyc", + "lib/python3.10/site-packages/conda/gateways/__pycache__/subprocess.cpython-310.pyc", + "lib/python3.10/site-packages/conda/gateways/anaconda_client.py", + "lib/python3.10/site-packages/conda/gateways/connection/__init__.py", + "lib/python3.10/site-packages/conda/gateways/connection/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/conda/gateways/connection/__pycache__/download.cpython-310.pyc", + "lib/python3.10/site-packages/conda/gateways/connection/__pycache__/session.cpython-310.pyc", + "lib/python3.10/site-packages/conda/gateways/connection/adapters/__init__.py", + "lib/python3.10/site-packages/conda/gateways/connection/adapters/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/conda/gateways/connection/adapters/__pycache__/ftp.cpython-310.pyc", + "lib/python3.10/site-packages/conda/gateways/connection/adapters/__pycache__/localfs.cpython-310.pyc", + "lib/python3.10/site-packages/conda/gateways/connection/adapters/__pycache__/s3.cpython-310.pyc", + "lib/python3.10/site-packages/conda/gateways/connection/adapters/ftp.py", + "lib/python3.10/site-packages/conda/gateways/connection/adapters/localfs.py", + "lib/python3.10/site-packages/conda/gateways/connection/adapters/s3.py", + "lib/python3.10/site-packages/conda/gateways/connection/download.py", + "lib/python3.10/site-packages/conda/gateways/connection/session.py", + "lib/python3.10/site-packages/conda/gateways/disk/__init__.py", + "lib/python3.10/site-packages/conda/gateways/disk/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/conda/gateways/disk/__pycache__/create.cpython-310.pyc", + "lib/python3.10/site-packages/conda/gateways/disk/__pycache__/delete.cpython-310.pyc", + "lib/python3.10/site-packages/conda/gateways/disk/__pycache__/link.cpython-310.pyc", + "lib/python3.10/site-packages/conda/gateways/disk/__pycache__/permissions.cpython-310.pyc", + "lib/python3.10/site-packages/conda/gateways/disk/__pycache__/read.cpython-310.pyc", + "lib/python3.10/site-packages/conda/gateways/disk/__pycache__/test.cpython-310.pyc", + "lib/python3.10/site-packages/conda/gateways/disk/__pycache__/update.cpython-310.pyc", + "lib/python3.10/site-packages/conda/gateways/disk/create.py", + "lib/python3.10/site-packages/conda/gateways/disk/delete.py", + "lib/python3.10/site-packages/conda/gateways/disk/link.py", + "lib/python3.10/site-packages/conda/gateways/disk/permissions.py", + "lib/python3.10/site-packages/conda/gateways/disk/read.py", + "lib/python3.10/site-packages/conda/gateways/disk/test.py", + "lib/python3.10/site-packages/conda/gateways/disk/update.py", + "lib/python3.10/site-packages/conda/gateways/logging.py", + "lib/python3.10/site-packages/conda/gateways/repodata/__init__.py", + "lib/python3.10/site-packages/conda/gateways/repodata/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/conda/gateways/subprocess.py", + "lib/python3.10/site-packages/conda/history.py", + "lib/python3.10/site-packages/conda/instructions.py", + "lib/python3.10/site-packages/conda/lock.py", + "lib/python3.10/site-packages/conda/misc.py", + "lib/python3.10/site-packages/conda/models/__init__.py", + "lib/python3.10/site-packages/conda/models/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/conda/models/__pycache__/channel.cpython-310.pyc", + "lib/python3.10/site-packages/conda/models/__pycache__/dist.cpython-310.pyc", + "lib/python3.10/site-packages/conda/models/__pycache__/enums.cpython-310.pyc", + "lib/python3.10/site-packages/conda/models/__pycache__/leased_path_entry.cpython-310.pyc", + "lib/python3.10/site-packages/conda/models/__pycache__/match_spec.cpython-310.pyc", + "lib/python3.10/site-packages/conda/models/__pycache__/package_info.cpython-310.pyc", + "lib/python3.10/site-packages/conda/models/__pycache__/prefix_graph.cpython-310.pyc", + "lib/python3.10/site-packages/conda/models/__pycache__/records.cpython-310.pyc", + "lib/python3.10/site-packages/conda/models/__pycache__/version.cpython-310.pyc", + "lib/python3.10/site-packages/conda/models/channel.py", + "lib/python3.10/site-packages/conda/models/dist.py", + "lib/python3.10/site-packages/conda/models/enums.py", + "lib/python3.10/site-packages/conda/models/leased_path_entry.py", + "lib/python3.10/site-packages/conda/models/match_spec.py", + "lib/python3.10/site-packages/conda/models/package_info.py", + "lib/python3.10/site-packages/conda/models/prefix_graph.py", + "lib/python3.10/site-packages/conda/models/records.py", + "lib/python3.10/site-packages/conda/models/version.py", + "lib/python3.10/site-packages/conda/notices/__init__.py", + "lib/python3.10/site-packages/conda/notices/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/conda/notices/__pycache__/cache.cpython-310.pyc", + "lib/python3.10/site-packages/conda/notices/__pycache__/core.cpython-310.pyc", + "lib/python3.10/site-packages/conda/notices/__pycache__/fetch.cpython-310.pyc", + "lib/python3.10/site-packages/conda/notices/__pycache__/types.cpython-310.pyc", + "lib/python3.10/site-packages/conda/notices/__pycache__/views.cpython-310.pyc", + "lib/python3.10/site-packages/conda/notices/cache.py", + "lib/python3.10/site-packages/conda/notices/core.py", + "lib/python3.10/site-packages/conda/notices/fetch.py", + "lib/python3.10/site-packages/conda/notices/types.py", + "lib/python3.10/site-packages/conda/notices/views.py", + "lib/python3.10/site-packages/conda/plan.py", + "lib/python3.10/site-packages/conda/plugins/__init__.py", + "lib/python3.10/site-packages/conda/plugins/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/conda/plugins/__pycache__/hookspec.cpython-310.pyc", + "lib/python3.10/site-packages/conda/plugins/__pycache__/manager.cpython-310.pyc", + "lib/python3.10/site-packages/conda/plugins/__pycache__/solvers.cpython-310.pyc", + "lib/python3.10/site-packages/conda/plugins/__pycache__/types.cpython-310.pyc", + "lib/python3.10/site-packages/conda/plugins/hookspec.py", + "lib/python3.10/site-packages/conda/plugins/manager.py", + "lib/python3.10/site-packages/conda/plugins/solvers.py", + "lib/python3.10/site-packages/conda/plugins/types.py", + "lib/python3.10/site-packages/conda/plugins/virtual_packages/__init__.py", + "lib/python3.10/site-packages/conda/plugins/virtual_packages/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/conda/plugins/virtual_packages/__pycache__/archspec.cpython-310.pyc", + "lib/python3.10/site-packages/conda/plugins/virtual_packages/__pycache__/cuda.cpython-310.pyc", + "lib/python3.10/site-packages/conda/plugins/virtual_packages/__pycache__/linux.cpython-310.pyc", + "lib/python3.10/site-packages/conda/plugins/virtual_packages/__pycache__/osx.cpython-310.pyc", + "lib/python3.10/site-packages/conda/plugins/virtual_packages/__pycache__/windows.cpython-310.pyc", + "lib/python3.10/site-packages/conda/plugins/virtual_packages/archspec.py", + "lib/python3.10/site-packages/conda/plugins/virtual_packages/cuda.py", + "lib/python3.10/site-packages/conda/plugins/virtual_packages/linux.py", + "lib/python3.10/site-packages/conda/plugins/virtual_packages/osx.py", + "lib/python3.10/site-packages/conda/plugins/virtual_packages/windows.py", + "lib/python3.10/site-packages/conda/resolve.py", + "lib/python3.10/site-packages/conda/shell/Library/bin/conda.bat", + "lib/python3.10/site-packages/conda/shell/Scripts/activate.bat", + "lib/python3.10/site-packages/conda/shell/bin/activate", + "lib/python3.10/site-packages/conda/shell/bin/conda", + "lib/python3.10/site-packages/conda/shell/bin/deactivate", + "lib/python3.10/site-packages/conda/shell/cli-32.exe", + "lib/python3.10/site-packages/conda/shell/cli-64.exe", + "lib/python3.10/site-packages/conda/shell/conda.xsh", + "lib/python3.10/site-packages/conda/shell/conda_icon.ico", + "lib/python3.10/site-packages/conda/shell/condabin/Conda.psm1", + "lib/python3.10/site-packages/conda/shell/condabin/_conda_activate.bat", + "lib/python3.10/site-packages/conda/shell/condabin/activate.bat", + "lib/python3.10/site-packages/conda/shell/condabin/conda-hook.ps1", + "lib/python3.10/site-packages/conda/shell/condabin/conda.bat", + "lib/python3.10/site-packages/conda/shell/condabin/conda_auto_activate.bat", + "lib/python3.10/site-packages/conda/shell/condabin/conda_hook.bat", + "lib/python3.10/site-packages/conda/shell/condabin/deactivate.bat", + "lib/python3.10/site-packages/conda/shell/condabin/rename_tmp.bat", + "lib/python3.10/site-packages/conda/shell/etc/fish/conf.d/conda.fish", + "lib/python3.10/site-packages/conda/shell/etc/profile.d/conda.csh", + "lib/python3.10/site-packages/conda/shell/etc/profile.d/conda.sh", + "lib/python3.10/site-packages/conda/testing/__init__.py", + "lib/python3.10/site-packages/conda/testing/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/conda/testing/__pycache__/cases.cpython-310.pyc", + "lib/python3.10/site-packages/conda/testing/__pycache__/fixtures.cpython-310.pyc", + "lib/python3.10/site-packages/conda/testing/__pycache__/helpers.cpython-310.pyc", + "lib/python3.10/site-packages/conda/testing/__pycache__/integration.cpython-310.pyc", + "lib/python3.10/site-packages/conda/testing/__pycache__/solver_helpers.cpython-310.pyc", + "lib/python3.10/site-packages/conda/testing/cases.py", + "lib/python3.10/site-packages/conda/testing/fixtures.py", + "lib/python3.10/site-packages/conda/testing/gateways/__init__.py", + "lib/python3.10/site-packages/conda/testing/gateways/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/conda/testing/gateways/__pycache__/fixtures.cpython-310.pyc", + "lib/python3.10/site-packages/conda/testing/gateways/fixtures.py", + "lib/python3.10/site-packages/conda/testing/helpers.py", + "lib/python3.10/site-packages/conda/testing/integration.py", + "lib/python3.10/site-packages/conda/testing/notices/__init__.py", + "lib/python3.10/site-packages/conda/testing/notices/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/conda/testing/notices/__pycache__/fixtures.cpython-310.pyc", + "lib/python3.10/site-packages/conda/testing/notices/__pycache__/helpers.cpython-310.pyc", + "lib/python3.10/site-packages/conda/testing/notices/fixtures.py", + "lib/python3.10/site-packages/conda/testing/notices/helpers.py", + "lib/python3.10/site-packages/conda/testing/solver_helpers.py", + "lib/python3.10/site-packages/conda/trust/__init__.py", + "lib/python3.10/site-packages/conda/trust/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/conda/trust/__pycache__/constants.cpython-310.pyc", + "lib/python3.10/site-packages/conda/trust/__pycache__/signature_verification.cpython-310.pyc", + "lib/python3.10/site-packages/conda/trust/constants.py", + "lib/python3.10/site-packages/conda/trust/signature_verification.py", + "lib/python3.10/site-packages/conda/utils.py", + "lib/python3.10/site-packages/conda_env/__init__.py", + "lib/python3.10/site-packages/conda_env/__main__.py", + "lib/python3.10/site-packages/conda_env/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/conda_env/__pycache__/__main__.cpython-310.pyc", + "lib/python3.10/site-packages/conda_env/__pycache__/env.cpython-310.pyc", + "lib/python3.10/site-packages/conda_env/__pycache__/pip_util.cpython-310.pyc", + "lib/python3.10/site-packages/conda_env/cli/__init__.py", + "lib/python3.10/site-packages/conda_env/cli/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/conda_env/cli/__pycache__/common.cpython-310.pyc", + "lib/python3.10/site-packages/conda_env/cli/__pycache__/main.cpython-310.pyc", + "lib/python3.10/site-packages/conda_env/cli/__pycache__/main_config.cpython-310.pyc", + "lib/python3.10/site-packages/conda_env/cli/__pycache__/main_create.cpython-310.pyc", + "lib/python3.10/site-packages/conda_env/cli/__pycache__/main_export.cpython-310.pyc", + "lib/python3.10/site-packages/conda_env/cli/__pycache__/main_list.cpython-310.pyc", + "lib/python3.10/site-packages/conda_env/cli/__pycache__/main_remove.cpython-310.pyc", + "lib/python3.10/site-packages/conda_env/cli/__pycache__/main_update.cpython-310.pyc", + "lib/python3.10/site-packages/conda_env/cli/__pycache__/main_vars.cpython-310.pyc", + "lib/python3.10/site-packages/conda_env/cli/common.py", + "lib/python3.10/site-packages/conda_env/cli/main.py", + "lib/python3.10/site-packages/conda_env/cli/main_config.py", + "lib/python3.10/site-packages/conda_env/cli/main_create.py", + "lib/python3.10/site-packages/conda_env/cli/main_export.py", + "lib/python3.10/site-packages/conda_env/cli/main_list.py", + "lib/python3.10/site-packages/conda_env/cli/main_remove.py", + "lib/python3.10/site-packages/conda_env/cli/main_update.py", + "lib/python3.10/site-packages/conda_env/cli/main_vars.py", + "lib/python3.10/site-packages/conda_env/env.py", + "lib/python3.10/site-packages/conda_env/installers/__init__.py", + "lib/python3.10/site-packages/conda_env/installers/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/conda_env/installers/__pycache__/base.cpython-310.pyc", + "lib/python3.10/site-packages/conda_env/installers/__pycache__/conda.cpython-310.pyc", + "lib/python3.10/site-packages/conda_env/installers/__pycache__/pip.cpython-310.pyc", + "lib/python3.10/site-packages/conda_env/installers/base.py", + "lib/python3.10/site-packages/conda_env/installers/conda.py", + "lib/python3.10/site-packages/conda_env/installers/pip.py", + "lib/python3.10/site-packages/conda_env/pip_util.py", + "lib/python3.10/site-packages/conda_env/specs/__init__.py", + "lib/python3.10/site-packages/conda_env/specs/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/conda_env/specs/__pycache__/binstar.cpython-310.pyc", + "lib/python3.10/site-packages/conda_env/specs/__pycache__/notebook.cpython-310.pyc", + "lib/python3.10/site-packages/conda_env/specs/__pycache__/requirements.cpython-310.pyc", + "lib/python3.10/site-packages/conda_env/specs/__pycache__/yaml_file.cpython-310.pyc", + "lib/python3.10/site-packages/conda_env/specs/binstar.py", + "lib/python3.10/site-packages/conda_env/specs/notebook.py", + "lib/python3.10/site-packages/conda_env/specs/requirements.py", + "lib/python3.10/site-packages/conda_env/specs/yaml_file.py", + "lib/python3.10/site-packages/xontrib/conda.xsh", + "shell/condabin/Conda.psm1", + "shell/condabin/conda-hook.ps1" + ], + "fn": "conda-23.1.0-py310hca03da5_0.conda", + "legacy_bz2_md5": "7c4f77c5ec509dcd5003dd693a2e3c9e", + "legacy_bz2_size": 990313, + "license": "BSD-3-Clause", + "license_family": "BSD", + "link": { + "source": "/Users/donjayamanne/.pyenv/versions/anaconda3-2023.03/pkgs/conda-23.1.0-py310hca03da5_0", + "type": 1 + }, + "md5": "00c5c7f9e827401bd66aaceb9c5ee4a8", + "name": "conda", + "package_tarball_full_path": "/Users/donjayamanne/.pyenv/versions/anaconda3-2023.03/pkgs/conda-23.1.0-py310hca03da5_0.conda", + "paths_data": { + "paths": [ + { + "_path": "bin/activate", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_f1vw_br1qm/croot/conda_1674574636144/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehol", + "sha256": "e276f622f70beeb3a1f25d5af51b76b6b715cad3f21e28eb79225be88d499ba4", + "sha256_in_prefix": "e0338158197b194a1452aecb186cbe38971f797192ece162d6ec574e8e8e6cda", + "size_in_bytes": 429 + }, + { + "_path": "bin/conda", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_f1vw_br1qm/croot/conda_1674574636144/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehol", + "sha256": "ab080152682efca803dac53cfbcfd102f3a33b06a057c492b0aa22c8a9cc739a", + "sha256_in_prefix": "3dccd282d2586f801bfd4fafe2a59cc97a9c05ad8202f6d9bc1ae2ead6c65b41", + "size_in_bytes": 756 + }, + { + "_path": "bin/conda-env", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_f1vw_br1qm/croot/conda_1674574636144/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehol", + "sha256": "64737294f79d62e8a522b03df355826194122f144f8f44f93cb9fca41a33e417", + "sha256_in_prefix": "0cfb694efceb4ad75fe1ed8250683eceb4004b7606bb8c261f77f5264ed2d658", + "size_in_bytes": 393 + }, + { + "_path": "bin/deactivate", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_f1vw_br1qm/croot/conda_1674574636144/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehol", + "sha256": "4970c998fe3718638b1fa504ebb608ecacfc0682f61229941a55ba2161bd20b3", + "sha256_in_prefix": "b619c825c6d1c76f630d01aca010cc78f099af9fa432bd4c010063c26483f59f", + "size_in_bytes": 517 + }, + { + "_path": "condabin/conda", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_f1vw_br1qm/croot/conda_1674574636144/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehol", + "sha256": "ab080152682efca803dac53cfbcfd102f3a33b06a057c492b0aa22c8a9cc739a", + "sha256_in_prefix": "3dccd282d2586f801bfd4fafe2a59cc97a9c05ad8202f6d9bc1ae2ead6c65b41", + "size_in_bytes": 756 + }, + { + "_path": "etc/fish/conf.d/conda.fish", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_f1vw_br1qm/croot/conda_1674574636144/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehol", + "sha256": "6ffed84ed6c728ac8cc324c82a944916bfa93974bd0f3431e48003687bb12883", + "sha256_in_prefix": "79df3672c7b2e72f58a8eeddad177ed7e1d738fca3c6d491951a09fd5787a7a2", + "size_in_bytes": 4880 + }, + { + "_path": "etc/profile.d/conda.csh", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_f1vw_br1qm/croot/conda_1674574636144/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehol", + "sha256": "5ffc2c88ff64d8f8a41f95135efe3012eceffd7e1144bdea20ac0365591d6bf9", + "sha256_in_prefix": "f4dd7bd7acb551cb41afe7775c963d7ab5759647464e953edc17f97b9d84c3bd", + "size_in_bytes": 3164 + }, + { + "_path": "etc/profile.d/conda.sh", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_f1vw_br1qm/croot/conda_1674574636144/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehol", + "sha256": "6d751a99d1dc5de6c41244a213890b583cff3a217ea3acac2b975d01bb971d9a", + "sha256_in_prefix": "18d5fc38f1808824dd557f0b12c0855f7981734de89176b391ea6faa9fa20592", + "size_in_bytes": 2553 + }, + { + "_path": "lib/python3.10/site-packages/xontrib/conda.xsh", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_f1vw_br1qm/croot/conda_1674574636144/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehol", + "sha256": "f4d511a3b380dfc1a015a1bb6f6201f157fdd5b025a3d0bcdc694555b78c8ca6", + "sha256_in_prefix": "7aa4186c00138a4c108e83f46d500a2d33c6d7f40386684d914f0a5c1b94657a", + "size_in_bytes": 7418 + }, + { + "_path": "shell/condabin/conda-hook.ps1", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_f1vw_br1qm/croot/conda_1674574636144/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehol", + "sha256": "d247c979ac45cb449f8988993c8fadea7b68dc32114a17d48619f8f671fea4ae", + "sha256_in_prefix": "bb43432a1dfe9936d54b4cb55e03e623e4e0046e926497ffef077cb83464a6ce", + "size_in_bytes": 1047 + } + ], + "paths_version": 1 + }, + "requested_spec": "defaults/osx-arm64::conda==23.1.0=py310hca03da5_0[md5=00c5c7f9e827401bd66aaceb9c5ee4a8]", + "sha256": "125ed5a84b2874b42430763e4543e23e0496aac8e8e09522594ace150eb6aacf", + "size": 982226, + "subdir": "osx-arm64", + "timestamp": 1674574815058, + "track_features": "", + "url": "https://repo.anaconda.com/pkgs/main/osx-arm64/conda-23.1.0-py310hca03da5_0.conda", + "version": "23.1.0" +} \ No newline at end of file diff --git a/crates/pet-conda/tests/unix/anaconda3-2023.03-without-history/conda-meta/conda-build-3.23.3-py310hca03da5_0.json b/crates/pet-conda/tests/unix/anaconda3-2023.03-without-history/conda-meta/conda-build-3.23.3-py310hca03da5_0.json new file mode 100644 index 00000000..f0f3640b --- /dev/null +++ b/crates/pet-conda/tests/unix/anaconda3-2023.03-without-history/conda-meta/conda-build-3.23.3-py310hca03da5_0.json @@ -0,0 +1,292 @@ +{ + "build": "py310hca03da5_0", + "build_number": 0, + "channel": "https://repo.anaconda.com/pkgs/main/osx-arm64", + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "cctools", + "chardet", + "conda >=4.13", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patch >=2.6", + "pkginfo", + "psutil", + "py-lief", + "python >=3.10,<3.11.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "setuptools", + "six", + "toml", + "tqdm" + ], + "extracted_package_dir": "/Users/donjayamanne/.pyenv/versions/anaconda3-2023.03/pkgs/conda-build-3.23.3-py310hca03da5_0", + "features": "", + "files": [ + "bin/conda-build", + "bin/conda-convert", + "bin/conda-debug", + "bin/conda-develop", + "bin/conda-index", + "bin/conda-inspect", + "bin/conda-metapackage", + "bin/conda-render", + "bin/conda-skeleton", + "lib/python3.10/site-packages/conda_build-3.23.3-py3.10.egg-info/PKG-INFO", + "lib/python3.10/site-packages/conda_build-3.23.3-py3.10.egg-info/SOURCES.txt", + "lib/python3.10/site-packages/conda_build-3.23.3-py3.10.egg-info/dependency_links.txt", + "lib/python3.10/site-packages/conda_build-3.23.3-py3.10.egg-info/entry_points.txt", + "lib/python3.10/site-packages/conda_build-3.23.3-py3.10.egg-info/not-zip-safe", + "lib/python3.10/site-packages/conda_build-3.23.3-py3.10.egg-info/requires.txt", + "lib/python3.10/site-packages/conda_build-3.23.3-py3.10.egg-info/top_level.txt", + "lib/python3.10/site-packages/conda_build/__init__.py", + "lib/python3.10/site-packages/conda_build/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/__pycache__/_link.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/__pycache__/_load_setup_py_data.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/__pycache__/_version.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/__pycache__/api.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/__pycache__/bdist_conda.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/__pycache__/build.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/__pycache__/conda_interface.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/__pycache__/config.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/__pycache__/convert.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/__pycache__/create_test.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/__pycache__/develop.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/__pycache__/environ.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/__pycache__/exceptions.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/__pycache__/features.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/__pycache__/index.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/__pycache__/inspect_pkg.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/__pycache__/jinja_context.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/__pycache__/license_family.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/__pycache__/metadata.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/__pycache__/metapackage.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/__pycache__/noarch_python.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/__pycache__/post.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/__pycache__/render.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/__pycache__/source.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/__pycache__/tarcheck.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/__pycache__/utils.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/__pycache__/variants.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/__pycache__/windows.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/_link.py", + "lib/python3.10/site-packages/conda_build/_load_setup_py_data.py", + "lib/python3.10/site-packages/conda_build/_version.py", + "lib/python3.10/site-packages/conda_build/api.py", + "lib/python3.10/site-packages/conda_build/bdist_conda.py", + "lib/python3.10/site-packages/conda_build/build.py", + "lib/python3.10/site-packages/conda_build/cli-32.exe", + "lib/python3.10/site-packages/conda_build/cli-64.exe", + "lib/python3.10/site-packages/conda_build/cli/__init__.py", + "lib/python3.10/site-packages/conda_build/cli/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/cli/__pycache__/actions.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/cli/__pycache__/main_build.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/cli/__pycache__/main_convert.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/cli/__pycache__/main_debug.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/cli/__pycache__/main_develop.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/cli/__pycache__/main_index.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/cli/__pycache__/main_inspect.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/cli/__pycache__/main_metapackage.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/cli/__pycache__/main_render.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/cli/__pycache__/main_skeleton.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/cli/__pycache__/validators.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/cli/actions.py", + "lib/python3.10/site-packages/conda_build/cli/main_build.py", + "lib/python3.10/site-packages/conda_build/cli/main_convert.py", + "lib/python3.10/site-packages/conda_build/cli/main_debug.py", + "lib/python3.10/site-packages/conda_build/cli/main_develop.py", + "lib/python3.10/site-packages/conda_build/cli/main_index.py", + "lib/python3.10/site-packages/conda_build/cli/main_inspect.py", + "lib/python3.10/site-packages/conda_build/cli/main_metapackage.py", + "lib/python3.10/site-packages/conda_build/cli/main_render.py", + "lib/python3.10/site-packages/conda_build/cli/main_skeleton.py", + "lib/python3.10/site-packages/conda_build/cli/validators.py", + "lib/python3.10/site-packages/conda_build/conda_interface.py", + "lib/python3.10/site-packages/conda_build/config.py", + "lib/python3.10/site-packages/conda_build/convert.py", + "lib/python3.10/site-packages/conda_build/create_test.py", + "lib/python3.10/site-packages/conda_build/develop.py", + "lib/python3.10/site-packages/conda_build/environ.py", + "lib/python3.10/site-packages/conda_build/exceptions.py", + "lib/python3.10/site-packages/conda_build/features.py", + "lib/python3.10/site-packages/conda_build/index.py", + "lib/python3.10/site-packages/conda_build/inspect_pkg.py", + "lib/python3.10/site-packages/conda_build/jinja_context.py", + "lib/python3.10/site-packages/conda_build/license_family.py", + "lib/python3.10/site-packages/conda_build/metadata.py", + "lib/python3.10/site-packages/conda_build/metapackage.py", + "lib/python3.10/site-packages/conda_build/noarch_python.py", + "lib/python3.10/site-packages/conda_build/os_utils/__init__.py", + "lib/python3.10/site-packages/conda_build/os_utils/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/os_utils/__pycache__/elf.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/os_utils/__pycache__/external.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/os_utils/__pycache__/ldd.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/os_utils/__pycache__/liefldd.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/os_utils/__pycache__/macho.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/os_utils/__pycache__/pyldd.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/os_utils/elf.py", + "lib/python3.10/site-packages/conda_build/os_utils/external.py", + "lib/python3.10/site-packages/conda_build/os_utils/ldd.py", + "lib/python3.10/site-packages/conda_build/os_utils/liefldd.py", + "lib/python3.10/site-packages/conda_build/os_utils/macho.py", + "lib/python3.10/site-packages/conda_build/os_utils/pyldd.py", + "lib/python3.10/site-packages/conda_build/post.py", + "lib/python3.10/site-packages/conda_build/render.py", + "lib/python3.10/site-packages/conda_build/skeletons/__init__.py", + "lib/python3.10/site-packages/conda_build/skeletons/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/skeletons/__pycache__/_example_skeleton.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/skeletons/__pycache__/cpan.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/skeletons/__pycache__/cran.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/skeletons/__pycache__/luarocks.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/skeletons/__pycache__/pypi.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/skeletons/__pycache__/rpm.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/skeletons/_example_skeleton.py", + "lib/python3.10/site-packages/conda_build/skeletons/cpan.py", + "lib/python3.10/site-packages/conda_build/skeletons/cran.py", + "lib/python3.10/site-packages/conda_build/skeletons/luarocks.py", + "lib/python3.10/site-packages/conda_build/skeletons/pypi.py", + "lib/python3.10/site-packages/conda_build/skeletons/rpm.py", + "lib/python3.10/site-packages/conda_build/source.py", + "lib/python3.10/site-packages/conda_build/tarcheck.py", + "lib/python3.10/site-packages/conda_build/templates/channeldata-index.html.j2", + "lib/python3.10/site-packages/conda_build/templates/npm.yaml", + "lib/python3.10/site-packages/conda_build/templates/rss.xml.j2", + "lib/python3.10/site-packages/conda_build/templates/setuptools.yaml", + "lib/python3.10/site-packages/conda_build/templates/subdir-index.html.j2", + "lib/python3.10/site-packages/conda_build/utils.py", + "lib/python3.10/site-packages/conda_build/variants.py", + "lib/python3.10/site-packages/conda_build/windows.py" + ], + "fn": "conda-build-3.23.3-py310hca03da5_0.conda", + "legacy_bz2_md5": "8ea35d4f734cdef277a94cf74d22d3ae", + "legacy_bz2_size": 576512, + "license": "BSD-3-Clause", + "license_family": "BSD", + "link": { + "source": "/Users/donjayamanne/.pyenv/versions/anaconda3-2023.03/pkgs/conda-build-3.23.3-py310hca03da5_0", + "type": 1 + }, + "md5": "4a6b06f0a14b98c819cd4b0e09c740e8", + "name": "conda-build", + "package_tarball_full_path": "/Users/donjayamanne/.pyenv/versions/anaconda3-2023.03/pkgs/conda-build-3.23.3-py310hca03da5_0.conda", + "paths_data": { + "paths": [ + { + "_path": "bin/conda-build", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_e9c9oqsgk0/croot/conda-build_1670407343391/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_pl", + "sha256": "bcb2e024326726eba4acd5a19f0a630864fdf5ba060f2e18f15ac7ebc480d110", + "sha256_in_prefix": "0e3157ec917846a3847fb675ea632a2ac8c36673f3be8a1c04f37fc0181733ee", + "size_in_bytes": 479 + }, + { + "_path": "bin/conda-convert", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_e9c9oqsgk0/croot/conda-build_1670407343391/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_pl", + "sha256": "d410d34b34ad6f68b7a1500ed6b63fc27561ce130dee75b39dbe411b5fb3a2af", + "sha256_in_prefix": "f14a90cb7a116bd45a2994c040c6957cac360f762e9c334af427cb8241770367", + "size_in_bytes": 481 + }, + { + "_path": "bin/conda-debug", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_e9c9oqsgk0/croot/conda-build_1670407343391/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_pl", + "sha256": "bd4dffebd208180e99ac73f86ce8ceb5f4bea5c2c71a95bbe687de2560ab9b08", + "sha256_in_prefix": "13a281bc24e2d7aaca30eb00307b6eb44563c677274ab3e07b0649c663ca419a", + "size_in_bytes": 479 + }, + { + "_path": "bin/conda-develop", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_e9c9oqsgk0/croot/conda-build_1670407343391/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_pl", + "sha256": "231799f45acb8119dfdb95f42f23e906fe70fbb144b303d9614fedeece77773f", + "sha256_in_prefix": "cbd4fccc2791cf5100694976d0cae72da508f8ad6e68b20c28c88f80dcca4993", + "size_in_bytes": 481 + }, + { + "_path": "bin/conda-index", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_e9c9oqsgk0/croot/conda-build_1670407343391/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_pl", + "sha256": "6864da7e624f38d401fb0583f0d8d90745c0364dc395ccb5a2f1376d2665dc0a", + "sha256_in_prefix": "82530863ef858181f6916b8119d958756f6369340725ec0c431566d9d069fd7d", + "size_in_bytes": 479 + }, + { + "_path": "bin/conda-inspect", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_e9c9oqsgk0/croot/conda-build_1670407343391/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_pl", + "sha256": "e6ac49718570dba57e082b1cada990916ad9c842428c1e4feb0ab2a8991b779a", + "sha256_in_prefix": "de395fada71e3b91388f77e58595c0ea5c312f3d9723f1166f53d02ee0cea7aa", + "size_in_bytes": 481 + }, + { + "_path": "bin/conda-metapackage", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_e9c9oqsgk0/croot/conda-build_1670407343391/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_pl", + "sha256": "cdb36b8e4952467f37afa6bff264785ce30283b4514930ff476007deeaf40c82", + "sha256_in_prefix": "39f4482e3f3cced297044aca946716cb0ba028d790fa2c0bb0750f18ade242a3", + "size_in_bytes": 485 + }, + { + "_path": "bin/conda-render", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_e9c9oqsgk0/croot/conda-build_1670407343391/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_pl", + "sha256": "1ce235e5b9079264b8e537cda0b4f2de978a7023a42b3e610cc25d187b2c0b5e", + "sha256_in_prefix": "fe22b853f463bc1e376ea2408b47a1b136bed9b7920df95f9a9c85cf01ee9d25", + "size_in_bytes": 480 + }, + { + "_path": "bin/conda-skeleton", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_e9c9oqsgk0/croot/conda-build_1670407343391/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_pl", + "sha256": "67dc5e0c39f5c60c3b0137e288e63f888b555238a61306bb9a543d07eb9055d6", + "sha256_in_prefix": "ad8ad61d3334dc35a06b7892e9ff74a3bff15e1a826dae1c12a7e0e14a03286c", + "size_in_bytes": 482 + }, + { + "_path": "lib/python3.10/site-packages/conda_build/build.py", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/opt/anaconda1anaconda2anaconda3", + "sha256": "80484c779970d54fc4770770d4fd7e8c3746bf9dca507422b0de9ac6318de577", + "sha256_in_prefix": "15b2555eafdddbbec1056215f7b7ad63ddb83119c7505fc58058f946b430898c", + "size_in_bytes": 165970 + }, + { + "_path": "lib/python3.10/site-packages/conda_build/convert.py", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/opt/anaconda1anaconda2anaconda3", + "sha256": "de70a8ed59cdfb67e8f929d6cb3152c87a2be8d57dd9c93e9facb8c35ee1ae3a", + "sha256_in_prefix": "2a64800bf62f67f4666563f7c4779390fd0e80382227e883e40646910fcf8a41", + "size_in_bytes": 32246 + } + ], + "paths_version": 1 + }, + "requested_spec": "defaults/osx-arm64::conda-build==3.23.3=py310hca03da5_0[md5=4a6b06f0a14b98c819cd4b0e09c740e8]", + "sha256": "5f67c17b8cda432f379e620df27dd0dee0dd028158a1e08ad7dfb5dd4a13a020", + "size": 594922, + "subdir": "osx-arm64", + "timestamp": 1670407406866, + "track_features": "", + "url": "https://repo.anaconda.com/pkgs/main/osx-arm64/conda-build-3.23.3-py310hca03da5_0.conda", + "version": "3.23.3" +} \ No newline at end of file diff --git a/crates/pet-conda/tests/unix/anaconda3-2023.03-without-history/conda-meta/pytest-7.1.2-py310hca03da5_0.json b/crates/pet-conda/tests/unix/anaconda3-2023.03-without-history/conda-meta/pytest-7.1.2-py310hca03da5_0.json new file mode 100644 index 00000000..eeac4446 --- /dev/null +++ b/crates/pet-conda/tests/unix/anaconda3-2023.03-without-history/conda-meta/pytest-7.1.2-py310hca03da5_0.json @@ -0,0 +1,209 @@ +{ + "build": "py310hca03da5_0", + "build_number": 0, + "channel": "https://repo.anaconda.com/pkgs/main/osx-arm64", + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=19.2.0", + "iniconfig", + "packaging", + "pluggy >=0.12,<2.0", + "py >=1.8.2", + "python >=3.10,<3.11.0a0", + "tomli >=1.0.0" + ], + "extracted_package_dir": "/Users/donjayamanne/.pyenv/versions/anaconda3-2023.03/pkgs/pytest-7.1.2-py310hca03da5_0", + "features": "", + "files": [ + "bin/py.test", + "bin/pytest", + "lib/python3.10/site-packages/_pytest/__init__.py", + "lib/python3.10/site-packages/_pytest/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/_argcomplete.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/_version.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/cacheprovider.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/capture.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/compat.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/debugging.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/deprecated.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/doctest.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/faulthandler.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/fixtures.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/freeze_support.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/helpconfig.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/hookspec.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/junitxml.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/legacypath.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/logging.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/main.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/monkeypatch.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/nodes.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/nose.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/outcomes.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/pastebin.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/pathlib.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/pytester.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/pytester_assertions.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/python.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/python_api.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/python_path.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/recwarn.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/reports.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/runner.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/scope.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/setuponly.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/setupplan.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/skipping.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/stash.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/stepwise.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/terminal.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/threadexception.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/timing.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/tmpdir.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/unittest.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/unraisableexception.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/warning_types.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/warnings.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/_argcomplete.py", + "lib/python3.10/site-packages/_pytest/_code/__init__.py", + "lib/python3.10/site-packages/_pytest/_code/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/_code/__pycache__/code.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/_code/__pycache__/source.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/_code/code.py", + "lib/python3.10/site-packages/_pytest/_code/source.py", + "lib/python3.10/site-packages/_pytest/_io/__init__.py", + "lib/python3.10/site-packages/_pytest/_io/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/_io/__pycache__/saferepr.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/_io/__pycache__/terminalwriter.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/_io/__pycache__/wcwidth.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/_io/saferepr.py", + "lib/python3.10/site-packages/_pytest/_io/terminalwriter.py", + "lib/python3.10/site-packages/_pytest/_io/wcwidth.py", + "lib/python3.10/site-packages/_pytest/_version.py", + "lib/python3.10/site-packages/_pytest/assertion/__init__.py", + "lib/python3.10/site-packages/_pytest/assertion/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/assertion/__pycache__/rewrite.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/assertion/__pycache__/truncate.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/assertion/__pycache__/util.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/assertion/rewrite.py", + "lib/python3.10/site-packages/_pytest/assertion/truncate.py", + "lib/python3.10/site-packages/_pytest/assertion/util.py", + "lib/python3.10/site-packages/_pytest/cacheprovider.py", + "lib/python3.10/site-packages/_pytest/capture.py", + "lib/python3.10/site-packages/_pytest/compat.py", + "lib/python3.10/site-packages/_pytest/config/__init__.py", + "lib/python3.10/site-packages/_pytest/config/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/config/__pycache__/argparsing.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/config/__pycache__/compat.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/config/__pycache__/exceptions.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/config/__pycache__/findpaths.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/config/argparsing.py", + "lib/python3.10/site-packages/_pytest/config/compat.py", + "lib/python3.10/site-packages/_pytest/config/exceptions.py", + "lib/python3.10/site-packages/_pytest/config/findpaths.py", + "lib/python3.10/site-packages/_pytest/debugging.py", + "lib/python3.10/site-packages/_pytest/deprecated.py", + "lib/python3.10/site-packages/_pytest/doctest.py", + "lib/python3.10/site-packages/_pytest/faulthandler.py", + "lib/python3.10/site-packages/_pytest/fixtures.py", + "lib/python3.10/site-packages/_pytest/freeze_support.py", + "lib/python3.10/site-packages/_pytest/helpconfig.py", + "lib/python3.10/site-packages/_pytest/hookspec.py", + "lib/python3.10/site-packages/_pytest/junitxml.py", + "lib/python3.10/site-packages/_pytest/legacypath.py", + "lib/python3.10/site-packages/_pytest/logging.py", + "lib/python3.10/site-packages/_pytest/main.py", + "lib/python3.10/site-packages/_pytest/mark/__init__.py", + "lib/python3.10/site-packages/_pytest/mark/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/mark/__pycache__/expression.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/mark/__pycache__/structures.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/mark/expression.py", + "lib/python3.10/site-packages/_pytest/mark/structures.py", + "lib/python3.10/site-packages/_pytest/monkeypatch.py", + "lib/python3.10/site-packages/_pytest/nodes.py", + "lib/python3.10/site-packages/_pytest/nose.py", + "lib/python3.10/site-packages/_pytest/outcomes.py", + "lib/python3.10/site-packages/_pytest/pastebin.py", + "lib/python3.10/site-packages/_pytest/pathlib.py", + "lib/python3.10/site-packages/_pytest/py.typed", + "lib/python3.10/site-packages/_pytest/pytester.py", + "lib/python3.10/site-packages/_pytest/pytester_assertions.py", + "lib/python3.10/site-packages/_pytest/python.py", + "lib/python3.10/site-packages/_pytest/python_api.py", + "lib/python3.10/site-packages/_pytest/python_path.py", + "lib/python3.10/site-packages/_pytest/recwarn.py", + "lib/python3.10/site-packages/_pytest/reports.py", + "lib/python3.10/site-packages/_pytest/runner.py", + "lib/python3.10/site-packages/_pytest/scope.py", + "lib/python3.10/site-packages/_pytest/setuponly.py", + "lib/python3.10/site-packages/_pytest/setupplan.py", + "lib/python3.10/site-packages/_pytest/skipping.py", + "lib/python3.10/site-packages/_pytest/stash.py", + "lib/python3.10/site-packages/_pytest/stepwise.py", + "lib/python3.10/site-packages/_pytest/terminal.py", + "lib/python3.10/site-packages/_pytest/threadexception.py", + "lib/python3.10/site-packages/_pytest/timing.py", + "lib/python3.10/site-packages/_pytest/tmpdir.py", + "lib/python3.10/site-packages/_pytest/unittest.py", + "lib/python3.10/site-packages/_pytest/unraisableexception.py", + "lib/python3.10/site-packages/_pytest/warning_types.py", + "lib/python3.10/site-packages/_pytest/warnings.py", + "lib/python3.10/site-packages/pytest-7.1.2-py3.10.egg-info/PKG-INFO", + "lib/python3.10/site-packages/pytest-7.1.2-py3.10.egg-info/SOURCES.txt", + "lib/python3.10/site-packages/pytest-7.1.2-py3.10.egg-info/dependency_links.txt", + "lib/python3.10/site-packages/pytest-7.1.2-py3.10.egg-info/entry_points.txt", + "lib/python3.10/site-packages/pytest-7.1.2-py3.10.egg-info/not-zip-safe", + "lib/python3.10/site-packages/pytest-7.1.2-py3.10.egg-info/requires.txt", + "lib/python3.10/site-packages/pytest-7.1.2-py3.10.egg-info/top_level.txt", + "lib/python3.10/site-packages/pytest/__init__.py", + "lib/python3.10/site-packages/pytest/__main__.py", + "lib/python3.10/site-packages/pytest/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/pytest/__pycache__/__main__.cpython-310.pyc", + "lib/python3.10/site-packages/pytest/py.typed" + ], + "fn": "pytest-7.1.2-py310hca03da5_0.conda", + "legacy_bz2_md5": "d5f7cb91582e7a1e1d0302b6691f4ff2", + "legacy_bz2_size": 475724, + "license": "MIT", + "license_family": "MIT", + "link": { + "source": "/Users/donjayamanne/.pyenv/versions/anaconda3-2023.03/pkgs/pytest-7.1.2-py310hca03da5_0", + "type": 1 + }, + "md5": "3d4ffcd5ce4a0f875ed0a577c35dd924", + "name": "pytest", + "package_tarball_full_path": "/Users/donjayamanne/.pyenv/versions/anaconda3-2023.03/pkgs/pytest-7.1.2-py310hca03da5_0.conda", + "paths_data": { + "paths": [ + { + "_path": "bin/py.test", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_bb79cf71-3b0d-4f6e-b127-6cd6f42cd0b3zuaib3yw/croots/recipe/pytest_1654684981069/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_place", + "sha256": "25a4084929551abe44daf94ad6db601477697c2e7fe7754bfa51e927f61a2a82", + "sha256_in_prefix": "74ca4d1facd6ae350af7bf80a69703271ebb7bf74053924e86a222e5d96d1f9e", + "size_in_bytes": 475 + }, + { + "_path": "bin/pytest", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_bb79cf71-3b0d-4f6e-b127-6cd6f42cd0b3zuaib3yw/croots/recipe/pytest_1654684981069/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_place", + "sha256": "25a4084929551abe44daf94ad6db601477697c2e7fe7754bfa51e927f61a2a82", + "sha256_in_prefix": "74ca4d1facd6ae350af7bf80a69703271ebb7bf74053924e86a222e5d96d1f9e", + "size_in_bytes": 475 + } + ], + "paths_version": 1 + }, + "requested_spec": "defaults/osx-arm64::pytest==7.1.2=py310hca03da5_0[md5=3d4ffcd5ce4a0f875ed0a577c35dd924]", + "sha256": "6d9d80df16880009035d6aeca466be48c7511e3dc366469459f3400928ef6c87", + "size": 458308, + "subdir": "osx-arm64", + "timestamp": 1654685008490, + "track_features": "", + "url": "https://repo.anaconda.com/pkgs/main/osx-arm64/pytest-7.1.2-py310hca03da5_0.conda", + "version": "7.1.2" +} \ No newline at end of file diff --git a/crates/pet-conda/tests/unix/anaconda3-2023.03-without-history/conda-meta/python-3.10.9-hc0d8a6c_1.json b/crates/pet-conda/tests/unix/anaconda3-2023.03-without-history/conda-meta/python-3.10.9-hc0d8a6c_1.json new file mode 100644 index 00000000..54078722 --- /dev/null +++ b/crates/pet-conda/tests/unix/anaconda3-2023.03-without-history/conda-meta/python-3.10.9-hc0d8a6c_1.json @@ -0,0 +1,2222 @@ +{ + "build": "hc0d8a6c_1", + "build_number": 1, + "channel": "https://repo.anaconda.com/pkgs/main/osx-arm64", + "constrains": [], + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "libffi >=3.4,<3.5", + "libffi >=3.4,<4.0a0", + "ncurses >=6.4,<7.0a0", + "openssl >=1.1.1t,<1.1.2a", + "readline >=8.1.2,<9.0a0", + "sqlite >=3.40.1,<4.0a0", + "tk >=8.6.12,<8.7.0a0", + "tzdata", + "xz >=5.2.10,<6.0a0", + "zlib >=1.2.13,<1.3.0a0", + "pip" + ], + "extracted_package_dir": "/Users/donjayamanne/.pyenv/versions/anaconda3-2023.03/pkgs/python-3.10.9-hc0d8a6c_1", + "features": "", + "files": [ + "bin/2to3", + "bin/2to3-3.10", + "bin/idle3", + "bin/idle3.10", + "bin/pydoc", + "bin/pydoc3", + "bin/pydoc3.10", + "bin/python", + "bin/python3", + "bin/python3-config", + "bin/python3.1", + "bin/python3.10", + "bin/python3.10-config", + "include/python3.10/Python.h", + "include/python3.10/abstract.h", + "include/python3.10/bltinmodule.h", + "include/python3.10/boolobject.h", + "include/python3.10/bytearrayobject.h", + "include/python3.10/bytesobject.h", + "include/python3.10/cellobject.h", + "include/python3.10/ceval.h", + "include/python3.10/classobject.h", + "include/python3.10/code.h", + "include/python3.10/codecs.h", + "include/python3.10/compile.h", + "include/python3.10/complexobject.h", + "include/python3.10/context.h", + "include/python3.10/cpython/abstract.h", + "include/python3.10/cpython/bytearrayobject.h", + "include/python3.10/cpython/bytesobject.h", + "include/python3.10/cpython/ceval.h", + "include/python3.10/cpython/code.h", + "include/python3.10/cpython/compile.h", + "include/python3.10/cpython/dictobject.h", + "include/python3.10/cpython/fileobject.h", + "include/python3.10/cpython/fileutils.h", + "include/python3.10/cpython/frameobject.h", + "include/python3.10/cpython/import.h", + "include/python3.10/cpython/initconfig.h", + "include/python3.10/cpython/interpreteridobject.h", + "include/python3.10/cpython/listobject.h", + "include/python3.10/cpython/methodobject.h", + "include/python3.10/cpython/object.h", + "include/python3.10/cpython/objimpl.h", + "include/python3.10/cpython/odictobject.h", + "include/python3.10/cpython/picklebufobject.h", + "include/python3.10/cpython/pyctype.h", + "include/python3.10/cpython/pydebug.h", + "include/python3.10/cpython/pyerrors.h", + "include/python3.10/cpython/pyfpe.h", + "include/python3.10/cpython/pylifecycle.h", + "include/python3.10/cpython/pymem.h", + "include/python3.10/cpython/pystate.h", + "include/python3.10/cpython/pythonrun.h", + "include/python3.10/cpython/pytime.h", + "include/python3.10/cpython/sysmodule.h", + "include/python3.10/cpython/traceback.h", + "include/python3.10/cpython/tupleobject.h", + "include/python3.10/cpython/unicodeobject.h", + "include/python3.10/datetime.h", + "include/python3.10/descrobject.h", + "include/python3.10/dictobject.h", + "include/python3.10/dynamic_annotations.h", + "include/python3.10/enumobject.h", + "include/python3.10/errcode.h", + "include/python3.10/eval.h", + "include/python3.10/exports.h", + "include/python3.10/fileobject.h", + "include/python3.10/fileutils.h", + "include/python3.10/floatobject.h", + "include/python3.10/frameobject.h", + "include/python3.10/funcobject.h", + "include/python3.10/genericaliasobject.h", + "include/python3.10/genobject.h", + "include/python3.10/import.h", + "include/python3.10/internal/pycore_abstract.h", + "include/python3.10/internal/pycore_accu.h", + "include/python3.10/internal/pycore_asdl.h", + "include/python3.10/internal/pycore_ast.h", + "include/python3.10/internal/pycore_ast_state.h", + "include/python3.10/internal/pycore_atomic.h", + "include/python3.10/internal/pycore_atomic_funcs.h", + "include/python3.10/internal/pycore_bitutils.h", + "include/python3.10/internal/pycore_blocks_output_buffer.h", + "include/python3.10/internal/pycore_bytes_methods.h", + "include/python3.10/internal/pycore_call.h", + "include/python3.10/internal/pycore_ceval.h", + "include/python3.10/internal/pycore_code.h", + "include/python3.10/internal/pycore_compile.h", + "include/python3.10/internal/pycore_condvar.h", + "include/python3.10/internal/pycore_context.h", + "include/python3.10/internal/pycore_dtoa.h", + "include/python3.10/internal/pycore_fileutils.h", + "include/python3.10/internal/pycore_format.h", + "include/python3.10/internal/pycore_gc.h", + "include/python3.10/internal/pycore_getopt.h", + "include/python3.10/internal/pycore_gil.h", + "include/python3.10/internal/pycore_hamt.h", + "include/python3.10/internal/pycore_hashtable.h", + "include/python3.10/internal/pycore_import.h", + "include/python3.10/internal/pycore_initconfig.h", + "include/python3.10/internal/pycore_interp.h", + "include/python3.10/internal/pycore_list.h", + "include/python3.10/internal/pycore_long.h", + "include/python3.10/internal/pycore_moduleobject.h", + "include/python3.10/internal/pycore_object.h", + "include/python3.10/internal/pycore_parser.h", + "include/python3.10/internal/pycore_pathconfig.h", + "include/python3.10/internal/pycore_pyarena.h", + "include/python3.10/internal/pycore_pyerrors.h", + "include/python3.10/internal/pycore_pyhash.h", + "include/python3.10/internal/pycore_pylifecycle.h", + "include/python3.10/internal/pycore_pymem.h", + "include/python3.10/internal/pycore_pystate.h", + "include/python3.10/internal/pycore_runtime.h", + "include/python3.10/internal/pycore_structseq.h", + "include/python3.10/internal/pycore_symtable.h", + "include/python3.10/internal/pycore_sysmodule.h", + "include/python3.10/internal/pycore_traceback.h", + "include/python3.10/internal/pycore_tuple.h", + "include/python3.10/internal/pycore_ucnhash.h", + "include/python3.10/internal/pycore_unionobject.h", + "include/python3.10/internal/pycore_warnings.h", + "include/python3.10/interpreteridobject.h", + "include/python3.10/intrcheck.h", + "include/python3.10/iterobject.h", + "include/python3.10/listobject.h", + "include/python3.10/longintrepr.h", + "include/python3.10/longobject.h", + "include/python3.10/marshal.h", + "include/python3.10/memoryobject.h", + "include/python3.10/methodobject.h", + "include/python3.10/modsupport.h", + "include/python3.10/moduleobject.h", + "include/python3.10/namespaceobject.h", + "include/python3.10/object.h", + "include/python3.10/objimpl.h", + "include/python3.10/opcode.h", + "include/python3.10/osdefs.h", + "include/python3.10/osmodule.h", + "include/python3.10/patchlevel.h", + "include/python3.10/py_curses.h", + "include/python3.10/pycapsule.h", + "include/python3.10/pyconfig.h", + "include/python3.10/pydtrace.h", + "include/python3.10/pyerrors.h", + "include/python3.10/pyexpat.h", + "include/python3.10/pyframe.h", + "include/python3.10/pyhash.h", + "include/python3.10/pylifecycle.h", + "include/python3.10/pymacconfig.h", + "include/python3.10/pymacro.h", + "include/python3.10/pymath.h", + "include/python3.10/pymem.h", + "include/python3.10/pyport.h", + "include/python3.10/pystate.h", + "include/python3.10/pystrcmp.h", + "include/python3.10/pystrhex.h", + "include/python3.10/pystrtod.h", + "include/python3.10/pythonrun.h", + "include/python3.10/pythread.h", + "include/python3.10/rangeobject.h", + "include/python3.10/setobject.h", + "include/python3.10/sliceobject.h", + "include/python3.10/structmember.h", + "include/python3.10/structseq.h", + "include/python3.10/sysmodule.h", + "include/python3.10/token.h", + "include/python3.10/traceback.h", + "include/python3.10/tracemalloc.h", + "include/python3.10/tupleobject.h", + "include/python3.10/typeslots.h", + "include/python3.10/unicodeobject.h", + "include/python3.10/warnings.h", + "include/python3.10/weakrefobject.h", + "lib/libpython3.10.dylib", + "lib/pkgconfig/python-3.10-embed.pc", + "lib/pkgconfig/python-3.10.pc", + "lib/pkgconfig/python3-embed.pc", + "lib/pkgconfig/python3.pc", + "lib/python3.1", + "lib/python3.10/LICENSE.txt", + "lib/python3.10/__future__.py", + "lib/python3.10/__phello__.foo.py", + "lib/python3.10/__pycache__/__future__.cpython-310.pyc", + "lib/python3.10/__pycache__/__phello__.foo.cpython-310.pyc", + "lib/python3.10/__pycache__/_aix_support.cpython-310.pyc", + "lib/python3.10/__pycache__/_bootsubprocess.cpython-310.pyc", + "lib/python3.10/__pycache__/_collections_abc.cpython-310.pyc", + "lib/python3.10/__pycache__/_compat_pickle.cpython-310.pyc", + "lib/python3.10/__pycache__/_compression.cpython-310.pyc", + "lib/python3.10/__pycache__/_markupbase.cpython-310.pyc", + "lib/python3.10/__pycache__/_osx_support.cpython-310.pyc", + "lib/python3.10/__pycache__/_py_abc.cpython-310.pyc", + "lib/python3.10/__pycache__/_pydecimal.cpython-310.pyc", + "lib/python3.10/__pycache__/_pyio.cpython-310.pyc", + "lib/python3.10/__pycache__/_sitebuiltins.cpython-310.pyc", + "lib/python3.10/__pycache__/_strptime.cpython-310.pyc", + "lib/python3.10/__pycache__/_sysconfigdata__darwin_darwin.cpython-310.pyc", + "lib/python3.10/__pycache__/_sysconfigdata_arm64_apple_darwin20_0_0.cpython-310.pyc", + "lib/python3.10/__pycache__/_threading_local.cpython-310.pyc", + "lib/python3.10/__pycache__/_weakrefset.cpython-310.pyc", + "lib/python3.10/__pycache__/abc.cpython-310.pyc", + "lib/python3.10/__pycache__/aifc.cpython-310.pyc", + "lib/python3.10/__pycache__/antigravity.cpython-310.pyc", + "lib/python3.10/__pycache__/argparse.cpython-310.pyc", + "lib/python3.10/__pycache__/ast.cpython-310.pyc", + "lib/python3.10/__pycache__/asynchat.cpython-310.pyc", + "lib/python3.10/__pycache__/asyncore.cpython-310.pyc", + "lib/python3.10/__pycache__/base64.cpython-310.pyc", + "lib/python3.10/__pycache__/bdb.cpython-310.pyc", + "lib/python3.10/__pycache__/binhex.cpython-310.pyc", + "lib/python3.10/__pycache__/bisect.cpython-310.pyc", + "lib/python3.10/__pycache__/bz2.cpython-310.pyc", + "lib/python3.10/__pycache__/cProfile.cpython-310.pyc", + "lib/python3.10/__pycache__/calendar.cpython-310.pyc", + "lib/python3.10/__pycache__/cgi.cpython-310.pyc", + "lib/python3.10/__pycache__/cgitb.cpython-310.pyc", + "lib/python3.10/__pycache__/chunk.cpython-310.pyc", + "lib/python3.10/__pycache__/cmd.cpython-310.pyc", + "lib/python3.10/__pycache__/code.cpython-310.pyc", + "lib/python3.10/__pycache__/codecs.cpython-310.pyc", + "lib/python3.10/__pycache__/codeop.cpython-310.pyc", + "lib/python3.10/__pycache__/colorsys.cpython-310.pyc", + "lib/python3.10/__pycache__/compileall.cpython-310.pyc", + "lib/python3.10/__pycache__/configparser.cpython-310.pyc", + "lib/python3.10/__pycache__/contextlib.cpython-310.pyc", + "lib/python3.10/__pycache__/contextvars.cpython-310.pyc", + "lib/python3.10/__pycache__/copy.cpython-310.pyc", + "lib/python3.10/__pycache__/copyreg.cpython-310.pyc", + "lib/python3.10/__pycache__/crypt.cpython-310.pyc", + "lib/python3.10/__pycache__/csv.cpython-310.pyc", + "lib/python3.10/__pycache__/dataclasses.cpython-310.pyc", + "lib/python3.10/__pycache__/datetime.cpython-310.pyc", + "lib/python3.10/__pycache__/decimal.cpython-310.pyc", + "lib/python3.10/__pycache__/difflib.cpython-310.pyc", + "lib/python3.10/__pycache__/dis.cpython-310.pyc", + "lib/python3.10/__pycache__/doctest.cpython-310.pyc", + "lib/python3.10/__pycache__/enum.cpython-310.pyc", + "lib/python3.10/__pycache__/filecmp.cpython-310.pyc", + "lib/python3.10/__pycache__/fileinput.cpython-310.pyc", + "lib/python3.10/__pycache__/fnmatch.cpython-310.pyc", + "lib/python3.10/__pycache__/fractions.cpython-310.pyc", + "lib/python3.10/__pycache__/ftplib.cpython-310.pyc", + "lib/python3.10/__pycache__/functools.cpython-310.pyc", + "lib/python3.10/__pycache__/genericpath.cpython-310.pyc", + "lib/python3.10/__pycache__/getopt.cpython-310.pyc", + "lib/python3.10/__pycache__/getpass.cpython-310.pyc", + "lib/python3.10/__pycache__/gettext.cpython-310.pyc", + "lib/python3.10/__pycache__/glob.cpython-310.pyc", + "lib/python3.10/__pycache__/graphlib.cpython-310.pyc", + "lib/python3.10/__pycache__/gzip.cpython-310.pyc", + "lib/python3.10/__pycache__/hashlib.cpython-310.pyc", + "lib/python3.10/__pycache__/heapq.cpython-310.pyc", + "lib/python3.10/__pycache__/hmac.cpython-310.pyc", + "lib/python3.10/__pycache__/imaplib.cpython-310.pyc", + "lib/python3.10/__pycache__/imghdr.cpython-310.pyc", + "lib/python3.10/__pycache__/imp.cpython-310.pyc", + "lib/python3.10/__pycache__/inspect.cpython-310.pyc", + "lib/python3.10/__pycache__/io.cpython-310.pyc", + "lib/python3.10/__pycache__/ipaddress.cpython-310.pyc", + "lib/python3.10/__pycache__/keyword.cpython-310.pyc", + "lib/python3.10/__pycache__/linecache.cpython-310.pyc", + "lib/python3.10/__pycache__/locale.cpython-310.pyc", + "lib/python3.10/__pycache__/lzma.cpython-310.pyc", + "lib/python3.10/__pycache__/mailbox.cpython-310.pyc", + "lib/python3.10/__pycache__/mailcap.cpython-310.pyc", + "lib/python3.10/__pycache__/mimetypes.cpython-310.pyc", + "lib/python3.10/__pycache__/modulefinder.cpython-310.pyc", + "lib/python3.10/__pycache__/netrc.cpython-310.pyc", + "lib/python3.10/__pycache__/nntplib.cpython-310.pyc", + "lib/python3.10/__pycache__/ntpath.cpython-310.pyc", + "lib/python3.10/__pycache__/nturl2path.cpython-310.pyc", + "lib/python3.10/__pycache__/numbers.cpython-310.pyc", + "lib/python3.10/__pycache__/opcode.cpython-310.pyc", + "lib/python3.10/__pycache__/operator.cpython-310.pyc", + "lib/python3.10/__pycache__/optparse.cpython-310.pyc", + "lib/python3.10/__pycache__/os.cpython-310.pyc", + "lib/python3.10/__pycache__/pathlib.cpython-310.pyc", + "lib/python3.10/__pycache__/pdb.cpython-310.pyc", + "lib/python3.10/__pycache__/pickle.cpython-310.pyc", + "lib/python3.10/__pycache__/pickletools.cpython-310.pyc", + "lib/python3.10/__pycache__/pipes.cpython-310.pyc", + "lib/python3.10/__pycache__/pkgutil.cpython-310.pyc", + "lib/python3.10/__pycache__/platform.cpython-310.pyc", + "lib/python3.10/__pycache__/plistlib.cpython-310.pyc", + "lib/python3.10/__pycache__/poplib.cpython-310.pyc", + "lib/python3.10/__pycache__/posixpath.cpython-310.pyc", + "lib/python3.10/__pycache__/pprint.cpython-310.pyc", + "lib/python3.10/__pycache__/profile.cpython-310.pyc", + "lib/python3.10/__pycache__/pstats.cpython-310.pyc", + "lib/python3.10/__pycache__/pty.cpython-310.pyc", + "lib/python3.10/__pycache__/py_compile.cpython-310.pyc", + "lib/python3.10/__pycache__/pyclbr.cpython-310.pyc", + "lib/python3.10/__pycache__/pydoc.cpython-310.pyc", + "lib/python3.10/__pycache__/queue.cpython-310.pyc", + "lib/python3.10/__pycache__/quopri.cpython-310.pyc", + "lib/python3.10/__pycache__/random.cpython-310.pyc", + "lib/python3.10/__pycache__/re.cpython-310.pyc", + "lib/python3.10/__pycache__/reprlib.cpython-310.pyc", + "lib/python3.10/__pycache__/rlcompleter.cpython-310.pyc", + "lib/python3.10/__pycache__/runpy.cpython-310.pyc", + "lib/python3.10/__pycache__/sched.cpython-310.pyc", + "lib/python3.10/__pycache__/secrets.cpython-310.pyc", + "lib/python3.10/__pycache__/selectors.cpython-310.pyc", + "lib/python3.10/__pycache__/shelve.cpython-310.pyc", + "lib/python3.10/__pycache__/shlex.cpython-310.pyc", + "lib/python3.10/__pycache__/shutil.cpython-310.pyc", + "lib/python3.10/__pycache__/signal.cpython-310.pyc", + "lib/python3.10/__pycache__/site.cpython-310.pyc", + "lib/python3.10/__pycache__/smtpd.cpython-310.pyc", + "lib/python3.10/__pycache__/smtplib.cpython-310.pyc", + "lib/python3.10/__pycache__/sndhdr.cpython-310.pyc", + "lib/python3.10/__pycache__/socket.cpython-310.pyc", + "lib/python3.10/__pycache__/socketserver.cpython-310.pyc", + "lib/python3.10/__pycache__/sre_compile.cpython-310.pyc", + "lib/python3.10/__pycache__/sre_constants.cpython-310.pyc", + "lib/python3.10/__pycache__/sre_parse.cpython-310.pyc", + "lib/python3.10/__pycache__/ssl.cpython-310.pyc", + "lib/python3.10/__pycache__/stat.cpython-310.pyc", + "lib/python3.10/__pycache__/statistics.cpython-310.pyc", + "lib/python3.10/__pycache__/string.cpython-310.pyc", + "lib/python3.10/__pycache__/stringprep.cpython-310.pyc", + "lib/python3.10/__pycache__/struct.cpython-310.pyc", + "lib/python3.10/__pycache__/subprocess.cpython-310.pyc", + "lib/python3.10/__pycache__/sunau.cpython-310.pyc", + "lib/python3.10/__pycache__/symtable.cpython-310.pyc", + "lib/python3.10/__pycache__/sysconfig.cpython-310.pyc", + "lib/python3.10/__pycache__/tabnanny.cpython-310.pyc", + "lib/python3.10/__pycache__/tarfile.cpython-310.pyc", + "lib/python3.10/__pycache__/telnetlib.cpython-310.pyc", + "lib/python3.10/__pycache__/tempfile.cpython-310.pyc", + "lib/python3.10/__pycache__/textwrap.cpython-310.pyc", + "lib/python3.10/__pycache__/this.cpython-310.pyc", + "lib/python3.10/__pycache__/threading.cpython-310.pyc", + "lib/python3.10/__pycache__/timeit.cpython-310.pyc", + "lib/python3.10/__pycache__/token.cpython-310.pyc", + "lib/python3.10/__pycache__/tokenize.cpython-310.pyc", + "lib/python3.10/__pycache__/trace.cpython-310.pyc", + "lib/python3.10/__pycache__/traceback.cpython-310.pyc", + "lib/python3.10/__pycache__/tracemalloc.cpython-310.pyc", + "lib/python3.10/__pycache__/tty.cpython-310.pyc", + "lib/python3.10/__pycache__/turtle.cpython-310.pyc", + "lib/python3.10/__pycache__/types.cpython-310.pyc", + "lib/python3.10/__pycache__/typing.cpython-310.pyc", + "lib/python3.10/__pycache__/uu.cpython-310.pyc", + "lib/python3.10/__pycache__/uuid.cpython-310.pyc", + "lib/python3.10/__pycache__/warnings.cpython-310.pyc", + "lib/python3.10/__pycache__/wave.cpython-310.pyc", + "lib/python3.10/__pycache__/weakref.cpython-310.pyc", + "lib/python3.10/__pycache__/webbrowser.cpython-310.pyc", + "lib/python3.10/__pycache__/xdrlib.cpython-310.pyc", + "lib/python3.10/__pycache__/zipapp.cpython-310.pyc", + "lib/python3.10/__pycache__/zipfile.cpython-310.pyc", + "lib/python3.10/__pycache__/zipimport.cpython-310.pyc", + "lib/python3.10/_aix_support.py", + "lib/python3.10/_bootsubprocess.py", + "lib/python3.10/_collections_abc.py", + "lib/python3.10/_compat_pickle.py", + "lib/python3.10/_compression.py", + "lib/python3.10/_markupbase.py", + "lib/python3.10/_osx_support.py", + "lib/python3.10/_py_abc.py", + "lib/python3.10/_pydecimal.py", + "lib/python3.10/_pyio.py", + "lib/python3.10/_sitebuiltins.py", + "lib/python3.10/_strptime.py", + "lib/python3.10/_sysconfigdata__darwin_darwin.py", + "lib/python3.10/_sysconfigdata__darwin_darwin.py.orig", + "lib/python3.10/_sysconfigdata_arm64_apple_darwin20_0_0.py", + "lib/python3.10/_threading_local.py", + "lib/python3.10/_weakrefset.py", + "lib/python3.10/abc.py", + "lib/python3.10/aifc.py", + "lib/python3.10/antigravity.py", + "lib/python3.10/argparse.py", + "lib/python3.10/ast.py", + "lib/python3.10/asynchat.py", + "lib/python3.10/asyncio/__init__.py", + "lib/python3.10/asyncio/__main__.py", + "lib/python3.10/asyncio/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/__main__.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/base_events.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/base_futures.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/base_subprocess.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/base_tasks.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/constants.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/coroutines.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/events.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/exceptions.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/format_helpers.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/futures.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/locks.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/log.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/mixins.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/proactor_events.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/protocols.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/queues.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/runners.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/selector_events.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/sslproto.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/staggered.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/streams.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/subprocess.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/tasks.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/threads.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/transports.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/trsock.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/unix_events.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/windows_events.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/windows_utils.cpython-310.pyc", + "lib/python3.10/asyncio/base_events.py", + "lib/python3.10/asyncio/base_futures.py", + "lib/python3.10/asyncio/base_subprocess.py", + "lib/python3.10/asyncio/base_tasks.py", + "lib/python3.10/asyncio/constants.py", + "lib/python3.10/asyncio/coroutines.py", + "lib/python3.10/asyncio/events.py", + "lib/python3.10/asyncio/exceptions.py", + "lib/python3.10/asyncio/format_helpers.py", + "lib/python3.10/asyncio/futures.py", + "lib/python3.10/asyncio/locks.py", + "lib/python3.10/asyncio/log.py", + "lib/python3.10/asyncio/mixins.py", + "lib/python3.10/asyncio/proactor_events.py", + "lib/python3.10/asyncio/protocols.py", + "lib/python3.10/asyncio/queues.py", + "lib/python3.10/asyncio/runners.py", + "lib/python3.10/asyncio/selector_events.py", + "lib/python3.10/asyncio/sslproto.py", + "lib/python3.10/asyncio/staggered.py", + "lib/python3.10/asyncio/streams.py", + "lib/python3.10/asyncio/subprocess.py", + "lib/python3.10/asyncio/tasks.py", + "lib/python3.10/asyncio/threads.py", + "lib/python3.10/asyncio/transports.py", + "lib/python3.10/asyncio/trsock.py", + "lib/python3.10/asyncio/unix_events.py", + "lib/python3.10/asyncio/windows_events.py", + "lib/python3.10/asyncio/windows_utils.py", + "lib/python3.10/asyncore.py", + "lib/python3.10/base64.py", + "lib/python3.10/bdb.py", + "lib/python3.10/binhex.py", + "lib/python3.10/bisect.py", + "lib/python3.10/bz2.py", + "lib/python3.10/cProfile.py", + "lib/python3.10/calendar.py", + "lib/python3.10/cgi.py", + "lib/python3.10/cgitb.py", + "lib/python3.10/chunk.py", + "lib/python3.10/cmd.py", + "lib/python3.10/code.py", + "lib/python3.10/codecs.py", + "lib/python3.10/codeop.py", + "lib/python3.10/collections/__init__.py", + "lib/python3.10/collections/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/collections/__pycache__/abc.cpython-310.pyc", + "lib/python3.10/collections/abc.py", + "lib/python3.10/colorsys.py", + "lib/python3.10/compileall.py", + "lib/python3.10/concurrent/__init__.py", + "lib/python3.10/concurrent/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/concurrent/futures/__init__.py", + "lib/python3.10/concurrent/futures/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/concurrent/futures/__pycache__/_base.cpython-310.pyc", + "lib/python3.10/concurrent/futures/__pycache__/process.cpython-310.pyc", + "lib/python3.10/concurrent/futures/__pycache__/thread.cpython-310.pyc", + "lib/python3.10/concurrent/futures/_base.py", + "lib/python3.10/concurrent/futures/process.py", + "lib/python3.10/concurrent/futures/thread.py", + "lib/python3.10/config-3.10-darwin/Makefile", + "lib/python3.10/config-3.10-darwin/Setup", + "lib/python3.10/config-3.10-darwin/Setup.local", + "lib/python3.10/config-3.10-darwin/__pycache__/python-config.cpython-310.pyc", + "lib/python3.10/config-3.10-darwin/config.c", + "lib/python3.10/config-3.10-darwin/config.c.in", + "lib/python3.10/config-3.10-darwin/install-sh", + "lib/python3.10/config-3.10-darwin/makesetup", + "lib/python3.10/config-3.10-darwin/python-config.py", + "lib/python3.10/config-3.10-darwin/python.o", + "lib/python3.10/configparser.py", + "lib/python3.10/contextlib.py", + "lib/python3.10/contextvars.py", + "lib/python3.10/copy.py", + "lib/python3.10/copyreg.py", + "lib/python3.10/crypt.py", + "lib/python3.10/csv.py", + "lib/python3.10/ctypes/__init__.py", + "lib/python3.10/ctypes/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/ctypes/__pycache__/_aix.cpython-310.pyc", + "lib/python3.10/ctypes/__pycache__/_endian.cpython-310.pyc", + "lib/python3.10/ctypes/__pycache__/util.cpython-310.pyc", + "lib/python3.10/ctypes/__pycache__/wintypes.cpython-310.pyc", + "lib/python3.10/ctypes/_aix.py", + "lib/python3.10/ctypes/_endian.py", + "lib/python3.10/ctypes/macholib/README.ctypes", + "lib/python3.10/ctypes/macholib/__init__.py", + "lib/python3.10/ctypes/macholib/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/ctypes/macholib/__pycache__/dyld.cpython-310.pyc", + "lib/python3.10/ctypes/macholib/__pycache__/dylib.cpython-310.pyc", + "lib/python3.10/ctypes/macholib/__pycache__/framework.cpython-310.pyc", + "lib/python3.10/ctypes/macholib/dyld.py", + "lib/python3.10/ctypes/macholib/dylib.py", + "lib/python3.10/ctypes/macholib/fetch_macholib", + "lib/python3.10/ctypes/macholib/fetch_macholib.bat", + "lib/python3.10/ctypes/macholib/framework.py", + "lib/python3.10/ctypes/util.py", + "lib/python3.10/ctypes/wintypes.py", + "lib/python3.10/curses/__init__.py", + "lib/python3.10/curses/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/curses/__pycache__/ascii.cpython-310.pyc", + "lib/python3.10/curses/__pycache__/has_key.cpython-310.pyc", + "lib/python3.10/curses/__pycache__/panel.cpython-310.pyc", + "lib/python3.10/curses/__pycache__/textpad.cpython-310.pyc", + "lib/python3.10/curses/ascii.py", + "lib/python3.10/curses/has_key.py", + "lib/python3.10/curses/panel.py", + "lib/python3.10/curses/textpad.py", + "lib/python3.10/dataclasses.py", + "lib/python3.10/datetime.py", + "lib/python3.10/dbm/__init__.py", + "lib/python3.10/dbm/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/dbm/__pycache__/dumb.cpython-310.pyc", + "lib/python3.10/dbm/__pycache__/gnu.cpython-310.pyc", + "lib/python3.10/dbm/__pycache__/ndbm.cpython-310.pyc", + "lib/python3.10/dbm/dumb.py", + "lib/python3.10/dbm/gnu.py", + "lib/python3.10/dbm/ndbm.py", + "lib/python3.10/decimal.py", + "lib/python3.10/difflib.py", + "lib/python3.10/dis.py", + "lib/python3.10/distutils/README", + "lib/python3.10/distutils/__init__.py", + "lib/python3.10/distutils/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/_msvccompiler.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/archive_util.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/bcppcompiler.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/ccompiler.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/cmd.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/config.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/core.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/cygwinccompiler.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/debug.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/dep_util.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/dir_util.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/dist.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/errors.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/extension.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/fancy_getopt.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/file_util.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/filelist.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/log.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/msvc9compiler.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/msvccompiler.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/spawn.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/sysconfig.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/text_file.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/unixccompiler.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/util.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/version.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/versionpredicate.cpython-310.pyc", + "lib/python3.10/distutils/_msvccompiler.py", + "lib/python3.10/distutils/archive_util.py", + "lib/python3.10/distutils/bcppcompiler.py", + "lib/python3.10/distutils/ccompiler.py", + "lib/python3.10/distutils/cmd.py", + "lib/python3.10/distutils/command/__init__.py", + "lib/python3.10/distutils/command/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/distutils/command/__pycache__/bdist.cpython-310.pyc", + "lib/python3.10/distutils/command/__pycache__/bdist_dumb.cpython-310.pyc", + "lib/python3.10/distutils/command/__pycache__/bdist_msi.cpython-310.pyc", + "lib/python3.10/distutils/command/__pycache__/bdist_rpm.cpython-310.pyc", + "lib/python3.10/distutils/command/__pycache__/build.cpython-310.pyc", + "lib/python3.10/distutils/command/__pycache__/build_clib.cpython-310.pyc", + "lib/python3.10/distutils/command/__pycache__/build_ext.cpython-310.pyc", + "lib/python3.10/distutils/command/__pycache__/build_py.cpython-310.pyc", + "lib/python3.10/distutils/command/__pycache__/build_scripts.cpython-310.pyc", + "lib/python3.10/distutils/command/__pycache__/check.cpython-310.pyc", + "lib/python3.10/distutils/command/__pycache__/clean.cpython-310.pyc", + "lib/python3.10/distutils/command/__pycache__/config.cpython-310.pyc", + "lib/python3.10/distutils/command/__pycache__/install.cpython-310.pyc", + "lib/python3.10/distutils/command/__pycache__/install_data.cpython-310.pyc", + "lib/python3.10/distutils/command/__pycache__/install_egg_info.cpython-310.pyc", + "lib/python3.10/distutils/command/__pycache__/install_headers.cpython-310.pyc", + "lib/python3.10/distutils/command/__pycache__/install_lib.cpython-310.pyc", + "lib/python3.10/distutils/command/__pycache__/install_scripts.cpython-310.pyc", + "lib/python3.10/distutils/command/__pycache__/register.cpython-310.pyc", + "lib/python3.10/distutils/command/__pycache__/sdist.cpython-310.pyc", + "lib/python3.10/distutils/command/__pycache__/upload.cpython-310.pyc", + "lib/python3.10/distutils/command/bdist.py", + "lib/python3.10/distutils/command/bdist_dumb.py", + "lib/python3.10/distutils/command/bdist_msi.py", + "lib/python3.10/distutils/command/bdist_rpm.py", + "lib/python3.10/distutils/command/build.py", + "lib/python3.10/distutils/command/build_clib.py", + "lib/python3.10/distutils/command/build_ext.py", + "lib/python3.10/distutils/command/build_py.py", + "lib/python3.10/distutils/command/build_scripts.py", + "lib/python3.10/distutils/command/check.py", + "lib/python3.10/distutils/command/clean.py", + "lib/python3.10/distutils/command/command_template", + "lib/python3.10/distutils/command/config.py", + "lib/python3.10/distutils/command/install.py", + "lib/python3.10/distutils/command/install_data.py", + "lib/python3.10/distutils/command/install_egg_info.py", + "lib/python3.10/distutils/command/install_headers.py", + "lib/python3.10/distutils/command/install_lib.py", + "lib/python3.10/distutils/command/install_scripts.py", + "lib/python3.10/distutils/command/register.py", + "lib/python3.10/distutils/command/sdist.py", + "lib/python3.10/distutils/command/upload.py", + "lib/python3.10/distutils/config.py", + "lib/python3.10/distutils/core.py", + "lib/python3.10/distutils/cygwinccompiler.py", + "lib/python3.10/distutils/debug.py", + "lib/python3.10/distutils/dep_util.py", + "lib/python3.10/distutils/dir_util.py", + "lib/python3.10/distutils/dist.py", + "lib/python3.10/distutils/errors.py", + "lib/python3.10/distutils/extension.py", + "lib/python3.10/distutils/fancy_getopt.py", + "lib/python3.10/distutils/file_util.py", + "lib/python3.10/distutils/filelist.py", + "lib/python3.10/distutils/log.py", + "lib/python3.10/distutils/msvc9compiler.py", + "lib/python3.10/distutils/msvccompiler.py", + "lib/python3.10/distutils/spawn.py", + "lib/python3.10/distutils/sysconfig.py", + "lib/python3.10/distutils/tests/Setup.sample", + "lib/python3.10/distutils/tests/__init__.py", + "lib/python3.10/distutils/tests/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/support.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_archive_util.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_bdist.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_bdist_dumb.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_bdist_msi.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_bdist_rpm.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_build.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_build_clib.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_build_ext.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_build_py.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_build_scripts.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_check.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_clean.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_cmd.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_config.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_config_cmd.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_core.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_cygwinccompiler.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_dep_util.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_dir_util.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_dist.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_extension.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_file_util.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_filelist.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_install.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_install_data.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_install_headers.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_install_lib.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_install_scripts.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_log.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_msvc9compiler.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_msvccompiler.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_register.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_sdist.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_spawn.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_sysconfig.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_text_file.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_unixccompiler.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_upload.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_util.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_version.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_versionpredicate.cpython-310.pyc", + "lib/python3.10/distutils/tests/includetest.rst", + "lib/python3.10/distutils/tests/support.py", + "lib/python3.10/distutils/tests/test_archive_util.py", + "lib/python3.10/distutils/tests/test_bdist.py", + "lib/python3.10/distutils/tests/test_bdist_dumb.py", + "lib/python3.10/distutils/tests/test_bdist_msi.py", + "lib/python3.10/distutils/tests/test_bdist_rpm.py", + "lib/python3.10/distutils/tests/test_build.py", + "lib/python3.10/distutils/tests/test_build_clib.py", + "lib/python3.10/distutils/tests/test_build_ext.py", + "lib/python3.10/distutils/tests/test_build_py.py", + "lib/python3.10/distutils/tests/test_build_scripts.py", + "lib/python3.10/distutils/tests/test_check.py", + "lib/python3.10/distutils/tests/test_clean.py", + "lib/python3.10/distutils/tests/test_cmd.py", + "lib/python3.10/distutils/tests/test_config.py", + "lib/python3.10/distutils/tests/test_config_cmd.py", + "lib/python3.10/distutils/tests/test_core.py", + "lib/python3.10/distutils/tests/test_cygwinccompiler.py", + "lib/python3.10/distutils/tests/test_dep_util.py", + "lib/python3.10/distutils/tests/test_dir_util.py", + "lib/python3.10/distutils/tests/test_dist.py", + "lib/python3.10/distutils/tests/test_extension.py", + "lib/python3.10/distutils/tests/test_file_util.py", + "lib/python3.10/distutils/tests/test_filelist.py", + "lib/python3.10/distutils/tests/test_install.py", + "lib/python3.10/distutils/tests/test_install_data.py", + "lib/python3.10/distutils/tests/test_install_headers.py", + "lib/python3.10/distutils/tests/test_install_lib.py", + "lib/python3.10/distutils/tests/test_install_scripts.py", + "lib/python3.10/distutils/tests/test_log.py", + "lib/python3.10/distutils/tests/test_msvc9compiler.py", + "lib/python3.10/distutils/tests/test_msvccompiler.py", + "lib/python3.10/distutils/tests/test_register.py", + "lib/python3.10/distutils/tests/test_sdist.py", + "lib/python3.10/distutils/tests/test_spawn.py", + "lib/python3.10/distutils/tests/test_sysconfig.py", + "lib/python3.10/distutils/tests/test_text_file.py", + "lib/python3.10/distutils/tests/test_unixccompiler.py", + "lib/python3.10/distutils/tests/test_upload.py", + "lib/python3.10/distutils/tests/test_util.py", + "lib/python3.10/distutils/tests/test_version.py", + "lib/python3.10/distutils/tests/test_versionpredicate.py", + "lib/python3.10/distutils/tests/xxmodule.c", + "lib/python3.10/distutils/text_file.py", + "lib/python3.10/distutils/unixccompiler.py", + "lib/python3.10/distutils/util.py", + "lib/python3.10/distutils/version.py", + "lib/python3.10/distutils/versionpredicate.py", + "lib/python3.10/doctest.py", + "lib/python3.10/email/__init__.py", + "lib/python3.10/email/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/email/__pycache__/_encoded_words.cpython-310.pyc", + "lib/python3.10/email/__pycache__/_header_value_parser.cpython-310.pyc", + "lib/python3.10/email/__pycache__/_parseaddr.cpython-310.pyc", + "lib/python3.10/email/__pycache__/_policybase.cpython-310.pyc", + "lib/python3.10/email/__pycache__/base64mime.cpython-310.pyc", + "lib/python3.10/email/__pycache__/charset.cpython-310.pyc", + "lib/python3.10/email/__pycache__/contentmanager.cpython-310.pyc", + "lib/python3.10/email/__pycache__/encoders.cpython-310.pyc", + "lib/python3.10/email/__pycache__/errors.cpython-310.pyc", + "lib/python3.10/email/__pycache__/feedparser.cpython-310.pyc", + "lib/python3.10/email/__pycache__/generator.cpython-310.pyc", + "lib/python3.10/email/__pycache__/header.cpython-310.pyc", + "lib/python3.10/email/__pycache__/headerregistry.cpython-310.pyc", + "lib/python3.10/email/__pycache__/iterators.cpython-310.pyc", + "lib/python3.10/email/__pycache__/message.cpython-310.pyc", + "lib/python3.10/email/__pycache__/parser.cpython-310.pyc", + "lib/python3.10/email/__pycache__/policy.cpython-310.pyc", + "lib/python3.10/email/__pycache__/quoprimime.cpython-310.pyc", + "lib/python3.10/email/__pycache__/utils.cpython-310.pyc", + "lib/python3.10/email/_encoded_words.py", + "lib/python3.10/email/_header_value_parser.py", + "lib/python3.10/email/_parseaddr.py", + "lib/python3.10/email/_policybase.py", + "lib/python3.10/email/architecture.rst", + "lib/python3.10/email/base64mime.py", + "lib/python3.10/email/charset.py", + "lib/python3.10/email/contentmanager.py", + "lib/python3.10/email/encoders.py", + "lib/python3.10/email/errors.py", + "lib/python3.10/email/feedparser.py", + "lib/python3.10/email/generator.py", + "lib/python3.10/email/header.py", + "lib/python3.10/email/headerregistry.py", + "lib/python3.10/email/iterators.py", + "lib/python3.10/email/message.py", + "lib/python3.10/email/mime/__init__.py", + "lib/python3.10/email/mime/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/email/mime/__pycache__/application.cpython-310.pyc", + "lib/python3.10/email/mime/__pycache__/audio.cpython-310.pyc", + "lib/python3.10/email/mime/__pycache__/base.cpython-310.pyc", + "lib/python3.10/email/mime/__pycache__/image.cpython-310.pyc", + "lib/python3.10/email/mime/__pycache__/message.cpython-310.pyc", + "lib/python3.10/email/mime/__pycache__/multipart.cpython-310.pyc", + "lib/python3.10/email/mime/__pycache__/nonmultipart.cpython-310.pyc", + "lib/python3.10/email/mime/__pycache__/text.cpython-310.pyc", + "lib/python3.10/email/mime/application.py", + "lib/python3.10/email/mime/audio.py", + "lib/python3.10/email/mime/base.py", + "lib/python3.10/email/mime/image.py", + "lib/python3.10/email/mime/message.py", + "lib/python3.10/email/mime/multipart.py", + "lib/python3.10/email/mime/nonmultipart.py", + "lib/python3.10/email/mime/text.py", + "lib/python3.10/email/parser.py", + "lib/python3.10/email/policy.py", + "lib/python3.10/email/quoprimime.py", + "lib/python3.10/email/utils.py", + "lib/python3.10/encodings/__init__.py", + "lib/python3.10/encodings/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/aliases.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/ascii.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/base64_codec.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/big5.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/big5hkscs.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/bz2_codec.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/charmap.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp037.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp1006.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp1026.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp1125.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp1140.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp1250.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp1251.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp1252.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp1253.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp1254.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp1255.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp1256.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp1257.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp1258.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp273.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp424.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp437.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp500.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp720.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp737.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp775.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp850.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp852.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp855.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp856.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp857.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp858.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp860.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp861.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp862.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp863.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp864.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp865.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp866.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp869.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp874.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp875.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp932.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp949.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp950.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/euc_jis_2004.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/euc_jisx0213.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/euc_jp.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/euc_kr.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/gb18030.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/gb2312.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/gbk.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/hex_codec.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/hp_roman8.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/hz.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/idna.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/iso2022_jp.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/iso2022_jp_1.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/iso2022_jp_2.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/iso2022_jp_2004.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/iso2022_jp_3.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/iso2022_jp_ext.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/iso2022_kr.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/iso8859_1.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/iso8859_10.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/iso8859_11.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/iso8859_13.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/iso8859_14.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/iso8859_15.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/iso8859_16.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/iso8859_2.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/iso8859_3.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/iso8859_4.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/iso8859_5.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/iso8859_6.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/iso8859_7.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/iso8859_8.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/iso8859_9.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/johab.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/koi8_r.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/koi8_t.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/koi8_u.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/kz1048.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/latin_1.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/mac_arabic.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/mac_croatian.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/mac_cyrillic.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/mac_farsi.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/mac_greek.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/mac_iceland.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/mac_latin2.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/mac_roman.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/mac_romanian.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/mac_turkish.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/mbcs.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/oem.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/palmos.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/ptcp154.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/punycode.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/quopri_codec.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/raw_unicode_escape.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/rot_13.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/shift_jis.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/shift_jis_2004.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/shift_jisx0213.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/tis_620.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/undefined.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/unicode_escape.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/utf_16.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/utf_16_be.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/utf_16_le.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/utf_32.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/utf_32_be.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/utf_32_le.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/utf_7.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/utf_8.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/utf_8_sig.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/uu_codec.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/zlib_codec.cpython-310.pyc", + "lib/python3.10/encodings/aliases.py", + "lib/python3.10/encodings/ascii.py", + "lib/python3.10/encodings/base64_codec.py", + "lib/python3.10/encodings/big5.py", + "lib/python3.10/encodings/big5hkscs.py", + "lib/python3.10/encodings/bz2_codec.py", + "lib/python3.10/encodings/charmap.py", + "lib/python3.10/encodings/cp037.py", + "lib/python3.10/encodings/cp1006.py", + "lib/python3.10/encodings/cp1026.py", + "lib/python3.10/encodings/cp1125.py", + "lib/python3.10/encodings/cp1140.py", + "lib/python3.10/encodings/cp1250.py", + "lib/python3.10/encodings/cp1251.py", + "lib/python3.10/encodings/cp1252.py", + "lib/python3.10/encodings/cp1253.py", + "lib/python3.10/encodings/cp1254.py", + "lib/python3.10/encodings/cp1255.py", + "lib/python3.10/encodings/cp1256.py", + "lib/python3.10/encodings/cp1257.py", + "lib/python3.10/encodings/cp1258.py", + "lib/python3.10/encodings/cp273.py", + "lib/python3.10/encodings/cp424.py", + "lib/python3.10/encodings/cp437.py", + "lib/python3.10/encodings/cp500.py", + "lib/python3.10/encodings/cp720.py", + "lib/python3.10/encodings/cp737.py", + "lib/python3.10/encodings/cp775.py", + "lib/python3.10/encodings/cp850.py", + "lib/python3.10/encodings/cp852.py", + "lib/python3.10/encodings/cp855.py", + "lib/python3.10/encodings/cp856.py", + "lib/python3.10/encodings/cp857.py", + "lib/python3.10/encodings/cp858.py", + "lib/python3.10/encodings/cp860.py", + "lib/python3.10/encodings/cp861.py", + "lib/python3.10/encodings/cp862.py", + "lib/python3.10/encodings/cp863.py", + "lib/python3.10/encodings/cp864.py", + "lib/python3.10/encodings/cp865.py", + "lib/python3.10/encodings/cp866.py", + "lib/python3.10/encodings/cp869.py", + "lib/python3.10/encodings/cp874.py", + "lib/python3.10/encodings/cp875.py", + "lib/python3.10/encodings/cp932.py", + "lib/python3.10/encodings/cp949.py", + "lib/python3.10/encodings/cp950.py", + "lib/python3.10/encodings/euc_jis_2004.py", + "lib/python3.10/encodings/euc_jisx0213.py", + "lib/python3.10/encodings/euc_jp.py", + "lib/python3.10/encodings/euc_kr.py", + "lib/python3.10/encodings/gb18030.py", + "lib/python3.10/encodings/gb2312.py", + "lib/python3.10/encodings/gbk.py", + "lib/python3.10/encodings/hex_codec.py", + "lib/python3.10/encodings/hp_roman8.py", + "lib/python3.10/encodings/hz.py", + "lib/python3.10/encodings/idna.py", + "lib/python3.10/encodings/iso2022_jp.py", + "lib/python3.10/encodings/iso2022_jp_1.py", + "lib/python3.10/encodings/iso2022_jp_2.py", + "lib/python3.10/encodings/iso2022_jp_2004.py", + "lib/python3.10/encodings/iso2022_jp_3.py", + "lib/python3.10/encodings/iso2022_jp_ext.py", + "lib/python3.10/encodings/iso2022_kr.py", + "lib/python3.10/encodings/iso8859_1.py", + "lib/python3.10/encodings/iso8859_10.py", + "lib/python3.10/encodings/iso8859_11.py", + "lib/python3.10/encodings/iso8859_13.py", + "lib/python3.10/encodings/iso8859_14.py", + "lib/python3.10/encodings/iso8859_15.py", + "lib/python3.10/encodings/iso8859_16.py", + "lib/python3.10/encodings/iso8859_2.py", + "lib/python3.10/encodings/iso8859_3.py", + "lib/python3.10/encodings/iso8859_4.py", + "lib/python3.10/encodings/iso8859_5.py", + "lib/python3.10/encodings/iso8859_6.py", + "lib/python3.10/encodings/iso8859_7.py", + "lib/python3.10/encodings/iso8859_8.py", + "lib/python3.10/encodings/iso8859_9.py", + "lib/python3.10/encodings/johab.py", + "lib/python3.10/encodings/koi8_r.py", + "lib/python3.10/encodings/koi8_t.py", + "lib/python3.10/encodings/koi8_u.py", + "lib/python3.10/encodings/kz1048.py", + "lib/python3.10/encodings/latin_1.py", + "lib/python3.10/encodings/mac_arabic.py", + "lib/python3.10/encodings/mac_croatian.py", + "lib/python3.10/encodings/mac_cyrillic.py", + "lib/python3.10/encodings/mac_farsi.py", + "lib/python3.10/encodings/mac_greek.py", + "lib/python3.10/encodings/mac_iceland.py", + "lib/python3.10/encodings/mac_latin2.py", + "lib/python3.10/encodings/mac_roman.py", + "lib/python3.10/encodings/mac_romanian.py", + "lib/python3.10/encodings/mac_turkish.py", + "lib/python3.10/encodings/mbcs.py", + "lib/python3.10/encodings/oem.py", + "lib/python3.10/encodings/palmos.py", + "lib/python3.10/encodings/ptcp154.py", + "lib/python3.10/encodings/punycode.py", + "lib/python3.10/encodings/quopri_codec.py", + "lib/python3.10/encodings/raw_unicode_escape.py", + "lib/python3.10/encodings/rot_13.py", + "lib/python3.10/encodings/shift_jis.py", + "lib/python3.10/encodings/shift_jis_2004.py", + "lib/python3.10/encodings/shift_jisx0213.py", + "lib/python3.10/encodings/tis_620.py", + "lib/python3.10/encodings/undefined.py", + "lib/python3.10/encodings/unicode_escape.py", + "lib/python3.10/encodings/utf_16.py", + "lib/python3.10/encodings/utf_16_be.py", + "lib/python3.10/encodings/utf_16_le.py", + "lib/python3.10/encodings/utf_32.py", + "lib/python3.10/encodings/utf_32_be.py", + "lib/python3.10/encodings/utf_32_le.py", + "lib/python3.10/encodings/utf_7.py", + "lib/python3.10/encodings/utf_8.py", + "lib/python3.10/encodings/utf_8_sig.py", + "lib/python3.10/encodings/uu_codec.py", + "lib/python3.10/encodings/zlib_codec.py", + "lib/python3.10/ensurepip/__init__.py", + "lib/python3.10/ensurepip/__main__.py", + "lib/python3.10/ensurepip/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/ensurepip/__pycache__/__main__.cpython-310.pyc", + "lib/python3.10/ensurepip/__pycache__/_uninstall.cpython-310.pyc", + "lib/python3.10/ensurepip/_bundled/__init__.py", + "lib/python3.10/ensurepip/_bundled/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/ensurepip/_bundled/pip-22.3.1-py3-none-any.whl", + "lib/python3.10/ensurepip/_bundled/setuptools-65.5.0-py3-none-any.whl", + "lib/python3.10/ensurepip/_uninstall.py", + "lib/python3.10/enum.py", + "lib/python3.10/filecmp.py", + "lib/python3.10/fileinput.py", + "lib/python3.10/fnmatch.py", + "lib/python3.10/fractions.py", + "lib/python3.10/ftplib.py", + "lib/python3.10/functools.py", + "lib/python3.10/genericpath.py", + "lib/python3.10/getopt.py", + "lib/python3.10/getpass.py", + "lib/python3.10/gettext.py", + "lib/python3.10/glob.py", + "lib/python3.10/graphlib.py", + "lib/python3.10/gzip.py", + "lib/python3.10/hashlib.py", + "lib/python3.10/heapq.py", + "lib/python3.10/hmac.py", + "lib/python3.10/html/__init__.py", + "lib/python3.10/html/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/html/__pycache__/entities.cpython-310.pyc", + "lib/python3.10/html/__pycache__/parser.cpython-310.pyc", + "lib/python3.10/html/entities.py", + "lib/python3.10/html/parser.py", + "lib/python3.10/http/__init__.py", + "lib/python3.10/http/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/http/__pycache__/client.cpython-310.pyc", + "lib/python3.10/http/__pycache__/cookiejar.cpython-310.pyc", + "lib/python3.10/http/__pycache__/cookies.cpython-310.pyc", + "lib/python3.10/http/__pycache__/server.cpython-310.pyc", + "lib/python3.10/http/client.py", + "lib/python3.10/http/cookiejar.py", + "lib/python3.10/http/cookies.py", + "lib/python3.10/http/server.py", + "lib/python3.10/idlelib/CREDITS.txt", + "lib/python3.10/idlelib/ChangeLog", + "lib/python3.10/idlelib/HISTORY.txt", + "lib/python3.10/idlelib/Icons/README.txt", + "lib/python3.10/idlelib/Icons/folder.gif", + "lib/python3.10/idlelib/Icons/idle.ico", + "lib/python3.10/idlelib/Icons/idle_16.gif", + "lib/python3.10/idlelib/Icons/idle_16.png", + "lib/python3.10/idlelib/Icons/idle_256.png", + "lib/python3.10/idlelib/Icons/idle_32.gif", + "lib/python3.10/idlelib/Icons/idle_32.png", + "lib/python3.10/idlelib/Icons/idle_48.gif", + "lib/python3.10/idlelib/Icons/idle_48.png", + "lib/python3.10/idlelib/Icons/minusnode.gif", + "lib/python3.10/idlelib/Icons/openfolder.gif", + "lib/python3.10/idlelib/Icons/plusnode.gif", + "lib/python3.10/idlelib/Icons/python.gif", + "lib/python3.10/idlelib/Icons/tk.gif", + "lib/python3.10/idlelib/NEWS.txt", + "lib/python3.10/idlelib/NEWS2x.txt", + "lib/python3.10/idlelib/README.txt", + "lib/python3.10/idlelib/TODO.txt", + "lib/python3.10/idlelib/__init__.py", + "lib/python3.10/idlelib/__main__.py", + "lib/python3.10/idlelib/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/__main__.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/autocomplete.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/autocomplete_w.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/autoexpand.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/browser.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/calltip.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/calltip_w.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/codecontext.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/colorizer.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/config.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/config_key.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/configdialog.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/debugger.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/debugger_r.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/debugobj.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/debugobj_r.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/delegator.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/dynoption.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/editor.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/filelist.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/format.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/grep.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/help.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/help_about.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/history.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/hyperparser.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/idle.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/iomenu.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/macosx.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/mainmenu.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/multicall.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/outwin.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/parenmatch.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/pathbrowser.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/percolator.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/pyparse.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/pyshell.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/query.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/redirector.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/replace.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/rpc.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/run.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/runscript.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/scrolledlist.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/search.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/searchbase.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/searchengine.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/sidebar.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/squeezer.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/stackviewer.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/statusbar.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/textview.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/tooltip.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/tree.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/undo.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/util.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/window.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/zoomheight.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/zzdummy.cpython-310.pyc", + "lib/python3.10/idlelib/autocomplete.py", + "lib/python3.10/idlelib/autocomplete_w.py", + "lib/python3.10/idlelib/autoexpand.py", + "lib/python3.10/idlelib/browser.py", + "lib/python3.10/idlelib/calltip.py", + "lib/python3.10/idlelib/calltip_w.py", + "lib/python3.10/idlelib/codecontext.py", + "lib/python3.10/idlelib/colorizer.py", + "lib/python3.10/idlelib/config-extensions.def", + "lib/python3.10/idlelib/config-highlight.def", + "lib/python3.10/idlelib/config-keys.def", + "lib/python3.10/idlelib/config-main.def", + "lib/python3.10/idlelib/config.py", + "lib/python3.10/idlelib/config_key.py", + "lib/python3.10/idlelib/configdialog.py", + "lib/python3.10/idlelib/debugger.py", + "lib/python3.10/idlelib/debugger_r.py", + "lib/python3.10/idlelib/debugobj.py", + "lib/python3.10/idlelib/debugobj_r.py", + "lib/python3.10/idlelib/delegator.py", + "lib/python3.10/idlelib/dynoption.py", + "lib/python3.10/idlelib/editor.py", + "lib/python3.10/idlelib/extend.txt", + "lib/python3.10/idlelib/filelist.py", + "lib/python3.10/idlelib/format.py", + "lib/python3.10/idlelib/grep.py", + "lib/python3.10/idlelib/help.html", + "lib/python3.10/idlelib/help.py", + "lib/python3.10/idlelib/help_about.py", + "lib/python3.10/idlelib/history.py", + "lib/python3.10/idlelib/hyperparser.py", + "lib/python3.10/idlelib/idle.bat", + "lib/python3.10/idlelib/idle.py", + "lib/python3.10/idlelib/idle.pyw", + "lib/python3.10/idlelib/idle_test/README.txt", + "lib/python3.10/idlelib/idle_test/__init__.py", + "lib/python3.10/idlelib/idle_test/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/htest.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/mock_idle.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/mock_tk.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/template.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_autocomplete.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_autocomplete_w.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_autoexpand.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_browser.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_calltip.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_calltip_w.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_codecontext.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_colorizer.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_config.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_config_key.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_configdialog.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_debugger.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_debugger_r.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_debugobj.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_debugobj_r.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_delegator.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_editmenu.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_editor.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_filelist.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_format.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_grep.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_help.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_help_about.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_history.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_hyperparser.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_iomenu.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_macosx.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_mainmenu.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_multicall.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_outwin.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_parenmatch.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_pathbrowser.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_percolator.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_pyparse.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_pyshell.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_query.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_redirector.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_replace.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_rpc.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_run.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_runscript.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_scrolledlist.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_search.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_searchbase.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_searchengine.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_sidebar.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_squeezer.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_stackviewer.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_statusbar.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_text.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_textview.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_tooltip.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_tree.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_undo.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_util.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_warning.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_window.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_zoomheight.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_zzdummy.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/tkinter_testing_utils.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/example_noext", + "lib/python3.10/idlelib/idle_test/example_stub.pyi", + "lib/python3.10/idlelib/idle_test/htest.py", + "lib/python3.10/idlelib/idle_test/mock_idle.py", + "lib/python3.10/idlelib/idle_test/mock_tk.py", + "lib/python3.10/idlelib/idle_test/template.py", + "lib/python3.10/idlelib/idle_test/test_autocomplete.py", + "lib/python3.10/idlelib/idle_test/test_autocomplete_w.py", + "lib/python3.10/idlelib/idle_test/test_autoexpand.py", + "lib/python3.10/idlelib/idle_test/test_browser.py", + "lib/python3.10/idlelib/idle_test/test_calltip.py", + "lib/python3.10/idlelib/idle_test/test_calltip_w.py", + "lib/python3.10/idlelib/idle_test/test_codecontext.py", + "lib/python3.10/idlelib/idle_test/test_colorizer.py", + "lib/python3.10/idlelib/idle_test/test_config.py", + "lib/python3.10/idlelib/idle_test/test_config_key.py", + "lib/python3.10/idlelib/idle_test/test_configdialog.py", + "lib/python3.10/idlelib/idle_test/test_debugger.py", + "lib/python3.10/idlelib/idle_test/test_debugger_r.py", + "lib/python3.10/idlelib/idle_test/test_debugobj.py", + "lib/python3.10/idlelib/idle_test/test_debugobj_r.py", + "lib/python3.10/idlelib/idle_test/test_delegator.py", + "lib/python3.10/idlelib/idle_test/test_editmenu.py", + "lib/python3.10/idlelib/idle_test/test_editor.py", + "lib/python3.10/idlelib/idle_test/test_filelist.py", + "lib/python3.10/idlelib/idle_test/test_format.py", + "lib/python3.10/idlelib/idle_test/test_grep.py", + "lib/python3.10/idlelib/idle_test/test_help.py", + "lib/python3.10/idlelib/idle_test/test_help_about.py", + "lib/python3.10/idlelib/idle_test/test_history.py", + "lib/python3.10/idlelib/idle_test/test_hyperparser.py", + "lib/python3.10/idlelib/idle_test/test_iomenu.py", + "lib/python3.10/idlelib/idle_test/test_macosx.py", + "lib/python3.10/idlelib/idle_test/test_mainmenu.py", + "lib/python3.10/idlelib/idle_test/test_multicall.py", + "lib/python3.10/idlelib/idle_test/test_outwin.py", + "lib/python3.10/idlelib/idle_test/test_parenmatch.py", + "lib/python3.10/idlelib/idle_test/test_pathbrowser.py", + "lib/python3.10/idlelib/idle_test/test_percolator.py", + "lib/python3.10/idlelib/idle_test/test_pyparse.py", + "lib/python3.10/idlelib/idle_test/test_pyshell.py", + "lib/python3.10/idlelib/idle_test/test_query.py", + "lib/python3.10/idlelib/idle_test/test_redirector.py", + "lib/python3.10/idlelib/idle_test/test_replace.py", + "lib/python3.10/idlelib/idle_test/test_rpc.py", + "lib/python3.10/idlelib/idle_test/test_run.py", + "lib/python3.10/idlelib/idle_test/test_runscript.py", + "lib/python3.10/idlelib/idle_test/test_scrolledlist.py", + "lib/python3.10/idlelib/idle_test/test_search.py", + "lib/python3.10/idlelib/idle_test/test_searchbase.py", + "lib/python3.10/idlelib/idle_test/test_searchengine.py", + "lib/python3.10/idlelib/idle_test/test_sidebar.py", + "lib/python3.10/idlelib/idle_test/test_squeezer.py", + "lib/python3.10/idlelib/idle_test/test_stackviewer.py", + "lib/python3.10/idlelib/idle_test/test_statusbar.py", + "lib/python3.10/idlelib/idle_test/test_text.py", + "lib/python3.10/idlelib/idle_test/test_textview.py", + "lib/python3.10/idlelib/idle_test/test_tooltip.py", + "lib/python3.10/idlelib/idle_test/test_tree.py", + "lib/python3.10/idlelib/idle_test/test_undo.py", + "lib/python3.10/idlelib/idle_test/test_util.py", + "lib/python3.10/idlelib/idle_test/test_warning.py", + "lib/python3.10/idlelib/idle_test/test_window.py", + "lib/python3.10/idlelib/idle_test/test_zoomheight.py", + "lib/python3.10/idlelib/idle_test/test_zzdummy.py", + "lib/python3.10/idlelib/idle_test/tkinter_testing_utils.py", + "lib/python3.10/idlelib/iomenu.py", + "lib/python3.10/idlelib/macosx.py", + "lib/python3.10/idlelib/mainmenu.py", + "lib/python3.10/idlelib/multicall.py", + "lib/python3.10/idlelib/outwin.py", + "lib/python3.10/idlelib/parenmatch.py", + "lib/python3.10/idlelib/pathbrowser.py", + "lib/python3.10/idlelib/percolator.py", + "lib/python3.10/idlelib/pyparse.py", + "lib/python3.10/idlelib/pyshell.py", + "lib/python3.10/idlelib/query.py", + "lib/python3.10/idlelib/redirector.py", + "lib/python3.10/idlelib/replace.py", + "lib/python3.10/idlelib/rpc.py", + "lib/python3.10/idlelib/run.py", + "lib/python3.10/idlelib/runscript.py", + "lib/python3.10/idlelib/scrolledlist.py", + "lib/python3.10/idlelib/search.py", + "lib/python3.10/idlelib/searchbase.py", + "lib/python3.10/idlelib/searchengine.py", + "lib/python3.10/idlelib/sidebar.py", + "lib/python3.10/idlelib/squeezer.py", + "lib/python3.10/idlelib/stackviewer.py", + "lib/python3.10/idlelib/statusbar.py", + "lib/python3.10/idlelib/textview.py", + "lib/python3.10/idlelib/tooltip.py", + "lib/python3.10/idlelib/tree.py", + "lib/python3.10/idlelib/undo.py", + "lib/python3.10/idlelib/util.py", + "lib/python3.10/idlelib/window.py", + "lib/python3.10/idlelib/zoomheight.py", + "lib/python3.10/idlelib/zzdummy.py", + "lib/python3.10/imaplib.py", + "lib/python3.10/imghdr.py", + "lib/python3.10/imp.py", + "lib/python3.10/importlib/__init__.py", + "lib/python3.10/importlib/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/importlib/__pycache__/_abc.cpython-310.pyc", + "lib/python3.10/importlib/__pycache__/_adapters.cpython-310.pyc", + "lib/python3.10/importlib/__pycache__/_bootstrap.cpython-310.pyc", + "lib/python3.10/importlib/__pycache__/_bootstrap_external.cpython-310.pyc", + "lib/python3.10/importlib/__pycache__/_common.cpython-310.pyc", + "lib/python3.10/importlib/__pycache__/abc.cpython-310.pyc", + "lib/python3.10/importlib/__pycache__/machinery.cpython-310.pyc", + "lib/python3.10/importlib/__pycache__/readers.cpython-310.pyc", + "lib/python3.10/importlib/__pycache__/resources.cpython-310.pyc", + "lib/python3.10/importlib/__pycache__/util.cpython-310.pyc", + "lib/python3.10/importlib/_abc.py", + "lib/python3.10/importlib/_adapters.py", + "lib/python3.10/importlib/_bootstrap.py", + "lib/python3.10/importlib/_bootstrap_external.py", + "lib/python3.10/importlib/_common.py", + "lib/python3.10/importlib/abc.py", + "lib/python3.10/importlib/machinery.py", + "lib/python3.10/importlib/metadata/__init__.py", + "lib/python3.10/importlib/metadata/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/importlib/metadata/__pycache__/_adapters.cpython-310.pyc", + "lib/python3.10/importlib/metadata/__pycache__/_collections.cpython-310.pyc", + "lib/python3.10/importlib/metadata/__pycache__/_functools.cpython-310.pyc", + "lib/python3.10/importlib/metadata/__pycache__/_itertools.cpython-310.pyc", + "lib/python3.10/importlib/metadata/__pycache__/_meta.cpython-310.pyc", + "lib/python3.10/importlib/metadata/__pycache__/_text.cpython-310.pyc", + "lib/python3.10/importlib/metadata/_adapters.py", + "lib/python3.10/importlib/metadata/_collections.py", + "lib/python3.10/importlib/metadata/_functools.py", + "lib/python3.10/importlib/metadata/_itertools.py", + "lib/python3.10/importlib/metadata/_meta.py", + "lib/python3.10/importlib/metadata/_text.py", + "lib/python3.10/importlib/readers.py", + "lib/python3.10/importlib/resources.py", + "lib/python3.10/importlib/util.py", + "lib/python3.10/inspect.py", + "lib/python3.10/io.py", + "lib/python3.10/ipaddress.py", + "lib/python3.10/json/__init__.py", + "lib/python3.10/json/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/json/__pycache__/decoder.cpython-310.pyc", + "lib/python3.10/json/__pycache__/encoder.cpython-310.pyc", + "lib/python3.10/json/__pycache__/scanner.cpython-310.pyc", + "lib/python3.10/json/__pycache__/tool.cpython-310.pyc", + "lib/python3.10/json/decoder.py", + "lib/python3.10/json/encoder.py", + "lib/python3.10/json/scanner.py", + "lib/python3.10/json/tool.py", + "lib/python3.10/keyword.py", + "lib/python3.10/lib-dynload/_asyncio.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_bisect.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_blake2.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_bz2.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_codecs_cn.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_codecs_hk.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_codecs_iso2022.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_codecs_jp.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_codecs_kr.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_codecs_tw.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_contextvars.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_crypt.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_csv.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_ctypes.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_ctypes_test.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_curses.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_curses_panel.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_datetime.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_dbm.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_decimal.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_elementtree.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_hashlib.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_heapq.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_json.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_lsprof.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_lzma.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_md5.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_multibytecodec.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_multiprocessing.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_opcode.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_pickle.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_posixshmem.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_posixsubprocess.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_queue.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_random.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_scproxy.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_sha1.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_sha256.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_sha3.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_sha512.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_socket.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_sqlite3.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_ssl.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_statistics.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_struct.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_testbuffer.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_testcapi.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_testimportmultiple.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_testinternalcapi.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_testmultiphase.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_tkinter.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_uuid.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_xxsubinterpreters.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_xxtestfuzz.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_zoneinfo.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/array.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/audioop.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/binascii.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/cmath.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/fcntl.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/grp.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/math.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/mmap.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/nis.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/pyexpat.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/readline.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/resource.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/select.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/syslog.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/termios.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/unicodedata.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/xxlimited.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/xxlimited_35.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/zlib.cpython-310-darwin.so", + "lib/python3.10/lib2to3/Grammar.txt", + "lib/python3.10/lib2to3/Grammar3.10.9.final.0.pickle", + "lib/python3.10/lib2to3/PatternGrammar.txt", + "lib/python3.10/lib2to3/PatternGrammar3.10.9.final.0.pickle", + "lib/python3.10/lib2to3/__init__.py", + "lib/python3.10/lib2to3/__main__.py", + "lib/python3.10/lib2to3/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/lib2to3/__pycache__/__main__.cpython-310.pyc", + "lib/python3.10/lib2to3/__pycache__/btm_matcher.cpython-310.pyc", + "lib/python3.10/lib2to3/__pycache__/btm_utils.cpython-310.pyc", + "lib/python3.10/lib2to3/__pycache__/fixer_base.cpython-310.pyc", + "lib/python3.10/lib2to3/__pycache__/fixer_util.cpython-310.pyc", + "lib/python3.10/lib2to3/__pycache__/main.cpython-310.pyc", + "lib/python3.10/lib2to3/__pycache__/patcomp.cpython-310.pyc", + "lib/python3.10/lib2to3/__pycache__/pygram.cpython-310.pyc", + "lib/python3.10/lib2to3/__pycache__/pytree.cpython-310.pyc", + "lib/python3.10/lib2to3/__pycache__/refactor.cpython-310.pyc", + "lib/python3.10/lib2to3/btm_matcher.py", + "lib/python3.10/lib2to3/btm_utils.py", + "lib/python3.10/lib2to3/fixer_base.py", + "lib/python3.10/lib2to3/fixer_util.py", + "lib/python3.10/lib2to3/fixes/__init__.py", + "lib/python3.10/lib2to3/fixes/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_apply.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_asserts.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_basestring.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_buffer.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_dict.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_except.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_exec.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_execfile.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_exitfunc.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_filter.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_funcattrs.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_future.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_getcwdu.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_has_key.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_idioms.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_import.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_imports.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_imports2.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_input.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_intern.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_isinstance.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_itertools.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_itertools_imports.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_long.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_map.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_metaclass.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_methodattrs.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_ne.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_next.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_nonzero.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_numliterals.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_operator.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_paren.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_print.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_raise.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_raw_input.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_reduce.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_reload.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_renames.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_repr.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_set_literal.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_standarderror.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_sys_exc.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_throw.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_tuple_params.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_types.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_unicode.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_urllib.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_ws_comma.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_xrange.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_xreadlines.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_zip.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/fix_apply.py", + "lib/python3.10/lib2to3/fixes/fix_asserts.py", + "lib/python3.10/lib2to3/fixes/fix_basestring.py", + "lib/python3.10/lib2to3/fixes/fix_buffer.py", + "lib/python3.10/lib2to3/fixes/fix_dict.py", + "lib/python3.10/lib2to3/fixes/fix_except.py", + "lib/python3.10/lib2to3/fixes/fix_exec.py", + "lib/python3.10/lib2to3/fixes/fix_execfile.py", + "lib/python3.10/lib2to3/fixes/fix_exitfunc.py", + "lib/python3.10/lib2to3/fixes/fix_filter.py", + "lib/python3.10/lib2to3/fixes/fix_funcattrs.py", + "lib/python3.10/lib2to3/fixes/fix_future.py", + "lib/python3.10/lib2to3/fixes/fix_getcwdu.py", + "lib/python3.10/lib2to3/fixes/fix_has_key.py", + "lib/python3.10/lib2to3/fixes/fix_idioms.py", + "lib/python3.10/lib2to3/fixes/fix_import.py", + "lib/python3.10/lib2to3/fixes/fix_imports.py", + "lib/python3.10/lib2to3/fixes/fix_imports2.py", + "lib/python3.10/lib2to3/fixes/fix_input.py", + "lib/python3.10/lib2to3/fixes/fix_intern.py", + "lib/python3.10/lib2to3/fixes/fix_isinstance.py", + "lib/python3.10/lib2to3/fixes/fix_itertools.py", + "lib/python3.10/lib2to3/fixes/fix_itertools_imports.py", + "lib/python3.10/lib2to3/fixes/fix_long.py", + "lib/python3.10/lib2to3/fixes/fix_map.py", + "lib/python3.10/lib2to3/fixes/fix_metaclass.py", + "lib/python3.10/lib2to3/fixes/fix_methodattrs.py", + "lib/python3.10/lib2to3/fixes/fix_ne.py", + "lib/python3.10/lib2to3/fixes/fix_next.py", + "lib/python3.10/lib2to3/fixes/fix_nonzero.py", + "lib/python3.10/lib2to3/fixes/fix_numliterals.py", + "lib/python3.10/lib2to3/fixes/fix_operator.py", + "lib/python3.10/lib2to3/fixes/fix_paren.py", + "lib/python3.10/lib2to3/fixes/fix_print.py", + "lib/python3.10/lib2to3/fixes/fix_raise.py", + "lib/python3.10/lib2to3/fixes/fix_raw_input.py", + "lib/python3.10/lib2to3/fixes/fix_reduce.py", + "lib/python3.10/lib2to3/fixes/fix_reload.py", + "lib/python3.10/lib2to3/fixes/fix_renames.py", + "lib/python3.10/lib2to3/fixes/fix_repr.py", + "lib/python3.10/lib2to3/fixes/fix_set_literal.py", + "lib/python3.10/lib2to3/fixes/fix_standarderror.py", + "lib/python3.10/lib2to3/fixes/fix_sys_exc.py", + "lib/python3.10/lib2to3/fixes/fix_throw.py", + "lib/python3.10/lib2to3/fixes/fix_tuple_params.py", + "lib/python3.10/lib2to3/fixes/fix_types.py", + "lib/python3.10/lib2to3/fixes/fix_unicode.py", + "lib/python3.10/lib2to3/fixes/fix_urllib.py", + "lib/python3.10/lib2to3/fixes/fix_ws_comma.py", + "lib/python3.10/lib2to3/fixes/fix_xrange.py", + "lib/python3.10/lib2to3/fixes/fix_xreadlines.py", + "lib/python3.10/lib2to3/fixes/fix_zip.py", + "lib/python3.10/lib2to3/main.py", + "lib/python3.10/lib2to3/patcomp.py", + "lib/python3.10/lib2to3/pgen2/__init__.py", + "lib/python3.10/lib2to3/pgen2/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/lib2to3/pgen2/__pycache__/conv.cpython-310.pyc", + "lib/python3.10/lib2to3/pgen2/__pycache__/driver.cpython-310.pyc", + "lib/python3.10/lib2to3/pgen2/__pycache__/grammar.cpython-310.pyc", + "lib/python3.10/lib2to3/pgen2/__pycache__/literals.cpython-310.pyc", + "lib/python3.10/lib2to3/pgen2/__pycache__/parse.cpython-310.pyc", + "lib/python3.10/lib2to3/pgen2/__pycache__/pgen.cpython-310.pyc", + "lib/python3.10/lib2to3/pgen2/__pycache__/token.cpython-310.pyc", + "lib/python3.10/lib2to3/pgen2/__pycache__/tokenize.cpython-310.pyc", + "lib/python3.10/lib2to3/pgen2/conv.py", + "lib/python3.10/lib2to3/pgen2/driver.py", + "lib/python3.10/lib2to3/pgen2/grammar.py", + "lib/python3.10/lib2to3/pgen2/literals.py", + "lib/python3.10/lib2to3/pgen2/parse.py", + "lib/python3.10/lib2to3/pgen2/pgen.py", + "lib/python3.10/lib2to3/pgen2/token.py", + "lib/python3.10/lib2to3/pgen2/tokenize.py", + "lib/python3.10/lib2to3/pygram.py", + "lib/python3.10/lib2to3/pytree.py", + "lib/python3.10/lib2to3/refactor.py", + "lib/python3.10/lib2to3/tests/__init__.py", + "lib/python3.10/lib2to3/tests/__main__.py", + "lib/python3.10/lib2to3/tests/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/lib2to3/tests/__pycache__/__main__.cpython-310.pyc", + "lib/python3.10/lib2to3/tests/__pycache__/pytree_idempotency.cpython-310.pyc", + "lib/python3.10/lib2to3/tests/__pycache__/support.cpython-310.pyc", + "lib/python3.10/lib2to3/tests/__pycache__/test_all_fixers.cpython-310.pyc", + "lib/python3.10/lib2to3/tests/__pycache__/test_fixers.cpython-310.pyc", + "lib/python3.10/lib2to3/tests/__pycache__/test_main.cpython-310.pyc", + "lib/python3.10/lib2to3/tests/__pycache__/test_parser.cpython-310.pyc", + "lib/python3.10/lib2to3/tests/__pycache__/test_pytree.cpython-310.pyc", + "lib/python3.10/lib2to3/tests/__pycache__/test_refactor.cpython-310.pyc", + "lib/python3.10/lib2to3/tests/__pycache__/test_util.cpython-310.pyc", + "lib/python3.10/lib2to3/tests/data/README", + "lib/python3.10/lib2to3/tests/data/__pycache__/infinite_recursion.cpython-310.pyc", + "lib/python3.10/lib2to3/tests/data/__pycache__/py3_test_grammar.cpython-310.pyc", + "lib/python3.10/lib2to3/tests/data/bom.py", + "lib/python3.10/lib2to3/tests/data/crlf.py", + "lib/python3.10/lib2to3/tests/data/different_encoding.py", + "lib/python3.10/lib2to3/tests/data/false_encoding.py", + "lib/python3.10/lib2to3/tests/data/fixers/__pycache__/bad_order.cpython-310.pyc", + "lib/python3.10/lib2to3/tests/data/fixers/__pycache__/no_fixer_cls.cpython-310.pyc", + "lib/python3.10/lib2to3/tests/data/fixers/__pycache__/parrot_example.cpython-310.pyc", + "lib/python3.10/lib2to3/tests/data/fixers/bad_order.py", + "lib/python3.10/lib2to3/tests/data/fixers/myfixes/__init__.py", + "lib/python3.10/lib2to3/tests/data/fixers/myfixes/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/lib2to3/tests/data/fixers/myfixes/__pycache__/fix_explicit.cpython-310.pyc", + "lib/python3.10/lib2to3/tests/data/fixers/myfixes/__pycache__/fix_first.cpython-310.pyc", + "lib/python3.10/lib2to3/tests/data/fixers/myfixes/__pycache__/fix_last.cpython-310.pyc", + "lib/python3.10/lib2to3/tests/data/fixers/myfixes/__pycache__/fix_parrot.cpython-310.pyc", + "lib/python3.10/lib2to3/tests/data/fixers/myfixes/__pycache__/fix_preorder.cpython-310.pyc", + "lib/python3.10/lib2to3/tests/data/fixers/myfixes/fix_explicit.py", + "lib/python3.10/lib2to3/tests/data/fixers/myfixes/fix_first.py", + "lib/python3.10/lib2to3/tests/data/fixers/myfixes/fix_last.py", + "lib/python3.10/lib2to3/tests/data/fixers/myfixes/fix_parrot.py", + "lib/python3.10/lib2to3/tests/data/fixers/myfixes/fix_preorder.py", + "lib/python3.10/lib2to3/tests/data/fixers/no_fixer_cls.py", + "lib/python3.10/lib2to3/tests/data/fixers/parrot_example.py", + "lib/python3.10/lib2to3/tests/data/infinite_recursion.py", + "lib/python3.10/lib2to3/tests/data/py2_test_grammar.py", + "lib/python3.10/lib2to3/tests/data/py3_test_grammar.py", + "lib/python3.10/lib2to3/tests/pytree_idempotency.py", + "lib/python3.10/lib2to3/tests/support.py", + "lib/python3.10/lib2to3/tests/test_all_fixers.py", + "lib/python3.10/lib2to3/tests/test_fixers.py", + "lib/python3.10/lib2to3/tests/test_main.py", + "lib/python3.10/lib2to3/tests/test_parser.py", + "lib/python3.10/lib2to3/tests/test_pytree.py", + "lib/python3.10/lib2to3/tests/test_refactor.py", + "lib/python3.10/lib2to3/tests/test_util.py", + "lib/python3.10/linecache.py", + "lib/python3.10/locale.py", + "lib/python3.10/logging/__init__.py", + "lib/python3.10/logging/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/logging/__pycache__/config.cpython-310.pyc", + "lib/python3.10/logging/__pycache__/handlers.cpython-310.pyc", + "lib/python3.10/logging/config.py", + "lib/python3.10/logging/handlers.py", + "lib/python3.10/lzma.py", + "lib/python3.10/mailbox.py", + "lib/python3.10/mailcap.py", + "lib/python3.10/mimetypes.py", + "lib/python3.10/modulefinder.py", + "lib/python3.10/multiprocessing/__init__.py", + "lib/python3.10/multiprocessing/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/multiprocessing/__pycache__/connection.cpython-310.pyc", + "lib/python3.10/multiprocessing/__pycache__/context.cpython-310.pyc", + "lib/python3.10/multiprocessing/__pycache__/forkserver.cpython-310.pyc", + "lib/python3.10/multiprocessing/__pycache__/heap.cpython-310.pyc", + "lib/python3.10/multiprocessing/__pycache__/managers.cpython-310.pyc", + "lib/python3.10/multiprocessing/__pycache__/pool.cpython-310.pyc", + "lib/python3.10/multiprocessing/__pycache__/popen_fork.cpython-310.pyc", + "lib/python3.10/multiprocessing/__pycache__/popen_forkserver.cpython-310.pyc", + "lib/python3.10/multiprocessing/__pycache__/popen_spawn_posix.cpython-310.pyc", + "lib/python3.10/multiprocessing/__pycache__/popen_spawn_win32.cpython-310.pyc", + "lib/python3.10/multiprocessing/__pycache__/process.cpython-310.pyc", + "lib/python3.10/multiprocessing/__pycache__/queues.cpython-310.pyc", + "lib/python3.10/multiprocessing/__pycache__/reduction.cpython-310.pyc", + "lib/python3.10/multiprocessing/__pycache__/resource_sharer.cpython-310.pyc", + "lib/python3.10/multiprocessing/__pycache__/resource_tracker.cpython-310.pyc", + "lib/python3.10/multiprocessing/__pycache__/shared_memory.cpython-310.pyc", + "lib/python3.10/multiprocessing/__pycache__/sharedctypes.cpython-310.pyc", + "lib/python3.10/multiprocessing/__pycache__/spawn.cpython-310.pyc", + "lib/python3.10/multiprocessing/__pycache__/synchronize.cpython-310.pyc", + "lib/python3.10/multiprocessing/__pycache__/util.cpython-310.pyc", + "lib/python3.10/multiprocessing/connection.py", + "lib/python3.10/multiprocessing/context.py", + "lib/python3.10/multiprocessing/dummy/__init__.py", + "lib/python3.10/multiprocessing/dummy/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/multiprocessing/dummy/__pycache__/connection.cpython-310.pyc", + "lib/python3.10/multiprocessing/dummy/connection.py", + "lib/python3.10/multiprocessing/forkserver.py", + "lib/python3.10/multiprocessing/heap.py", + "lib/python3.10/multiprocessing/managers.py", + "lib/python3.10/multiprocessing/pool.py", + "lib/python3.10/multiprocessing/popen_fork.py", + "lib/python3.10/multiprocessing/popen_forkserver.py", + "lib/python3.10/multiprocessing/popen_spawn_posix.py", + "lib/python3.10/multiprocessing/popen_spawn_win32.py", + "lib/python3.10/multiprocessing/process.py", + "lib/python3.10/multiprocessing/queues.py", + "lib/python3.10/multiprocessing/reduction.py", + "lib/python3.10/multiprocessing/resource_sharer.py", + "lib/python3.10/multiprocessing/resource_tracker.py", + "lib/python3.10/multiprocessing/shared_memory.py", + "lib/python3.10/multiprocessing/sharedctypes.py", + "lib/python3.10/multiprocessing/spawn.py", + "lib/python3.10/multiprocessing/synchronize.py", + "lib/python3.10/multiprocessing/util.py", + "lib/python3.10/netrc.py", + "lib/python3.10/nntplib.py", + "lib/python3.10/ntpath.py", + "lib/python3.10/nturl2path.py", + "lib/python3.10/numbers.py", + "lib/python3.10/opcode.py", + "lib/python3.10/operator.py", + "lib/python3.10/optparse.py", + "lib/python3.10/os.py", + "lib/python3.10/pathlib.py", + "lib/python3.10/pdb.py", + "lib/python3.10/pickle.py", + "lib/python3.10/pickletools.py", + "lib/python3.10/pipes.py", + "lib/python3.10/pkgutil.py", + "lib/python3.10/platform.py", + "lib/python3.10/plistlib.py", + "lib/python3.10/poplib.py", + "lib/python3.10/posixpath.py", + "lib/python3.10/pprint.py", + "lib/python3.10/profile.py", + "lib/python3.10/pstats.py", + "lib/python3.10/pty.py", + "lib/python3.10/py_compile.py", + "lib/python3.10/pyclbr.py", + "lib/python3.10/pydoc.py", + "lib/python3.10/pydoc_data/__init__.py", + "lib/python3.10/pydoc_data/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/pydoc_data/__pycache__/topics.cpython-310.pyc", + "lib/python3.10/pydoc_data/_pydoc.css", + "lib/python3.10/pydoc_data/topics.py", + "lib/python3.10/queue.py", + "lib/python3.10/quopri.py", + "lib/python3.10/random.py", + "lib/python3.10/re.py", + "lib/python3.10/reprlib.py", + "lib/python3.10/rlcompleter.py", + "lib/python3.10/runpy.py", + "lib/python3.10/sched.py", + "lib/python3.10/secrets.py", + "lib/python3.10/selectors.py", + "lib/python3.10/shelve.py", + "lib/python3.10/shlex.py", + "lib/python3.10/shutil.py", + "lib/python3.10/signal.py", + "lib/python3.10/site-packages/README.txt", + "lib/python3.10/site.py", + "lib/python3.10/smtpd.py", + "lib/python3.10/smtplib.py", + "lib/python3.10/sndhdr.py", + "lib/python3.10/socket.py", + "lib/python3.10/socketserver.py", + "lib/python3.10/sqlite3/__init__.py", + "lib/python3.10/sqlite3/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/sqlite3/__pycache__/dbapi2.cpython-310.pyc", + "lib/python3.10/sqlite3/__pycache__/dump.cpython-310.pyc", + "lib/python3.10/sqlite3/dbapi2.py", + "lib/python3.10/sqlite3/dump.py", + "lib/python3.10/sre_compile.py", + "lib/python3.10/sre_constants.py", + "lib/python3.10/sre_parse.py", + "lib/python3.10/ssl.py", + "lib/python3.10/stat.py", + "lib/python3.10/statistics.py", + "lib/python3.10/string.py", + "lib/python3.10/stringprep.py", + "lib/python3.10/struct.py", + "lib/python3.10/subprocess.py", + "lib/python3.10/sunau.py", + "lib/python3.10/symtable.py", + "lib/python3.10/sysconfig.py", + "lib/python3.10/tabnanny.py", + "lib/python3.10/tarfile.py", + "lib/python3.10/telnetlib.py", + "lib/python3.10/tempfile.py", + "lib/python3.10/test/__init__.py", + "lib/python3.10/test/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/test/__pycache__/test_script_helper.cpython-310.pyc", + "lib/python3.10/test/__pycache__/test_support.cpython-310.pyc", + "lib/python3.10/test/support/__init__.py", + "lib/python3.10/test/support/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/test/support/__pycache__/bytecode_helper.cpython-310.pyc", + "lib/python3.10/test/support/__pycache__/hashlib_helper.cpython-310.pyc", + "lib/python3.10/test/support/__pycache__/import_helper.cpython-310.pyc", + "lib/python3.10/test/support/__pycache__/interpreters.cpython-310.pyc", + "lib/python3.10/test/support/__pycache__/logging_helper.cpython-310.pyc", + "lib/python3.10/test/support/__pycache__/os_helper.cpython-310.pyc", + "lib/python3.10/test/support/__pycache__/script_helper.cpython-310.pyc", + "lib/python3.10/test/support/__pycache__/socket_helper.cpython-310.pyc", + "lib/python3.10/test/support/__pycache__/testresult.cpython-310.pyc", + "lib/python3.10/test/support/__pycache__/threading_helper.cpython-310.pyc", + "lib/python3.10/test/support/__pycache__/warnings_helper.cpython-310.pyc", + "lib/python3.10/test/support/bytecode_helper.py", + "lib/python3.10/test/support/hashlib_helper.py", + "lib/python3.10/test/support/import_helper.py", + "lib/python3.10/test/support/interpreters.py", + "lib/python3.10/test/support/logging_helper.py", + "lib/python3.10/test/support/os_helper.py", + "lib/python3.10/test/support/script_helper.py", + "lib/python3.10/test/support/socket_helper.py", + "lib/python3.10/test/support/testresult.py", + "lib/python3.10/test/support/threading_helper.py", + "lib/python3.10/test/support/warnings_helper.py", + "lib/python3.10/test/test_script_helper.py", + "lib/python3.10/test/test_support.py", + "lib/python3.10/textwrap.py", + "lib/python3.10/this.py", + "lib/python3.10/threading.py", + "lib/python3.10/timeit.py", + "lib/python3.10/tkinter/__init__.py", + "lib/python3.10/tkinter/__main__.py", + "lib/python3.10/tkinter/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/tkinter/__pycache__/__main__.cpython-310.pyc", + "lib/python3.10/tkinter/__pycache__/colorchooser.cpython-310.pyc", + "lib/python3.10/tkinter/__pycache__/commondialog.cpython-310.pyc", + "lib/python3.10/tkinter/__pycache__/constants.cpython-310.pyc", + "lib/python3.10/tkinter/__pycache__/dialog.cpython-310.pyc", + "lib/python3.10/tkinter/__pycache__/dnd.cpython-310.pyc", + "lib/python3.10/tkinter/__pycache__/filedialog.cpython-310.pyc", + "lib/python3.10/tkinter/__pycache__/font.cpython-310.pyc", + "lib/python3.10/tkinter/__pycache__/messagebox.cpython-310.pyc", + "lib/python3.10/tkinter/__pycache__/scrolledtext.cpython-310.pyc", + "lib/python3.10/tkinter/__pycache__/simpledialog.cpython-310.pyc", + "lib/python3.10/tkinter/__pycache__/tix.cpython-310.pyc", + "lib/python3.10/tkinter/__pycache__/ttk.cpython-310.pyc", + "lib/python3.10/tkinter/colorchooser.py", + "lib/python3.10/tkinter/commondialog.py", + "lib/python3.10/tkinter/constants.py", + "lib/python3.10/tkinter/dialog.py", + "lib/python3.10/tkinter/dnd.py", + "lib/python3.10/tkinter/filedialog.py", + "lib/python3.10/tkinter/font.py", + "lib/python3.10/tkinter/messagebox.py", + "lib/python3.10/tkinter/scrolledtext.py", + "lib/python3.10/tkinter/simpledialog.py", + "lib/python3.10/tkinter/tix.py", + "lib/python3.10/tkinter/ttk.py", + "lib/python3.10/token.py", + "lib/python3.10/tokenize.py", + "lib/python3.10/trace.py", + "lib/python3.10/traceback.py", + "lib/python3.10/tracemalloc.py", + "lib/python3.10/tty.py", + "lib/python3.10/turtle.py", + "lib/python3.10/turtledemo/__init__.py", + "lib/python3.10/turtledemo/__main__.py", + "lib/python3.10/turtledemo/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/turtledemo/__pycache__/__main__.cpython-310.pyc", + "lib/python3.10/turtledemo/__pycache__/bytedesign.cpython-310.pyc", + "lib/python3.10/turtledemo/__pycache__/chaos.cpython-310.pyc", + "lib/python3.10/turtledemo/__pycache__/clock.cpython-310.pyc", + "lib/python3.10/turtledemo/__pycache__/colormixer.cpython-310.pyc", + "lib/python3.10/turtledemo/__pycache__/forest.cpython-310.pyc", + "lib/python3.10/turtledemo/__pycache__/fractalcurves.cpython-310.pyc", + "lib/python3.10/turtledemo/__pycache__/lindenmayer.cpython-310.pyc", + "lib/python3.10/turtledemo/__pycache__/minimal_hanoi.cpython-310.pyc", + "lib/python3.10/turtledemo/__pycache__/nim.cpython-310.pyc", + "lib/python3.10/turtledemo/__pycache__/paint.cpython-310.pyc", + "lib/python3.10/turtledemo/__pycache__/peace.cpython-310.pyc", + "lib/python3.10/turtledemo/__pycache__/penrose.cpython-310.pyc", + "lib/python3.10/turtledemo/__pycache__/planet_and_moon.cpython-310.pyc", + "lib/python3.10/turtledemo/__pycache__/rosette.cpython-310.pyc", + "lib/python3.10/turtledemo/__pycache__/round_dance.cpython-310.pyc", + "lib/python3.10/turtledemo/__pycache__/sorting_animate.cpython-310.pyc", + "lib/python3.10/turtledemo/__pycache__/tree.cpython-310.pyc", + "lib/python3.10/turtledemo/__pycache__/two_canvases.cpython-310.pyc", + "lib/python3.10/turtledemo/__pycache__/yinyang.cpython-310.pyc", + "lib/python3.10/turtledemo/bytedesign.py", + "lib/python3.10/turtledemo/chaos.py", + "lib/python3.10/turtledemo/clock.py", + "lib/python3.10/turtledemo/colormixer.py", + "lib/python3.10/turtledemo/forest.py", + "lib/python3.10/turtledemo/fractalcurves.py", + "lib/python3.10/turtledemo/lindenmayer.py", + "lib/python3.10/turtledemo/minimal_hanoi.py", + "lib/python3.10/turtledemo/nim.py", + "lib/python3.10/turtledemo/paint.py", + "lib/python3.10/turtledemo/peace.py", + "lib/python3.10/turtledemo/penrose.py", + "lib/python3.10/turtledemo/planet_and_moon.py", + "lib/python3.10/turtledemo/rosette.py", + "lib/python3.10/turtledemo/round_dance.py", + "lib/python3.10/turtledemo/sorting_animate.py", + "lib/python3.10/turtledemo/tree.py", + "lib/python3.10/turtledemo/turtle.cfg", + "lib/python3.10/turtledemo/two_canvases.py", + "lib/python3.10/turtledemo/yinyang.py", + "lib/python3.10/types.py", + "lib/python3.10/typing.py", + "lib/python3.10/unittest/__init__.py", + "lib/python3.10/unittest/__main__.py", + "lib/python3.10/unittest/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/unittest/__pycache__/__main__.cpython-310.pyc", + "lib/python3.10/unittest/__pycache__/_log.cpython-310.pyc", + "lib/python3.10/unittest/__pycache__/async_case.cpython-310.pyc", + "lib/python3.10/unittest/__pycache__/case.cpython-310.pyc", + "lib/python3.10/unittest/__pycache__/loader.cpython-310.pyc", + "lib/python3.10/unittest/__pycache__/main.cpython-310.pyc", + "lib/python3.10/unittest/__pycache__/mock.cpython-310.pyc", + "lib/python3.10/unittest/__pycache__/result.cpython-310.pyc", + "lib/python3.10/unittest/__pycache__/runner.cpython-310.pyc", + "lib/python3.10/unittest/__pycache__/signals.cpython-310.pyc", + "lib/python3.10/unittest/__pycache__/suite.cpython-310.pyc", + "lib/python3.10/unittest/__pycache__/util.cpython-310.pyc", + "lib/python3.10/unittest/_log.py", + "lib/python3.10/unittest/async_case.py", + "lib/python3.10/unittest/case.py", + "lib/python3.10/unittest/loader.py", + "lib/python3.10/unittest/main.py", + "lib/python3.10/unittest/mock.py", + "lib/python3.10/unittest/result.py", + "lib/python3.10/unittest/runner.py", + "lib/python3.10/unittest/signals.py", + "lib/python3.10/unittest/suite.py", + "lib/python3.10/unittest/util.py", + "lib/python3.10/urllib/__init__.py", + "lib/python3.10/urllib/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/urllib/__pycache__/error.cpython-310.pyc", + "lib/python3.10/urllib/__pycache__/parse.cpython-310.pyc", + "lib/python3.10/urllib/__pycache__/request.cpython-310.pyc", + "lib/python3.10/urllib/__pycache__/response.cpython-310.pyc", + "lib/python3.10/urllib/__pycache__/robotparser.cpython-310.pyc", + "lib/python3.10/urllib/error.py", + "lib/python3.10/urllib/parse.py", + "lib/python3.10/urllib/request.py", + "lib/python3.10/urllib/response.py", + "lib/python3.10/urllib/robotparser.py", + "lib/python3.10/uu.py", + "lib/python3.10/uuid.py", + "lib/python3.10/venv/__init__.py", + "lib/python3.10/venv/__main__.py", + "lib/python3.10/venv/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/venv/__pycache__/__main__.cpython-310.pyc", + "lib/python3.10/venv/scripts/common/Activate.ps1", + "lib/python3.10/venv/scripts/common/activate", + "lib/python3.10/venv/scripts/posix/activate.csh", + "lib/python3.10/venv/scripts/posix/activate.fish", + "lib/python3.10/warnings.py", + "lib/python3.10/wave.py", + "lib/python3.10/weakref.py", + "lib/python3.10/webbrowser.py", + "lib/python3.10/wsgiref/__init__.py", + "lib/python3.10/wsgiref/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/wsgiref/__pycache__/handlers.cpython-310.pyc", + "lib/python3.10/wsgiref/__pycache__/headers.cpython-310.pyc", + "lib/python3.10/wsgiref/__pycache__/simple_server.cpython-310.pyc", + "lib/python3.10/wsgiref/__pycache__/util.cpython-310.pyc", + "lib/python3.10/wsgiref/__pycache__/validate.cpython-310.pyc", + "lib/python3.10/wsgiref/handlers.py", + "lib/python3.10/wsgiref/headers.py", + "lib/python3.10/wsgiref/simple_server.py", + "lib/python3.10/wsgiref/util.py", + "lib/python3.10/wsgiref/validate.py", + "lib/python3.10/xdrlib.py", + "lib/python3.10/xml/__init__.py", + "lib/python3.10/xml/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/xml/dom/NodeFilter.py", + "lib/python3.10/xml/dom/__init__.py", + "lib/python3.10/xml/dom/__pycache__/NodeFilter.cpython-310.pyc", + "lib/python3.10/xml/dom/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/xml/dom/__pycache__/domreg.cpython-310.pyc", + "lib/python3.10/xml/dom/__pycache__/expatbuilder.cpython-310.pyc", + "lib/python3.10/xml/dom/__pycache__/minicompat.cpython-310.pyc", + "lib/python3.10/xml/dom/__pycache__/minidom.cpython-310.pyc", + "lib/python3.10/xml/dom/__pycache__/pulldom.cpython-310.pyc", + "lib/python3.10/xml/dom/__pycache__/xmlbuilder.cpython-310.pyc", + "lib/python3.10/xml/dom/domreg.py", + "lib/python3.10/xml/dom/expatbuilder.py", + "lib/python3.10/xml/dom/minicompat.py", + "lib/python3.10/xml/dom/minidom.py", + "lib/python3.10/xml/dom/pulldom.py", + "lib/python3.10/xml/dom/xmlbuilder.py", + "lib/python3.10/xml/etree/ElementInclude.py", + "lib/python3.10/xml/etree/ElementPath.py", + "lib/python3.10/xml/etree/ElementTree.py", + "lib/python3.10/xml/etree/__init__.py", + "lib/python3.10/xml/etree/__pycache__/ElementInclude.cpython-310.pyc", + "lib/python3.10/xml/etree/__pycache__/ElementPath.cpython-310.pyc", + "lib/python3.10/xml/etree/__pycache__/ElementTree.cpython-310.pyc", + "lib/python3.10/xml/etree/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/xml/etree/__pycache__/cElementTree.cpython-310.pyc", + "lib/python3.10/xml/etree/cElementTree.py", + "lib/python3.10/xml/parsers/__init__.py", + "lib/python3.10/xml/parsers/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/xml/parsers/__pycache__/expat.cpython-310.pyc", + "lib/python3.10/xml/parsers/expat.py", + "lib/python3.10/xml/sax/__init__.py", + "lib/python3.10/xml/sax/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/xml/sax/__pycache__/_exceptions.cpython-310.pyc", + "lib/python3.10/xml/sax/__pycache__/expatreader.cpython-310.pyc", + "lib/python3.10/xml/sax/__pycache__/handler.cpython-310.pyc", + "lib/python3.10/xml/sax/__pycache__/saxutils.cpython-310.pyc", + "lib/python3.10/xml/sax/__pycache__/xmlreader.cpython-310.pyc", + "lib/python3.10/xml/sax/_exceptions.py", + "lib/python3.10/xml/sax/expatreader.py", + "lib/python3.10/xml/sax/handler.py", + "lib/python3.10/xml/sax/saxutils.py", + "lib/python3.10/xml/sax/xmlreader.py", + "lib/python3.10/xmlrpc/__init__.py", + "lib/python3.10/xmlrpc/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/xmlrpc/__pycache__/client.cpython-310.pyc", + "lib/python3.10/xmlrpc/__pycache__/server.cpython-310.pyc", + "lib/python3.10/xmlrpc/client.py", + "lib/python3.10/xmlrpc/server.py", + "lib/python3.10/zipapp.py", + "lib/python3.10/zipfile.py", + "lib/python3.10/zipimport.py", + "lib/python3.10/zoneinfo/__init__.py", + "lib/python3.10/zoneinfo/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/zoneinfo/__pycache__/_common.cpython-310.pyc", + "lib/python3.10/zoneinfo/__pycache__/_tzpath.cpython-310.pyc", + "lib/python3.10/zoneinfo/__pycache__/_zoneinfo.cpython-310.pyc", + "lib/python3.10/zoneinfo/_common.py", + "lib/python3.10/zoneinfo/_tzpath.py", + "lib/python3.10/zoneinfo/_zoneinfo.py", + "share/man/man1/python3.1", + "share/man/man1/python3.10.1" + ], + "fn": "python-3.10.9-hc0d8a6c_1.conda", + "legacy_bz2_md5": "79db6ab46b228ae5779c077a7f4314b9", + "legacy_bz2_size": 13813760, + "license": "PSF-2.0", + "license_family": "PSF", + "link": { + "source": "/Users/donjayamanne/.pyenv/versions/anaconda3-2023.03/pkgs/python-3.10.9-hc0d8a6c_1", + "type": 1 + }, + "md5": "b49223285e681289fe846def063b8c61", + "name": "python", + "package_tarball_full_path": "/Users/donjayamanne/.pyenv/versions/anaconda3-2023.03/pkgs/python-3.10.9-hc0d8a6c_1.conda", + "paths_data": { + "paths": [ + { + "_path": "bin/2to3-3.10", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_7a849mskhu/croot/python-split_1677694510376/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_p", + "sha256": "49f8de215d5769259789d0f08d8de049361c9f25670628f3e5efbd90007a3187", + "sha256_in_prefix": "dd0f50efced047ea4e30d973142d09499d4feb8554842d01442f9f2108d5a741", + "size_in_bytes": 347 + }, + { + "_path": "bin/idle3.10", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_7a849mskhu/croot/python-split_1677694510376/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_p", + "sha256": "65b96fcd8aa20754413b467b9a885fb9e90541c57b6fbdf6ecbdb4a3b8c6d2b8", + "sha256_in_prefix": "435786c49358497a8794c08aded2142087b68d97bf8fc2e7a30e0d1f7cff1f37", + "size_in_bytes": 345 + }, + { + "_path": "bin/pydoc3.10", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_7a849mskhu/croot/python-split_1677694510376/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_p", + "sha256": "5e1857422b891dc0699ca50ca21b719119d2c47092d669a262da1a3cdafef055", + "sha256_in_prefix": "66e27555a064b90acc248e3292372a80e19c7adce86da67fc3f5555c2b4eb8b4", + "size_in_bytes": 330 + }, + { + "_path": "bin/python3.10", + "file_mode": "binary", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_7a849mskhu/croot/python-split_1677694510376/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_p", + "sha256": "57759740171bb912fe1eabd295867fad467018f8fc17cb677b9de841a4d3ddea", + "sha256_in_prefix": "e0c8b88c55eae3c3d331055e6f22e23b51afea4b77d47f748abf897fc80827d8", + "size_in_bytes": 3880624 + }, + { + "_path": "bin/python3.10-config", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_7a849mskhu/croot/python-split_1677694510376/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_p", + "sha256": "73722fe35f6884c20967418b6c0c827670e0323a40e4b0686bd6101c73fd4bfd", + "sha256_in_prefix": "f2ab0a490482c0a1dd2e1bb373c3363233e96953118950fcbe8a6170c3a9a941", + "size_in_bytes": 2289 + }, + { + "_path": "lib/libpython3.10.dylib", + "file_mode": "binary", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_7a849mskhu/croot/python-split_1677694510376/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_p", + "sha256": "9b5064ad68a06a3b6c8a827c359f6cde8a18303d2506d589f5f634b9eb8c3a29", + "sha256_in_prefix": "0f2cc0004c39200b1fee5d7247a40a658522d1b3edd49d84b87e1890a34e1bb1", + "size_in_bytes": 3880992 + }, + { + "_path": "lib/pkgconfig/python-3.10-embed.pc", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_7a849mskhu/croot/python-split_1677694510376/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_p", + "sha256": "267ee6603068cc40b1e3cc70e31b12acae4ea280f32b1ee1d76eb35eb46a97ea", + "sha256_in_prefix": "e72ec48cd066261568511e04e4b8a2c77bb400906871ae000308c26c754161da", + "size_in_bytes": 559 + }, + { + "_path": "lib/pkgconfig/python-3.10.pc", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_7a849mskhu/croot/python-split_1677694510376/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_p", + "sha256": "3437ae5485a090fdee7120bb1913b4616fa3e64a4e762c8d0277bf3faa36c69c", + "sha256_in_prefix": "dd3256512d0f7edc4b316556350fda490e536c229e538bec5650a73470dace73", + "size_in_bytes": 532 + }, + { + "_path": "lib/python3.10/_sysconfigdata__darwin_darwin.py", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_7a849mskhu/croot/python-split_1677694510376/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_p", + "sha256": "04bc97e2a3ff9d6d1b8aa6fe456426b37e2530cace3a9aefd88bb138c20200a1", + "sha256_in_prefix": "3090497323d66dbbc11f637972fa5514d00904beb92846349fb4d2361e497254", + "size_in_bytes": 57548 + }, + { + "_path": "lib/python3.10/_sysconfigdata__darwin_darwin.py.orig", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_7a849mskhu/croot/python-split_1677694510376/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_p", + "sha256": "aa64b16d8e75e057bd4e607f588ee5bf38d3f83022de6c7c5f1375860cdb029c", + "sha256_in_prefix": "ce87da2ca67f461f26ed561573fe5a10ce3bb86594225981b15af1dfd0223115", + "size_in_bytes": 66662 + }, + { + "_path": "lib/python3.10/_sysconfigdata_arm64_apple_darwin20_0_0.py", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_7a849mskhu/croot/python-split_1677694510376/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_p", + "sha256": "bf7fd0677c2d7c908d5b9c8f4da8ea9361ca90f02bafbddb3006957276a68258", + "sha256_in_prefix": "bca2eff7df3e2da0dc25776767cd1748f268b2250b21dfaba88f82d1356c852a", + "size_in_bytes": 59223 + }, + { + "_path": "lib/python3.10/config-3.10-darwin/Makefile", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_7a849mskhu/croot/python-split_1677694510376/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_p", + "sha256": "176f81b1323a41f74e47631bc320d300711102b48cc5ac588cab68cd3d6ca375", + "sha256_in_prefix": "dfec273360eacf5e5dcf06f7da1f9e59cd44fbb6f756720dc18bdc55750835de", + "size_in_bytes": 91516 + }, + { + "_path": "lib/python3.10/config-3.10-darwin/python-config.py", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_7a849mskhu/croot/python-split_1677694510376/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_p", + "sha256": "73722fe35f6884c20967418b6c0c827670e0323a40e4b0686bd6101c73fd4bfd", + "sha256_in_prefix": "f2ab0a490482c0a1dd2e1bb373c3363233e96953118950fcbe8a6170c3a9a941", + "size_in_bytes": 2289 + } + ], + "paths_version": 1 + }, + "requested_spec": "defaults/osx-arm64::python==3.10.9=hc0d8a6c_1[md5=b49223285e681289fe846def063b8c61]", + "sha256": "717f4901666a82f0d1fb71be02870d845a72eaec083218e71200000481e5577b", + "size": 13556748, + "subdir": "osx-arm64", + "timestamp": 1677695073705, + "track_features": "", + "url": "https://repo.anaconda.com/pkgs/main/osx-arm64/python-3.10.9-hc0d8a6c_1.conda", + "version": "3.10.9" +} \ No newline at end of file diff --git a/crates/pet-conda/tests/unix/anaconda3-2023.03-without-history/conda-meta/python-dateutil-2.8.2-pyhd3eb1b0_0.json b/crates/pet-conda/tests/unix/anaconda3-2023.03-without-history/conda-meta/python-dateutil-2.8.2-pyhd3eb1b0_0.json new file mode 100644 index 00000000..868b827d --- /dev/null +++ b/crates/pet-conda/tests/unix/anaconda3-2023.03-without-history/conda-meta/python-dateutil-2.8.2-pyhd3eb1b0_0.json @@ -0,0 +1,159 @@ +{ + "build": "pyhd3eb1b0_0", + "build_number": 0, + "channel": "https://repo.anaconda.com/pkgs/main/noarch", + "constrains": [], + "depends": [ + "python", + "six >=1.5" + ], + "extracted_package_dir": "/Users/donjayamanne/.pyenv/versions/anaconda3-2023.03/pkgs/python-dateutil-2.8.2-pyhd3eb1b0_0", + "features": "", + "files": [ + "lib/python3.10/site-packages/dateutil/__init__.py", + "lib/python3.10/site-packages/dateutil/_common.py", + "lib/python3.10/site-packages/dateutil/_version.py", + "lib/python3.10/site-packages/dateutil/easter.py", + "lib/python3.10/site-packages/dateutil/parser/__init__.py", + "lib/python3.10/site-packages/dateutil/parser/_parser.py", + "lib/python3.10/site-packages/dateutil/parser/isoparser.py", + "lib/python3.10/site-packages/dateutil/relativedelta.py", + "lib/python3.10/site-packages/dateutil/rrule.py", + "lib/python3.10/site-packages/dateutil/tz/__init__.py", + "lib/python3.10/site-packages/dateutil/tz/_common.py", + "lib/python3.10/site-packages/dateutil/tz/_factories.py", + "lib/python3.10/site-packages/dateutil/tz/tz.py", + "lib/python3.10/site-packages/dateutil/tz/win.py", + "lib/python3.10/site-packages/dateutil/tzwin.py", + "lib/python3.10/site-packages/dateutil/utils.py", + "lib/python3.10/site-packages/dateutil/zoneinfo/__init__.py", + "lib/python3.10/site-packages/dateutil/zoneinfo/dateutil-zoneinfo.tar.gz", + "lib/python3.10/site-packages/dateutil/zoneinfo/rebuild.py", + "lib/python3.10/site-packages/python_dateutil-2.8.2.dist-info/INSTALLER", + "lib/python3.10/site-packages/python_dateutil-2.8.2.dist-info/LICENSE", + "lib/python3.10/site-packages/python_dateutil-2.8.2.dist-info/METADATA", + "lib/python3.10/site-packages/python_dateutil-2.8.2.dist-info/RECORD", + "lib/python3.10/site-packages/python_dateutil-2.8.2.dist-info/REQUESTED", + "lib/python3.10/site-packages/python_dateutil-2.8.2.dist-info/WHEEL", + "lib/python3.10/site-packages/python_dateutil-2.8.2.dist-info/direct_url.json", + "lib/python3.10/site-packages/python_dateutil-2.8.2.dist-info/top_level.txt", + "lib/python3.10/site-packages/python_dateutil-2.8.2.dist-info/zip-safe", + "lib/python3.10/site-packages/dateutil/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/dateutil/__pycache__/_common.cpython-310.pyc", + "lib/python3.10/site-packages/dateutil/__pycache__/_version.cpython-310.pyc", + "lib/python3.10/site-packages/dateutil/__pycache__/easter.cpython-310.pyc", + "lib/python3.10/site-packages/dateutil/parser/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/dateutil/parser/__pycache__/_parser.cpython-310.pyc", + "lib/python3.10/site-packages/dateutil/parser/__pycache__/isoparser.cpython-310.pyc", + "lib/python3.10/site-packages/dateutil/__pycache__/relativedelta.cpython-310.pyc", + "lib/python3.10/site-packages/dateutil/__pycache__/rrule.cpython-310.pyc", + "lib/python3.10/site-packages/dateutil/tz/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/dateutil/tz/__pycache__/_common.cpython-310.pyc", + "lib/python3.10/site-packages/dateutil/tz/__pycache__/_factories.cpython-310.pyc", + "lib/python3.10/site-packages/dateutil/tz/__pycache__/tz.cpython-310.pyc", + "lib/python3.10/site-packages/dateutil/tz/__pycache__/win.cpython-310.pyc", + "lib/python3.10/site-packages/dateutil/__pycache__/tzwin.cpython-310.pyc", + "lib/python3.10/site-packages/dateutil/__pycache__/utils.cpython-310.pyc", + "lib/python3.10/site-packages/dateutil/zoneinfo/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/dateutil/zoneinfo/__pycache__/rebuild.cpython-310.pyc" + ], + "fn": "python-dateutil-2.8.2-pyhd3eb1b0_0.conda", + "legacy_bz2_md5": "2eb923cc014094f4acf7f849d67d73f8", + "legacy_bz2_size": 246457, + "license": "BSD-3-Clause and Apache", + "license_family": "BSD", + "link": { + "source": "/Users/donjayamanne/.pyenv/versions/anaconda3-2023.03/pkgs/python-dateutil-2.8.2-pyhd3eb1b0_0", + "type": 1 + }, + "md5": "211ee00320b08a1ac9fea6677649f6c9", + "name": "python-dateutil", + "noarch": "python", + "package_tarball_full_path": "/Users/donjayamanne/.pyenv/versions/anaconda3-2023.03/pkgs/python-dateutil-2.8.2-pyhd3eb1b0_0.conda", + "package_type": "noarch_python", + "paths_data": { + "paths": [ + { + "_path": "lib/python3.10/site-packages/dateutil/__pycache__/__init__.cpython-310.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.10/site-packages/dateutil/__pycache__/_common.cpython-310.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.10/site-packages/dateutil/__pycache__/_version.cpython-310.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.10/site-packages/dateutil/__pycache__/easter.cpython-310.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.10/site-packages/dateutil/parser/__pycache__/__init__.cpython-310.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.10/site-packages/dateutil/parser/__pycache__/_parser.cpython-310.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.10/site-packages/dateutil/parser/__pycache__/isoparser.cpython-310.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.10/site-packages/dateutil/__pycache__/relativedelta.cpython-310.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.10/site-packages/dateutil/__pycache__/rrule.cpython-310.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.10/site-packages/dateutil/tz/__pycache__/__init__.cpython-310.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.10/site-packages/dateutil/tz/__pycache__/_common.cpython-310.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.10/site-packages/dateutil/tz/__pycache__/_factories.cpython-310.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.10/site-packages/dateutil/tz/__pycache__/tz.cpython-310.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.10/site-packages/dateutil/tz/__pycache__/win.cpython-310.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.10/site-packages/dateutil/__pycache__/tzwin.cpython-310.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.10/site-packages/dateutil/__pycache__/utils.cpython-310.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.10/site-packages/dateutil/zoneinfo/__pycache__/__init__.cpython-310.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.10/site-packages/dateutil/zoneinfo/__pycache__/rebuild.cpython-310.pyc", + "path_type": "pyc_file" + } + ], + "paths_version": 1 + }, + "requested_spec": "defaults/noarch::python-dateutil==2.8.2=pyhd3eb1b0_0[md5=211ee00320b08a1ac9fea6677649f6c9]", + "sha256": "01e82704b3d84c1b0b1f8823fa64259eb372a1278e6a40dddf2cefb4c96ab942", + "size": 238135, + "subdir": "noarch", + "timestamp": 1626374695070, + "track_features": "", + "url": "https://repo.anaconda.com/pkgs/main/noarch/python-dateutil-2.8.2-pyhd3eb1b0_0.conda", + "version": "2.8.2" +} \ No newline at end of file diff --git a/crates/pet-conda/tests/unix/anaconda3-2023.03-without-history/conda-meta/python-fastjsonschema-2.16.2-py310hca03da5_0.json b/crates/pet-conda/tests/unix/anaconda3-2023.03-without-history/conda-meta/python-fastjsonschema-2.16.2-py310hca03da5_0.json new file mode 100644 index 00000000..1e617319 --- /dev/null +++ b/crates/pet-conda/tests/unix/anaconda3-2023.03-without-history/conda-meta/python-fastjsonschema-2.16.2-py310hca03da5_0.json @@ -0,0 +1,66 @@ +{ + "build": "py310hca03da5_0", + "build_number": 0, + "channel": "https://repo.anaconda.com/pkgs/main/osx-arm64", + "constrains": [], + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "extracted_package_dir": "/Users/donjayamanne/.pyenv/versions/anaconda3-2023.03/pkgs/python-fastjsonschema-2.16.2-py310hca03da5_0", + "features": "", + "files": [ + "lib/python3.10/site-packages/fastjsonschema-2.16.2.dist-info/AUTHORS", + "lib/python3.10/site-packages/fastjsonschema-2.16.2.dist-info/INSTALLER", + "lib/python3.10/site-packages/fastjsonschema-2.16.2.dist-info/LICENSE", + "lib/python3.10/site-packages/fastjsonschema-2.16.2.dist-info/METADATA", + "lib/python3.10/site-packages/fastjsonschema-2.16.2.dist-info/RECORD", + "lib/python3.10/site-packages/fastjsonschema-2.16.2.dist-info/REQUESTED", + "lib/python3.10/site-packages/fastjsonschema-2.16.2.dist-info/WHEEL", + "lib/python3.10/site-packages/fastjsonschema-2.16.2.dist-info/direct_url.json", + "lib/python3.10/site-packages/fastjsonschema-2.16.2.dist-info/top_level.txt", + "lib/python3.10/site-packages/fastjsonschema/__init__.py", + "lib/python3.10/site-packages/fastjsonschema/__main__.py", + "lib/python3.10/site-packages/fastjsonschema/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/fastjsonschema/__pycache__/__main__.cpython-310.pyc", + "lib/python3.10/site-packages/fastjsonschema/__pycache__/draft04.cpython-310.pyc", + "lib/python3.10/site-packages/fastjsonschema/__pycache__/draft06.cpython-310.pyc", + "lib/python3.10/site-packages/fastjsonschema/__pycache__/draft07.cpython-310.pyc", + "lib/python3.10/site-packages/fastjsonschema/__pycache__/exceptions.cpython-310.pyc", + "lib/python3.10/site-packages/fastjsonschema/__pycache__/generator.cpython-310.pyc", + "lib/python3.10/site-packages/fastjsonschema/__pycache__/indent.cpython-310.pyc", + "lib/python3.10/site-packages/fastjsonschema/__pycache__/ref_resolver.cpython-310.pyc", + "lib/python3.10/site-packages/fastjsonschema/__pycache__/version.cpython-310.pyc", + "lib/python3.10/site-packages/fastjsonschema/draft04.py", + "lib/python3.10/site-packages/fastjsonschema/draft06.py", + "lib/python3.10/site-packages/fastjsonschema/draft07.py", + "lib/python3.10/site-packages/fastjsonschema/exceptions.py", + "lib/python3.10/site-packages/fastjsonschema/generator.py", + "lib/python3.10/site-packages/fastjsonschema/indent.py", + "lib/python3.10/site-packages/fastjsonschema/ref_resolver.py", + "lib/python3.10/site-packages/fastjsonschema/version.py" + ], + "fn": "python-fastjsonschema-2.16.2-py310hca03da5_0.conda", + "legacy_bz2_md5": "fac5645515e04c5ac0e47d80133671e2", + "legacy_bz2_size": 267399, + "license": "BSD-3-Clause", + "license_family": "BSD", + "link": { + "source": "/Users/donjayamanne/.pyenv/versions/anaconda3-2023.03/pkgs/python-fastjsonschema-2.16.2-py310hca03da5_0", + "type": 1 + }, + "md5": "70d5db9481d95286a170b6ef099949ed", + "name": "python-fastjsonschema", + "package_tarball_full_path": "/Users/donjayamanne/.pyenv/versions/anaconda3-2023.03/pkgs/python-fastjsonschema-2.16.2-py310hca03da5_0.conda", + "paths_data": { + "paths": [], + "paths_version": 1 + }, + "requested_spec": "defaults/osx-arm64::python-fastjsonschema==2.16.2=py310hca03da5_0[md5=70d5db9481d95286a170b6ef099949ed]", + "sha256": "074dae8587f84038a5bd10cd37d389b663a812aa0e2115a106e6a6aa757cc3b9", + "size": 237477, + "subdir": "osx-arm64", + "timestamp": 1661368747513, + "track_features": "", + "url": "https://repo.anaconda.com/pkgs/main/osx-arm64/python-fastjsonschema-2.16.2-py310hca03da5_0.conda", + "version": "2.16.2" +} \ No newline at end of file diff --git a/crates/pet-conda/tests/unix/anaconda3-2023.03-without-history/condabin/conda b/crates/pet-conda/tests/unix/anaconda3-2023.03-without-history/condabin/conda new file mode 100644 index 00000000..e69de29b diff --git a/crates/pet-conda/tests/unix/anaconda3-2023.03/bin/conda b/crates/pet-conda/tests/unix/anaconda3-2023.03/bin/conda new file mode 100644 index 00000000..e69de29b diff --git a/crates/pet-conda/tests/unix/anaconda3-2023.03/bin/python b/crates/pet-conda/tests/unix/anaconda3-2023.03/bin/python new file mode 100644 index 00000000..e69de29b diff --git a/crates/pet-conda/tests/unix/anaconda3-2023.03/bin/python3 b/crates/pet-conda/tests/unix/anaconda3-2023.03/bin/python3 new file mode 100644 index 00000000..e69de29b diff --git a/crates/pet-conda/tests/unix/anaconda3-2023.03/bin/python3.1 b/crates/pet-conda/tests/unix/anaconda3-2023.03/bin/python3.1 new file mode 100644 index 00000000..e69de29b diff --git a/crates/pet-conda/tests/unix/anaconda3-2023.03/bin/python3.10 b/crates/pet-conda/tests/unix/anaconda3-2023.03/bin/python3.10 new file mode 100644 index 00000000..e69de29b diff --git a/crates/pet-conda/tests/unix/anaconda3-2023.03/conda-meta/conda-23.1.0-py310hca03da5_0.json b/crates/pet-conda/tests/unix/anaconda3-2023.03/conda-meta/conda-23.1.0-py310hca03da5_0.json new file mode 100644 index 00000000..0ab7e321 --- /dev/null +++ b/crates/pet-conda/tests/unix/anaconda3-2023.03/conda-meta/conda-23.1.0-py310hca03da5_0.json @@ -0,0 +1,575 @@ +{ + "build": "py310hca03da5_0", + "build_number": 0, + "channel": "https://repo.anaconda.com/pkgs/main/osx-arm64", + "constrains": [ + "conda-content-trust >=0.1.1", + "cytoolz >=0.8.1", + "conda-env >=2.6", + "conda-libmamba-solver >=22.12.0", + "conda-build >=3" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pluggy >=1.0.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.10,<3.11.0a0", + "requests >=2.20.1,<3", + "ruamel.yaml >=0.11.14,<0.18", + "setuptools >=31.0.1", + "toolz >=0.8.1", + "tqdm >=4" + ], + "extracted_package_dir": "/Users/donjayamanne/.pyenv/versions/anaconda3-2023.03/pkgs/conda-23.1.0-py310hca03da5_0", + "features": "", + "files": [ + "bin/activate", + "bin/conda", + "bin/conda-env", + "bin/deactivate", + "condabin/conda", + "etc/fish/conf.d/conda.fish", + "etc/profile.d/conda.csh", + "etc/profile.d/conda.sh", + "lib/python3.10/site-packages/conda-23.1.0-py3.10.egg-info/PKG-INFO", + "lib/python3.10/site-packages/conda-23.1.0-py3.10.egg-info/SOURCES.txt", + "lib/python3.10/site-packages/conda-23.1.0-py3.10.egg-info/dependency_links.txt", + "lib/python3.10/site-packages/conda-23.1.0-py3.10.egg-info/entry_points.txt", + "lib/python3.10/site-packages/conda-23.1.0-py3.10.egg-info/not-zip-safe", + "lib/python3.10/site-packages/conda-23.1.0-py3.10.egg-info/requires.txt", + "lib/python3.10/site-packages/conda-23.1.0-py3.10.egg-info/top_level.txt", + "lib/python3.10/site-packages/conda/.version", + "lib/python3.10/site-packages/conda/__init__.py", + "lib/python3.10/site-packages/conda/__main__.py", + "lib/python3.10/site-packages/conda/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/conda/__pycache__/__main__.cpython-310.pyc", + "lib/python3.10/site-packages/conda/__pycache__/activate.cpython-310.pyc", + "lib/python3.10/site-packages/conda/__pycache__/api.cpython-310.pyc", + "lib/python3.10/site-packages/conda/__pycache__/exceptions.cpython-310.pyc", + "lib/python3.10/site-packages/conda/__pycache__/exports.cpython-310.pyc", + "lib/python3.10/site-packages/conda/__pycache__/history.cpython-310.pyc", + "lib/python3.10/site-packages/conda/__pycache__/instructions.cpython-310.pyc", + "lib/python3.10/site-packages/conda/__pycache__/lock.cpython-310.pyc", + "lib/python3.10/site-packages/conda/__pycache__/misc.cpython-310.pyc", + "lib/python3.10/site-packages/conda/__pycache__/plan.cpython-310.pyc", + "lib/python3.10/site-packages/conda/__pycache__/resolve.cpython-310.pyc", + "lib/python3.10/site-packages/conda/__pycache__/utils.cpython-310.pyc", + "lib/python3.10/site-packages/conda/_vendor/__init__.py", + "lib/python3.10/site-packages/conda/_vendor/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/conda/_vendor/__pycache__/appdirs.cpython-310.pyc", + "lib/python3.10/site-packages/conda/_vendor/__pycache__/distro.cpython-310.pyc", + "lib/python3.10/site-packages/conda/_vendor/appdirs.py", + "lib/python3.10/site-packages/conda/_vendor/boltons/LICENSE", + "lib/python3.10/site-packages/conda/_vendor/boltons/__init__.py", + "lib/python3.10/site-packages/conda/_vendor/boltons/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/conda/_vendor/boltons/__pycache__/setutils.cpython-310.pyc", + "lib/python3.10/site-packages/conda/_vendor/boltons/__pycache__/timeutils.cpython-310.pyc", + "lib/python3.10/site-packages/conda/_vendor/boltons/setutils.py", + "lib/python3.10/site-packages/conda/_vendor/boltons/timeutils.py", + "lib/python3.10/site-packages/conda/_vendor/cpuinfo/__init__.py", + "lib/python3.10/site-packages/conda/_vendor/cpuinfo/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/conda/_vendor/cpuinfo/__pycache__/cpuinfo.cpython-310.pyc", + "lib/python3.10/site-packages/conda/_vendor/cpuinfo/cpuinfo.py", + "lib/python3.10/site-packages/conda/_vendor/distro.py", + "lib/python3.10/site-packages/conda/_vendor/frozendict/__init__.py", + "lib/python3.10/site-packages/conda/_vendor/frozendict/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/conda/_vendor/toolz/__init__.py", + "lib/python3.10/site-packages/conda/_vendor/toolz/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/conda/_vendor/toolz/__pycache__/compatibility.cpython-310.pyc", + "lib/python3.10/site-packages/conda/_vendor/toolz/__pycache__/dicttoolz.cpython-310.pyc", + "lib/python3.10/site-packages/conda/_vendor/toolz/__pycache__/itertoolz.cpython-310.pyc", + "lib/python3.10/site-packages/conda/_vendor/toolz/__pycache__/recipes.cpython-310.pyc", + "lib/python3.10/site-packages/conda/_vendor/toolz/__pycache__/utils.cpython-310.pyc", + "lib/python3.10/site-packages/conda/_vendor/toolz/compatibility.py", + "lib/python3.10/site-packages/conda/_vendor/toolz/dicttoolz.py", + "lib/python3.10/site-packages/conda/_vendor/toolz/itertoolz.py", + "lib/python3.10/site-packages/conda/_vendor/toolz/recipes.py", + "lib/python3.10/site-packages/conda/_vendor/toolz/utils.py", + "lib/python3.10/site-packages/conda/_vendor/tqdm/__init__.py", + "lib/python3.10/site-packages/conda/_vendor/tqdm/__main__.py", + "lib/python3.10/site-packages/conda/_vendor/tqdm/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/conda/_vendor/tqdm/__pycache__/__main__.cpython-310.pyc", + "lib/python3.10/site-packages/conda/_vendor/tqdm/__pycache__/_main.cpython-310.pyc", + "lib/python3.10/site-packages/conda/_vendor/tqdm/__pycache__/_monitor.cpython-310.pyc", + "lib/python3.10/site-packages/conda/_vendor/tqdm/__pycache__/_tqdm.cpython-310.pyc", + "lib/python3.10/site-packages/conda/_vendor/tqdm/__pycache__/_utils.cpython-310.pyc", + "lib/python3.10/site-packages/conda/_vendor/tqdm/__pycache__/asyncio.cpython-310.pyc", + "lib/python3.10/site-packages/conda/_vendor/tqdm/__pycache__/auto.cpython-310.pyc", + "lib/python3.10/site-packages/conda/_vendor/tqdm/__pycache__/cli.cpython-310.pyc", + "lib/python3.10/site-packages/conda/_vendor/tqdm/__pycache__/std.cpython-310.pyc", + "lib/python3.10/site-packages/conda/_vendor/tqdm/__pycache__/utils.cpython-310.pyc", + "lib/python3.10/site-packages/conda/_vendor/tqdm/__pycache__/version.cpython-310.pyc", + "lib/python3.10/site-packages/conda/_vendor/tqdm/_main.py", + "lib/python3.10/site-packages/conda/_vendor/tqdm/_monitor.py", + "lib/python3.10/site-packages/conda/_vendor/tqdm/_tqdm.py", + "lib/python3.10/site-packages/conda/_vendor/tqdm/_utils.py", + "lib/python3.10/site-packages/conda/_vendor/tqdm/asyncio.py", + "lib/python3.10/site-packages/conda/_vendor/tqdm/auto.py", + "lib/python3.10/site-packages/conda/_vendor/tqdm/cli.py", + "lib/python3.10/site-packages/conda/_vendor/tqdm/std.py", + "lib/python3.10/site-packages/conda/_vendor/tqdm/utils.py", + "lib/python3.10/site-packages/conda/_vendor/tqdm/version.py", + "lib/python3.10/site-packages/conda/activate.py", + "lib/python3.10/site-packages/conda/api.py", + "lib/python3.10/site-packages/conda/auxlib/LICENSE", + "lib/python3.10/site-packages/conda/auxlib/__init__.py", + "lib/python3.10/site-packages/conda/auxlib/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/conda/auxlib/__pycache__/collection.cpython-310.pyc", + "lib/python3.10/site-packages/conda/auxlib/__pycache__/compat.cpython-310.pyc", + "lib/python3.10/site-packages/conda/auxlib/__pycache__/decorators.cpython-310.pyc", + "lib/python3.10/site-packages/conda/auxlib/__pycache__/entity.cpython-310.pyc", + "lib/python3.10/site-packages/conda/auxlib/__pycache__/exceptions.cpython-310.pyc", + "lib/python3.10/site-packages/conda/auxlib/__pycache__/ish.cpython-310.pyc", + "lib/python3.10/site-packages/conda/auxlib/__pycache__/logz.cpython-310.pyc", + "lib/python3.10/site-packages/conda/auxlib/__pycache__/packaging.cpython-310.pyc", + "lib/python3.10/site-packages/conda/auxlib/__pycache__/type_coercion.cpython-310.pyc", + "lib/python3.10/site-packages/conda/auxlib/collection.py", + "lib/python3.10/site-packages/conda/auxlib/compat.py", + "lib/python3.10/site-packages/conda/auxlib/decorators.py", + "lib/python3.10/site-packages/conda/auxlib/entity.py", + "lib/python3.10/site-packages/conda/auxlib/exceptions.py", + "lib/python3.10/site-packages/conda/auxlib/ish.py", + "lib/python3.10/site-packages/conda/auxlib/logz.py", + "lib/python3.10/site-packages/conda/auxlib/packaging.py", + "lib/python3.10/site-packages/conda/auxlib/type_coercion.py", + "lib/python3.10/site-packages/conda/base/__init__.py", + "lib/python3.10/site-packages/conda/base/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/conda/base/__pycache__/constants.cpython-310.pyc", + "lib/python3.10/site-packages/conda/base/__pycache__/context.cpython-310.pyc", + "lib/python3.10/site-packages/conda/base/__pycache__/exceptions.cpython-310.pyc", + "lib/python3.10/site-packages/conda/base/constants.py", + "lib/python3.10/site-packages/conda/base/context.py", + "lib/python3.10/site-packages/conda/base/exceptions.py", + "lib/python3.10/site-packages/conda/cli/__init__.py", + "lib/python3.10/site-packages/conda/cli/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/conda/cli/__pycache__/common.cpython-310.pyc", + "lib/python3.10/site-packages/conda/cli/__pycache__/conda_argparse.cpython-310.pyc", + "lib/python3.10/site-packages/conda/cli/__pycache__/find_commands.cpython-310.pyc", + "lib/python3.10/site-packages/conda/cli/__pycache__/install.cpython-310.pyc", + "lib/python3.10/site-packages/conda/cli/__pycache__/main.cpython-310.pyc", + "lib/python3.10/site-packages/conda/cli/__pycache__/main_clean.cpython-310.pyc", + "lib/python3.10/site-packages/conda/cli/__pycache__/main_compare.cpython-310.pyc", + "lib/python3.10/site-packages/conda/cli/__pycache__/main_config.cpython-310.pyc", + "lib/python3.10/site-packages/conda/cli/__pycache__/main_create.cpython-310.pyc", + "lib/python3.10/site-packages/conda/cli/__pycache__/main_info.cpython-310.pyc", + "lib/python3.10/site-packages/conda/cli/__pycache__/main_init.cpython-310.pyc", + "lib/python3.10/site-packages/conda/cli/__pycache__/main_install.cpython-310.pyc", + "lib/python3.10/site-packages/conda/cli/__pycache__/main_list.cpython-310.pyc", + "lib/python3.10/site-packages/conda/cli/__pycache__/main_notices.cpython-310.pyc", + "lib/python3.10/site-packages/conda/cli/__pycache__/main_package.cpython-310.pyc", + "lib/python3.10/site-packages/conda/cli/__pycache__/main_pip.cpython-310.pyc", + "lib/python3.10/site-packages/conda/cli/__pycache__/main_remove.cpython-310.pyc", + "lib/python3.10/site-packages/conda/cli/__pycache__/main_rename.cpython-310.pyc", + "lib/python3.10/site-packages/conda/cli/__pycache__/main_run.cpython-310.pyc", + "lib/python3.10/site-packages/conda/cli/__pycache__/main_search.cpython-310.pyc", + "lib/python3.10/site-packages/conda/cli/__pycache__/main_update.cpython-310.pyc", + "lib/python3.10/site-packages/conda/cli/__pycache__/python_api.cpython-310.pyc", + "lib/python3.10/site-packages/conda/cli/common.py", + "lib/python3.10/site-packages/conda/cli/conda_argparse.py", + "lib/python3.10/site-packages/conda/cli/find_commands.py", + "lib/python3.10/site-packages/conda/cli/install.py", + "lib/python3.10/site-packages/conda/cli/main.py", + "lib/python3.10/site-packages/conda/cli/main_clean.py", + "lib/python3.10/site-packages/conda/cli/main_compare.py", + "lib/python3.10/site-packages/conda/cli/main_config.py", + "lib/python3.10/site-packages/conda/cli/main_create.py", + "lib/python3.10/site-packages/conda/cli/main_info.py", + "lib/python3.10/site-packages/conda/cli/main_init.py", + "lib/python3.10/site-packages/conda/cli/main_install.py", + "lib/python3.10/site-packages/conda/cli/main_list.py", + "lib/python3.10/site-packages/conda/cli/main_notices.py", + "lib/python3.10/site-packages/conda/cli/main_package.py", + "lib/python3.10/site-packages/conda/cli/main_pip.py", + "lib/python3.10/site-packages/conda/cli/main_remove.py", + "lib/python3.10/site-packages/conda/cli/main_rename.py", + "lib/python3.10/site-packages/conda/cli/main_run.py", + "lib/python3.10/site-packages/conda/cli/main_search.py", + "lib/python3.10/site-packages/conda/cli/main_update.py", + "lib/python3.10/site-packages/conda/cli/python_api.py", + "lib/python3.10/site-packages/conda/common/__init__.py", + "lib/python3.10/site-packages/conda/common/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/conda/common/__pycache__/_logic.cpython-310.pyc", + "lib/python3.10/site-packages/conda/common/__pycache__/compat.cpython-310.pyc", + "lib/python3.10/site-packages/conda/common/__pycache__/configuration.cpython-310.pyc", + "lib/python3.10/site-packages/conda/common/__pycache__/constants.cpython-310.pyc", + "lib/python3.10/site-packages/conda/common/__pycache__/cuda.cpython-310.pyc", + "lib/python3.10/site-packages/conda/common/__pycache__/decorators.cpython-310.pyc", + "lib/python3.10/site-packages/conda/common/__pycache__/disk.cpython-310.pyc", + "lib/python3.10/site-packages/conda/common/__pycache__/io.cpython-310.pyc", + "lib/python3.10/site-packages/conda/common/__pycache__/iterators.cpython-310.pyc", + "lib/python3.10/site-packages/conda/common/__pycache__/logic.cpython-310.pyc", + "lib/python3.10/site-packages/conda/common/__pycache__/path.cpython-310.pyc", + "lib/python3.10/site-packages/conda/common/__pycache__/serialize.cpython-310.pyc", + "lib/python3.10/site-packages/conda/common/__pycache__/signals.cpython-310.pyc", + "lib/python3.10/site-packages/conda/common/__pycache__/toposort.cpython-310.pyc", + "lib/python3.10/site-packages/conda/common/__pycache__/url.cpython-310.pyc", + "lib/python3.10/site-packages/conda/common/_logic.py", + "lib/python3.10/site-packages/conda/common/_os/__init__.py", + "lib/python3.10/site-packages/conda/common/_os/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/conda/common/_os/__pycache__/linux.cpython-310.pyc", + "lib/python3.10/site-packages/conda/common/_os/__pycache__/unix.cpython-310.pyc", + "lib/python3.10/site-packages/conda/common/_os/__pycache__/windows.cpython-310.pyc", + "lib/python3.10/site-packages/conda/common/_os/linux.py", + "lib/python3.10/site-packages/conda/common/_os/unix.py", + "lib/python3.10/site-packages/conda/common/_os/windows.py", + "lib/python3.10/site-packages/conda/common/compat.py", + "lib/python3.10/site-packages/conda/common/configuration.py", + "lib/python3.10/site-packages/conda/common/constants.py", + "lib/python3.10/site-packages/conda/common/cuda.py", + "lib/python3.10/site-packages/conda/common/decorators.py", + "lib/python3.10/site-packages/conda/common/disk.py", + "lib/python3.10/site-packages/conda/common/io.py", + "lib/python3.10/site-packages/conda/common/iterators.py", + "lib/python3.10/site-packages/conda/common/logic.py", + "lib/python3.10/site-packages/conda/common/path.py", + "lib/python3.10/site-packages/conda/common/pkg_formats/__init__.py", + "lib/python3.10/site-packages/conda/common/pkg_formats/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/conda/common/pkg_formats/__pycache__/python.cpython-310.pyc", + "lib/python3.10/site-packages/conda/common/pkg_formats/python.py", + "lib/python3.10/site-packages/conda/common/serialize.py", + "lib/python3.10/site-packages/conda/common/signals.py", + "lib/python3.10/site-packages/conda/common/toposort.py", + "lib/python3.10/site-packages/conda/common/url.py", + "lib/python3.10/site-packages/conda/core/__init__.py", + "lib/python3.10/site-packages/conda/core/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/conda/core/__pycache__/envs_manager.cpython-310.pyc", + "lib/python3.10/site-packages/conda/core/__pycache__/index.cpython-310.pyc", + "lib/python3.10/site-packages/conda/core/__pycache__/initialize.cpython-310.pyc", + "lib/python3.10/site-packages/conda/core/__pycache__/link.cpython-310.pyc", + "lib/python3.10/site-packages/conda/core/__pycache__/package_cache.cpython-310.pyc", + "lib/python3.10/site-packages/conda/core/__pycache__/package_cache_data.cpython-310.pyc", + "lib/python3.10/site-packages/conda/core/__pycache__/path_actions.cpython-310.pyc", + "lib/python3.10/site-packages/conda/core/__pycache__/portability.cpython-310.pyc", + "lib/python3.10/site-packages/conda/core/__pycache__/prefix_data.cpython-310.pyc", + "lib/python3.10/site-packages/conda/core/__pycache__/solve.cpython-310.pyc", + "lib/python3.10/site-packages/conda/core/__pycache__/subdir_data.cpython-310.pyc", + "lib/python3.10/site-packages/conda/core/envs_manager.py", + "lib/python3.10/site-packages/conda/core/index.py", + "lib/python3.10/site-packages/conda/core/initialize.py", + "lib/python3.10/site-packages/conda/core/link.py", + "lib/python3.10/site-packages/conda/core/package_cache.py", + "lib/python3.10/site-packages/conda/core/package_cache_data.py", + "lib/python3.10/site-packages/conda/core/path_actions.py", + "lib/python3.10/site-packages/conda/core/portability.py", + "lib/python3.10/site-packages/conda/core/prefix_data.py", + "lib/python3.10/site-packages/conda/core/solve.py", + "lib/python3.10/site-packages/conda/core/subdir_data.py", + "lib/python3.10/site-packages/conda/exceptions.py", + "lib/python3.10/site-packages/conda/exports.py", + "lib/python3.10/site-packages/conda/gateways/__init__.py", + "lib/python3.10/site-packages/conda/gateways/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/conda/gateways/__pycache__/anaconda_client.cpython-310.pyc", + "lib/python3.10/site-packages/conda/gateways/__pycache__/logging.cpython-310.pyc", + "lib/python3.10/site-packages/conda/gateways/__pycache__/subprocess.cpython-310.pyc", + "lib/python3.10/site-packages/conda/gateways/anaconda_client.py", + "lib/python3.10/site-packages/conda/gateways/connection/__init__.py", + "lib/python3.10/site-packages/conda/gateways/connection/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/conda/gateways/connection/__pycache__/download.cpython-310.pyc", + "lib/python3.10/site-packages/conda/gateways/connection/__pycache__/session.cpython-310.pyc", + "lib/python3.10/site-packages/conda/gateways/connection/adapters/__init__.py", + "lib/python3.10/site-packages/conda/gateways/connection/adapters/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/conda/gateways/connection/adapters/__pycache__/ftp.cpython-310.pyc", + "lib/python3.10/site-packages/conda/gateways/connection/adapters/__pycache__/localfs.cpython-310.pyc", + "lib/python3.10/site-packages/conda/gateways/connection/adapters/__pycache__/s3.cpython-310.pyc", + "lib/python3.10/site-packages/conda/gateways/connection/adapters/ftp.py", + "lib/python3.10/site-packages/conda/gateways/connection/adapters/localfs.py", + "lib/python3.10/site-packages/conda/gateways/connection/adapters/s3.py", + "lib/python3.10/site-packages/conda/gateways/connection/download.py", + "lib/python3.10/site-packages/conda/gateways/connection/session.py", + "lib/python3.10/site-packages/conda/gateways/disk/__init__.py", + "lib/python3.10/site-packages/conda/gateways/disk/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/conda/gateways/disk/__pycache__/create.cpython-310.pyc", + "lib/python3.10/site-packages/conda/gateways/disk/__pycache__/delete.cpython-310.pyc", + "lib/python3.10/site-packages/conda/gateways/disk/__pycache__/link.cpython-310.pyc", + "lib/python3.10/site-packages/conda/gateways/disk/__pycache__/permissions.cpython-310.pyc", + "lib/python3.10/site-packages/conda/gateways/disk/__pycache__/read.cpython-310.pyc", + "lib/python3.10/site-packages/conda/gateways/disk/__pycache__/test.cpython-310.pyc", + "lib/python3.10/site-packages/conda/gateways/disk/__pycache__/update.cpython-310.pyc", + "lib/python3.10/site-packages/conda/gateways/disk/create.py", + "lib/python3.10/site-packages/conda/gateways/disk/delete.py", + "lib/python3.10/site-packages/conda/gateways/disk/link.py", + "lib/python3.10/site-packages/conda/gateways/disk/permissions.py", + "lib/python3.10/site-packages/conda/gateways/disk/read.py", + "lib/python3.10/site-packages/conda/gateways/disk/test.py", + "lib/python3.10/site-packages/conda/gateways/disk/update.py", + "lib/python3.10/site-packages/conda/gateways/logging.py", + "lib/python3.10/site-packages/conda/gateways/repodata/__init__.py", + "lib/python3.10/site-packages/conda/gateways/repodata/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/conda/gateways/subprocess.py", + "lib/python3.10/site-packages/conda/history.py", + "lib/python3.10/site-packages/conda/instructions.py", + "lib/python3.10/site-packages/conda/lock.py", + "lib/python3.10/site-packages/conda/misc.py", + "lib/python3.10/site-packages/conda/models/__init__.py", + "lib/python3.10/site-packages/conda/models/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/conda/models/__pycache__/channel.cpython-310.pyc", + "lib/python3.10/site-packages/conda/models/__pycache__/dist.cpython-310.pyc", + "lib/python3.10/site-packages/conda/models/__pycache__/enums.cpython-310.pyc", + "lib/python3.10/site-packages/conda/models/__pycache__/leased_path_entry.cpython-310.pyc", + "lib/python3.10/site-packages/conda/models/__pycache__/match_spec.cpython-310.pyc", + "lib/python3.10/site-packages/conda/models/__pycache__/package_info.cpython-310.pyc", + "lib/python3.10/site-packages/conda/models/__pycache__/prefix_graph.cpython-310.pyc", + "lib/python3.10/site-packages/conda/models/__pycache__/records.cpython-310.pyc", + "lib/python3.10/site-packages/conda/models/__pycache__/version.cpython-310.pyc", + "lib/python3.10/site-packages/conda/models/channel.py", + "lib/python3.10/site-packages/conda/models/dist.py", + "lib/python3.10/site-packages/conda/models/enums.py", + "lib/python3.10/site-packages/conda/models/leased_path_entry.py", + "lib/python3.10/site-packages/conda/models/match_spec.py", + "lib/python3.10/site-packages/conda/models/package_info.py", + "lib/python3.10/site-packages/conda/models/prefix_graph.py", + "lib/python3.10/site-packages/conda/models/records.py", + "lib/python3.10/site-packages/conda/models/version.py", + "lib/python3.10/site-packages/conda/notices/__init__.py", + "lib/python3.10/site-packages/conda/notices/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/conda/notices/__pycache__/cache.cpython-310.pyc", + "lib/python3.10/site-packages/conda/notices/__pycache__/core.cpython-310.pyc", + "lib/python3.10/site-packages/conda/notices/__pycache__/fetch.cpython-310.pyc", + "lib/python3.10/site-packages/conda/notices/__pycache__/types.cpython-310.pyc", + "lib/python3.10/site-packages/conda/notices/__pycache__/views.cpython-310.pyc", + "lib/python3.10/site-packages/conda/notices/cache.py", + "lib/python3.10/site-packages/conda/notices/core.py", + "lib/python3.10/site-packages/conda/notices/fetch.py", + "lib/python3.10/site-packages/conda/notices/types.py", + "lib/python3.10/site-packages/conda/notices/views.py", + "lib/python3.10/site-packages/conda/plan.py", + "lib/python3.10/site-packages/conda/plugins/__init__.py", + "lib/python3.10/site-packages/conda/plugins/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/conda/plugins/__pycache__/hookspec.cpython-310.pyc", + "lib/python3.10/site-packages/conda/plugins/__pycache__/manager.cpython-310.pyc", + "lib/python3.10/site-packages/conda/plugins/__pycache__/solvers.cpython-310.pyc", + "lib/python3.10/site-packages/conda/plugins/__pycache__/types.cpython-310.pyc", + "lib/python3.10/site-packages/conda/plugins/hookspec.py", + "lib/python3.10/site-packages/conda/plugins/manager.py", + "lib/python3.10/site-packages/conda/plugins/solvers.py", + "lib/python3.10/site-packages/conda/plugins/types.py", + "lib/python3.10/site-packages/conda/plugins/virtual_packages/__init__.py", + "lib/python3.10/site-packages/conda/plugins/virtual_packages/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/conda/plugins/virtual_packages/__pycache__/archspec.cpython-310.pyc", + "lib/python3.10/site-packages/conda/plugins/virtual_packages/__pycache__/cuda.cpython-310.pyc", + "lib/python3.10/site-packages/conda/plugins/virtual_packages/__pycache__/linux.cpython-310.pyc", + "lib/python3.10/site-packages/conda/plugins/virtual_packages/__pycache__/osx.cpython-310.pyc", + "lib/python3.10/site-packages/conda/plugins/virtual_packages/__pycache__/windows.cpython-310.pyc", + "lib/python3.10/site-packages/conda/plugins/virtual_packages/archspec.py", + "lib/python3.10/site-packages/conda/plugins/virtual_packages/cuda.py", + "lib/python3.10/site-packages/conda/plugins/virtual_packages/linux.py", + "lib/python3.10/site-packages/conda/plugins/virtual_packages/osx.py", + "lib/python3.10/site-packages/conda/plugins/virtual_packages/windows.py", + "lib/python3.10/site-packages/conda/resolve.py", + "lib/python3.10/site-packages/conda/shell/Library/bin/conda.bat", + "lib/python3.10/site-packages/conda/shell/Scripts/activate.bat", + "lib/python3.10/site-packages/conda/shell/bin/activate", + "lib/python3.10/site-packages/conda/shell/bin/conda", + "lib/python3.10/site-packages/conda/shell/bin/deactivate", + "lib/python3.10/site-packages/conda/shell/cli-32.exe", + "lib/python3.10/site-packages/conda/shell/cli-64.exe", + "lib/python3.10/site-packages/conda/shell/conda.xsh", + "lib/python3.10/site-packages/conda/shell/conda_icon.ico", + "lib/python3.10/site-packages/conda/shell/condabin/Conda.psm1", + "lib/python3.10/site-packages/conda/shell/condabin/_conda_activate.bat", + "lib/python3.10/site-packages/conda/shell/condabin/activate.bat", + "lib/python3.10/site-packages/conda/shell/condabin/conda-hook.ps1", + "lib/python3.10/site-packages/conda/shell/condabin/conda.bat", + "lib/python3.10/site-packages/conda/shell/condabin/conda_auto_activate.bat", + "lib/python3.10/site-packages/conda/shell/condabin/conda_hook.bat", + "lib/python3.10/site-packages/conda/shell/condabin/deactivate.bat", + "lib/python3.10/site-packages/conda/shell/condabin/rename_tmp.bat", + "lib/python3.10/site-packages/conda/shell/etc/fish/conf.d/conda.fish", + "lib/python3.10/site-packages/conda/shell/etc/profile.d/conda.csh", + "lib/python3.10/site-packages/conda/shell/etc/profile.d/conda.sh", + "lib/python3.10/site-packages/conda/testing/__init__.py", + "lib/python3.10/site-packages/conda/testing/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/conda/testing/__pycache__/cases.cpython-310.pyc", + "lib/python3.10/site-packages/conda/testing/__pycache__/fixtures.cpython-310.pyc", + "lib/python3.10/site-packages/conda/testing/__pycache__/helpers.cpython-310.pyc", + "lib/python3.10/site-packages/conda/testing/__pycache__/integration.cpython-310.pyc", + "lib/python3.10/site-packages/conda/testing/__pycache__/solver_helpers.cpython-310.pyc", + "lib/python3.10/site-packages/conda/testing/cases.py", + "lib/python3.10/site-packages/conda/testing/fixtures.py", + "lib/python3.10/site-packages/conda/testing/gateways/__init__.py", + "lib/python3.10/site-packages/conda/testing/gateways/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/conda/testing/gateways/__pycache__/fixtures.cpython-310.pyc", + "lib/python3.10/site-packages/conda/testing/gateways/fixtures.py", + "lib/python3.10/site-packages/conda/testing/helpers.py", + "lib/python3.10/site-packages/conda/testing/integration.py", + "lib/python3.10/site-packages/conda/testing/notices/__init__.py", + "lib/python3.10/site-packages/conda/testing/notices/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/conda/testing/notices/__pycache__/fixtures.cpython-310.pyc", + "lib/python3.10/site-packages/conda/testing/notices/__pycache__/helpers.cpython-310.pyc", + "lib/python3.10/site-packages/conda/testing/notices/fixtures.py", + "lib/python3.10/site-packages/conda/testing/notices/helpers.py", + "lib/python3.10/site-packages/conda/testing/solver_helpers.py", + "lib/python3.10/site-packages/conda/trust/__init__.py", + "lib/python3.10/site-packages/conda/trust/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/conda/trust/__pycache__/constants.cpython-310.pyc", + "lib/python3.10/site-packages/conda/trust/__pycache__/signature_verification.cpython-310.pyc", + "lib/python3.10/site-packages/conda/trust/constants.py", + "lib/python3.10/site-packages/conda/trust/signature_verification.py", + "lib/python3.10/site-packages/conda/utils.py", + "lib/python3.10/site-packages/conda_env/__init__.py", + "lib/python3.10/site-packages/conda_env/__main__.py", + "lib/python3.10/site-packages/conda_env/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/conda_env/__pycache__/__main__.cpython-310.pyc", + "lib/python3.10/site-packages/conda_env/__pycache__/env.cpython-310.pyc", + "lib/python3.10/site-packages/conda_env/__pycache__/pip_util.cpython-310.pyc", + "lib/python3.10/site-packages/conda_env/cli/__init__.py", + "lib/python3.10/site-packages/conda_env/cli/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/conda_env/cli/__pycache__/common.cpython-310.pyc", + "lib/python3.10/site-packages/conda_env/cli/__pycache__/main.cpython-310.pyc", + "lib/python3.10/site-packages/conda_env/cli/__pycache__/main_config.cpython-310.pyc", + "lib/python3.10/site-packages/conda_env/cli/__pycache__/main_create.cpython-310.pyc", + "lib/python3.10/site-packages/conda_env/cli/__pycache__/main_export.cpython-310.pyc", + "lib/python3.10/site-packages/conda_env/cli/__pycache__/main_list.cpython-310.pyc", + "lib/python3.10/site-packages/conda_env/cli/__pycache__/main_remove.cpython-310.pyc", + "lib/python3.10/site-packages/conda_env/cli/__pycache__/main_update.cpython-310.pyc", + "lib/python3.10/site-packages/conda_env/cli/__pycache__/main_vars.cpython-310.pyc", + "lib/python3.10/site-packages/conda_env/cli/common.py", + "lib/python3.10/site-packages/conda_env/cli/main.py", + "lib/python3.10/site-packages/conda_env/cli/main_config.py", + "lib/python3.10/site-packages/conda_env/cli/main_create.py", + "lib/python3.10/site-packages/conda_env/cli/main_export.py", + "lib/python3.10/site-packages/conda_env/cli/main_list.py", + "lib/python3.10/site-packages/conda_env/cli/main_remove.py", + "lib/python3.10/site-packages/conda_env/cli/main_update.py", + "lib/python3.10/site-packages/conda_env/cli/main_vars.py", + "lib/python3.10/site-packages/conda_env/env.py", + "lib/python3.10/site-packages/conda_env/installers/__init__.py", + "lib/python3.10/site-packages/conda_env/installers/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/conda_env/installers/__pycache__/base.cpython-310.pyc", + "lib/python3.10/site-packages/conda_env/installers/__pycache__/conda.cpython-310.pyc", + "lib/python3.10/site-packages/conda_env/installers/__pycache__/pip.cpython-310.pyc", + "lib/python3.10/site-packages/conda_env/installers/base.py", + "lib/python3.10/site-packages/conda_env/installers/conda.py", + "lib/python3.10/site-packages/conda_env/installers/pip.py", + "lib/python3.10/site-packages/conda_env/pip_util.py", + "lib/python3.10/site-packages/conda_env/specs/__init__.py", + "lib/python3.10/site-packages/conda_env/specs/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/conda_env/specs/__pycache__/binstar.cpython-310.pyc", + "lib/python3.10/site-packages/conda_env/specs/__pycache__/notebook.cpython-310.pyc", + "lib/python3.10/site-packages/conda_env/specs/__pycache__/requirements.cpython-310.pyc", + "lib/python3.10/site-packages/conda_env/specs/__pycache__/yaml_file.cpython-310.pyc", + "lib/python3.10/site-packages/conda_env/specs/binstar.py", + "lib/python3.10/site-packages/conda_env/specs/notebook.py", + "lib/python3.10/site-packages/conda_env/specs/requirements.py", + "lib/python3.10/site-packages/conda_env/specs/yaml_file.py", + "lib/python3.10/site-packages/xontrib/conda.xsh", + "shell/condabin/Conda.psm1", + "shell/condabin/conda-hook.ps1" + ], + "fn": "conda-23.1.0-py310hca03da5_0.conda", + "legacy_bz2_md5": "7c4f77c5ec509dcd5003dd693a2e3c9e", + "legacy_bz2_size": 990313, + "license": "BSD-3-Clause", + "license_family": "BSD", + "link": { + "source": "/Users/donjayamanne/.pyenv/versions/anaconda3-2023.03/pkgs/conda-23.1.0-py310hca03da5_0", + "type": 1 + }, + "md5": "00c5c7f9e827401bd66aaceb9c5ee4a8", + "name": "conda", + "package_tarball_full_path": "/Users/donjayamanne/.pyenv/versions/anaconda3-2023.03/pkgs/conda-23.1.0-py310hca03da5_0.conda", + "paths_data": { + "paths": [ + { + "_path": "bin/activate", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_f1vw_br1qm/croot/conda_1674574636144/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehol", + "sha256": "e276f622f70beeb3a1f25d5af51b76b6b715cad3f21e28eb79225be88d499ba4", + "sha256_in_prefix": "e0338158197b194a1452aecb186cbe38971f797192ece162d6ec574e8e8e6cda", + "size_in_bytes": 429 + }, + { + "_path": "bin/conda", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_f1vw_br1qm/croot/conda_1674574636144/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehol", + "sha256": "ab080152682efca803dac53cfbcfd102f3a33b06a057c492b0aa22c8a9cc739a", + "sha256_in_prefix": "3dccd282d2586f801bfd4fafe2a59cc97a9c05ad8202f6d9bc1ae2ead6c65b41", + "size_in_bytes": 756 + }, + { + "_path": "bin/conda-env", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_f1vw_br1qm/croot/conda_1674574636144/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehol", + "sha256": "64737294f79d62e8a522b03df355826194122f144f8f44f93cb9fca41a33e417", + "sha256_in_prefix": "0cfb694efceb4ad75fe1ed8250683eceb4004b7606bb8c261f77f5264ed2d658", + "size_in_bytes": 393 + }, + { + "_path": "bin/deactivate", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_f1vw_br1qm/croot/conda_1674574636144/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehol", + "sha256": "4970c998fe3718638b1fa504ebb608ecacfc0682f61229941a55ba2161bd20b3", + "sha256_in_prefix": "b619c825c6d1c76f630d01aca010cc78f099af9fa432bd4c010063c26483f59f", + "size_in_bytes": 517 + }, + { + "_path": "condabin/conda", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_f1vw_br1qm/croot/conda_1674574636144/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehol", + "sha256": "ab080152682efca803dac53cfbcfd102f3a33b06a057c492b0aa22c8a9cc739a", + "sha256_in_prefix": "3dccd282d2586f801bfd4fafe2a59cc97a9c05ad8202f6d9bc1ae2ead6c65b41", + "size_in_bytes": 756 + }, + { + "_path": "etc/fish/conf.d/conda.fish", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_f1vw_br1qm/croot/conda_1674574636144/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehol", + "sha256": "6ffed84ed6c728ac8cc324c82a944916bfa93974bd0f3431e48003687bb12883", + "sha256_in_prefix": "79df3672c7b2e72f58a8eeddad177ed7e1d738fca3c6d491951a09fd5787a7a2", + "size_in_bytes": 4880 + }, + { + "_path": "etc/profile.d/conda.csh", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_f1vw_br1qm/croot/conda_1674574636144/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehol", + "sha256": "5ffc2c88ff64d8f8a41f95135efe3012eceffd7e1144bdea20ac0365591d6bf9", + "sha256_in_prefix": "f4dd7bd7acb551cb41afe7775c963d7ab5759647464e953edc17f97b9d84c3bd", + "size_in_bytes": 3164 + }, + { + "_path": "etc/profile.d/conda.sh", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_f1vw_br1qm/croot/conda_1674574636144/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehol", + "sha256": "6d751a99d1dc5de6c41244a213890b583cff3a217ea3acac2b975d01bb971d9a", + "sha256_in_prefix": "18d5fc38f1808824dd557f0b12c0855f7981734de89176b391ea6faa9fa20592", + "size_in_bytes": 2553 + }, + { + "_path": "lib/python3.10/site-packages/xontrib/conda.xsh", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_f1vw_br1qm/croot/conda_1674574636144/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehol", + "sha256": "f4d511a3b380dfc1a015a1bb6f6201f157fdd5b025a3d0bcdc694555b78c8ca6", + "sha256_in_prefix": "7aa4186c00138a4c108e83f46d500a2d33c6d7f40386684d914f0a5c1b94657a", + "size_in_bytes": 7418 + }, + { + "_path": "shell/condabin/conda-hook.ps1", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_f1vw_br1qm/croot/conda_1674574636144/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehol", + "sha256": "d247c979ac45cb449f8988993c8fadea7b68dc32114a17d48619f8f671fea4ae", + "sha256_in_prefix": "bb43432a1dfe9936d54b4cb55e03e623e4e0046e926497ffef077cb83464a6ce", + "size_in_bytes": 1047 + } + ], + "paths_version": 1 + }, + "requested_spec": "defaults/osx-arm64::conda==23.1.0=py310hca03da5_0[md5=00c5c7f9e827401bd66aaceb9c5ee4a8]", + "sha256": "125ed5a84b2874b42430763e4543e23e0496aac8e8e09522594ace150eb6aacf", + "size": 982226, + "subdir": "osx-arm64", + "timestamp": 1674574815058, + "track_features": "", + "url": "https://repo.anaconda.com/pkgs/main/osx-arm64/conda-23.1.0-py310hca03da5_0.conda", + "version": "23.1.0" +} \ No newline at end of file diff --git a/crates/pet-conda/tests/unix/anaconda3-2023.03/conda-meta/conda-build-3.23.3-py310hca03da5_0.json b/crates/pet-conda/tests/unix/anaconda3-2023.03/conda-meta/conda-build-3.23.3-py310hca03da5_0.json new file mode 100644 index 00000000..f0f3640b --- /dev/null +++ b/crates/pet-conda/tests/unix/anaconda3-2023.03/conda-meta/conda-build-3.23.3-py310hca03da5_0.json @@ -0,0 +1,292 @@ +{ + "build": "py310hca03da5_0", + "build_number": 0, + "channel": "https://repo.anaconda.com/pkgs/main/osx-arm64", + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "cctools", + "chardet", + "conda >=4.13", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patch >=2.6", + "pkginfo", + "psutil", + "py-lief", + "python >=3.10,<3.11.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "setuptools", + "six", + "toml", + "tqdm" + ], + "extracted_package_dir": "/Users/donjayamanne/.pyenv/versions/anaconda3-2023.03/pkgs/conda-build-3.23.3-py310hca03da5_0", + "features": "", + "files": [ + "bin/conda-build", + "bin/conda-convert", + "bin/conda-debug", + "bin/conda-develop", + "bin/conda-index", + "bin/conda-inspect", + "bin/conda-metapackage", + "bin/conda-render", + "bin/conda-skeleton", + "lib/python3.10/site-packages/conda_build-3.23.3-py3.10.egg-info/PKG-INFO", + "lib/python3.10/site-packages/conda_build-3.23.3-py3.10.egg-info/SOURCES.txt", + "lib/python3.10/site-packages/conda_build-3.23.3-py3.10.egg-info/dependency_links.txt", + "lib/python3.10/site-packages/conda_build-3.23.3-py3.10.egg-info/entry_points.txt", + "lib/python3.10/site-packages/conda_build-3.23.3-py3.10.egg-info/not-zip-safe", + "lib/python3.10/site-packages/conda_build-3.23.3-py3.10.egg-info/requires.txt", + "lib/python3.10/site-packages/conda_build-3.23.3-py3.10.egg-info/top_level.txt", + "lib/python3.10/site-packages/conda_build/__init__.py", + "lib/python3.10/site-packages/conda_build/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/__pycache__/_link.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/__pycache__/_load_setup_py_data.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/__pycache__/_version.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/__pycache__/api.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/__pycache__/bdist_conda.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/__pycache__/build.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/__pycache__/conda_interface.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/__pycache__/config.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/__pycache__/convert.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/__pycache__/create_test.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/__pycache__/develop.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/__pycache__/environ.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/__pycache__/exceptions.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/__pycache__/features.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/__pycache__/index.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/__pycache__/inspect_pkg.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/__pycache__/jinja_context.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/__pycache__/license_family.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/__pycache__/metadata.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/__pycache__/metapackage.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/__pycache__/noarch_python.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/__pycache__/post.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/__pycache__/render.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/__pycache__/source.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/__pycache__/tarcheck.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/__pycache__/utils.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/__pycache__/variants.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/__pycache__/windows.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/_link.py", + "lib/python3.10/site-packages/conda_build/_load_setup_py_data.py", + "lib/python3.10/site-packages/conda_build/_version.py", + "lib/python3.10/site-packages/conda_build/api.py", + "lib/python3.10/site-packages/conda_build/bdist_conda.py", + "lib/python3.10/site-packages/conda_build/build.py", + "lib/python3.10/site-packages/conda_build/cli-32.exe", + "lib/python3.10/site-packages/conda_build/cli-64.exe", + "lib/python3.10/site-packages/conda_build/cli/__init__.py", + "lib/python3.10/site-packages/conda_build/cli/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/cli/__pycache__/actions.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/cli/__pycache__/main_build.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/cli/__pycache__/main_convert.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/cli/__pycache__/main_debug.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/cli/__pycache__/main_develop.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/cli/__pycache__/main_index.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/cli/__pycache__/main_inspect.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/cli/__pycache__/main_metapackage.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/cli/__pycache__/main_render.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/cli/__pycache__/main_skeleton.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/cli/__pycache__/validators.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/cli/actions.py", + "lib/python3.10/site-packages/conda_build/cli/main_build.py", + "lib/python3.10/site-packages/conda_build/cli/main_convert.py", + "lib/python3.10/site-packages/conda_build/cli/main_debug.py", + "lib/python3.10/site-packages/conda_build/cli/main_develop.py", + "lib/python3.10/site-packages/conda_build/cli/main_index.py", + "lib/python3.10/site-packages/conda_build/cli/main_inspect.py", + "lib/python3.10/site-packages/conda_build/cli/main_metapackage.py", + "lib/python3.10/site-packages/conda_build/cli/main_render.py", + "lib/python3.10/site-packages/conda_build/cli/main_skeleton.py", + "lib/python3.10/site-packages/conda_build/cli/validators.py", + "lib/python3.10/site-packages/conda_build/conda_interface.py", + "lib/python3.10/site-packages/conda_build/config.py", + "lib/python3.10/site-packages/conda_build/convert.py", + "lib/python3.10/site-packages/conda_build/create_test.py", + "lib/python3.10/site-packages/conda_build/develop.py", + "lib/python3.10/site-packages/conda_build/environ.py", + "lib/python3.10/site-packages/conda_build/exceptions.py", + "lib/python3.10/site-packages/conda_build/features.py", + "lib/python3.10/site-packages/conda_build/index.py", + "lib/python3.10/site-packages/conda_build/inspect_pkg.py", + "lib/python3.10/site-packages/conda_build/jinja_context.py", + "lib/python3.10/site-packages/conda_build/license_family.py", + "lib/python3.10/site-packages/conda_build/metadata.py", + "lib/python3.10/site-packages/conda_build/metapackage.py", + "lib/python3.10/site-packages/conda_build/noarch_python.py", + "lib/python3.10/site-packages/conda_build/os_utils/__init__.py", + "lib/python3.10/site-packages/conda_build/os_utils/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/os_utils/__pycache__/elf.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/os_utils/__pycache__/external.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/os_utils/__pycache__/ldd.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/os_utils/__pycache__/liefldd.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/os_utils/__pycache__/macho.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/os_utils/__pycache__/pyldd.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/os_utils/elf.py", + "lib/python3.10/site-packages/conda_build/os_utils/external.py", + "lib/python3.10/site-packages/conda_build/os_utils/ldd.py", + "lib/python3.10/site-packages/conda_build/os_utils/liefldd.py", + "lib/python3.10/site-packages/conda_build/os_utils/macho.py", + "lib/python3.10/site-packages/conda_build/os_utils/pyldd.py", + "lib/python3.10/site-packages/conda_build/post.py", + "lib/python3.10/site-packages/conda_build/render.py", + "lib/python3.10/site-packages/conda_build/skeletons/__init__.py", + "lib/python3.10/site-packages/conda_build/skeletons/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/skeletons/__pycache__/_example_skeleton.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/skeletons/__pycache__/cpan.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/skeletons/__pycache__/cran.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/skeletons/__pycache__/luarocks.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/skeletons/__pycache__/pypi.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/skeletons/__pycache__/rpm.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/skeletons/_example_skeleton.py", + "lib/python3.10/site-packages/conda_build/skeletons/cpan.py", + "lib/python3.10/site-packages/conda_build/skeletons/cran.py", + "lib/python3.10/site-packages/conda_build/skeletons/luarocks.py", + "lib/python3.10/site-packages/conda_build/skeletons/pypi.py", + "lib/python3.10/site-packages/conda_build/skeletons/rpm.py", + "lib/python3.10/site-packages/conda_build/source.py", + "lib/python3.10/site-packages/conda_build/tarcheck.py", + "lib/python3.10/site-packages/conda_build/templates/channeldata-index.html.j2", + "lib/python3.10/site-packages/conda_build/templates/npm.yaml", + "lib/python3.10/site-packages/conda_build/templates/rss.xml.j2", + "lib/python3.10/site-packages/conda_build/templates/setuptools.yaml", + "lib/python3.10/site-packages/conda_build/templates/subdir-index.html.j2", + "lib/python3.10/site-packages/conda_build/utils.py", + "lib/python3.10/site-packages/conda_build/variants.py", + "lib/python3.10/site-packages/conda_build/windows.py" + ], + "fn": "conda-build-3.23.3-py310hca03da5_0.conda", + "legacy_bz2_md5": "8ea35d4f734cdef277a94cf74d22d3ae", + "legacy_bz2_size": 576512, + "license": "BSD-3-Clause", + "license_family": "BSD", + "link": { + "source": "/Users/donjayamanne/.pyenv/versions/anaconda3-2023.03/pkgs/conda-build-3.23.3-py310hca03da5_0", + "type": 1 + }, + "md5": "4a6b06f0a14b98c819cd4b0e09c740e8", + "name": "conda-build", + "package_tarball_full_path": "/Users/donjayamanne/.pyenv/versions/anaconda3-2023.03/pkgs/conda-build-3.23.3-py310hca03da5_0.conda", + "paths_data": { + "paths": [ + { + "_path": "bin/conda-build", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_e9c9oqsgk0/croot/conda-build_1670407343391/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_pl", + "sha256": "bcb2e024326726eba4acd5a19f0a630864fdf5ba060f2e18f15ac7ebc480d110", + "sha256_in_prefix": "0e3157ec917846a3847fb675ea632a2ac8c36673f3be8a1c04f37fc0181733ee", + "size_in_bytes": 479 + }, + { + "_path": "bin/conda-convert", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_e9c9oqsgk0/croot/conda-build_1670407343391/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_pl", + "sha256": "d410d34b34ad6f68b7a1500ed6b63fc27561ce130dee75b39dbe411b5fb3a2af", + "sha256_in_prefix": "f14a90cb7a116bd45a2994c040c6957cac360f762e9c334af427cb8241770367", + "size_in_bytes": 481 + }, + { + "_path": "bin/conda-debug", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_e9c9oqsgk0/croot/conda-build_1670407343391/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_pl", + "sha256": "bd4dffebd208180e99ac73f86ce8ceb5f4bea5c2c71a95bbe687de2560ab9b08", + "sha256_in_prefix": "13a281bc24e2d7aaca30eb00307b6eb44563c677274ab3e07b0649c663ca419a", + "size_in_bytes": 479 + }, + { + "_path": "bin/conda-develop", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_e9c9oqsgk0/croot/conda-build_1670407343391/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_pl", + "sha256": "231799f45acb8119dfdb95f42f23e906fe70fbb144b303d9614fedeece77773f", + "sha256_in_prefix": "cbd4fccc2791cf5100694976d0cae72da508f8ad6e68b20c28c88f80dcca4993", + "size_in_bytes": 481 + }, + { + "_path": "bin/conda-index", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_e9c9oqsgk0/croot/conda-build_1670407343391/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_pl", + "sha256": "6864da7e624f38d401fb0583f0d8d90745c0364dc395ccb5a2f1376d2665dc0a", + "sha256_in_prefix": "82530863ef858181f6916b8119d958756f6369340725ec0c431566d9d069fd7d", + "size_in_bytes": 479 + }, + { + "_path": "bin/conda-inspect", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_e9c9oqsgk0/croot/conda-build_1670407343391/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_pl", + "sha256": "e6ac49718570dba57e082b1cada990916ad9c842428c1e4feb0ab2a8991b779a", + "sha256_in_prefix": "de395fada71e3b91388f77e58595c0ea5c312f3d9723f1166f53d02ee0cea7aa", + "size_in_bytes": 481 + }, + { + "_path": "bin/conda-metapackage", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_e9c9oqsgk0/croot/conda-build_1670407343391/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_pl", + "sha256": "cdb36b8e4952467f37afa6bff264785ce30283b4514930ff476007deeaf40c82", + "sha256_in_prefix": "39f4482e3f3cced297044aca946716cb0ba028d790fa2c0bb0750f18ade242a3", + "size_in_bytes": 485 + }, + { + "_path": "bin/conda-render", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_e9c9oqsgk0/croot/conda-build_1670407343391/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_pl", + "sha256": "1ce235e5b9079264b8e537cda0b4f2de978a7023a42b3e610cc25d187b2c0b5e", + "sha256_in_prefix": "fe22b853f463bc1e376ea2408b47a1b136bed9b7920df95f9a9c85cf01ee9d25", + "size_in_bytes": 480 + }, + { + "_path": "bin/conda-skeleton", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_e9c9oqsgk0/croot/conda-build_1670407343391/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_pl", + "sha256": "67dc5e0c39f5c60c3b0137e288e63f888b555238a61306bb9a543d07eb9055d6", + "sha256_in_prefix": "ad8ad61d3334dc35a06b7892e9ff74a3bff15e1a826dae1c12a7e0e14a03286c", + "size_in_bytes": 482 + }, + { + "_path": "lib/python3.10/site-packages/conda_build/build.py", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/opt/anaconda1anaconda2anaconda3", + "sha256": "80484c779970d54fc4770770d4fd7e8c3746bf9dca507422b0de9ac6318de577", + "sha256_in_prefix": "15b2555eafdddbbec1056215f7b7ad63ddb83119c7505fc58058f946b430898c", + "size_in_bytes": 165970 + }, + { + "_path": "lib/python3.10/site-packages/conda_build/convert.py", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/opt/anaconda1anaconda2anaconda3", + "sha256": "de70a8ed59cdfb67e8f929d6cb3152c87a2be8d57dd9c93e9facb8c35ee1ae3a", + "sha256_in_prefix": "2a64800bf62f67f4666563f7c4779390fd0e80382227e883e40646910fcf8a41", + "size_in_bytes": 32246 + } + ], + "paths_version": 1 + }, + "requested_spec": "defaults/osx-arm64::conda-build==3.23.3=py310hca03da5_0[md5=4a6b06f0a14b98c819cd4b0e09c740e8]", + "sha256": "5f67c17b8cda432f379e620df27dd0dee0dd028158a1e08ad7dfb5dd4a13a020", + "size": 594922, + "subdir": "osx-arm64", + "timestamp": 1670407406866, + "track_features": "", + "url": "https://repo.anaconda.com/pkgs/main/osx-arm64/conda-build-3.23.3-py310hca03da5_0.conda", + "version": "3.23.3" +} \ No newline at end of file diff --git a/crates/pet-conda/tests/unix/anaconda3-2023.03/conda-meta/history b/crates/pet-conda/tests/unix/anaconda3-2023.03/conda-meta/history new file mode 100644 index 00000000..59f60f91 --- /dev/null +++ b/crates/pet-conda/tests/unix/anaconda3-2023.03/conda-meta/history @@ -0,0 +1,428 @@ +==> 2023-03-09 04:25:49 <== +# cmd: constructor /var/folders/24/8k48jl6d249_n_qfxwsl6xvm0000gn/T/tmp.3zs0BaU4sl/Anaconda3/ --output-dir /var/folders/24/8k48jl6d249_n_qfxwsl6xvm0000gn/T/tmp.3zs0BaU4sl --conda-exe /var/folders/24/8k48jl6d249_n_qfxwsl6xvm0000gn/T/tmp.3zs0BaU4sl/conda_exe/standalone_conda/conda.exe --platform osx-arm64 ++defaults::blas-1.0-openblas ++defaults::bzip2-1.0.8-h620ffc9_4 ++defaults::c-ares-1.18.1-h1a28f6b_0 ++defaults::ca-certificates-2023.01.10-hca03da5_0 ++defaults::giflib-5.2.1-h80987f9_3 ++defaults::jpeg-9e-h80987f9_1 ++defaults::jxrlib-1.1-h1a28f6b_2 ++defaults::ldid-2.1.2-h64d1936_2 ++defaults::libbrotlicommon-1.0.9-h1a28f6b_7 ++defaults::libcxx-14.0.6-h848a8c0_0 ++defaults::libdeflate-1.17-h80987f9_0 ++defaults::libev-4.33-h1a28f6b_1 ++defaults::libffi-3.4.2-hca03da5_6 ++defaults::libiconv-1.16-h1a28f6b_2 ++defaults::libsodium-1.0.18-h1a28f6b_0 ++defaults::libuv-1.44.2-h80987f9_0 ++defaults::libwebp-base-1.2.4-h80987f9_1 ++defaults::llvm-openmp-14.0.6-hc6e5704_0 ++defaults::lzo-2.10-h1a28f6b_2 ++defaults::ncurses-6.4-h313beb8_0 ++defaults::oniguruma-6.9.7.1-h1a28f6b_0 ++defaults::patch-2.7.6-h1a28f6b_1001 ++defaults::tzdata-2022g-h04d1e81_0 ++defaults::xz-5.2.10-h80987f9_1 ++defaults::yaml-0.2.5-h1a28f6b_0 ++defaults::zlib-1.2.13-h5a0b063_0 ++defaults::charls-2.2.0-hc377ac9_0 ++defaults::gmp-6.2.1-hc377ac9_3 ++defaults::icu-68.1-hc377ac9_0 ++defaults::jq-1.6-h1a28f6b_1 ++defaults::lerc-3.0-hc377ac9_0 ++defaults::libaec-1.0.4-hc377ac9_1 ++defaults::libbrotlidec-1.0.9-h1a28f6b_7 ++defaults::libbrotlienc-1.0.9-h1a28f6b_7 ++defaults::libedit-3.1.20221030-h80987f9_0 ++defaults::libgfortran5-11.3.0-h009349e_28 ++defaults::liblief-0.12.3-h313beb8_0 ++defaults::libllvm11-11.1.0-h12f7ac0_6 ++defaults::libllvm12-12.0.0-h12f7ac0_4 ++defaults::libllvm14-14.0.6-h7ec7a93_1 ++defaults::libpng-1.6.39-h80987f9_0 ++defaults::libprotobuf-3.20.3-h514c7bf_0 ++defaults::libspatialindex-1.9.3-hc377ac9_0 ++defaults::libzopfli-1.0.3-hc377ac9_0 ++defaults::lz4-c-1.9.4-h313beb8_0 ++defaults::ninja-base-1.10.2-h525c30c_5 ++defaults::nspr-4.33-hc377ac9_0 ++defaults::openssl-1.1.1t-h1a28f6b_0 ++defaults::pcre-8.45-hc377ac9_0 ++defaults::readline-8.2-h1a28f6b_0 ++defaults::sleef-3.5.1-hf27765b_1 ++defaults::snappy-1.1.9-hc377ac9_0 ++defaults::tapi-1100.0.11-h8754e6a_1 ++defaults::tbb-2021.7.0-h48ca7d4_0 ++defaults::tk-8.6.12-hb8d0fd4_0 ++defaults::zeromq-4.3.4-hc377ac9_0 ++defaults::zfp-0.5.5-hc377ac9_6 ++defaults::brotli-bin-1.0.9-h1a28f6b_7 ++defaults::freetype-2.12.1-h1192e45_0 ++defaults::krb5-1.19.4-h8380606_0 ++defaults::ld64_osx-arm64-530-h001ce53_25 ++defaults::libclang-12.0.0-default_hc321e17_4 ++defaults::libgfortran-5.0.0-11_3_0_hca03da5_28 ++defaults::libnghttp2-1.46.0-h95c9599_0 ++defaults::libssh2-1.10.0-hf27765b_0 ++defaults::libxml2-2.9.14-h8c5e841_0 ++defaults::mpfr-4.0.2-h695f6f0_1 ++defaults::sqlite-3.40.1-h7a7dc30_0 ++defaults::unixodbc-2.3.11-h1a28f6b_0 ++defaults::zstd-1.5.2-h8574219_0 ++defaults::blosc-1.21.3-h313beb8_0 ++defaults::brotli-1.0.9-h1a28f6b_7 ++defaults::cctools_osx-arm64-949.0.1-h332cad3_25 ++defaults::gettext-0.21.0-h826f4ad_0 ++defaults::ld64-530-hb29bf3f_25 ++defaults::libarchive-3.6.2-h3d4dd14_0 ++defaults::libcurl-7.87.0-h0f1d93c_0 ++defaults::libopenblas-0.3.21-h269037a_0 ++defaults::libpq-12.9-h65cfe13_3 ++defaults::libtiff-4.5.0-h313beb8_2 ++defaults::libxslt-1.1.35-h9833966_0 ++defaults::mpc-1.1.0-h8c48613_1 ++defaults::nss-3.74-h142855e_0 ++defaults::python-3.10.9-hc0d8a6c_1 ++defaults::alabaster-0.7.12-pyhd3eb1b0_0 ++defaults::appdirs-1.4.4-pyhd3eb1b0_0 ++defaults::appnope-0.1.2-py310hca03da5_1001 ++defaults::appscript-1.1.2-py310h1a28f6b_0 ++defaults::atomicwrites-1.4.0-py_0 ++defaults::attrs-22.1.0-py310hca03da5_0 ++defaults::backcall-0.2.0-pyhd3eb1b0_0 ++defaults::backports-1.1-pyhd3eb1b0_0 ++defaults::brunsli-0.1-hc377ac9_1 ++defaults::cctools-949.0.1-hc179dcd_25 ++defaults::certifi-2022.12.7-py310hca03da5_0 ++defaults::cfitsio-3.470-h7f6438f_7 ++defaults::chardet-4.0.0-py310hca03da5_1003 ++defaults::charset-normalizer-2.0.4-pyhd3eb1b0_0 ++defaults::click-8.0.4-py310hca03da5_0 ++defaults::cloudpickle-2.0.0-pyhd3eb1b0_0 ++defaults::colorama-0.4.6-py310hca03da5_0 ++defaults::constantly-15.1.0-py310hca03da5_0 ++defaults::cssselect-1.1.0-pyhd3eb1b0_0 ++defaults::curl-7.87.0-h80987f9_0 ++defaults::cycler-0.11.0-pyhd3eb1b0_0 ++defaults::debugpy-1.5.1-py310hc377ac9_0 ++defaults::decorator-5.1.1-pyhd3eb1b0_0 ++defaults::defusedxml-0.7.1-pyhd3eb1b0_0 ++defaults::diff-match-patch-20200713-pyhd3eb1b0_0 ++defaults::dill-0.3.6-py310hca03da5_0 ++defaults::docstring-to-markdown-0.11-py310hca03da5_0 ++defaults::docutils-0.18.1-py310hca03da5_3 ++defaults::entrypoints-0.4-py310hca03da5_0 ++defaults::et_xmlfile-1.1.0-py310hca03da5_0 ++defaults::executing-0.8.3-pyhd3eb1b0_0 ++defaults::filelock-3.9.0-py310hca03da5_0 ++defaults::flit-core-3.6.0-pyhd3eb1b0_0 ++defaults::fsspec-2022.11.0-py310hca03da5_0 ++defaults::future-0.18.3-py310hca03da5_0 ++defaults::glib-2.69.1-h514c7bf_2 ++defaults::glob2-0.7-pyhd3eb1b0_0 ++defaults::gmpy2-2.1.2-py310h8c48613_0 ++defaults::greenlet-2.0.1-py310h313beb8_0 ++defaults::hdf5-1.12.1-h160e8cb_2 ++defaults::heapdict-1.0.1-pyhd3eb1b0_0 ++defaults::idna-3.4-py310hca03da5_0 ++defaults::imagesize-1.4.1-py310hca03da5_0 ++defaults::incremental-21.3.0-pyhd3eb1b0_0 ++defaults::inflection-0.5.1-py310hca03da5_0 ++defaults::iniconfig-1.1.1-pyhd3eb1b0_0 ++defaults::ipython_genutils-0.2.0-pyhd3eb1b0_1 ++defaults::isort-5.9.3-pyhd3eb1b0_0 ++defaults::itemadapter-0.3.0-pyhd3eb1b0_0 ++defaults::itsdangerous-2.0.1-pyhd3eb1b0_0 ++defaults::jellyfish-0.9.0-py310h1a28f6b_0 ++defaults::jmespath-0.10.0-pyhd3eb1b0_0 ++defaults::joblib-1.1.1-py310hca03da5_0 ++defaults::json5-0.9.6-pyhd3eb1b0_0 ++defaults::kiwisolver-1.4.4-py310h313beb8_0 ++defaults::lazy-object-proxy-1.6.0-py310h1a28f6b_0 ++defaults::lcms2-2.12-hba8e193_0 ++defaults::libwebp-1.2.4-ha3663a8_1 ++defaults::llvmlite-0.39.1-py310h98b2900_0 ++defaults::locket-1.0.0-py310hca03da5_0 ++defaults::lxml-4.9.1-py310h2fae87d_0 ++defaults::lz4-3.1.3-py310h1a28f6b_0 ++defaults::markdown-3.4.1-py310hca03da5_0 ++defaults::markupsafe-2.1.1-py310h1a28f6b_0 ++defaults::mccabe-0.7.0-pyhd3eb1b0_0 ++defaults::mistune-0.8.4-py310h1a28f6b_1000 ++defaults::mock-4.0.3-pyhd3eb1b0_0 ++defaults::mpmath-1.2.1-py310hca03da5_0 ++defaults::msgpack-python-1.0.3-py310h525c30c_0 ++defaults::munkres-1.1.4-py_0 ++defaults::mypy_extensions-0.4.3-py310hca03da5_1 ++defaults::nest-asyncio-1.5.6-py310hca03da5_0 ++defaults::networkx-2.8.4-py310hca03da5_0 ++defaults::ninja-1.10.2-hca03da5_5 ++defaults::numpy-base-1.23.5-py310haf87e8b_0 ++defaults::openjpeg-2.3.0-h7a6adac_2 ++defaults::packaging-22.0-py310hca03da5_0 ++defaults::pandocfilters-1.5.0-pyhd3eb1b0_0 ++defaults::param-1.12.3-py310hca03da5_0 ++defaults::parso-0.8.3-pyhd3eb1b0_0 ++defaults::pathlib-1.0.1-pyhd3eb1b0_1 ++defaults::pathspec-0.10.3-py310hca03da5_0 ++defaults::pep8-1.7.1-py310hca03da5_1 ++defaults::pickleshare-0.7.5-pyhd3eb1b0_1003 ++defaults::pkginfo-1.8.3-py310hca03da5_0 ++defaults::platformdirs-2.5.2-py310hca03da5_0 ++defaults::pluggy-1.0.0-py310hca03da5_1 ++defaults::ply-3.11-py310hca03da5_0 ++defaults::poyo-0.5.0-pyhd3eb1b0_0 ++defaults::prometheus_client-0.14.1-py310hca03da5_0 ++defaults::psutil-5.9.0-py310h1a28f6b_0 ++defaults::ptyprocess-0.7.0-pyhd3eb1b0_2 ++defaults::pure_eval-0.2.2-pyhd3eb1b0_0 ++defaults::py-1.11.0-pyhd3eb1b0_0 ++defaults::py-lief-0.12.3-py310h313beb8_0 ++defaults::pyasn1-0.4.8-pyhd3eb1b0_0 ++defaults::pycodestyle-2.10.0-py310hca03da5_0 ++defaults::pycosat-0.6.4-py310h1a28f6b_0 ++defaults::pycparser-2.21-pyhd3eb1b0_0 ++defaults::pycurl-7.45.1-py310hf27765b_0 ++defaults::pydispatcher-2.0.5-py310hca03da5_2 ++defaults::pyflakes-3.0.1-py310hca03da5_0 ++defaults::pygments-2.11.2-pyhd3eb1b0_0 ++defaults::pyjwt-2.4.0-py310hca03da5_0 ++defaults::pylint-venv-2.3.0-py310hca03da5_0 ++defaults::pyobjc-core-9.0-py310h3eb5a62_1 ++defaults::pyodbc-4.0.34-py310hc377ac9_0 ++defaults::pyparsing-3.0.9-py310hca03da5_0 ++defaults::pyrsistent-0.18.0-py310h1a28f6b_0 ++defaults::pysocks-1.7.1-py310hca03da5_0 ++defaults::python-fastjsonschema-2.16.2-py310hca03da5_0 ++defaults::python-libarchive-c-2.9-pyhd3eb1b0_1 ++defaults::python-snappy-0.6.1-py310h313beb8_0 ++defaults::python.app-3-py310h1a28f6b_0 ++defaults::pytz-2022.7-py310hca03da5_0 ++defaults::pyyaml-6.0-py310h80987f9_1 ++defaults::pyzmq-23.2.0-py310hc377ac9_0 ++defaults::qdarkstyle-3.0.2-pyhd3eb1b0_0 ++defaults::queuelib-1.5.0-py310hca03da5_0 ++defaults::regex-2022.7.9-py310h1a28f6b_0 ++defaults::rtree-1.0.1-py310hca03da5_0 ++defaults::ruamel.yaml.clib-0.2.6-py310h1a28f6b_1 ++defaults::send2trash-1.8.0-pyhd3eb1b0_1 ++defaults::six-1.16.0-pyhd3eb1b0_1 ++defaults::smart_open-5.2.1-py310hca03da5_0 ++defaults::sniffio-1.2.0-py310hca03da5_1 ++defaults::snowballstemmer-2.2.0-pyhd3eb1b0_0 ++defaults::sortedcontainers-2.4.0-pyhd3eb1b0_0 ++defaults::soupsieve-2.3.2.post1-py310hca03da5_0 ++defaults::sphinxcontrib-applehelp-1.0.2-pyhd3eb1b0_0 ++defaults::sphinxcontrib-devhelp-1.0.2-pyhd3eb1b0_0 ++defaults::sphinxcontrib-htmlhelp-2.0.0-pyhd3eb1b0_0 ++defaults::sphinxcontrib-jsmath-1.0.1-pyhd3eb1b0_0 ++defaults::sphinxcontrib-qthelp-1.0.3-pyhd3eb1b0_0 ++defaults::sphinxcontrib-serializinghtml-1.1.5-pyhd3eb1b0_0 ++defaults::tabulate-0.8.10-py310hca03da5_0 ++defaults::tbb4py-2021.7.0-py310h48ca7d4_0 ++defaults::tblib-1.7.0-pyhd3eb1b0_0 ++defaults::tenacity-8.0.1-py310hca03da5_1 ++defaults::text-unidecode-1.3-pyhd3eb1b0_0 ++defaults::textdistance-4.2.1-pyhd3eb1b0_0 ++defaults::threadpoolctl-2.2.0-pyh0d69192_0 ++defaults::tokenizers-0.11.4-py310h5c5695e_1 ++defaults::toml-0.10.2-pyhd3eb1b0_0 ++defaults::tomli-2.0.1-py310hca03da5_0 ++defaults::tomlkit-0.11.1-py310hca03da5_0 ++defaults::toolz-0.12.0-py310hca03da5_0 ++defaults::tornado-6.1-py310h1a28f6b_0 ++defaults::tqdm-4.64.1-py310hca03da5_0 ++defaults::traitlets-5.7.1-py310hca03da5_0 ++defaults::ujson-5.4.0-py310hc377ac9_0 ++defaults::unidecode-1.2.0-pyhd3eb1b0_0 ++defaults::wcwidth-0.2.5-pyhd3eb1b0_0 ++defaults::webencodings-0.5.1-py310hca03da5_1 ++defaults::whatthepatch-1.0.2-py310hca03da5_0 ++defaults::wheel-0.38.4-py310hca03da5_0 ++defaults::wrapt-1.14.1-py310h1a28f6b_0 ++defaults::wurlitzer-3.0.2-py310hca03da5_0 ++defaults::yapf-0.31.0-pyhd3eb1b0_0 ++defaults::zipp-3.11.0-py310hca03da5_0 ++defaults::zope-1.0-py310hca03da5_1 ++defaults::anyio-3.5.0-py310hca03da5_0 ++defaults::asttokens-2.0.5-pyhd3eb1b0_0 ++defaults::automat-20.2.0-py_0 ++defaults::autopep8-1.6.0-pyhd3eb1b0_1 ++defaults::babel-2.11.0-py310hca03da5_0 ++defaults::backports.weakref-1.0.post1-py_1 ++defaults::beautifulsoup4-4.11.1-py310hca03da5_0 ++defaults::binaryornot-0.4.4-pyhd3eb1b0_1 ++defaults::black-22.6.0-py310hca03da5_0 ++defaults::bleach-4.1.0-pyhd3eb1b0_0 ++defaults::cffi-1.15.1-py310h80987f9_3 ++defaults::comm-0.1.2-py310hca03da5_0 ++defaults::cytoolz-0.12.0-py310h1a28f6b_0 ++defaults::flake8-6.0.0-py310hca03da5_0 ++defaults::fonttools-4.25.0-pyhd3eb1b0_0 ++defaults::gstreamer-1.14.1-h80987f9_1 ++defaults::hyperlink-21.0.0-pyhd3eb1b0_0 ++defaults::importlib-metadata-4.11.3-py310hca03da5_0 ++defaults::intervaltree-3.1.0-pyhd3eb1b0_0 ++defaults::jedi-0.18.1-py310hca03da5_1 ++defaults::jinja2-3.1.2-py310hca03da5_0 ++defaults::jsonschema-4.17.3-py310hca03da5_0 ++defaults::jupyter_core-5.2.0-py310hca03da5_0 ++defaults::jupyterlab_pygments-0.1.2-py_0 ++defaults::matplotlib-inline-0.1.6-py310hca03da5_0 ++defaults::multipledispatch-0.6.0-py310hca03da5_0 ++defaults::nltk-3.7-pyhd3eb1b0_0 ++defaults::numpy-1.23.5-py310hb93e574_0 ++defaults::openpyxl-3.0.10-py310h1a28f6b_0 ++defaults::partd-1.2.0-pyhd3eb1b0_1 ++defaults::pexpect-4.8.0-pyhd3eb1b0_3 ++defaults::pillow-9.4.0-py310h313beb8_0 ++defaults::plotly-5.9.0-py310hca03da5_0 ++defaults::prompt-toolkit-3.0.36-py310hca03da5_0 ++defaults::protego-0.1.16-py_0 ++defaults::pyasn1-modules-0.2.8-py_0 ++defaults::pydocstyle-6.3.0-py310hca03da5_0 ++defaults::pyhamcrest-2.0.2-pyhd3eb1b0_2 ++defaults::pyobjc-framework-cocoa-9.0-py310hb094c41_0 ++defaults::pytest-7.1.2-py310hca03da5_0 ++defaults::python-dateutil-2.8.2-pyhd3eb1b0_0 ++defaults::python-lsp-jsonrpc-1.0.0-pyhd3eb1b0_0 ++defaults::python-slugify-5.0.2-pyhd3eb1b0_0 ++defaults::pytoolconfig-1.2.5-py310hca03da5_1 ++defaults::pyviz_comms-2.0.2-pyhd3eb1b0_0 ++defaults::qtpy-2.2.0-py310hca03da5_0 ++defaults::ruamel.yaml-0.17.21-py310h1a28f6b_0 ++defaults::ruamel_yaml-0.17.21-py310h1a28f6b_0 ++defaults::setuptools-65.6.3-py310hca03da5_0 ++defaults::sip-6.6.2-py310hc377ac9_0 ++defaults::sqlalchemy-1.4.39-py310h1a28f6b_0 ++defaults::sympy-1.11.1-py310hca03da5_0 ++defaults::terminado-0.17.1-py310hca03da5_0 ++defaults::three-merge-0.1.1-pyhd3eb1b0_0 ++defaults::tinycss2-1.2.1-py310hca03da5_0 ++defaults::typing_extensions-4.4.0-py310hca03da5_0 ++defaults::w3lib-1.21.0-pyhd3eb1b0_0 ++defaults::watchdog-2.1.6-py310h1a28f6b_0 ++defaults::websocket-client-0.58.0-py310hca03da5_4 ++defaults::werkzeug-2.2.2-py310hca03da5_0 ++defaults::xlwings-0.29.1-py310hca03da5_0 ++defaults::zict-2.1.0-py310hca03da5_0 ++defaults::argon2-cffi-bindings-21.2.0-py310h1a28f6b_0 ++defaults::arrow-1.2.3-py310hca03da5_1 ++defaults::backports.functools_lru_cache-1.6.4-pyhd3eb1b0_0 ++defaults::backports.tempfile-1.0-pyhd3eb1b0_1 ++defaults::bokeh-2.4.3-py310hca03da5_0 ++defaults::bottleneck-1.3.5-py310h96f19d2_0 ++defaults::brotlipy-0.7.0-py310h1a28f6b_1002 ++defaults::clyent-1.2.2-py310hca03da5_1 ++defaults::conda-pack-0.6.0-pyhd3eb1b0_0 ++defaults::contourpy-1.0.5-py310h525c30c_0 ++defaults::cryptography-39.0.1-py310h834c97f_0 ++defaults::dask-core-2022.7.0-py310hca03da5_0 ++defaults::datashape-0.5.4-py310hca03da5_1 ++defaults::flask-2.2.2-py310hca03da5_0 ++defaults::gst-plugins-base-1.14.1-h313beb8_1 ++defaults::h5py-3.7.0-py310h181c318_0 ++defaults::imagecodecs-2021.8.26-py310h48bc37f_2 ++defaults::imageio-2.26.0-py310hca03da5_0 ++defaults::importlib_metadata-4.11.3-hd3eb1b0_0 ++defaults::jupyter_client-7.3.4-py310hca03da5_0 ++defaults::nbformat-5.7.0-py310hca03da5_0 ++defaults::numba-0.56.4-py310h46d7db6_0 ++defaults::numexpr-2.8.4-py310hecc3335_0 ++defaults::parsel-1.6.0-py310hca03da5_0 ++defaults::patsy-0.5.3-py310hca03da5_0 ++defaults::pip-22.3.1-py310hca03da5_0 ++defaults::pyerfa-2.0.0-py310h1a28f6b_0 ++defaults::pyobjc-framework-fsevents-9.0-py310hca03da5_0 ++defaults::pyqt5-sip-12.11.0-py310hc377ac9_0 ++defaults::pywavelets-1.4.1-py310h80987f9_0 ++defaults::qstylizer-0.2.2-py310hca03da5_0 ++defaults::qtawesome-1.2.2-py310hca03da5_0 ++defaults::rope-1.7.0-py310hca03da5_0 ++defaults::stack_data-0.2.0-pyhd3eb1b0_0 ++defaults::typing-extensions-4.4.0-py310hca03da5_0 ++defaults::zope.interface-5.4.0-py310h1a28f6b_0 ++defaults::zstandard-0.19.0-py310h80987f9_0 ++defaults::argon2-cffi-21.3.0-pyhd3eb1b0_0 ++defaults::astroid-2.14.2-py310hca03da5_0 ++defaults::astropy-5.1-py310h96f19d2_0 ++defaults::bcrypt-3.2.0-py310h1a28f6b_1 ++defaults::conda-content-trust-0.1.3-py310hca03da5_0 ++defaults::conda-package-streaming-0.7.0-py310hca03da5_0 ++defaults::ipython-8.10.0-py310hca03da5_0 ++defaults::itemloaders-1.0.4-pyhd3eb1b0_1 ++defaults::jinja2-time-0.2.0-pyhd3eb1b0_3 ++defaults::keyring-23.4.0-py310hca03da5_0 ++defaults::matplotlib-base-3.7.0-py310h46d7db6_0 ++defaults::nbclient-0.5.13-py310hca03da5_0 ++defaults::pandas-1.5.3-py310h46d7db6_0 ++defaults::pyobjc-framework-coreservices-9.0-py310hdd8dd1f_0 ++defaults::pyopenssl-23.0.0-py310hca03da5_0 ++defaults::pytables-3.7.0-py310ha5d4e50_1 ++defaults::pytorch-1.12.1-cpu_py310h8370978_1 ++defaults::qt-main-5.15.2-ha2d02b5_7 ++defaults::service_identity-18.1.0-pyhd3eb1b0_1 ++defaults::tifffile-2021.7.2-pyhd3eb1b0_2 ++defaults::applaunchservices-0.3.0-py310hca03da5_0 ++defaults::conda-package-handling-2.0.2-py310hca03da5_0 ++defaults::ipykernel-6.19.2-py310h33ce5c2_0 ++defaults::matplotlib-3.7.0-py310hca03da5_0 ++defaults::nbconvert-6.5.4-py310hca03da5_0 ++defaults::pylint-2.16.2-py310hca03da5_0 ++defaults::qt-webengine-5.15.9-h2903aaf_4 ++defaults::seaborn-0.12.2-py310hca03da5_0 ++defaults::twisted-22.2.0-py310h1a28f6b_1 ++defaults::urllib3-1.26.14-py310hca03da5_0 ++defaults::xarray-2022.11.0-py310hca03da5_0 ++defaults::conda-verify-3.4.2-py_1 ++defaults::distributed-2022.7.0-py310hca03da5_0 ++defaults::jupyter_server-1.23.4-py310hca03da5_0 ++defaults::python-lsp-server-1.7.1-py310hca03da5_0 ++defaults::qtwebkit-5.212-h0f11f3c_4 ++defaults::requests-2.28.1-py310hca03da5_0 ++defaults::spyder-kernels-2.4.1-py310hca03da5_0 ++defaults::anaconda-client-1.11.1-py310hca03da5_0 ++defaults::conda-23.1.0-py310hca03da5_0 ++defaults::cookiecutter-1.7.3-pyhd3eb1b0_0 ++defaults::dask-2022.7.0-py310hca03da5_0 ++defaults::huggingface_hub-0.10.1-py310hca03da5_0 ++defaults::jupyterlab_server-2.19.0-py310hca03da5_0 ++defaults::notebook-shim-0.2.2-py310hca03da5_0 ++defaults::pooch-1.4.0-pyhd3eb1b0_0 ++defaults::pyct-0.5.0-py310hca03da5_0 ++defaults::pyls-spyder-0.4.0-pyhd3eb1b0_0 ++defaults::pyqt-5.15.7-py310hc377ac9_0 ++defaults::python-lsp-black-1.2.1-py310hca03da5_0 ++defaults::requests-file-1.5.1-pyhd3eb1b0_0 ++defaults::sphinx-5.0.2-py310hca03da5_0 ++defaults::anaconda-project-0.11.1-py310hca03da5_0 ++defaults::colorcet-3.0.1-py310hca03da5_0 ++defaults::conda-build-3.23.3-py310hca03da5_0 ++defaults::conda-repo-cli-1.0.27-py310hca03da5_0 ++defaults::conda-token-0.4.0-pyhd3eb1b0_0 ++defaults::intake-0.6.7-py310hca03da5_0 ++defaults::navigator-updater-0.3.0-py310hca03da5_0 ++defaults::nbclassic-0.5.2-py310hca03da5_0 ++defaults::numpydoc-1.5.0-py310hca03da5_0 ++defaults::panel-0.14.3-py310hca03da5_0 ++defaults::pyqtwebengine-5.15.7-py310hc377ac9_0 ++defaults::qtconsole-5.4.0-py310hca03da5_0 ++defaults::scipy-1.10.0-py310h20cbe94_1 ++defaults::tldextract-3.2.0-pyhd3eb1b0_0 ++defaults::transformers-4.24.0-py310hca03da5_0 ++defaults::anaconda-navigator-2.4.0-py310hca03da5_0 ++defaults::datashader-0.14.4-py310hca03da5_0 ++defaults::gensim-4.3.0-py310h46d7db6_0 ++defaults::notebook-6.5.2-py310hca03da5_0 ++defaults::scikit-image-0.19.3-py310h313beb8_1 ++defaults::scikit-learn-1.2.1-py310h313beb8_0 ++defaults::scrapy-2.8.0-py310hca03da5_0 ++defaults::spyder-5.4.1-py310hca03da5_0 ++defaults::statsmodels-0.13.5-py310hbda83bc_1 ++defaults::holoviews-1.15.4-py310hca03da5_0 ++defaults::imbalanced-learn-0.10.1-py310hca03da5_0 ++defaults::jupyterlab-3.5.3-py310hca03da5_0 ++defaults::hvplot-0.8.2-py310hca03da5_0 +# update specs: ['anaconda==2023.03', 'python=3.10', 'setuptools', 'pip', 'wheel', 'anaconda-client', 'anaconda-project', 'anaconda-navigator', 'conda', 'conda-build', 'conda-content-trust', 'conda-pack', 'conda-package-handling', 'conda-package-streaming', 'conda-token', 'conda-verify', 'python.app'] + diff --git a/crates/pet-conda/tests/unix/anaconda3-2023.03/conda-meta/pytest-7.1.2-py310hca03da5_0.json b/crates/pet-conda/tests/unix/anaconda3-2023.03/conda-meta/pytest-7.1.2-py310hca03da5_0.json new file mode 100644 index 00000000..eeac4446 --- /dev/null +++ b/crates/pet-conda/tests/unix/anaconda3-2023.03/conda-meta/pytest-7.1.2-py310hca03da5_0.json @@ -0,0 +1,209 @@ +{ + "build": "py310hca03da5_0", + "build_number": 0, + "channel": "https://repo.anaconda.com/pkgs/main/osx-arm64", + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=19.2.0", + "iniconfig", + "packaging", + "pluggy >=0.12,<2.0", + "py >=1.8.2", + "python >=3.10,<3.11.0a0", + "tomli >=1.0.0" + ], + "extracted_package_dir": "/Users/donjayamanne/.pyenv/versions/anaconda3-2023.03/pkgs/pytest-7.1.2-py310hca03da5_0", + "features": "", + "files": [ + "bin/py.test", + "bin/pytest", + "lib/python3.10/site-packages/_pytest/__init__.py", + "lib/python3.10/site-packages/_pytest/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/_argcomplete.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/_version.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/cacheprovider.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/capture.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/compat.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/debugging.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/deprecated.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/doctest.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/faulthandler.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/fixtures.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/freeze_support.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/helpconfig.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/hookspec.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/junitxml.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/legacypath.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/logging.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/main.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/monkeypatch.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/nodes.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/nose.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/outcomes.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/pastebin.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/pathlib.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/pytester.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/pytester_assertions.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/python.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/python_api.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/python_path.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/recwarn.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/reports.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/runner.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/scope.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/setuponly.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/setupplan.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/skipping.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/stash.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/stepwise.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/terminal.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/threadexception.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/timing.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/tmpdir.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/unittest.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/unraisableexception.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/warning_types.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/warnings.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/_argcomplete.py", + "lib/python3.10/site-packages/_pytest/_code/__init__.py", + "lib/python3.10/site-packages/_pytest/_code/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/_code/__pycache__/code.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/_code/__pycache__/source.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/_code/code.py", + "lib/python3.10/site-packages/_pytest/_code/source.py", + "lib/python3.10/site-packages/_pytest/_io/__init__.py", + "lib/python3.10/site-packages/_pytest/_io/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/_io/__pycache__/saferepr.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/_io/__pycache__/terminalwriter.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/_io/__pycache__/wcwidth.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/_io/saferepr.py", + "lib/python3.10/site-packages/_pytest/_io/terminalwriter.py", + "lib/python3.10/site-packages/_pytest/_io/wcwidth.py", + "lib/python3.10/site-packages/_pytest/_version.py", + "lib/python3.10/site-packages/_pytest/assertion/__init__.py", + "lib/python3.10/site-packages/_pytest/assertion/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/assertion/__pycache__/rewrite.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/assertion/__pycache__/truncate.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/assertion/__pycache__/util.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/assertion/rewrite.py", + "lib/python3.10/site-packages/_pytest/assertion/truncate.py", + "lib/python3.10/site-packages/_pytest/assertion/util.py", + "lib/python3.10/site-packages/_pytest/cacheprovider.py", + "lib/python3.10/site-packages/_pytest/capture.py", + "lib/python3.10/site-packages/_pytest/compat.py", + "lib/python3.10/site-packages/_pytest/config/__init__.py", + "lib/python3.10/site-packages/_pytest/config/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/config/__pycache__/argparsing.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/config/__pycache__/compat.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/config/__pycache__/exceptions.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/config/__pycache__/findpaths.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/config/argparsing.py", + "lib/python3.10/site-packages/_pytest/config/compat.py", + "lib/python3.10/site-packages/_pytest/config/exceptions.py", + "lib/python3.10/site-packages/_pytest/config/findpaths.py", + "lib/python3.10/site-packages/_pytest/debugging.py", + "lib/python3.10/site-packages/_pytest/deprecated.py", + "lib/python3.10/site-packages/_pytest/doctest.py", + "lib/python3.10/site-packages/_pytest/faulthandler.py", + "lib/python3.10/site-packages/_pytest/fixtures.py", + "lib/python3.10/site-packages/_pytest/freeze_support.py", + "lib/python3.10/site-packages/_pytest/helpconfig.py", + "lib/python3.10/site-packages/_pytest/hookspec.py", + "lib/python3.10/site-packages/_pytest/junitxml.py", + "lib/python3.10/site-packages/_pytest/legacypath.py", + "lib/python3.10/site-packages/_pytest/logging.py", + "lib/python3.10/site-packages/_pytest/main.py", + "lib/python3.10/site-packages/_pytest/mark/__init__.py", + "lib/python3.10/site-packages/_pytest/mark/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/mark/__pycache__/expression.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/mark/__pycache__/structures.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/mark/expression.py", + "lib/python3.10/site-packages/_pytest/mark/structures.py", + "lib/python3.10/site-packages/_pytest/monkeypatch.py", + "lib/python3.10/site-packages/_pytest/nodes.py", + "lib/python3.10/site-packages/_pytest/nose.py", + "lib/python3.10/site-packages/_pytest/outcomes.py", + "lib/python3.10/site-packages/_pytest/pastebin.py", + "lib/python3.10/site-packages/_pytest/pathlib.py", + "lib/python3.10/site-packages/_pytest/py.typed", + "lib/python3.10/site-packages/_pytest/pytester.py", + "lib/python3.10/site-packages/_pytest/pytester_assertions.py", + "lib/python3.10/site-packages/_pytest/python.py", + "lib/python3.10/site-packages/_pytest/python_api.py", + "lib/python3.10/site-packages/_pytest/python_path.py", + "lib/python3.10/site-packages/_pytest/recwarn.py", + "lib/python3.10/site-packages/_pytest/reports.py", + "lib/python3.10/site-packages/_pytest/runner.py", + "lib/python3.10/site-packages/_pytest/scope.py", + "lib/python3.10/site-packages/_pytest/setuponly.py", + "lib/python3.10/site-packages/_pytest/setupplan.py", + "lib/python3.10/site-packages/_pytest/skipping.py", + "lib/python3.10/site-packages/_pytest/stash.py", + "lib/python3.10/site-packages/_pytest/stepwise.py", + "lib/python3.10/site-packages/_pytest/terminal.py", + "lib/python3.10/site-packages/_pytest/threadexception.py", + "lib/python3.10/site-packages/_pytest/timing.py", + "lib/python3.10/site-packages/_pytest/tmpdir.py", + "lib/python3.10/site-packages/_pytest/unittest.py", + "lib/python3.10/site-packages/_pytest/unraisableexception.py", + "lib/python3.10/site-packages/_pytest/warning_types.py", + "lib/python3.10/site-packages/_pytest/warnings.py", + "lib/python3.10/site-packages/pytest-7.1.2-py3.10.egg-info/PKG-INFO", + "lib/python3.10/site-packages/pytest-7.1.2-py3.10.egg-info/SOURCES.txt", + "lib/python3.10/site-packages/pytest-7.1.2-py3.10.egg-info/dependency_links.txt", + "lib/python3.10/site-packages/pytest-7.1.2-py3.10.egg-info/entry_points.txt", + "lib/python3.10/site-packages/pytest-7.1.2-py3.10.egg-info/not-zip-safe", + "lib/python3.10/site-packages/pytest-7.1.2-py3.10.egg-info/requires.txt", + "lib/python3.10/site-packages/pytest-7.1.2-py3.10.egg-info/top_level.txt", + "lib/python3.10/site-packages/pytest/__init__.py", + "lib/python3.10/site-packages/pytest/__main__.py", + "lib/python3.10/site-packages/pytest/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/pytest/__pycache__/__main__.cpython-310.pyc", + "lib/python3.10/site-packages/pytest/py.typed" + ], + "fn": "pytest-7.1.2-py310hca03da5_0.conda", + "legacy_bz2_md5": "d5f7cb91582e7a1e1d0302b6691f4ff2", + "legacy_bz2_size": 475724, + "license": "MIT", + "license_family": "MIT", + "link": { + "source": "/Users/donjayamanne/.pyenv/versions/anaconda3-2023.03/pkgs/pytest-7.1.2-py310hca03da5_0", + "type": 1 + }, + "md5": "3d4ffcd5ce4a0f875ed0a577c35dd924", + "name": "pytest", + "package_tarball_full_path": "/Users/donjayamanne/.pyenv/versions/anaconda3-2023.03/pkgs/pytest-7.1.2-py310hca03da5_0.conda", + "paths_data": { + "paths": [ + { + "_path": "bin/py.test", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_bb79cf71-3b0d-4f6e-b127-6cd6f42cd0b3zuaib3yw/croots/recipe/pytest_1654684981069/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_place", + "sha256": "25a4084929551abe44daf94ad6db601477697c2e7fe7754bfa51e927f61a2a82", + "sha256_in_prefix": "74ca4d1facd6ae350af7bf80a69703271ebb7bf74053924e86a222e5d96d1f9e", + "size_in_bytes": 475 + }, + { + "_path": "bin/pytest", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_bb79cf71-3b0d-4f6e-b127-6cd6f42cd0b3zuaib3yw/croots/recipe/pytest_1654684981069/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_place", + "sha256": "25a4084929551abe44daf94ad6db601477697c2e7fe7754bfa51e927f61a2a82", + "sha256_in_prefix": "74ca4d1facd6ae350af7bf80a69703271ebb7bf74053924e86a222e5d96d1f9e", + "size_in_bytes": 475 + } + ], + "paths_version": 1 + }, + "requested_spec": "defaults/osx-arm64::pytest==7.1.2=py310hca03da5_0[md5=3d4ffcd5ce4a0f875ed0a577c35dd924]", + "sha256": "6d9d80df16880009035d6aeca466be48c7511e3dc366469459f3400928ef6c87", + "size": 458308, + "subdir": "osx-arm64", + "timestamp": 1654685008490, + "track_features": "", + "url": "https://repo.anaconda.com/pkgs/main/osx-arm64/pytest-7.1.2-py310hca03da5_0.conda", + "version": "7.1.2" +} \ No newline at end of file diff --git a/crates/pet-conda/tests/unix/anaconda3-2023.03/conda-meta/python-3.10.9-hc0d8a6c_1.json b/crates/pet-conda/tests/unix/anaconda3-2023.03/conda-meta/python-3.10.9-hc0d8a6c_1.json new file mode 100644 index 00000000..54078722 --- /dev/null +++ b/crates/pet-conda/tests/unix/anaconda3-2023.03/conda-meta/python-3.10.9-hc0d8a6c_1.json @@ -0,0 +1,2222 @@ +{ + "build": "hc0d8a6c_1", + "build_number": 1, + "channel": "https://repo.anaconda.com/pkgs/main/osx-arm64", + "constrains": [], + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "libffi >=3.4,<3.5", + "libffi >=3.4,<4.0a0", + "ncurses >=6.4,<7.0a0", + "openssl >=1.1.1t,<1.1.2a", + "readline >=8.1.2,<9.0a0", + "sqlite >=3.40.1,<4.0a0", + "tk >=8.6.12,<8.7.0a0", + "tzdata", + "xz >=5.2.10,<6.0a0", + "zlib >=1.2.13,<1.3.0a0", + "pip" + ], + "extracted_package_dir": "/Users/donjayamanne/.pyenv/versions/anaconda3-2023.03/pkgs/python-3.10.9-hc0d8a6c_1", + "features": "", + "files": [ + "bin/2to3", + "bin/2to3-3.10", + "bin/idle3", + "bin/idle3.10", + "bin/pydoc", + "bin/pydoc3", + "bin/pydoc3.10", + "bin/python", + "bin/python3", + "bin/python3-config", + "bin/python3.1", + "bin/python3.10", + "bin/python3.10-config", + "include/python3.10/Python.h", + "include/python3.10/abstract.h", + "include/python3.10/bltinmodule.h", + "include/python3.10/boolobject.h", + "include/python3.10/bytearrayobject.h", + "include/python3.10/bytesobject.h", + "include/python3.10/cellobject.h", + "include/python3.10/ceval.h", + "include/python3.10/classobject.h", + "include/python3.10/code.h", + "include/python3.10/codecs.h", + "include/python3.10/compile.h", + "include/python3.10/complexobject.h", + "include/python3.10/context.h", + "include/python3.10/cpython/abstract.h", + "include/python3.10/cpython/bytearrayobject.h", + "include/python3.10/cpython/bytesobject.h", + "include/python3.10/cpython/ceval.h", + "include/python3.10/cpython/code.h", + "include/python3.10/cpython/compile.h", + "include/python3.10/cpython/dictobject.h", + "include/python3.10/cpython/fileobject.h", + "include/python3.10/cpython/fileutils.h", + "include/python3.10/cpython/frameobject.h", + "include/python3.10/cpython/import.h", + "include/python3.10/cpython/initconfig.h", + "include/python3.10/cpython/interpreteridobject.h", + "include/python3.10/cpython/listobject.h", + "include/python3.10/cpython/methodobject.h", + "include/python3.10/cpython/object.h", + "include/python3.10/cpython/objimpl.h", + "include/python3.10/cpython/odictobject.h", + "include/python3.10/cpython/picklebufobject.h", + "include/python3.10/cpython/pyctype.h", + "include/python3.10/cpython/pydebug.h", + "include/python3.10/cpython/pyerrors.h", + "include/python3.10/cpython/pyfpe.h", + "include/python3.10/cpython/pylifecycle.h", + "include/python3.10/cpython/pymem.h", + "include/python3.10/cpython/pystate.h", + "include/python3.10/cpython/pythonrun.h", + "include/python3.10/cpython/pytime.h", + "include/python3.10/cpython/sysmodule.h", + "include/python3.10/cpython/traceback.h", + "include/python3.10/cpython/tupleobject.h", + "include/python3.10/cpython/unicodeobject.h", + "include/python3.10/datetime.h", + "include/python3.10/descrobject.h", + "include/python3.10/dictobject.h", + "include/python3.10/dynamic_annotations.h", + "include/python3.10/enumobject.h", + "include/python3.10/errcode.h", + "include/python3.10/eval.h", + "include/python3.10/exports.h", + "include/python3.10/fileobject.h", + "include/python3.10/fileutils.h", + "include/python3.10/floatobject.h", + "include/python3.10/frameobject.h", + "include/python3.10/funcobject.h", + "include/python3.10/genericaliasobject.h", + "include/python3.10/genobject.h", + "include/python3.10/import.h", + "include/python3.10/internal/pycore_abstract.h", + "include/python3.10/internal/pycore_accu.h", + "include/python3.10/internal/pycore_asdl.h", + "include/python3.10/internal/pycore_ast.h", + "include/python3.10/internal/pycore_ast_state.h", + "include/python3.10/internal/pycore_atomic.h", + "include/python3.10/internal/pycore_atomic_funcs.h", + "include/python3.10/internal/pycore_bitutils.h", + "include/python3.10/internal/pycore_blocks_output_buffer.h", + "include/python3.10/internal/pycore_bytes_methods.h", + "include/python3.10/internal/pycore_call.h", + "include/python3.10/internal/pycore_ceval.h", + "include/python3.10/internal/pycore_code.h", + "include/python3.10/internal/pycore_compile.h", + "include/python3.10/internal/pycore_condvar.h", + "include/python3.10/internal/pycore_context.h", + "include/python3.10/internal/pycore_dtoa.h", + "include/python3.10/internal/pycore_fileutils.h", + "include/python3.10/internal/pycore_format.h", + "include/python3.10/internal/pycore_gc.h", + "include/python3.10/internal/pycore_getopt.h", + "include/python3.10/internal/pycore_gil.h", + "include/python3.10/internal/pycore_hamt.h", + "include/python3.10/internal/pycore_hashtable.h", + "include/python3.10/internal/pycore_import.h", + "include/python3.10/internal/pycore_initconfig.h", + "include/python3.10/internal/pycore_interp.h", + "include/python3.10/internal/pycore_list.h", + "include/python3.10/internal/pycore_long.h", + "include/python3.10/internal/pycore_moduleobject.h", + "include/python3.10/internal/pycore_object.h", + "include/python3.10/internal/pycore_parser.h", + "include/python3.10/internal/pycore_pathconfig.h", + "include/python3.10/internal/pycore_pyarena.h", + "include/python3.10/internal/pycore_pyerrors.h", + "include/python3.10/internal/pycore_pyhash.h", + "include/python3.10/internal/pycore_pylifecycle.h", + "include/python3.10/internal/pycore_pymem.h", + "include/python3.10/internal/pycore_pystate.h", + "include/python3.10/internal/pycore_runtime.h", + "include/python3.10/internal/pycore_structseq.h", + "include/python3.10/internal/pycore_symtable.h", + "include/python3.10/internal/pycore_sysmodule.h", + "include/python3.10/internal/pycore_traceback.h", + "include/python3.10/internal/pycore_tuple.h", + "include/python3.10/internal/pycore_ucnhash.h", + "include/python3.10/internal/pycore_unionobject.h", + "include/python3.10/internal/pycore_warnings.h", + "include/python3.10/interpreteridobject.h", + "include/python3.10/intrcheck.h", + "include/python3.10/iterobject.h", + "include/python3.10/listobject.h", + "include/python3.10/longintrepr.h", + "include/python3.10/longobject.h", + "include/python3.10/marshal.h", + "include/python3.10/memoryobject.h", + "include/python3.10/methodobject.h", + "include/python3.10/modsupport.h", + "include/python3.10/moduleobject.h", + "include/python3.10/namespaceobject.h", + "include/python3.10/object.h", + "include/python3.10/objimpl.h", + "include/python3.10/opcode.h", + "include/python3.10/osdefs.h", + "include/python3.10/osmodule.h", + "include/python3.10/patchlevel.h", + "include/python3.10/py_curses.h", + "include/python3.10/pycapsule.h", + "include/python3.10/pyconfig.h", + "include/python3.10/pydtrace.h", + "include/python3.10/pyerrors.h", + "include/python3.10/pyexpat.h", + "include/python3.10/pyframe.h", + "include/python3.10/pyhash.h", + "include/python3.10/pylifecycle.h", + "include/python3.10/pymacconfig.h", + "include/python3.10/pymacro.h", + "include/python3.10/pymath.h", + "include/python3.10/pymem.h", + "include/python3.10/pyport.h", + "include/python3.10/pystate.h", + "include/python3.10/pystrcmp.h", + "include/python3.10/pystrhex.h", + "include/python3.10/pystrtod.h", + "include/python3.10/pythonrun.h", + "include/python3.10/pythread.h", + "include/python3.10/rangeobject.h", + "include/python3.10/setobject.h", + "include/python3.10/sliceobject.h", + "include/python3.10/structmember.h", + "include/python3.10/structseq.h", + "include/python3.10/sysmodule.h", + "include/python3.10/token.h", + "include/python3.10/traceback.h", + "include/python3.10/tracemalloc.h", + "include/python3.10/tupleobject.h", + "include/python3.10/typeslots.h", + "include/python3.10/unicodeobject.h", + "include/python3.10/warnings.h", + "include/python3.10/weakrefobject.h", + "lib/libpython3.10.dylib", + "lib/pkgconfig/python-3.10-embed.pc", + "lib/pkgconfig/python-3.10.pc", + "lib/pkgconfig/python3-embed.pc", + "lib/pkgconfig/python3.pc", + "lib/python3.1", + "lib/python3.10/LICENSE.txt", + "lib/python3.10/__future__.py", + "lib/python3.10/__phello__.foo.py", + "lib/python3.10/__pycache__/__future__.cpython-310.pyc", + "lib/python3.10/__pycache__/__phello__.foo.cpython-310.pyc", + "lib/python3.10/__pycache__/_aix_support.cpython-310.pyc", + "lib/python3.10/__pycache__/_bootsubprocess.cpython-310.pyc", + "lib/python3.10/__pycache__/_collections_abc.cpython-310.pyc", + "lib/python3.10/__pycache__/_compat_pickle.cpython-310.pyc", + "lib/python3.10/__pycache__/_compression.cpython-310.pyc", + "lib/python3.10/__pycache__/_markupbase.cpython-310.pyc", + "lib/python3.10/__pycache__/_osx_support.cpython-310.pyc", + "lib/python3.10/__pycache__/_py_abc.cpython-310.pyc", + "lib/python3.10/__pycache__/_pydecimal.cpython-310.pyc", + "lib/python3.10/__pycache__/_pyio.cpython-310.pyc", + "lib/python3.10/__pycache__/_sitebuiltins.cpython-310.pyc", + "lib/python3.10/__pycache__/_strptime.cpython-310.pyc", + "lib/python3.10/__pycache__/_sysconfigdata__darwin_darwin.cpython-310.pyc", + "lib/python3.10/__pycache__/_sysconfigdata_arm64_apple_darwin20_0_0.cpython-310.pyc", + "lib/python3.10/__pycache__/_threading_local.cpython-310.pyc", + "lib/python3.10/__pycache__/_weakrefset.cpython-310.pyc", + "lib/python3.10/__pycache__/abc.cpython-310.pyc", + "lib/python3.10/__pycache__/aifc.cpython-310.pyc", + "lib/python3.10/__pycache__/antigravity.cpython-310.pyc", + "lib/python3.10/__pycache__/argparse.cpython-310.pyc", + "lib/python3.10/__pycache__/ast.cpython-310.pyc", + "lib/python3.10/__pycache__/asynchat.cpython-310.pyc", + "lib/python3.10/__pycache__/asyncore.cpython-310.pyc", + "lib/python3.10/__pycache__/base64.cpython-310.pyc", + "lib/python3.10/__pycache__/bdb.cpython-310.pyc", + "lib/python3.10/__pycache__/binhex.cpython-310.pyc", + "lib/python3.10/__pycache__/bisect.cpython-310.pyc", + "lib/python3.10/__pycache__/bz2.cpython-310.pyc", + "lib/python3.10/__pycache__/cProfile.cpython-310.pyc", + "lib/python3.10/__pycache__/calendar.cpython-310.pyc", + "lib/python3.10/__pycache__/cgi.cpython-310.pyc", + "lib/python3.10/__pycache__/cgitb.cpython-310.pyc", + "lib/python3.10/__pycache__/chunk.cpython-310.pyc", + "lib/python3.10/__pycache__/cmd.cpython-310.pyc", + "lib/python3.10/__pycache__/code.cpython-310.pyc", + "lib/python3.10/__pycache__/codecs.cpython-310.pyc", + "lib/python3.10/__pycache__/codeop.cpython-310.pyc", + "lib/python3.10/__pycache__/colorsys.cpython-310.pyc", + "lib/python3.10/__pycache__/compileall.cpython-310.pyc", + "lib/python3.10/__pycache__/configparser.cpython-310.pyc", + "lib/python3.10/__pycache__/contextlib.cpython-310.pyc", + "lib/python3.10/__pycache__/contextvars.cpython-310.pyc", + "lib/python3.10/__pycache__/copy.cpython-310.pyc", + "lib/python3.10/__pycache__/copyreg.cpython-310.pyc", + "lib/python3.10/__pycache__/crypt.cpython-310.pyc", + "lib/python3.10/__pycache__/csv.cpython-310.pyc", + "lib/python3.10/__pycache__/dataclasses.cpython-310.pyc", + "lib/python3.10/__pycache__/datetime.cpython-310.pyc", + "lib/python3.10/__pycache__/decimal.cpython-310.pyc", + "lib/python3.10/__pycache__/difflib.cpython-310.pyc", + "lib/python3.10/__pycache__/dis.cpython-310.pyc", + "lib/python3.10/__pycache__/doctest.cpython-310.pyc", + "lib/python3.10/__pycache__/enum.cpython-310.pyc", + "lib/python3.10/__pycache__/filecmp.cpython-310.pyc", + "lib/python3.10/__pycache__/fileinput.cpython-310.pyc", + "lib/python3.10/__pycache__/fnmatch.cpython-310.pyc", + "lib/python3.10/__pycache__/fractions.cpython-310.pyc", + "lib/python3.10/__pycache__/ftplib.cpython-310.pyc", + "lib/python3.10/__pycache__/functools.cpython-310.pyc", + "lib/python3.10/__pycache__/genericpath.cpython-310.pyc", + "lib/python3.10/__pycache__/getopt.cpython-310.pyc", + "lib/python3.10/__pycache__/getpass.cpython-310.pyc", + "lib/python3.10/__pycache__/gettext.cpython-310.pyc", + "lib/python3.10/__pycache__/glob.cpython-310.pyc", + "lib/python3.10/__pycache__/graphlib.cpython-310.pyc", + "lib/python3.10/__pycache__/gzip.cpython-310.pyc", + "lib/python3.10/__pycache__/hashlib.cpython-310.pyc", + "lib/python3.10/__pycache__/heapq.cpython-310.pyc", + "lib/python3.10/__pycache__/hmac.cpython-310.pyc", + "lib/python3.10/__pycache__/imaplib.cpython-310.pyc", + "lib/python3.10/__pycache__/imghdr.cpython-310.pyc", + "lib/python3.10/__pycache__/imp.cpython-310.pyc", + "lib/python3.10/__pycache__/inspect.cpython-310.pyc", + "lib/python3.10/__pycache__/io.cpython-310.pyc", + "lib/python3.10/__pycache__/ipaddress.cpython-310.pyc", + "lib/python3.10/__pycache__/keyword.cpython-310.pyc", + "lib/python3.10/__pycache__/linecache.cpython-310.pyc", + "lib/python3.10/__pycache__/locale.cpython-310.pyc", + "lib/python3.10/__pycache__/lzma.cpython-310.pyc", + "lib/python3.10/__pycache__/mailbox.cpython-310.pyc", + "lib/python3.10/__pycache__/mailcap.cpython-310.pyc", + "lib/python3.10/__pycache__/mimetypes.cpython-310.pyc", + "lib/python3.10/__pycache__/modulefinder.cpython-310.pyc", + "lib/python3.10/__pycache__/netrc.cpython-310.pyc", + "lib/python3.10/__pycache__/nntplib.cpython-310.pyc", + "lib/python3.10/__pycache__/ntpath.cpython-310.pyc", + "lib/python3.10/__pycache__/nturl2path.cpython-310.pyc", + "lib/python3.10/__pycache__/numbers.cpython-310.pyc", + "lib/python3.10/__pycache__/opcode.cpython-310.pyc", + "lib/python3.10/__pycache__/operator.cpython-310.pyc", + "lib/python3.10/__pycache__/optparse.cpython-310.pyc", + "lib/python3.10/__pycache__/os.cpython-310.pyc", + "lib/python3.10/__pycache__/pathlib.cpython-310.pyc", + "lib/python3.10/__pycache__/pdb.cpython-310.pyc", + "lib/python3.10/__pycache__/pickle.cpython-310.pyc", + "lib/python3.10/__pycache__/pickletools.cpython-310.pyc", + "lib/python3.10/__pycache__/pipes.cpython-310.pyc", + "lib/python3.10/__pycache__/pkgutil.cpython-310.pyc", + "lib/python3.10/__pycache__/platform.cpython-310.pyc", + "lib/python3.10/__pycache__/plistlib.cpython-310.pyc", + "lib/python3.10/__pycache__/poplib.cpython-310.pyc", + "lib/python3.10/__pycache__/posixpath.cpython-310.pyc", + "lib/python3.10/__pycache__/pprint.cpython-310.pyc", + "lib/python3.10/__pycache__/profile.cpython-310.pyc", + "lib/python3.10/__pycache__/pstats.cpython-310.pyc", + "lib/python3.10/__pycache__/pty.cpython-310.pyc", + "lib/python3.10/__pycache__/py_compile.cpython-310.pyc", + "lib/python3.10/__pycache__/pyclbr.cpython-310.pyc", + "lib/python3.10/__pycache__/pydoc.cpython-310.pyc", + "lib/python3.10/__pycache__/queue.cpython-310.pyc", + "lib/python3.10/__pycache__/quopri.cpython-310.pyc", + "lib/python3.10/__pycache__/random.cpython-310.pyc", + "lib/python3.10/__pycache__/re.cpython-310.pyc", + "lib/python3.10/__pycache__/reprlib.cpython-310.pyc", + "lib/python3.10/__pycache__/rlcompleter.cpython-310.pyc", + "lib/python3.10/__pycache__/runpy.cpython-310.pyc", + "lib/python3.10/__pycache__/sched.cpython-310.pyc", + "lib/python3.10/__pycache__/secrets.cpython-310.pyc", + "lib/python3.10/__pycache__/selectors.cpython-310.pyc", + "lib/python3.10/__pycache__/shelve.cpython-310.pyc", + "lib/python3.10/__pycache__/shlex.cpython-310.pyc", + "lib/python3.10/__pycache__/shutil.cpython-310.pyc", + "lib/python3.10/__pycache__/signal.cpython-310.pyc", + "lib/python3.10/__pycache__/site.cpython-310.pyc", + "lib/python3.10/__pycache__/smtpd.cpython-310.pyc", + "lib/python3.10/__pycache__/smtplib.cpython-310.pyc", + "lib/python3.10/__pycache__/sndhdr.cpython-310.pyc", + "lib/python3.10/__pycache__/socket.cpython-310.pyc", + "lib/python3.10/__pycache__/socketserver.cpython-310.pyc", + "lib/python3.10/__pycache__/sre_compile.cpython-310.pyc", + "lib/python3.10/__pycache__/sre_constants.cpython-310.pyc", + "lib/python3.10/__pycache__/sre_parse.cpython-310.pyc", + "lib/python3.10/__pycache__/ssl.cpython-310.pyc", + "lib/python3.10/__pycache__/stat.cpython-310.pyc", + "lib/python3.10/__pycache__/statistics.cpython-310.pyc", + "lib/python3.10/__pycache__/string.cpython-310.pyc", + "lib/python3.10/__pycache__/stringprep.cpython-310.pyc", + "lib/python3.10/__pycache__/struct.cpython-310.pyc", + "lib/python3.10/__pycache__/subprocess.cpython-310.pyc", + "lib/python3.10/__pycache__/sunau.cpython-310.pyc", + "lib/python3.10/__pycache__/symtable.cpython-310.pyc", + "lib/python3.10/__pycache__/sysconfig.cpython-310.pyc", + "lib/python3.10/__pycache__/tabnanny.cpython-310.pyc", + "lib/python3.10/__pycache__/tarfile.cpython-310.pyc", + "lib/python3.10/__pycache__/telnetlib.cpython-310.pyc", + "lib/python3.10/__pycache__/tempfile.cpython-310.pyc", + "lib/python3.10/__pycache__/textwrap.cpython-310.pyc", + "lib/python3.10/__pycache__/this.cpython-310.pyc", + "lib/python3.10/__pycache__/threading.cpython-310.pyc", + "lib/python3.10/__pycache__/timeit.cpython-310.pyc", + "lib/python3.10/__pycache__/token.cpython-310.pyc", + "lib/python3.10/__pycache__/tokenize.cpython-310.pyc", + "lib/python3.10/__pycache__/trace.cpython-310.pyc", + "lib/python3.10/__pycache__/traceback.cpython-310.pyc", + "lib/python3.10/__pycache__/tracemalloc.cpython-310.pyc", + "lib/python3.10/__pycache__/tty.cpython-310.pyc", + "lib/python3.10/__pycache__/turtle.cpython-310.pyc", + "lib/python3.10/__pycache__/types.cpython-310.pyc", + "lib/python3.10/__pycache__/typing.cpython-310.pyc", + "lib/python3.10/__pycache__/uu.cpython-310.pyc", + "lib/python3.10/__pycache__/uuid.cpython-310.pyc", + "lib/python3.10/__pycache__/warnings.cpython-310.pyc", + "lib/python3.10/__pycache__/wave.cpython-310.pyc", + "lib/python3.10/__pycache__/weakref.cpython-310.pyc", + "lib/python3.10/__pycache__/webbrowser.cpython-310.pyc", + "lib/python3.10/__pycache__/xdrlib.cpython-310.pyc", + "lib/python3.10/__pycache__/zipapp.cpython-310.pyc", + "lib/python3.10/__pycache__/zipfile.cpython-310.pyc", + "lib/python3.10/__pycache__/zipimport.cpython-310.pyc", + "lib/python3.10/_aix_support.py", + "lib/python3.10/_bootsubprocess.py", + "lib/python3.10/_collections_abc.py", + "lib/python3.10/_compat_pickle.py", + "lib/python3.10/_compression.py", + "lib/python3.10/_markupbase.py", + "lib/python3.10/_osx_support.py", + "lib/python3.10/_py_abc.py", + "lib/python3.10/_pydecimal.py", + "lib/python3.10/_pyio.py", + "lib/python3.10/_sitebuiltins.py", + "lib/python3.10/_strptime.py", + "lib/python3.10/_sysconfigdata__darwin_darwin.py", + "lib/python3.10/_sysconfigdata__darwin_darwin.py.orig", + "lib/python3.10/_sysconfigdata_arm64_apple_darwin20_0_0.py", + "lib/python3.10/_threading_local.py", + "lib/python3.10/_weakrefset.py", + "lib/python3.10/abc.py", + "lib/python3.10/aifc.py", + "lib/python3.10/antigravity.py", + "lib/python3.10/argparse.py", + "lib/python3.10/ast.py", + "lib/python3.10/asynchat.py", + "lib/python3.10/asyncio/__init__.py", + "lib/python3.10/asyncio/__main__.py", + "lib/python3.10/asyncio/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/__main__.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/base_events.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/base_futures.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/base_subprocess.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/base_tasks.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/constants.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/coroutines.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/events.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/exceptions.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/format_helpers.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/futures.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/locks.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/log.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/mixins.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/proactor_events.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/protocols.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/queues.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/runners.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/selector_events.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/sslproto.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/staggered.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/streams.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/subprocess.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/tasks.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/threads.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/transports.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/trsock.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/unix_events.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/windows_events.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/windows_utils.cpython-310.pyc", + "lib/python3.10/asyncio/base_events.py", + "lib/python3.10/asyncio/base_futures.py", + "lib/python3.10/asyncio/base_subprocess.py", + "lib/python3.10/asyncio/base_tasks.py", + "lib/python3.10/asyncio/constants.py", + "lib/python3.10/asyncio/coroutines.py", + "lib/python3.10/asyncio/events.py", + "lib/python3.10/asyncio/exceptions.py", + "lib/python3.10/asyncio/format_helpers.py", + "lib/python3.10/asyncio/futures.py", + "lib/python3.10/asyncio/locks.py", + "lib/python3.10/asyncio/log.py", + "lib/python3.10/asyncio/mixins.py", + "lib/python3.10/asyncio/proactor_events.py", + "lib/python3.10/asyncio/protocols.py", + "lib/python3.10/asyncio/queues.py", + "lib/python3.10/asyncio/runners.py", + "lib/python3.10/asyncio/selector_events.py", + "lib/python3.10/asyncio/sslproto.py", + "lib/python3.10/asyncio/staggered.py", + "lib/python3.10/asyncio/streams.py", + "lib/python3.10/asyncio/subprocess.py", + "lib/python3.10/asyncio/tasks.py", + "lib/python3.10/asyncio/threads.py", + "lib/python3.10/asyncio/transports.py", + "lib/python3.10/asyncio/trsock.py", + "lib/python3.10/asyncio/unix_events.py", + "lib/python3.10/asyncio/windows_events.py", + "lib/python3.10/asyncio/windows_utils.py", + "lib/python3.10/asyncore.py", + "lib/python3.10/base64.py", + "lib/python3.10/bdb.py", + "lib/python3.10/binhex.py", + "lib/python3.10/bisect.py", + "lib/python3.10/bz2.py", + "lib/python3.10/cProfile.py", + "lib/python3.10/calendar.py", + "lib/python3.10/cgi.py", + "lib/python3.10/cgitb.py", + "lib/python3.10/chunk.py", + "lib/python3.10/cmd.py", + "lib/python3.10/code.py", + "lib/python3.10/codecs.py", + "lib/python3.10/codeop.py", + "lib/python3.10/collections/__init__.py", + "lib/python3.10/collections/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/collections/__pycache__/abc.cpython-310.pyc", + "lib/python3.10/collections/abc.py", + "lib/python3.10/colorsys.py", + "lib/python3.10/compileall.py", + "lib/python3.10/concurrent/__init__.py", + "lib/python3.10/concurrent/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/concurrent/futures/__init__.py", + "lib/python3.10/concurrent/futures/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/concurrent/futures/__pycache__/_base.cpython-310.pyc", + "lib/python3.10/concurrent/futures/__pycache__/process.cpython-310.pyc", + "lib/python3.10/concurrent/futures/__pycache__/thread.cpython-310.pyc", + "lib/python3.10/concurrent/futures/_base.py", + "lib/python3.10/concurrent/futures/process.py", + "lib/python3.10/concurrent/futures/thread.py", + "lib/python3.10/config-3.10-darwin/Makefile", + "lib/python3.10/config-3.10-darwin/Setup", + "lib/python3.10/config-3.10-darwin/Setup.local", + "lib/python3.10/config-3.10-darwin/__pycache__/python-config.cpython-310.pyc", + "lib/python3.10/config-3.10-darwin/config.c", + "lib/python3.10/config-3.10-darwin/config.c.in", + "lib/python3.10/config-3.10-darwin/install-sh", + "lib/python3.10/config-3.10-darwin/makesetup", + "lib/python3.10/config-3.10-darwin/python-config.py", + "lib/python3.10/config-3.10-darwin/python.o", + "lib/python3.10/configparser.py", + "lib/python3.10/contextlib.py", + "lib/python3.10/contextvars.py", + "lib/python3.10/copy.py", + "lib/python3.10/copyreg.py", + "lib/python3.10/crypt.py", + "lib/python3.10/csv.py", + "lib/python3.10/ctypes/__init__.py", + "lib/python3.10/ctypes/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/ctypes/__pycache__/_aix.cpython-310.pyc", + "lib/python3.10/ctypes/__pycache__/_endian.cpython-310.pyc", + "lib/python3.10/ctypes/__pycache__/util.cpython-310.pyc", + "lib/python3.10/ctypes/__pycache__/wintypes.cpython-310.pyc", + "lib/python3.10/ctypes/_aix.py", + "lib/python3.10/ctypes/_endian.py", + "lib/python3.10/ctypes/macholib/README.ctypes", + "lib/python3.10/ctypes/macholib/__init__.py", + "lib/python3.10/ctypes/macholib/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/ctypes/macholib/__pycache__/dyld.cpython-310.pyc", + "lib/python3.10/ctypes/macholib/__pycache__/dylib.cpython-310.pyc", + "lib/python3.10/ctypes/macholib/__pycache__/framework.cpython-310.pyc", + "lib/python3.10/ctypes/macholib/dyld.py", + "lib/python3.10/ctypes/macholib/dylib.py", + "lib/python3.10/ctypes/macholib/fetch_macholib", + "lib/python3.10/ctypes/macholib/fetch_macholib.bat", + "lib/python3.10/ctypes/macholib/framework.py", + "lib/python3.10/ctypes/util.py", + "lib/python3.10/ctypes/wintypes.py", + "lib/python3.10/curses/__init__.py", + "lib/python3.10/curses/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/curses/__pycache__/ascii.cpython-310.pyc", + "lib/python3.10/curses/__pycache__/has_key.cpython-310.pyc", + "lib/python3.10/curses/__pycache__/panel.cpython-310.pyc", + "lib/python3.10/curses/__pycache__/textpad.cpython-310.pyc", + "lib/python3.10/curses/ascii.py", + "lib/python3.10/curses/has_key.py", + "lib/python3.10/curses/panel.py", + "lib/python3.10/curses/textpad.py", + "lib/python3.10/dataclasses.py", + "lib/python3.10/datetime.py", + "lib/python3.10/dbm/__init__.py", + "lib/python3.10/dbm/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/dbm/__pycache__/dumb.cpython-310.pyc", + "lib/python3.10/dbm/__pycache__/gnu.cpython-310.pyc", + "lib/python3.10/dbm/__pycache__/ndbm.cpython-310.pyc", + "lib/python3.10/dbm/dumb.py", + "lib/python3.10/dbm/gnu.py", + "lib/python3.10/dbm/ndbm.py", + "lib/python3.10/decimal.py", + "lib/python3.10/difflib.py", + "lib/python3.10/dis.py", + "lib/python3.10/distutils/README", + "lib/python3.10/distutils/__init__.py", + "lib/python3.10/distutils/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/_msvccompiler.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/archive_util.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/bcppcompiler.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/ccompiler.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/cmd.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/config.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/core.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/cygwinccompiler.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/debug.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/dep_util.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/dir_util.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/dist.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/errors.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/extension.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/fancy_getopt.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/file_util.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/filelist.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/log.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/msvc9compiler.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/msvccompiler.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/spawn.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/sysconfig.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/text_file.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/unixccompiler.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/util.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/version.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/versionpredicate.cpython-310.pyc", + "lib/python3.10/distutils/_msvccompiler.py", + "lib/python3.10/distutils/archive_util.py", + "lib/python3.10/distutils/bcppcompiler.py", + "lib/python3.10/distutils/ccompiler.py", + "lib/python3.10/distutils/cmd.py", + "lib/python3.10/distutils/command/__init__.py", + "lib/python3.10/distutils/command/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/distutils/command/__pycache__/bdist.cpython-310.pyc", + "lib/python3.10/distutils/command/__pycache__/bdist_dumb.cpython-310.pyc", + "lib/python3.10/distutils/command/__pycache__/bdist_msi.cpython-310.pyc", + "lib/python3.10/distutils/command/__pycache__/bdist_rpm.cpython-310.pyc", + "lib/python3.10/distutils/command/__pycache__/build.cpython-310.pyc", + "lib/python3.10/distutils/command/__pycache__/build_clib.cpython-310.pyc", + "lib/python3.10/distutils/command/__pycache__/build_ext.cpython-310.pyc", + "lib/python3.10/distutils/command/__pycache__/build_py.cpython-310.pyc", + "lib/python3.10/distutils/command/__pycache__/build_scripts.cpython-310.pyc", + "lib/python3.10/distutils/command/__pycache__/check.cpython-310.pyc", + "lib/python3.10/distutils/command/__pycache__/clean.cpython-310.pyc", + "lib/python3.10/distutils/command/__pycache__/config.cpython-310.pyc", + "lib/python3.10/distutils/command/__pycache__/install.cpython-310.pyc", + "lib/python3.10/distutils/command/__pycache__/install_data.cpython-310.pyc", + "lib/python3.10/distutils/command/__pycache__/install_egg_info.cpython-310.pyc", + "lib/python3.10/distutils/command/__pycache__/install_headers.cpython-310.pyc", + "lib/python3.10/distutils/command/__pycache__/install_lib.cpython-310.pyc", + "lib/python3.10/distutils/command/__pycache__/install_scripts.cpython-310.pyc", + "lib/python3.10/distutils/command/__pycache__/register.cpython-310.pyc", + "lib/python3.10/distutils/command/__pycache__/sdist.cpython-310.pyc", + "lib/python3.10/distutils/command/__pycache__/upload.cpython-310.pyc", + "lib/python3.10/distutils/command/bdist.py", + "lib/python3.10/distutils/command/bdist_dumb.py", + "lib/python3.10/distutils/command/bdist_msi.py", + "lib/python3.10/distutils/command/bdist_rpm.py", + "lib/python3.10/distutils/command/build.py", + "lib/python3.10/distutils/command/build_clib.py", + "lib/python3.10/distutils/command/build_ext.py", + "lib/python3.10/distutils/command/build_py.py", + "lib/python3.10/distutils/command/build_scripts.py", + "lib/python3.10/distutils/command/check.py", + "lib/python3.10/distutils/command/clean.py", + "lib/python3.10/distutils/command/command_template", + "lib/python3.10/distutils/command/config.py", + "lib/python3.10/distutils/command/install.py", + "lib/python3.10/distutils/command/install_data.py", + "lib/python3.10/distutils/command/install_egg_info.py", + "lib/python3.10/distutils/command/install_headers.py", + "lib/python3.10/distutils/command/install_lib.py", + "lib/python3.10/distutils/command/install_scripts.py", + "lib/python3.10/distutils/command/register.py", + "lib/python3.10/distutils/command/sdist.py", + "lib/python3.10/distutils/command/upload.py", + "lib/python3.10/distutils/config.py", + "lib/python3.10/distutils/core.py", + "lib/python3.10/distutils/cygwinccompiler.py", + "lib/python3.10/distutils/debug.py", + "lib/python3.10/distutils/dep_util.py", + "lib/python3.10/distutils/dir_util.py", + "lib/python3.10/distutils/dist.py", + "lib/python3.10/distutils/errors.py", + "lib/python3.10/distutils/extension.py", + "lib/python3.10/distutils/fancy_getopt.py", + "lib/python3.10/distutils/file_util.py", + "lib/python3.10/distutils/filelist.py", + "lib/python3.10/distutils/log.py", + "lib/python3.10/distutils/msvc9compiler.py", + "lib/python3.10/distutils/msvccompiler.py", + "lib/python3.10/distutils/spawn.py", + "lib/python3.10/distutils/sysconfig.py", + "lib/python3.10/distutils/tests/Setup.sample", + "lib/python3.10/distutils/tests/__init__.py", + "lib/python3.10/distutils/tests/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/support.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_archive_util.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_bdist.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_bdist_dumb.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_bdist_msi.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_bdist_rpm.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_build.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_build_clib.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_build_ext.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_build_py.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_build_scripts.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_check.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_clean.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_cmd.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_config.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_config_cmd.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_core.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_cygwinccompiler.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_dep_util.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_dir_util.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_dist.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_extension.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_file_util.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_filelist.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_install.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_install_data.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_install_headers.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_install_lib.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_install_scripts.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_log.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_msvc9compiler.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_msvccompiler.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_register.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_sdist.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_spawn.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_sysconfig.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_text_file.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_unixccompiler.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_upload.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_util.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_version.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_versionpredicate.cpython-310.pyc", + "lib/python3.10/distutils/tests/includetest.rst", + "lib/python3.10/distutils/tests/support.py", + "lib/python3.10/distutils/tests/test_archive_util.py", + "lib/python3.10/distutils/tests/test_bdist.py", + "lib/python3.10/distutils/tests/test_bdist_dumb.py", + "lib/python3.10/distutils/tests/test_bdist_msi.py", + "lib/python3.10/distutils/tests/test_bdist_rpm.py", + "lib/python3.10/distutils/tests/test_build.py", + "lib/python3.10/distutils/tests/test_build_clib.py", + "lib/python3.10/distutils/tests/test_build_ext.py", + "lib/python3.10/distutils/tests/test_build_py.py", + "lib/python3.10/distutils/tests/test_build_scripts.py", + "lib/python3.10/distutils/tests/test_check.py", + "lib/python3.10/distutils/tests/test_clean.py", + "lib/python3.10/distutils/tests/test_cmd.py", + "lib/python3.10/distutils/tests/test_config.py", + "lib/python3.10/distutils/tests/test_config_cmd.py", + "lib/python3.10/distutils/tests/test_core.py", + "lib/python3.10/distutils/tests/test_cygwinccompiler.py", + "lib/python3.10/distutils/tests/test_dep_util.py", + "lib/python3.10/distutils/tests/test_dir_util.py", + "lib/python3.10/distutils/tests/test_dist.py", + "lib/python3.10/distutils/tests/test_extension.py", + "lib/python3.10/distutils/tests/test_file_util.py", + "lib/python3.10/distutils/tests/test_filelist.py", + "lib/python3.10/distutils/tests/test_install.py", + "lib/python3.10/distutils/tests/test_install_data.py", + "lib/python3.10/distutils/tests/test_install_headers.py", + "lib/python3.10/distutils/tests/test_install_lib.py", + "lib/python3.10/distutils/tests/test_install_scripts.py", + "lib/python3.10/distutils/tests/test_log.py", + "lib/python3.10/distutils/tests/test_msvc9compiler.py", + "lib/python3.10/distutils/tests/test_msvccompiler.py", + "lib/python3.10/distutils/tests/test_register.py", + "lib/python3.10/distutils/tests/test_sdist.py", + "lib/python3.10/distutils/tests/test_spawn.py", + "lib/python3.10/distutils/tests/test_sysconfig.py", + "lib/python3.10/distutils/tests/test_text_file.py", + "lib/python3.10/distutils/tests/test_unixccompiler.py", + "lib/python3.10/distutils/tests/test_upload.py", + "lib/python3.10/distutils/tests/test_util.py", + "lib/python3.10/distutils/tests/test_version.py", + "lib/python3.10/distutils/tests/test_versionpredicate.py", + "lib/python3.10/distutils/tests/xxmodule.c", + "lib/python3.10/distutils/text_file.py", + "lib/python3.10/distutils/unixccompiler.py", + "lib/python3.10/distutils/util.py", + "lib/python3.10/distutils/version.py", + "lib/python3.10/distutils/versionpredicate.py", + "lib/python3.10/doctest.py", + "lib/python3.10/email/__init__.py", + "lib/python3.10/email/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/email/__pycache__/_encoded_words.cpython-310.pyc", + "lib/python3.10/email/__pycache__/_header_value_parser.cpython-310.pyc", + "lib/python3.10/email/__pycache__/_parseaddr.cpython-310.pyc", + "lib/python3.10/email/__pycache__/_policybase.cpython-310.pyc", + "lib/python3.10/email/__pycache__/base64mime.cpython-310.pyc", + "lib/python3.10/email/__pycache__/charset.cpython-310.pyc", + "lib/python3.10/email/__pycache__/contentmanager.cpython-310.pyc", + "lib/python3.10/email/__pycache__/encoders.cpython-310.pyc", + "lib/python3.10/email/__pycache__/errors.cpython-310.pyc", + "lib/python3.10/email/__pycache__/feedparser.cpython-310.pyc", + "lib/python3.10/email/__pycache__/generator.cpython-310.pyc", + "lib/python3.10/email/__pycache__/header.cpython-310.pyc", + "lib/python3.10/email/__pycache__/headerregistry.cpython-310.pyc", + "lib/python3.10/email/__pycache__/iterators.cpython-310.pyc", + "lib/python3.10/email/__pycache__/message.cpython-310.pyc", + "lib/python3.10/email/__pycache__/parser.cpython-310.pyc", + "lib/python3.10/email/__pycache__/policy.cpython-310.pyc", + "lib/python3.10/email/__pycache__/quoprimime.cpython-310.pyc", + "lib/python3.10/email/__pycache__/utils.cpython-310.pyc", + "lib/python3.10/email/_encoded_words.py", + "lib/python3.10/email/_header_value_parser.py", + "lib/python3.10/email/_parseaddr.py", + "lib/python3.10/email/_policybase.py", + "lib/python3.10/email/architecture.rst", + "lib/python3.10/email/base64mime.py", + "lib/python3.10/email/charset.py", + "lib/python3.10/email/contentmanager.py", + "lib/python3.10/email/encoders.py", + "lib/python3.10/email/errors.py", + "lib/python3.10/email/feedparser.py", + "lib/python3.10/email/generator.py", + "lib/python3.10/email/header.py", + "lib/python3.10/email/headerregistry.py", + "lib/python3.10/email/iterators.py", + "lib/python3.10/email/message.py", + "lib/python3.10/email/mime/__init__.py", + "lib/python3.10/email/mime/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/email/mime/__pycache__/application.cpython-310.pyc", + "lib/python3.10/email/mime/__pycache__/audio.cpython-310.pyc", + "lib/python3.10/email/mime/__pycache__/base.cpython-310.pyc", + "lib/python3.10/email/mime/__pycache__/image.cpython-310.pyc", + "lib/python3.10/email/mime/__pycache__/message.cpython-310.pyc", + "lib/python3.10/email/mime/__pycache__/multipart.cpython-310.pyc", + "lib/python3.10/email/mime/__pycache__/nonmultipart.cpython-310.pyc", + "lib/python3.10/email/mime/__pycache__/text.cpython-310.pyc", + "lib/python3.10/email/mime/application.py", + "lib/python3.10/email/mime/audio.py", + "lib/python3.10/email/mime/base.py", + "lib/python3.10/email/mime/image.py", + "lib/python3.10/email/mime/message.py", + "lib/python3.10/email/mime/multipart.py", + "lib/python3.10/email/mime/nonmultipart.py", + "lib/python3.10/email/mime/text.py", + "lib/python3.10/email/parser.py", + "lib/python3.10/email/policy.py", + "lib/python3.10/email/quoprimime.py", + "lib/python3.10/email/utils.py", + "lib/python3.10/encodings/__init__.py", + "lib/python3.10/encodings/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/aliases.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/ascii.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/base64_codec.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/big5.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/big5hkscs.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/bz2_codec.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/charmap.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp037.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp1006.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp1026.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp1125.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp1140.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp1250.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp1251.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp1252.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp1253.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp1254.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp1255.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp1256.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp1257.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp1258.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp273.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp424.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp437.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp500.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp720.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp737.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp775.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp850.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp852.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp855.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp856.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp857.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp858.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp860.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp861.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp862.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp863.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp864.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp865.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp866.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp869.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp874.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp875.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp932.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp949.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp950.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/euc_jis_2004.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/euc_jisx0213.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/euc_jp.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/euc_kr.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/gb18030.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/gb2312.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/gbk.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/hex_codec.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/hp_roman8.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/hz.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/idna.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/iso2022_jp.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/iso2022_jp_1.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/iso2022_jp_2.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/iso2022_jp_2004.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/iso2022_jp_3.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/iso2022_jp_ext.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/iso2022_kr.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/iso8859_1.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/iso8859_10.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/iso8859_11.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/iso8859_13.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/iso8859_14.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/iso8859_15.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/iso8859_16.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/iso8859_2.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/iso8859_3.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/iso8859_4.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/iso8859_5.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/iso8859_6.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/iso8859_7.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/iso8859_8.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/iso8859_9.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/johab.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/koi8_r.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/koi8_t.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/koi8_u.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/kz1048.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/latin_1.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/mac_arabic.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/mac_croatian.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/mac_cyrillic.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/mac_farsi.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/mac_greek.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/mac_iceland.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/mac_latin2.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/mac_roman.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/mac_romanian.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/mac_turkish.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/mbcs.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/oem.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/palmos.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/ptcp154.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/punycode.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/quopri_codec.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/raw_unicode_escape.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/rot_13.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/shift_jis.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/shift_jis_2004.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/shift_jisx0213.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/tis_620.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/undefined.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/unicode_escape.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/utf_16.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/utf_16_be.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/utf_16_le.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/utf_32.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/utf_32_be.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/utf_32_le.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/utf_7.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/utf_8.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/utf_8_sig.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/uu_codec.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/zlib_codec.cpython-310.pyc", + "lib/python3.10/encodings/aliases.py", + "lib/python3.10/encodings/ascii.py", + "lib/python3.10/encodings/base64_codec.py", + "lib/python3.10/encodings/big5.py", + "lib/python3.10/encodings/big5hkscs.py", + "lib/python3.10/encodings/bz2_codec.py", + "lib/python3.10/encodings/charmap.py", + "lib/python3.10/encodings/cp037.py", + "lib/python3.10/encodings/cp1006.py", + "lib/python3.10/encodings/cp1026.py", + "lib/python3.10/encodings/cp1125.py", + "lib/python3.10/encodings/cp1140.py", + "lib/python3.10/encodings/cp1250.py", + "lib/python3.10/encodings/cp1251.py", + "lib/python3.10/encodings/cp1252.py", + "lib/python3.10/encodings/cp1253.py", + "lib/python3.10/encodings/cp1254.py", + "lib/python3.10/encodings/cp1255.py", + "lib/python3.10/encodings/cp1256.py", + "lib/python3.10/encodings/cp1257.py", + "lib/python3.10/encodings/cp1258.py", + "lib/python3.10/encodings/cp273.py", + "lib/python3.10/encodings/cp424.py", + "lib/python3.10/encodings/cp437.py", + "lib/python3.10/encodings/cp500.py", + "lib/python3.10/encodings/cp720.py", + "lib/python3.10/encodings/cp737.py", + "lib/python3.10/encodings/cp775.py", + "lib/python3.10/encodings/cp850.py", + "lib/python3.10/encodings/cp852.py", + "lib/python3.10/encodings/cp855.py", + "lib/python3.10/encodings/cp856.py", + "lib/python3.10/encodings/cp857.py", + "lib/python3.10/encodings/cp858.py", + "lib/python3.10/encodings/cp860.py", + "lib/python3.10/encodings/cp861.py", + "lib/python3.10/encodings/cp862.py", + "lib/python3.10/encodings/cp863.py", + "lib/python3.10/encodings/cp864.py", + "lib/python3.10/encodings/cp865.py", + "lib/python3.10/encodings/cp866.py", + "lib/python3.10/encodings/cp869.py", + "lib/python3.10/encodings/cp874.py", + "lib/python3.10/encodings/cp875.py", + "lib/python3.10/encodings/cp932.py", + "lib/python3.10/encodings/cp949.py", + "lib/python3.10/encodings/cp950.py", + "lib/python3.10/encodings/euc_jis_2004.py", + "lib/python3.10/encodings/euc_jisx0213.py", + "lib/python3.10/encodings/euc_jp.py", + "lib/python3.10/encodings/euc_kr.py", + "lib/python3.10/encodings/gb18030.py", + "lib/python3.10/encodings/gb2312.py", + "lib/python3.10/encodings/gbk.py", + "lib/python3.10/encodings/hex_codec.py", + "lib/python3.10/encodings/hp_roman8.py", + "lib/python3.10/encodings/hz.py", + "lib/python3.10/encodings/idna.py", + "lib/python3.10/encodings/iso2022_jp.py", + "lib/python3.10/encodings/iso2022_jp_1.py", + "lib/python3.10/encodings/iso2022_jp_2.py", + "lib/python3.10/encodings/iso2022_jp_2004.py", + "lib/python3.10/encodings/iso2022_jp_3.py", + "lib/python3.10/encodings/iso2022_jp_ext.py", + "lib/python3.10/encodings/iso2022_kr.py", + "lib/python3.10/encodings/iso8859_1.py", + "lib/python3.10/encodings/iso8859_10.py", + "lib/python3.10/encodings/iso8859_11.py", + "lib/python3.10/encodings/iso8859_13.py", + "lib/python3.10/encodings/iso8859_14.py", + "lib/python3.10/encodings/iso8859_15.py", + "lib/python3.10/encodings/iso8859_16.py", + "lib/python3.10/encodings/iso8859_2.py", + "lib/python3.10/encodings/iso8859_3.py", + "lib/python3.10/encodings/iso8859_4.py", + "lib/python3.10/encodings/iso8859_5.py", + "lib/python3.10/encodings/iso8859_6.py", + "lib/python3.10/encodings/iso8859_7.py", + "lib/python3.10/encodings/iso8859_8.py", + "lib/python3.10/encodings/iso8859_9.py", + "lib/python3.10/encodings/johab.py", + "lib/python3.10/encodings/koi8_r.py", + "lib/python3.10/encodings/koi8_t.py", + "lib/python3.10/encodings/koi8_u.py", + "lib/python3.10/encodings/kz1048.py", + "lib/python3.10/encodings/latin_1.py", + "lib/python3.10/encodings/mac_arabic.py", + "lib/python3.10/encodings/mac_croatian.py", + "lib/python3.10/encodings/mac_cyrillic.py", + "lib/python3.10/encodings/mac_farsi.py", + "lib/python3.10/encodings/mac_greek.py", + "lib/python3.10/encodings/mac_iceland.py", + "lib/python3.10/encodings/mac_latin2.py", + "lib/python3.10/encodings/mac_roman.py", + "lib/python3.10/encodings/mac_romanian.py", + "lib/python3.10/encodings/mac_turkish.py", + "lib/python3.10/encodings/mbcs.py", + "lib/python3.10/encodings/oem.py", + "lib/python3.10/encodings/palmos.py", + "lib/python3.10/encodings/ptcp154.py", + "lib/python3.10/encodings/punycode.py", + "lib/python3.10/encodings/quopri_codec.py", + "lib/python3.10/encodings/raw_unicode_escape.py", + "lib/python3.10/encodings/rot_13.py", + "lib/python3.10/encodings/shift_jis.py", + "lib/python3.10/encodings/shift_jis_2004.py", + "lib/python3.10/encodings/shift_jisx0213.py", + "lib/python3.10/encodings/tis_620.py", + "lib/python3.10/encodings/undefined.py", + "lib/python3.10/encodings/unicode_escape.py", + "lib/python3.10/encodings/utf_16.py", + "lib/python3.10/encodings/utf_16_be.py", + "lib/python3.10/encodings/utf_16_le.py", + "lib/python3.10/encodings/utf_32.py", + "lib/python3.10/encodings/utf_32_be.py", + "lib/python3.10/encodings/utf_32_le.py", + "lib/python3.10/encodings/utf_7.py", + "lib/python3.10/encodings/utf_8.py", + "lib/python3.10/encodings/utf_8_sig.py", + "lib/python3.10/encodings/uu_codec.py", + "lib/python3.10/encodings/zlib_codec.py", + "lib/python3.10/ensurepip/__init__.py", + "lib/python3.10/ensurepip/__main__.py", + "lib/python3.10/ensurepip/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/ensurepip/__pycache__/__main__.cpython-310.pyc", + "lib/python3.10/ensurepip/__pycache__/_uninstall.cpython-310.pyc", + "lib/python3.10/ensurepip/_bundled/__init__.py", + "lib/python3.10/ensurepip/_bundled/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/ensurepip/_bundled/pip-22.3.1-py3-none-any.whl", + "lib/python3.10/ensurepip/_bundled/setuptools-65.5.0-py3-none-any.whl", + "lib/python3.10/ensurepip/_uninstall.py", + "lib/python3.10/enum.py", + "lib/python3.10/filecmp.py", + "lib/python3.10/fileinput.py", + "lib/python3.10/fnmatch.py", + "lib/python3.10/fractions.py", + "lib/python3.10/ftplib.py", + "lib/python3.10/functools.py", + "lib/python3.10/genericpath.py", + "lib/python3.10/getopt.py", + "lib/python3.10/getpass.py", + "lib/python3.10/gettext.py", + "lib/python3.10/glob.py", + "lib/python3.10/graphlib.py", + "lib/python3.10/gzip.py", + "lib/python3.10/hashlib.py", + "lib/python3.10/heapq.py", + "lib/python3.10/hmac.py", + "lib/python3.10/html/__init__.py", + "lib/python3.10/html/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/html/__pycache__/entities.cpython-310.pyc", + "lib/python3.10/html/__pycache__/parser.cpython-310.pyc", + "lib/python3.10/html/entities.py", + "lib/python3.10/html/parser.py", + "lib/python3.10/http/__init__.py", + "lib/python3.10/http/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/http/__pycache__/client.cpython-310.pyc", + "lib/python3.10/http/__pycache__/cookiejar.cpython-310.pyc", + "lib/python3.10/http/__pycache__/cookies.cpython-310.pyc", + "lib/python3.10/http/__pycache__/server.cpython-310.pyc", + "lib/python3.10/http/client.py", + "lib/python3.10/http/cookiejar.py", + "lib/python3.10/http/cookies.py", + "lib/python3.10/http/server.py", + "lib/python3.10/idlelib/CREDITS.txt", + "lib/python3.10/idlelib/ChangeLog", + "lib/python3.10/idlelib/HISTORY.txt", + "lib/python3.10/idlelib/Icons/README.txt", + "lib/python3.10/idlelib/Icons/folder.gif", + "lib/python3.10/idlelib/Icons/idle.ico", + "lib/python3.10/idlelib/Icons/idle_16.gif", + "lib/python3.10/idlelib/Icons/idle_16.png", + "lib/python3.10/idlelib/Icons/idle_256.png", + "lib/python3.10/idlelib/Icons/idle_32.gif", + "lib/python3.10/idlelib/Icons/idle_32.png", + "lib/python3.10/idlelib/Icons/idle_48.gif", + "lib/python3.10/idlelib/Icons/idle_48.png", + "lib/python3.10/idlelib/Icons/minusnode.gif", + "lib/python3.10/idlelib/Icons/openfolder.gif", + "lib/python3.10/idlelib/Icons/plusnode.gif", + "lib/python3.10/idlelib/Icons/python.gif", + "lib/python3.10/idlelib/Icons/tk.gif", + "lib/python3.10/idlelib/NEWS.txt", + "lib/python3.10/idlelib/NEWS2x.txt", + "lib/python3.10/idlelib/README.txt", + "lib/python3.10/idlelib/TODO.txt", + "lib/python3.10/idlelib/__init__.py", + "lib/python3.10/idlelib/__main__.py", + "lib/python3.10/idlelib/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/__main__.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/autocomplete.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/autocomplete_w.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/autoexpand.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/browser.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/calltip.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/calltip_w.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/codecontext.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/colorizer.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/config.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/config_key.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/configdialog.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/debugger.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/debugger_r.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/debugobj.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/debugobj_r.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/delegator.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/dynoption.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/editor.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/filelist.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/format.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/grep.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/help.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/help_about.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/history.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/hyperparser.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/idle.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/iomenu.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/macosx.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/mainmenu.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/multicall.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/outwin.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/parenmatch.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/pathbrowser.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/percolator.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/pyparse.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/pyshell.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/query.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/redirector.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/replace.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/rpc.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/run.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/runscript.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/scrolledlist.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/search.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/searchbase.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/searchengine.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/sidebar.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/squeezer.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/stackviewer.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/statusbar.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/textview.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/tooltip.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/tree.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/undo.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/util.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/window.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/zoomheight.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/zzdummy.cpython-310.pyc", + "lib/python3.10/idlelib/autocomplete.py", + "lib/python3.10/idlelib/autocomplete_w.py", + "lib/python3.10/idlelib/autoexpand.py", + "lib/python3.10/idlelib/browser.py", + "lib/python3.10/idlelib/calltip.py", + "lib/python3.10/idlelib/calltip_w.py", + "lib/python3.10/idlelib/codecontext.py", + "lib/python3.10/idlelib/colorizer.py", + "lib/python3.10/idlelib/config-extensions.def", + "lib/python3.10/idlelib/config-highlight.def", + "lib/python3.10/idlelib/config-keys.def", + "lib/python3.10/idlelib/config-main.def", + "lib/python3.10/idlelib/config.py", + "lib/python3.10/idlelib/config_key.py", + "lib/python3.10/idlelib/configdialog.py", + "lib/python3.10/idlelib/debugger.py", + "lib/python3.10/idlelib/debugger_r.py", + "lib/python3.10/idlelib/debugobj.py", + "lib/python3.10/idlelib/debugobj_r.py", + "lib/python3.10/idlelib/delegator.py", + "lib/python3.10/idlelib/dynoption.py", + "lib/python3.10/idlelib/editor.py", + "lib/python3.10/idlelib/extend.txt", + "lib/python3.10/idlelib/filelist.py", + "lib/python3.10/idlelib/format.py", + "lib/python3.10/idlelib/grep.py", + "lib/python3.10/idlelib/help.html", + "lib/python3.10/idlelib/help.py", + "lib/python3.10/idlelib/help_about.py", + "lib/python3.10/idlelib/history.py", + "lib/python3.10/idlelib/hyperparser.py", + "lib/python3.10/idlelib/idle.bat", + "lib/python3.10/idlelib/idle.py", + "lib/python3.10/idlelib/idle.pyw", + "lib/python3.10/idlelib/idle_test/README.txt", + "lib/python3.10/idlelib/idle_test/__init__.py", + "lib/python3.10/idlelib/idle_test/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/htest.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/mock_idle.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/mock_tk.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/template.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_autocomplete.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_autocomplete_w.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_autoexpand.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_browser.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_calltip.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_calltip_w.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_codecontext.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_colorizer.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_config.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_config_key.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_configdialog.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_debugger.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_debugger_r.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_debugobj.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_debugobj_r.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_delegator.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_editmenu.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_editor.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_filelist.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_format.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_grep.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_help.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_help_about.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_history.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_hyperparser.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_iomenu.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_macosx.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_mainmenu.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_multicall.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_outwin.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_parenmatch.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_pathbrowser.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_percolator.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_pyparse.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_pyshell.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_query.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_redirector.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_replace.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_rpc.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_run.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_runscript.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_scrolledlist.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_search.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_searchbase.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_searchengine.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_sidebar.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_squeezer.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_stackviewer.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_statusbar.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_text.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_textview.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_tooltip.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_tree.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_undo.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_util.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_warning.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_window.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_zoomheight.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_zzdummy.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/tkinter_testing_utils.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/example_noext", + "lib/python3.10/idlelib/idle_test/example_stub.pyi", + "lib/python3.10/idlelib/idle_test/htest.py", + "lib/python3.10/idlelib/idle_test/mock_idle.py", + "lib/python3.10/idlelib/idle_test/mock_tk.py", + "lib/python3.10/idlelib/idle_test/template.py", + "lib/python3.10/idlelib/idle_test/test_autocomplete.py", + "lib/python3.10/idlelib/idle_test/test_autocomplete_w.py", + "lib/python3.10/idlelib/idle_test/test_autoexpand.py", + "lib/python3.10/idlelib/idle_test/test_browser.py", + "lib/python3.10/idlelib/idle_test/test_calltip.py", + "lib/python3.10/idlelib/idle_test/test_calltip_w.py", + "lib/python3.10/idlelib/idle_test/test_codecontext.py", + "lib/python3.10/idlelib/idle_test/test_colorizer.py", + "lib/python3.10/idlelib/idle_test/test_config.py", + "lib/python3.10/idlelib/idle_test/test_config_key.py", + "lib/python3.10/idlelib/idle_test/test_configdialog.py", + "lib/python3.10/idlelib/idle_test/test_debugger.py", + "lib/python3.10/idlelib/idle_test/test_debugger_r.py", + "lib/python3.10/idlelib/idle_test/test_debugobj.py", + "lib/python3.10/idlelib/idle_test/test_debugobj_r.py", + "lib/python3.10/idlelib/idle_test/test_delegator.py", + "lib/python3.10/idlelib/idle_test/test_editmenu.py", + "lib/python3.10/idlelib/idle_test/test_editor.py", + "lib/python3.10/idlelib/idle_test/test_filelist.py", + "lib/python3.10/idlelib/idle_test/test_format.py", + "lib/python3.10/idlelib/idle_test/test_grep.py", + "lib/python3.10/idlelib/idle_test/test_help.py", + "lib/python3.10/idlelib/idle_test/test_help_about.py", + "lib/python3.10/idlelib/idle_test/test_history.py", + "lib/python3.10/idlelib/idle_test/test_hyperparser.py", + "lib/python3.10/idlelib/idle_test/test_iomenu.py", + "lib/python3.10/idlelib/idle_test/test_macosx.py", + "lib/python3.10/idlelib/idle_test/test_mainmenu.py", + "lib/python3.10/idlelib/idle_test/test_multicall.py", + "lib/python3.10/idlelib/idle_test/test_outwin.py", + "lib/python3.10/idlelib/idle_test/test_parenmatch.py", + "lib/python3.10/idlelib/idle_test/test_pathbrowser.py", + "lib/python3.10/idlelib/idle_test/test_percolator.py", + "lib/python3.10/idlelib/idle_test/test_pyparse.py", + "lib/python3.10/idlelib/idle_test/test_pyshell.py", + "lib/python3.10/idlelib/idle_test/test_query.py", + "lib/python3.10/idlelib/idle_test/test_redirector.py", + "lib/python3.10/idlelib/idle_test/test_replace.py", + "lib/python3.10/idlelib/idle_test/test_rpc.py", + "lib/python3.10/idlelib/idle_test/test_run.py", + "lib/python3.10/idlelib/idle_test/test_runscript.py", + "lib/python3.10/idlelib/idle_test/test_scrolledlist.py", + "lib/python3.10/idlelib/idle_test/test_search.py", + "lib/python3.10/idlelib/idle_test/test_searchbase.py", + "lib/python3.10/idlelib/idle_test/test_searchengine.py", + "lib/python3.10/idlelib/idle_test/test_sidebar.py", + "lib/python3.10/idlelib/idle_test/test_squeezer.py", + "lib/python3.10/idlelib/idle_test/test_stackviewer.py", + "lib/python3.10/idlelib/idle_test/test_statusbar.py", + "lib/python3.10/idlelib/idle_test/test_text.py", + "lib/python3.10/idlelib/idle_test/test_textview.py", + "lib/python3.10/idlelib/idle_test/test_tooltip.py", + "lib/python3.10/idlelib/idle_test/test_tree.py", + "lib/python3.10/idlelib/idle_test/test_undo.py", + "lib/python3.10/idlelib/idle_test/test_util.py", + "lib/python3.10/idlelib/idle_test/test_warning.py", + "lib/python3.10/idlelib/idle_test/test_window.py", + "lib/python3.10/idlelib/idle_test/test_zoomheight.py", + "lib/python3.10/idlelib/idle_test/test_zzdummy.py", + "lib/python3.10/idlelib/idle_test/tkinter_testing_utils.py", + "lib/python3.10/idlelib/iomenu.py", + "lib/python3.10/idlelib/macosx.py", + "lib/python3.10/idlelib/mainmenu.py", + "lib/python3.10/idlelib/multicall.py", + "lib/python3.10/idlelib/outwin.py", + "lib/python3.10/idlelib/parenmatch.py", + "lib/python3.10/idlelib/pathbrowser.py", + "lib/python3.10/idlelib/percolator.py", + "lib/python3.10/idlelib/pyparse.py", + "lib/python3.10/idlelib/pyshell.py", + "lib/python3.10/idlelib/query.py", + "lib/python3.10/idlelib/redirector.py", + "lib/python3.10/idlelib/replace.py", + "lib/python3.10/idlelib/rpc.py", + "lib/python3.10/idlelib/run.py", + "lib/python3.10/idlelib/runscript.py", + "lib/python3.10/idlelib/scrolledlist.py", + "lib/python3.10/idlelib/search.py", + "lib/python3.10/idlelib/searchbase.py", + "lib/python3.10/idlelib/searchengine.py", + "lib/python3.10/idlelib/sidebar.py", + "lib/python3.10/idlelib/squeezer.py", + "lib/python3.10/idlelib/stackviewer.py", + "lib/python3.10/idlelib/statusbar.py", + "lib/python3.10/idlelib/textview.py", + "lib/python3.10/idlelib/tooltip.py", + "lib/python3.10/idlelib/tree.py", + "lib/python3.10/idlelib/undo.py", + "lib/python3.10/idlelib/util.py", + "lib/python3.10/idlelib/window.py", + "lib/python3.10/idlelib/zoomheight.py", + "lib/python3.10/idlelib/zzdummy.py", + "lib/python3.10/imaplib.py", + "lib/python3.10/imghdr.py", + "lib/python3.10/imp.py", + "lib/python3.10/importlib/__init__.py", + "lib/python3.10/importlib/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/importlib/__pycache__/_abc.cpython-310.pyc", + "lib/python3.10/importlib/__pycache__/_adapters.cpython-310.pyc", + "lib/python3.10/importlib/__pycache__/_bootstrap.cpython-310.pyc", + "lib/python3.10/importlib/__pycache__/_bootstrap_external.cpython-310.pyc", + "lib/python3.10/importlib/__pycache__/_common.cpython-310.pyc", + "lib/python3.10/importlib/__pycache__/abc.cpython-310.pyc", + "lib/python3.10/importlib/__pycache__/machinery.cpython-310.pyc", + "lib/python3.10/importlib/__pycache__/readers.cpython-310.pyc", + "lib/python3.10/importlib/__pycache__/resources.cpython-310.pyc", + "lib/python3.10/importlib/__pycache__/util.cpython-310.pyc", + "lib/python3.10/importlib/_abc.py", + "lib/python3.10/importlib/_adapters.py", + "lib/python3.10/importlib/_bootstrap.py", + "lib/python3.10/importlib/_bootstrap_external.py", + "lib/python3.10/importlib/_common.py", + "lib/python3.10/importlib/abc.py", + "lib/python3.10/importlib/machinery.py", + "lib/python3.10/importlib/metadata/__init__.py", + "lib/python3.10/importlib/metadata/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/importlib/metadata/__pycache__/_adapters.cpython-310.pyc", + "lib/python3.10/importlib/metadata/__pycache__/_collections.cpython-310.pyc", + "lib/python3.10/importlib/metadata/__pycache__/_functools.cpython-310.pyc", + "lib/python3.10/importlib/metadata/__pycache__/_itertools.cpython-310.pyc", + "lib/python3.10/importlib/metadata/__pycache__/_meta.cpython-310.pyc", + "lib/python3.10/importlib/metadata/__pycache__/_text.cpython-310.pyc", + "lib/python3.10/importlib/metadata/_adapters.py", + "lib/python3.10/importlib/metadata/_collections.py", + "lib/python3.10/importlib/metadata/_functools.py", + "lib/python3.10/importlib/metadata/_itertools.py", + "lib/python3.10/importlib/metadata/_meta.py", + "lib/python3.10/importlib/metadata/_text.py", + "lib/python3.10/importlib/readers.py", + "lib/python3.10/importlib/resources.py", + "lib/python3.10/importlib/util.py", + "lib/python3.10/inspect.py", + "lib/python3.10/io.py", + "lib/python3.10/ipaddress.py", + "lib/python3.10/json/__init__.py", + "lib/python3.10/json/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/json/__pycache__/decoder.cpython-310.pyc", + "lib/python3.10/json/__pycache__/encoder.cpython-310.pyc", + "lib/python3.10/json/__pycache__/scanner.cpython-310.pyc", + "lib/python3.10/json/__pycache__/tool.cpython-310.pyc", + "lib/python3.10/json/decoder.py", + "lib/python3.10/json/encoder.py", + "lib/python3.10/json/scanner.py", + "lib/python3.10/json/tool.py", + "lib/python3.10/keyword.py", + "lib/python3.10/lib-dynload/_asyncio.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_bisect.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_blake2.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_bz2.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_codecs_cn.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_codecs_hk.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_codecs_iso2022.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_codecs_jp.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_codecs_kr.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_codecs_tw.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_contextvars.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_crypt.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_csv.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_ctypes.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_ctypes_test.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_curses.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_curses_panel.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_datetime.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_dbm.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_decimal.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_elementtree.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_hashlib.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_heapq.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_json.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_lsprof.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_lzma.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_md5.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_multibytecodec.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_multiprocessing.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_opcode.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_pickle.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_posixshmem.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_posixsubprocess.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_queue.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_random.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_scproxy.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_sha1.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_sha256.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_sha3.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_sha512.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_socket.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_sqlite3.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_ssl.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_statistics.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_struct.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_testbuffer.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_testcapi.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_testimportmultiple.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_testinternalcapi.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_testmultiphase.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_tkinter.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_uuid.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_xxsubinterpreters.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_xxtestfuzz.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_zoneinfo.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/array.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/audioop.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/binascii.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/cmath.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/fcntl.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/grp.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/math.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/mmap.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/nis.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/pyexpat.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/readline.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/resource.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/select.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/syslog.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/termios.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/unicodedata.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/xxlimited.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/xxlimited_35.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/zlib.cpython-310-darwin.so", + "lib/python3.10/lib2to3/Grammar.txt", + "lib/python3.10/lib2to3/Grammar3.10.9.final.0.pickle", + "lib/python3.10/lib2to3/PatternGrammar.txt", + "lib/python3.10/lib2to3/PatternGrammar3.10.9.final.0.pickle", + "lib/python3.10/lib2to3/__init__.py", + "lib/python3.10/lib2to3/__main__.py", + "lib/python3.10/lib2to3/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/lib2to3/__pycache__/__main__.cpython-310.pyc", + "lib/python3.10/lib2to3/__pycache__/btm_matcher.cpython-310.pyc", + "lib/python3.10/lib2to3/__pycache__/btm_utils.cpython-310.pyc", + "lib/python3.10/lib2to3/__pycache__/fixer_base.cpython-310.pyc", + "lib/python3.10/lib2to3/__pycache__/fixer_util.cpython-310.pyc", + "lib/python3.10/lib2to3/__pycache__/main.cpython-310.pyc", + "lib/python3.10/lib2to3/__pycache__/patcomp.cpython-310.pyc", + "lib/python3.10/lib2to3/__pycache__/pygram.cpython-310.pyc", + "lib/python3.10/lib2to3/__pycache__/pytree.cpython-310.pyc", + "lib/python3.10/lib2to3/__pycache__/refactor.cpython-310.pyc", + "lib/python3.10/lib2to3/btm_matcher.py", + "lib/python3.10/lib2to3/btm_utils.py", + "lib/python3.10/lib2to3/fixer_base.py", + "lib/python3.10/lib2to3/fixer_util.py", + "lib/python3.10/lib2to3/fixes/__init__.py", + "lib/python3.10/lib2to3/fixes/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_apply.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_asserts.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_basestring.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_buffer.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_dict.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_except.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_exec.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_execfile.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_exitfunc.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_filter.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_funcattrs.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_future.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_getcwdu.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_has_key.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_idioms.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_import.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_imports.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_imports2.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_input.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_intern.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_isinstance.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_itertools.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_itertools_imports.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_long.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_map.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_metaclass.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_methodattrs.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_ne.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_next.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_nonzero.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_numliterals.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_operator.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_paren.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_print.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_raise.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_raw_input.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_reduce.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_reload.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_renames.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_repr.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_set_literal.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_standarderror.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_sys_exc.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_throw.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_tuple_params.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_types.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_unicode.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_urllib.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_ws_comma.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_xrange.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_xreadlines.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_zip.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/fix_apply.py", + "lib/python3.10/lib2to3/fixes/fix_asserts.py", + "lib/python3.10/lib2to3/fixes/fix_basestring.py", + "lib/python3.10/lib2to3/fixes/fix_buffer.py", + "lib/python3.10/lib2to3/fixes/fix_dict.py", + "lib/python3.10/lib2to3/fixes/fix_except.py", + "lib/python3.10/lib2to3/fixes/fix_exec.py", + "lib/python3.10/lib2to3/fixes/fix_execfile.py", + "lib/python3.10/lib2to3/fixes/fix_exitfunc.py", + "lib/python3.10/lib2to3/fixes/fix_filter.py", + "lib/python3.10/lib2to3/fixes/fix_funcattrs.py", + "lib/python3.10/lib2to3/fixes/fix_future.py", + "lib/python3.10/lib2to3/fixes/fix_getcwdu.py", + "lib/python3.10/lib2to3/fixes/fix_has_key.py", + "lib/python3.10/lib2to3/fixes/fix_idioms.py", + "lib/python3.10/lib2to3/fixes/fix_import.py", + "lib/python3.10/lib2to3/fixes/fix_imports.py", + "lib/python3.10/lib2to3/fixes/fix_imports2.py", + "lib/python3.10/lib2to3/fixes/fix_input.py", + "lib/python3.10/lib2to3/fixes/fix_intern.py", + "lib/python3.10/lib2to3/fixes/fix_isinstance.py", + "lib/python3.10/lib2to3/fixes/fix_itertools.py", + "lib/python3.10/lib2to3/fixes/fix_itertools_imports.py", + "lib/python3.10/lib2to3/fixes/fix_long.py", + "lib/python3.10/lib2to3/fixes/fix_map.py", + "lib/python3.10/lib2to3/fixes/fix_metaclass.py", + "lib/python3.10/lib2to3/fixes/fix_methodattrs.py", + "lib/python3.10/lib2to3/fixes/fix_ne.py", + "lib/python3.10/lib2to3/fixes/fix_next.py", + "lib/python3.10/lib2to3/fixes/fix_nonzero.py", + "lib/python3.10/lib2to3/fixes/fix_numliterals.py", + "lib/python3.10/lib2to3/fixes/fix_operator.py", + "lib/python3.10/lib2to3/fixes/fix_paren.py", + "lib/python3.10/lib2to3/fixes/fix_print.py", + "lib/python3.10/lib2to3/fixes/fix_raise.py", + "lib/python3.10/lib2to3/fixes/fix_raw_input.py", + "lib/python3.10/lib2to3/fixes/fix_reduce.py", + "lib/python3.10/lib2to3/fixes/fix_reload.py", + "lib/python3.10/lib2to3/fixes/fix_renames.py", + "lib/python3.10/lib2to3/fixes/fix_repr.py", + "lib/python3.10/lib2to3/fixes/fix_set_literal.py", + "lib/python3.10/lib2to3/fixes/fix_standarderror.py", + "lib/python3.10/lib2to3/fixes/fix_sys_exc.py", + "lib/python3.10/lib2to3/fixes/fix_throw.py", + "lib/python3.10/lib2to3/fixes/fix_tuple_params.py", + "lib/python3.10/lib2to3/fixes/fix_types.py", + "lib/python3.10/lib2to3/fixes/fix_unicode.py", + "lib/python3.10/lib2to3/fixes/fix_urllib.py", + "lib/python3.10/lib2to3/fixes/fix_ws_comma.py", + "lib/python3.10/lib2to3/fixes/fix_xrange.py", + "lib/python3.10/lib2to3/fixes/fix_xreadlines.py", + "lib/python3.10/lib2to3/fixes/fix_zip.py", + "lib/python3.10/lib2to3/main.py", + "lib/python3.10/lib2to3/patcomp.py", + "lib/python3.10/lib2to3/pgen2/__init__.py", + "lib/python3.10/lib2to3/pgen2/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/lib2to3/pgen2/__pycache__/conv.cpython-310.pyc", + "lib/python3.10/lib2to3/pgen2/__pycache__/driver.cpython-310.pyc", + "lib/python3.10/lib2to3/pgen2/__pycache__/grammar.cpython-310.pyc", + "lib/python3.10/lib2to3/pgen2/__pycache__/literals.cpython-310.pyc", + "lib/python3.10/lib2to3/pgen2/__pycache__/parse.cpython-310.pyc", + "lib/python3.10/lib2to3/pgen2/__pycache__/pgen.cpython-310.pyc", + "lib/python3.10/lib2to3/pgen2/__pycache__/token.cpython-310.pyc", + "lib/python3.10/lib2to3/pgen2/__pycache__/tokenize.cpython-310.pyc", + "lib/python3.10/lib2to3/pgen2/conv.py", + "lib/python3.10/lib2to3/pgen2/driver.py", + "lib/python3.10/lib2to3/pgen2/grammar.py", + "lib/python3.10/lib2to3/pgen2/literals.py", + "lib/python3.10/lib2to3/pgen2/parse.py", + "lib/python3.10/lib2to3/pgen2/pgen.py", + "lib/python3.10/lib2to3/pgen2/token.py", + "lib/python3.10/lib2to3/pgen2/tokenize.py", + "lib/python3.10/lib2to3/pygram.py", + "lib/python3.10/lib2to3/pytree.py", + "lib/python3.10/lib2to3/refactor.py", + "lib/python3.10/lib2to3/tests/__init__.py", + "lib/python3.10/lib2to3/tests/__main__.py", + "lib/python3.10/lib2to3/tests/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/lib2to3/tests/__pycache__/__main__.cpython-310.pyc", + "lib/python3.10/lib2to3/tests/__pycache__/pytree_idempotency.cpython-310.pyc", + "lib/python3.10/lib2to3/tests/__pycache__/support.cpython-310.pyc", + "lib/python3.10/lib2to3/tests/__pycache__/test_all_fixers.cpython-310.pyc", + "lib/python3.10/lib2to3/tests/__pycache__/test_fixers.cpython-310.pyc", + "lib/python3.10/lib2to3/tests/__pycache__/test_main.cpython-310.pyc", + "lib/python3.10/lib2to3/tests/__pycache__/test_parser.cpython-310.pyc", + "lib/python3.10/lib2to3/tests/__pycache__/test_pytree.cpython-310.pyc", + "lib/python3.10/lib2to3/tests/__pycache__/test_refactor.cpython-310.pyc", + "lib/python3.10/lib2to3/tests/__pycache__/test_util.cpython-310.pyc", + "lib/python3.10/lib2to3/tests/data/README", + "lib/python3.10/lib2to3/tests/data/__pycache__/infinite_recursion.cpython-310.pyc", + "lib/python3.10/lib2to3/tests/data/__pycache__/py3_test_grammar.cpython-310.pyc", + "lib/python3.10/lib2to3/tests/data/bom.py", + "lib/python3.10/lib2to3/tests/data/crlf.py", + "lib/python3.10/lib2to3/tests/data/different_encoding.py", + "lib/python3.10/lib2to3/tests/data/false_encoding.py", + "lib/python3.10/lib2to3/tests/data/fixers/__pycache__/bad_order.cpython-310.pyc", + "lib/python3.10/lib2to3/tests/data/fixers/__pycache__/no_fixer_cls.cpython-310.pyc", + "lib/python3.10/lib2to3/tests/data/fixers/__pycache__/parrot_example.cpython-310.pyc", + "lib/python3.10/lib2to3/tests/data/fixers/bad_order.py", + "lib/python3.10/lib2to3/tests/data/fixers/myfixes/__init__.py", + "lib/python3.10/lib2to3/tests/data/fixers/myfixes/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/lib2to3/tests/data/fixers/myfixes/__pycache__/fix_explicit.cpython-310.pyc", + "lib/python3.10/lib2to3/tests/data/fixers/myfixes/__pycache__/fix_first.cpython-310.pyc", + "lib/python3.10/lib2to3/tests/data/fixers/myfixes/__pycache__/fix_last.cpython-310.pyc", + "lib/python3.10/lib2to3/tests/data/fixers/myfixes/__pycache__/fix_parrot.cpython-310.pyc", + "lib/python3.10/lib2to3/tests/data/fixers/myfixes/__pycache__/fix_preorder.cpython-310.pyc", + "lib/python3.10/lib2to3/tests/data/fixers/myfixes/fix_explicit.py", + "lib/python3.10/lib2to3/tests/data/fixers/myfixes/fix_first.py", + "lib/python3.10/lib2to3/tests/data/fixers/myfixes/fix_last.py", + "lib/python3.10/lib2to3/tests/data/fixers/myfixes/fix_parrot.py", + "lib/python3.10/lib2to3/tests/data/fixers/myfixes/fix_preorder.py", + "lib/python3.10/lib2to3/tests/data/fixers/no_fixer_cls.py", + "lib/python3.10/lib2to3/tests/data/fixers/parrot_example.py", + "lib/python3.10/lib2to3/tests/data/infinite_recursion.py", + "lib/python3.10/lib2to3/tests/data/py2_test_grammar.py", + "lib/python3.10/lib2to3/tests/data/py3_test_grammar.py", + "lib/python3.10/lib2to3/tests/pytree_idempotency.py", + "lib/python3.10/lib2to3/tests/support.py", + "lib/python3.10/lib2to3/tests/test_all_fixers.py", + "lib/python3.10/lib2to3/tests/test_fixers.py", + "lib/python3.10/lib2to3/tests/test_main.py", + "lib/python3.10/lib2to3/tests/test_parser.py", + "lib/python3.10/lib2to3/tests/test_pytree.py", + "lib/python3.10/lib2to3/tests/test_refactor.py", + "lib/python3.10/lib2to3/tests/test_util.py", + "lib/python3.10/linecache.py", + "lib/python3.10/locale.py", + "lib/python3.10/logging/__init__.py", + "lib/python3.10/logging/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/logging/__pycache__/config.cpython-310.pyc", + "lib/python3.10/logging/__pycache__/handlers.cpython-310.pyc", + "lib/python3.10/logging/config.py", + "lib/python3.10/logging/handlers.py", + "lib/python3.10/lzma.py", + "lib/python3.10/mailbox.py", + "lib/python3.10/mailcap.py", + "lib/python3.10/mimetypes.py", + "lib/python3.10/modulefinder.py", + "lib/python3.10/multiprocessing/__init__.py", + "lib/python3.10/multiprocessing/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/multiprocessing/__pycache__/connection.cpython-310.pyc", + "lib/python3.10/multiprocessing/__pycache__/context.cpython-310.pyc", + "lib/python3.10/multiprocessing/__pycache__/forkserver.cpython-310.pyc", + "lib/python3.10/multiprocessing/__pycache__/heap.cpython-310.pyc", + "lib/python3.10/multiprocessing/__pycache__/managers.cpython-310.pyc", + "lib/python3.10/multiprocessing/__pycache__/pool.cpython-310.pyc", + "lib/python3.10/multiprocessing/__pycache__/popen_fork.cpython-310.pyc", + "lib/python3.10/multiprocessing/__pycache__/popen_forkserver.cpython-310.pyc", + "lib/python3.10/multiprocessing/__pycache__/popen_spawn_posix.cpython-310.pyc", + "lib/python3.10/multiprocessing/__pycache__/popen_spawn_win32.cpython-310.pyc", + "lib/python3.10/multiprocessing/__pycache__/process.cpython-310.pyc", + "lib/python3.10/multiprocessing/__pycache__/queues.cpython-310.pyc", + "lib/python3.10/multiprocessing/__pycache__/reduction.cpython-310.pyc", + "lib/python3.10/multiprocessing/__pycache__/resource_sharer.cpython-310.pyc", + "lib/python3.10/multiprocessing/__pycache__/resource_tracker.cpython-310.pyc", + "lib/python3.10/multiprocessing/__pycache__/shared_memory.cpython-310.pyc", + "lib/python3.10/multiprocessing/__pycache__/sharedctypes.cpython-310.pyc", + "lib/python3.10/multiprocessing/__pycache__/spawn.cpython-310.pyc", + "lib/python3.10/multiprocessing/__pycache__/synchronize.cpython-310.pyc", + "lib/python3.10/multiprocessing/__pycache__/util.cpython-310.pyc", + "lib/python3.10/multiprocessing/connection.py", + "lib/python3.10/multiprocessing/context.py", + "lib/python3.10/multiprocessing/dummy/__init__.py", + "lib/python3.10/multiprocessing/dummy/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/multiprocessing/dummy/__pycache__/connection.cpython-310.pyc", + "lib/python3.10/multiprocessing/dummy/connection.py", + "lib/python3.10/multiprocessing/forkserver.py", + "lib/python3.10/multiprocessing/heap.py", + "lib/python3.10/multiprocessing/managers.py", + "lib/python3.10/multiprocessing/pool.py", + "lib/python3.10/multiprocessing/popen_fork.py", + "lib/python3.10/multiprocessing/popen_forkserver.py", + "lib/python3.10/multiprocessing/popen_spawn_posix.py", + "lib/python3.10/multiprocessing/popen_spawn_win32.py", + "lib/python3.10/multiprocessing/process.py", + "lib/python3.10/multiprocessing/queues.py", + "lib/python3.10/multiprocessing/reduction.py", + "lib/python3.10/multiprocessing/resource_sharer.py", + "lib/python3.10/multiprocessing/resource_tracker.py", + "lib/python3.10/multiprocessing/shared_memory.py", + "lib/python3.10/multiprocessing/sharedctypes.py", + "lib/python3.10/multiprocessing/spawn.py", + "lib/python3.10/multiprocessing/synchronize.py", + "lib/python3.10/multiprocessing/util.py", + "lib/python3.10/netrc.py", + "lib/python3.10/nntplib.py", + "lib/python3.10/ntpath.py", + "lib/python3.10/nturl2path.py", + "lib/python3.10/numbers.py", + "lib/python3.10/opcode.py", + "lib/python3.10/operator.py", + "lib/python3.10/optparse.py", + "lib/python3.10/os.py", + "lib/python3.10/pathlib.py", + "lib/python3.10/pdb.py", + "lib/python3.10/pickle.py", + "lib/python3.10/pickletools.py", + "lib/python3.10/pipes.py", + "lib/python3.10/pkgutil.py", + "lib/python3.10/platform.py", + "lib/python3.10/plistlib.py", + "lib/python3.10/poplib.py", + "lib/python3.10/posixpath.py", + "lib/python3.10/pprint.py", + "lib/python3.10/profile.py", + "lib/python3.10/pstats.py", + "lib/python3.10/pty.py", + "lib/python3.10/py_compile.py", + "lib/python3.10/pyclbr.py", + "lib/python3.10/pydoc.py", + "lib/python3.10/pydoc_data/__init__.py", + "lib/python3.10/pydoc_data/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/pydoc_data/__pycache__/topics.cpython-310.pyc", + "lib/python3.10/pydoc_data/_pydoc.css", + "lib/python3.10/pydoc_data/topics.py", + "lib/python3.10/queue.py", + "lib/python3.10/quopri.py", + "lib/python3.10/random.py", + "lib/python3.10/re.py", + "lib/python3.10/reprlib.py", + "lib/python3.10/rlcompleter.py", + "lib/python3.10/runpy.py", + "lib/python3.10/sched.py", + "lib/python3.10/secrets.py", + "lib/python3.10/selectors.py", + "lib/python3.10/shelve.py", + "lib/python3.10/shlex.py", + "lib/python3.10/shutil.py", + "lib/python3.10/signal.py", + "lib/python3.10/site-packages/README.txt", + "lib/python3.10/site.py", + "lib/python3.10/smtpd.py", + "lib/python3.10/smtplib.py", + "lib/python3.10/sndhdr.py", + "lib/python3.10/socket.py", + "lib/python3.10/socketserver.py", + "lib/python3.10/sqlite3/__init__.py", + "lib/python3.10/sqlite3/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/sqlite3/__pycache__/dbapi2.cpython-310.pyc", + "lib/python3.10/sqlite3/__pycache__/dump.cpython-310.pyc", + "lib/python3.10/sqlite3/dbapi2.py", + "lib/python3.10/sqlite3/dump.py", + "lib/python3.10/sre_compile.py", + "lib/python3.10/sre_constants.py", + "lib/python3.10/sre_parse.py", + "lib/python3.10/ssl.py", + "lib/python3.10/stat.py", + "lib/python3.10/statistics.py", + "lib/python3.10/string.py", + "lib/python3.10/stringprep.py", + "lib/python3.10/struct.py", + "lib/python3.10/subprocess.py", + "lib/python3.10/sunau.py", + "lib/python3.10/symtable.py", + "lib/python3.10/sysconfig.py", + "lib/python3.10/tabnanny.py", + "lib/python3.10/tarfile.py", + "lib/python3.10/telnetlib.py", + "lib/python3.10/tempfile.py", + "lib/python3.10/test/__init__.py", + "lib/python3.10/test/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/test/__pycache__/test_script_helper.cpython-310.pyc", + "lib/python3.10/test/__pycache__/test_support.cpython-310.pyc", + "lib/python3.10/test/support/__init__.py", + "lib/python3.10/test/support/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/test/support/__pycache__/bytecode_helper.cpython-310.pyc", + "lib/python3.10/test/support/__pycache__/hashlib_helper.cpython-310.pyc", + "lib/python3.10/test/support/__pycache__/import_helper.cpython-310.pyc", + "lib/python3.10/test/support/__pycache__/interpreters.cpython-310.pyc", + "lib/python3.10/test/support/__pycache__/logging_helper.cpython-310.pyc", + "lib/python3.10/test/support/__pycache__/os_helper.cpython-310.pyc", + "lib/python3.10/test/support/__pycache__/script_helper.cpython-310.pyc", + "lib/python3.10/test/support/__pycache__/socket_helper.cpython-310.pyc", + "lib/python3.10/test/support/__pycache__/testresult.cpython-310.pyc", + "lib/python3.10/test/support/__pycache__/threading_helper.cpython-310.pyc", + "lib/python3.10/test/support/__pycache__/warnings_helper.cpython-310.pyc", + "lib/python3.10/test/support/bytecode_helper.py", + "lib/python3.10/test/support/hashlib_helper.py", + "lib/python3.10/test/support/import_helper.py", + "lib/python3.10/test/support/interpreters.py", + "lib/python3.10/test/support/logging_helper.py", + "lib/python3.10/test/support/os_helper.py", + "lib/python3.10/test/support/script_helper.py", + "lib/python3.10/test/support/socket_helper.py", + "lib/python3.10/test/support/testresult.py", + "lib/python3.10/test/support/threading_helper.py", + "lib/python3.10/test/support/warnings_helper.py", + "lib/python3.10/test/test_script_helper.py", + "lib/python3.10/test/test_support.py", + "lib/python3.10/textwrap.py", + "lib/python3.10/this.py", + "lib/python3.10/threading.py", + "lib/python3.10/timeit.py", + "lib/python3.10/tkinter/__init__.py", + "lib/python3.10/tkinter/__main__.py", + "lib/python3.10/tkinter/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/tkinter/__pycache__/__main__.cpython-310.pyc", + "lib/python3.10/tkinter/__pycache__/colorchooser.cpython-310.pyc", + "lib/python3.10/tkinter/__pycache__/commondialog.cpython-310.pyc", + "lib/python3.10/tkinter/__pycache__/constants.cpython-310.pyc", + "lib/python3.10/tkinter/__pycache__/dialog.cpython-310.pyc", + "lib/python3.10/tkinter/__pycache__/dnd.cpython-310.pyc", + "lib/python3.10/tkinter/__pycache__/filedialog.cpython-310.pyc", + "lib/python3.10/tkinter/__pycache__/font.cpython-310.pyc", + "lib/python3.10/tkinter/__pycache__/messagebox.cpython-310.pyc", + "lib/python3.10/tkinter/__pycache__/scrolledtext.cpython-310.pyc", + "lib/python3.10/tkinter/__pycache__/simpledialog.cpython-310.pyc", + "lib/python3.10/tkinter/__pycache__/tix.cpython-310.pyc", + "lib/python3.10/tkinter/__pycache__/ttk.cpython-310.pyc", + "lib/python3.10/tkinter/colorchooser.py", + "lib/python3.10/tkinter/commondialog.py", + "lib/python3.10/tkinter/constants.py", + "lib/python3.10/tkinter/dialog.py", + "lib/python3.10/tkinter/dnd.py", + "lib/python3.10/tkinter/filedialog.py", + "lib/python3.10/tkinter/font.py", + "lib/python3.10/tkinter/messagebox.py", + "lib/python3.10/tkinter/scrolledtext.py", + "lib/python3.10/tkinter/simpledialog.py", + "lib/python3.10/tkinter/tix.py", + "lib/python3.10/tkinter/ttk.py", + "lib/python3.10/token.py", + "lib/python3.10/tokenize.py", + "lib/python3.10/trace.py", + "lib/python3.10/traceback.py", + "lib/python3.10/tracemalloc.py", + "lib/python3.10/tty.py", + "lib/python3.10/turtle.py", + "lib/python3.10/turtledemo/__init__.py", + "lib/python3.10/turtledemo/__main__.py", + "lib/python3.10/turtledemo/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/turtledemo/__pycache__/__main__.cpython-310.pyc", + "lib/python3.10/turtledemo/__pycache__/bytedesign.cpython-310.pyc", + "lib/python3.10/turtledemo/__pycache__/chaos.cpython-310.pyc", + "lib/python3.10/turtledemo/__pycache__/clock.cpython-310.pyc", + "lib/python3.10/turtledemo/__pycache__/colormixer.cpython-310.pyc", + "lib/python3.10/turtledemo/__pycache__/forest.cpython-310.pyc", + "lib/python3.10/turtledemo/__pycache__/fractalcurves.cpython-310.pyc", + "lib/python3.10/turtledemo/__pycache__/lindenmayer.cpython-310.pyc", + "lib/python3.10/turtledemo/__pycache__/minimal_hanoi.cpython-310.pyc", + "lib/python3.10/turtledemo/__pycache__/nim.cpython-310.pyc", + "lib/python3.10/turtledemo/__pycache__/paint.cpython-310.pyc", + "lib/python3.10/turtledemo/__pycache__/peace.cpython-310.pyc", + "lib/python3.10/turtledemo/__pycache__/penrose.cpython-310.pyc", + "lib/python3.10/turtledemo/__pycache__/planet_and_moon.cpython-310.pyc", + "lib/python3.10/turtledemo/__pycache__/rosette.cpython-310.pyc", + "lib/python3.10/turtledemo/__pycache__/round_dance.cpython-310.pyc", + "lib/python3.10/turtledemo/__pycache__/sorting_animate.cpython-310.pyc", + "lib/python3.10/turtledemo/__pycache__/tree.cpython-310.pyc", + "lib/python3.10/turtledemo/__pycache__/two_canvases.cpython-310.pyc", + "lib/python3.10/turtledemo/__pycache__/yinyang.cpython-310.pyc", + "lib/python3.10/turtledemo/bytedesign.py", + "lib/python3.10/turtledemo/chaos.py", + "lib/python3.10/turtledemo/clock.py", + "lib/python3.10/turtledemo/colormixer.py", + "lib/python3.10/turtledemo/forest.py", + "lib/python3.10/turtledemo/fractalcurves.py", + "lib/python3.10/turtledemo/lindenmayer.py", + "lib/python3.10/turtledemo/minimal_hanoi.py", + "lib/python3.10/turtledemo/nim.py", + "lib/python3.10/turtledemo/paint.py", + "lib/python3.10/turtledemo/peace.py", + "lib/python3.10/turtledemo/penrose.py", + "lib/python3.10/turtledemo/planet_and_moon.py", + "lib/python3.10/turtledemo/rosette.py", + "lib/python3.10/turtledemo/round_dance.py", + "lib/python3.10/turtledemo/sorting_animate.py", + "lib/python3.10/turtledemo/tree.py", + "lib/python3.10/turtledemo/turtle.cfg", + "lib/python3.10/turtledemo/two_canvases.py", + "lib/python3.10/turtledemo/yinyang.py", + "lib/python3.10/types.py", + "lib/python3.10/typing.py", + "lib/python3.10/unittest/__init__.py", + "lib/python3.10/unittest/__main__.py", + "lib/python3.10/unittest/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/unittest/__pycache__/__main__.cpython-310.pyc", + "lib/python3.10/unittest/__pycache__/_log.cpython-310.pyc", + "lib/python3.10/unittest/__pycache__/async_case.cpython-310.pyc", + "lib/python3.10/unittest/__pycache__/case.cpython-310.pyc", + "lib/python3.10/unittest/__pycache__/loader.cpython-310.pyc", + "lib/python3.10/unittest/__pycache__/main.cpython-310.pyc", + "lib/python3.10/unittest/__pycache__/mock.cpython-310.pyc", + "lib/python3.10/unittest/__pycache__/result.cpython-310.pyc", + "lib/python3.10/unittest/__pycache__/runner.cpython-310.pyc", + "lib/python3.10/unittest/__pycache__/signals.cpython-310.pyc", + "lib/python3.10/unittest/__pycache__/suite.cpython-310.pyc", + "lib/python3.10/unittest/__pycache__/util.cpython-310.pyc", + "lib/python3.10/unittest/_log.py", + "lib/python3.10/unittest/async_case.py", + "lib/python3.10/unittest/case.py", + "lib/python3.10/unittest/loader.py", + "lib/python3.10/unittest/main.py", + "lib/python3.10/unittest/mock.py", + "lib/python3.10/unittest/result.py", + "lib/python3.10/unittest/runner.py", + "lib/python3.10/unittest/signals.py", + "lib/python3.10/unittest/suite.py", + "lib/python3.10/unittest/util.py", + "lib/python3.10/urllib/__init__.py", + "lib/python3.10/urllib/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/urllib/__pycache__/error.cpython-310.pyc", + "lib/python3.10/urllib/__pycache__/parse.cpython-310.pyc", + "lib/python3.10/urllib/__pycache__/request.cpython-310.pyc", + "lib/python3.10/urllib/__pycache__/response.cpython-310.pyc", + "lib/python3.10/urllib/__pycache__/robotparser.cpython-310.pyc", + "lib/python3.10/urllib/error.py", + "lib/python3.10/urllib/parse.py", + "lib/python3.10/urllib/request.py", + "lib/python3.10/urllib/response.py", + "lib/python3.10/urllib/robotparser.py", + "lib/python3.10/uu.py", + "lib/python3.10/uuid.py", + "lib/python3.10/venv/__init__.py", + "lib/python3.10/venv/__main__.py", + "lib/python3.10/venv/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/venv/__pycache__/__main__.cpython-310.pyc", + "lib/python3.10/venv/scripts/common/Activate.ps1", + "lib/python3.10/venv/scripts/common/activate", + "lib/python3.10/venv/scripts/posix/activate.csh", + "lib/python3.10/venv/scripts/posix/activate.fish", + "lib/python3.10/warnings.py", + "lib/python3.10/wave.py", + "lib/python3.10/weakref.py", + "lib/python3.10/webbrowser.py", + "lib/python3.10/wsgiref/__init__.py", + "lib/python3.10/wsgiref/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/wsgiref/__pycache__/handlers.cpython-310.pyc", + "lib/python3.10/wsgiref/__pycache__/headers.cpython-310.pyc", + "lib/python3.10/wsgiref/__pycache__/simple_server.cpython-310.pyc", + "lib/python3.10/wsgiref/__pycache__/util.cpython-310.pyc", + "lib/python3.10/wsgiref/__pycache__/validate.cpython-310.pyc", + "lib/python3.10/wsgiref/handlers.py", + "lib/python3.10/wsgiref/headers.py", + "lib/python3.10/wsgiref/simple_server.py", + "lib/python3.10/wsgiref/util.py", + "lib/python3.10/wsgiref/validate.py", + "lib/python3.10/xdrlib.py", + "lib/python3.10/xml/__init__.py", + "lib/python3.10/xml/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/xml/dom/NodeFilter.py", + "lib/python3.10/xml/dom/__init__.py", + "lib/python3.10/xml/dom/__pycache__/NodeFilter.cpython-310.pyc", + "lib/python3.10/xml/dom/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/xml/dom/__pycache__/domreg.cpython-310.pyc", + "lib/python3.10/xml/dom/__pycache__/expatbuilder.cpython-310.pyc", + "lib/python3.10/xml/dom/__pycache__/minicompat.cpython-310.pyc", + "lib/python3.10/xml/dom/__pycache__/minidom.cpython-310.pyc", + "lib/python3.10/xml/dom/__pycache__/pulldom.cpython-310.pyc", + "lib/python3.10/xml/dom/__pycache__/xmlbuilder.cpython-310.pyc", + "lib/python3.10/xml/dom/domreg.py", + "lib/python3.10/xml/dom/expatbuilder.py", + "lib/python3.10/xml/dom/minicompat.py", + "lib/python3.10/xml/dom/minidom.py", + "lib/python3.10/xml/dom/pulldom.py", + "lib/python3.10/xml/dom/xmlbuilder.py", + "lib/python3.10/xml/etree/ElementInclude.py", + "lib/python3.10/xml/etree/ElementPath.py", + "lib/python3.10/xml/etree/ElementTree.py", + "lib/python3.10/xml/etree/__init__.py", + "lib/python3.10/xml/etree/__pycache__/ElementInclude.cpython-310.pyc", + "lib/python3.10/xml/etree/__pycache__/ElementPath.cpython-310.pyc", + "lib/python3.10/xml/etree/__pycache__/ElementTree.cpython-310.pyc", + "lib/python3.10/xml/etree/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/xml/etree/__pycache__/cElementTree.cpython-310.pyc", + "lib/python3.10/xml/etree/cElementTree.py", + "lib/python3.10/xml/parsers/__init__.py", + "lib/python3.10/xml/parsers/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/xml/parsers/__pycache__/expat.cpython-310.pyc", + "lib/python3.10/xml/parsers/expat.py", + "lib/python3.10/xml/sax/__init__.py", + "lib/python3.10/xml/sax/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/xml/sax/__pycache__/_exceptions.cpython-310.pyc", + "lib/python3.10/xml/sax/__pycache__/expatreader.cpython-310.pyc", + "lib/python3.10/xml/sax/__pycache__/handler.cpython-310.pyc", + "lib/python3.10/xml/sax/__pycache__/saxutils.cpython-310.pyc", + "lib/python3.10/xml/sax/__pycache__/xmlreader.cpython-310.pyc", + "lib/python3.10/xml/sax/_exceptions.py", + "lib/python3.10/xml/sax/expatreader.py", + "lib/python3.10/xml/sax/handler.py", + "lib/python3.10/xml/sax/saxutils.py", + "lib/python3.10/xml/sax/xmlreader.py", + "lib/python3.10/xmlrpc/__init__.py", + "lib/python3.10/xmlrpc/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/xmlrpc/__pycache__/client.cpython-310.pyc", + "lib/python3.10/xmlrpc/__pycache__/server.cpython-310.pyc", + "lib/python3.10/xmlrpc/client.py", + "lib/python3.10/xmlrpc/server.py", + "lib/python3.10/zipapp.py", + "lib/python3.10/zipfile.py", + "lib/python3.10/zipimport.py", + "lib/python3.10/zoneinfo/__init__.py", + "lib/python3.10/zoneinfo/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/zoneinfo/__pycache__/_common.cpython-310.pyc", + "lib/python3.10/zoneinfo/__pycache__/_tzpath.cpython-310.pyc", + "lib/python3.10/zoneinfo/__pycache__/_zoneinfo.cpython-310.pyc", + "lib/python3.10/zoneinfo/_common.py", + "lib/python3.10/zoneinfo/_tzpath.py", + "lib/python3.10/zoneinfo/_zoneinfo.py", + "share/man/man1/python3.1", + "share/man/man1/python3.10.1" + ], + "fn": "python-3.10.9-hc0d8a6c_1.conda", + "legacy_bz2_md5": "79db6ab46b228ae5779c077a7f4314b9", + "legacy_bz2_size": 13813760, + "license": "PSF-2.0", + "license_family": "PSF", + "link": { + "source": "/Users/donjayamanne/.pyenv/versions/anaconda3-2023.03/pkgs/python-3.10.9-hc0d8a6c_1", + "type": 1 + }, + "md5": "b49223285e681289fe846def063b8c61", + "name": "python", + "package_tarball_full_path": "/Users/donjayamanne/.pyenv/versions/anaconda3-2023.03/pkgs/python-3.10.9-hc0d8a6c_1.conda", + "paths_data": { + "paths": [ + { + "_path": "bin/2to3-3.10", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_7a849mskhu/croot/python-split_1677694510376/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_p", + "sha256": "49f8de215d5769259789d0f08d8de049361c9f25670628f3e5efbd90007a3187", + "sha256_in_prefix": "dd0f50efced047ea4e30d973142d09499d4feb8554842d01442f9f2108d5a741", + "size_in_bytes": 347 + }, + { + "_path": "bin/idle3.10", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_7a849mskhu/croot/python-split_1677694510376/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_p", + "sha256": "65b96fcd8aa20754413b467b9a885fb9e90541c57b6fbdf6ecbdb4a3b8c6d2b8", + "sha256_in_prefix": "435786c49358497a8794c08aded2142087b68d97bf8fc2e7a30e0d1f7cff1f37", + "size_in_bytes": 345 + }, + { + "_path": "bin/pydoc3.10", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_7a849mskhu/croot/python-split_1677694510376/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_p", + "sha256": "5e1857422b891dc0699ca50ca21b719119d2c47092d669a262da1a3cdafef055", + "sha256_in_prefix": "66e27555a064b90acc248e3292372a80e19c7adce86da67fc3f5555c2b4eb8b4", + "size_in_bytes": 330 + }, + { + "_path": "bin/python3.10", + "file_mode": "binary", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_7a849mskhu/croot/python-split_1677694510376/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_p", + "sha256": "57759740171bb912fe1eabd295867fad467018f8fc17cb677b9de841a4d3ddea", + "sha256_in_prefix": "e0c8b88c55eae3c3d331055e6f22e23b51afea4b77d47f748abf897fc80827d8", + "size_in_bytes": 3880624 + }, + { + "_path": "bin/python3.10-config", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_7a849mskhu/croot/python-split_1677694510376/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_p", + "sha256": "73722fe35f6884c20967418b6c0c827670e0323a40e4b0686bd6101c73fd4bfd", + "sha256_in_prefix": "f2ab0a490482c0a1dd2e1bb373c3363233e96953118950fcbe8a6170c3a9a941", + "size_in_bytes": 2289 + }, + { + "_path": "lib/libpython3.10.dylib", + "file_mode": "binary", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_7a849mskhu/croot/python-split_1677694510376/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_p", + "sha256": "9b5064ad68a06a3b6c8a827c359f6cde8a18303d2506d589f5f634b9eb8c3a29", + "sha256_in_prefix": "0f2cc0004c39200b1fee5d7247a40a658522d1b3edd49d84b87e1890a34e1bb1", + "size_in_bytes": 3880992 + }, + { + "_path": "lib/pkgconfig/python-3.10-embed.pc", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_7a849mskhu/croot/python-split_1677694510376/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_p", + "sha256": "267ee6603068cc40b1e3cc70e31b12acae4ea280f32b1ee1d76eb35eb46a97ea", + "sha256_in_prefix": "e72ec48cd066261568511e04e4b8a2c77bb400906871ae000308c26c754161da", + "size_in_bytes": 559 + }, + { + "_path": "lib/pkgconfig/python-3.10.pc", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_7a849mskhu/croot/python-split_1677694510376/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_p", + "sha256": "3437ae5485a090fdee7120bb1913b4616fa3e64a4e762c8d0277bf3faa36c69c", + "sha256_in_prefix": "dd3256512d0f7edc4b316556350fda490e536c229e538bec5650a73470dace73", + "size_in_bytes": 532 + }, + { + "_path": "lib/python3.10/_sysconfigdata__darwin_darwin.py", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_7a849mskhu/croot/python-split_1677694510376/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_p", + "sha256": "04bc97e2a3ff9d6d1b8aa6fe456426b37e2530cace3a9aefd88bb138c20200a1", + "sha256_in_prefix": "3090497323d66dbbc11f637972fa5514d00904beb92846349fb4d2361e497254", + "size_in_bytes": 57548 + }, + { + "_path": "lib/python3.10/_sysconfigdata__darwin_darwin.py.orig", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_7a849mskhu/croot/python-split_1677694510376/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_p", + "sha256": "aa64b16d8e75e057bd4e607f588ee5bf38d3f83022de6c7c5f1375860cdb029c", + "sha256_in_prefix": "ce87da2ca67f461f26ed561573fe5a10ce3bb86594225981b15af1dfd0223115", + "size_in_bytes": 66662 + }, + { + "_path": "lib/python3.10/_sysconfigdata_arm64_apple_darwin20_0_0.py", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_7a849mskhu/croot/python-split_1677694510376/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_p", + "sha256": "bf7fd0677c2d7c908d5b9c8f4da8ea9361ca90f02bafbddb3006957276a68258", + "sha256_in_prefix": "bca2eff7df3e2da0dc25776767cd1748f268b2250b21dfaba88f82d1356c852a", + "size_in_bytes": 59223 + }, + { + "_path": "lib/python3.10/config-3.10-darwin/Makefile", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_7a849mskhu/croot/python-split_1677694510376/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_p", + "sha256": "176f81b1323a41f74e47631bc320d300711102b48cc5ac588cab68cd3d6ca375", + "sha256_in_prefix": "dfec273360eacf5e5dcf06f7da1f9e59cd44fbb6f756720dc18bdc55750835de", + "size_in_bytes": 91516 + }, + { + "_path": "lib/python3.10/config-3.10-darwin/python-config.py", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_7a849mskhu/croot/python-split_1677694510376/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_p", + "sha256": "73722fe35f6884c20967418b6c0c827670e0323a40e4b0686bd6101c73fd4bfd", + "sha256_in_prefix": "f2ab0a490482c0a1dd2e1bb373c3363233e96953118950fcbe8a6170c3a9a941", + "size_in_bytes": 2289 + } + ], + "paths_version": 1 + }, + "requested_spec": "defaults/osx-arm64::python==3.10.9=hc0d8a6c_1[md5=b49223285e681289fe846def063b8c61]", + "sha256": "717f4901666a82f0d1fb71be02870d845a72eaec083218e71200000481e5577b", + "size": 13556748, + "subdir": "osx-arm64", + "timestamp": 1677695073705, + "track_features": "", + "url": "https://repo.anaconda.com/pkgs/main/osx-arm64/python-3.10.9-hc0d8a6c_1.conda", + "version": "3.10.9" +} \ No newline at end of file diff --git a/crates/pet-conda/tests/unix/anaconda3-2023.03/conda-meta/python-dateutil-2.8.2-pyhd3eb1b0_0.json b/crates/pet-conda/tests/unix/anaconda3-2023.03/conda-meta/python-dateutil-2.8.2-pyhd3eb1b0_0.json new file mode 100644 index 00000000..868b827d --- /dev/null +++ b/crates/pet-conda/tests/unix/anaconda3-2023.03/conda-meta/python-dateutil-2.8.2-pyhd3eb1b0_0.json @@ -0,0 +1,159 @@ +{ + "build": "pyhd3eb1b0_0", + "build_number": 0, + "channel": "https://repo.anaconda.com/pkgs/main/noarch", + "constrains": [], + "depends": [ + "python", + "six >=1.5" + ], + "extracted_package_dir": "/Users/donjayamanne/.pyenv/versions/anaconda3-2023.03/pkgs/python-dateutil-2.8.2-pyhd3eb1b0_0", + "features": "", + "files": [ + "lib/python3.10/site-packages/dateutil/__init__.py", + "lib/python3.10/site-packages/dateutil/_common.py", + "lib/python3.10/site-packages/dateutil/_version.py", + "lib/python3.10/site-packages/dateutil/easter.py", + "lib/python3.10/site-packages/dateutil/parser/__init__.py", + "lib/python3.10/site-packages/dateutil/parser/_parser.py", + "lib/python3.10/site-packages/dateutil/parser/isoparser.py", + "lib/python3.10/site-packages/dateutil/relativedelta.py", + "lib/python3.10/site-packages/dateutil/rrule.py", + "lib/python3.10/site-packages/dateutil/tz/__init__.py", + "lib/python3.10/site-packages/dateutil/tz/_common.py", + "lib/python3.10/site-packages/dateutil/tz/_factories.py", + "lib/python3.10/site-packages/dateutil/tz/tz.py", + "lib/python3.10/site-packages/dateutil/tz/win.py", + "lib/python3.10/site-packages/dateutil/tzwin.py", + "lib/python3.10/site-packages/dateutil/utils.py", + "lib/python3.10/site-packages/dateutil/zoneinfo/__init__.py", + "lib/python3.10/site-packages/dateutil/zoneinfo/dateutil-zoneinfo.tar.gz", + "lib/python3.10/site-packages/dateutil/zoneinfo/rebuild.py", + "lib/python3.10/site-packages/python_dateutil-2.8.2.dist-info/INSTALLER", + "lib/python3.10/site-packages/python_dateutil-2.8.2.dist-info/LICENSE", + "lib/python3.10/site-packages/python_dateutil-2.8.2.dist-info/METADATA", + "lib/python3.10/site-packages/python_dateutil-2.8.2.dist-info/RECORD", + "lib/python3.10/site-packages/python_dateutil-2.8.2.dist-info/REQUESTED", + "lib/python3.10/site-packages/python_dateutil-2.8.2.dist-info/WHEEL", + "lib/python3.10/site-packages/python_dateutil-2.8.2.dist-info/direct_url.json", + "lib/python3.10/site-packages/python_dateutil-2.8.2.dist-info/top_level.txt", + "lib/python3.10/site-packages/python_dateutil-2.8.2.dist-info/zip-safe", + "lib/python3.10/site-packages/dateutil/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/dateutil/__pycache__/_common.cpython-310.pyc", + "lib/python3.10/site-packages/dateutil/__pycache__/_version.cpython-310.pyc", + "lib/python3.10/site-packages/dateutil/__pycache__/easter.cpython-310.pyc", + "lib/python3.10/site-packages/dateutil/parser/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/dateutil/parser/__pycache__/_parser.cpython-310.pyc", + "lib/python3.10/site-packages/dateutil/parser/__pycache__/isoparser.cpython-310.pyc", + "lib/python3.10/site-packages/dateutil/__pycache__/relativedelta.cpython-310.pyc", + "lib/python3.10/site-packages/dateutil/__pycache__/rrule.cpython-310.pyc", + "lib/python3.10/site-packages/dateutil/tz/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/dateutil/tz/__pycache__/_common.cpython-310.pyc", + "lib/python3.10/site-packages/dateutil/tz/__pycache__/_factories.cpython-310.pyc", + "lib/python3.10/site-packages/dateutil/tz/__pycache__/tz.cpython-310.pyc", + "lib/python3.10/site-packages/dateutil/tz/__pycache__/win.cpython-310.pyc", + "lib/python3.10/site-packages/dateutil/__pycache__/tzwin.cpython-310.pyc", + "lib/python3.10/site-packages/dateutil/__pycache__/utils.cpython-310.pyc", + "lib/python3.10/site-packages/dateutil/zoneinfo/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/dateutil/zoneinfo/__pycache__/rebuild.cpython-310.pyc" + ], + "fn": "python-dateutil-2.8.2-pyhd3eb1b0_0.conda", + "legacy_bz2_md5": "2eb923cc014094f4acf7f849d67d73f8", + "legacy_bz2_size": 246457, + "license": "BSD-3-Clause and Apache", + "license_family": "BSD", + "link": { + "source": "/Users/donjayamanne/.pyenv/versions/anaconda3-2023.03/pkgs/python-dateutil-2.8.2-pyhd3eb1b0_0", + "type": 1 + }, + "md5": "211ee00320b08a1ac9fea6677649f6c9", + "name": "python-dateutil", + "noarch": "python", + "package_tarball_full_path": "/Users/donjayamanne/.pyenv/versions/anaconda3-2023.03/pkgs/python-dateutil-2.8.2-pyhd3eb1b0_0.conda", + "package_type": "noarch_python", + "paths_data": { + "paths": [ + { + "_path": "lib/python3.10/site-packages/dateutil/__pycache__/__init__.cpython-310.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.10/site-packages/dateutil/__pycache__/_common.cpython-310.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.10/site-packages/dateutil/__pycache__/_version.cpython-310.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.10/site-packages/dateutil/__pycache__/easter.cpython-310.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.10/site-packages/dateutil/parser/__pycache__/__init__.cpython-310.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.10/site-packages/dateutil/parser/__pycache__/_parser.cpython-310.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.10/site-packages/dateutil/parser/__pycache__/isoparser.cpython-310.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.10/site-packages/dateutil/__pycache__/relativedelta.cpython-310.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.10/site-packages/dateutil/__pycache__/rrule.cpython-310.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.10/site-packages/dateutil/tz/__pycache__/__init__.cpython-310.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.10/site-packages/dateutil/tz/__pycache__/_common.cpython-310.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.10/site-packages/dateutil/tz/__pycache__/_factories.cpython-310.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.10/site-packages/dateutil/tz/__pycache__/tz.cpython-310.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.10/site-packages/dateutil/tz/__pycache__/win.cpython-310.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.10/site-packages/dateutil/__pycache__/tzwin.cpython-310.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.10/site-packages/dateutil/__pycache__/utils.cpython-310.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.10/site-packages/dateutil/zoneinfo/__pycache__/__init__.cpython-310.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.10/site-packages/dateutil/zoneinfo/__pycache__/rebuild.cpython-310.pyc", + "path_type": "pyc_file" + } + ], + "paths_version": 1 + }, + "requested_spec": "defaults/noarch::python-dateutil==2.8.2=pyhd3eb1b0_0[md5=211ee00320b08a1ac9fea6677649f6c9]", + "sha256": "01e82704b3d84c1b0b1f8823fa64259eb372a1278e6a40dddf2cefb4c96ab942", + "size": 238135, + "subdir": "noarch", + "timestamp": 1626374695070, + "track_features": "", + "url": "https://repo.anaconda.com/pkgs/main/noarch/python-dateutil-2.8.2-pyhd3eb1b0_0.conda", + "version": "2.8.2" +} \ No newline at end of file diff --git a/crates/pet-conda/tests/unix/anaconda3-2023.03/conda-meta/python-fastjsonschema-2.16.2-py310hca03da5_0.json b/crates/pet-conda/tests/unix/anaconda3-2023.03/conda-meta/python-fastjsonschema-2.16.2-py310hca03da5_0.json new file mode 100644 index 00000000..1e617319 --- /dev/null +++ b/crates/pet-conda/tests/unix/anaconda3-2023.03/conda-meta/python-fastjsonschema-2.16.2-py310hca03da5_0.json @@ -0,0 +1,66 @@ +{ + "build": "py310hca03da5_0", + "build_number": 0, + "channel": "https://repo.anaconda.com/pkgs/main/osx-arm64", + "constrains": [], + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "extracted_package_dir": "/Users/donjayamanne/.pyenv/versions/anaconda3-2023.03/pkgs/python-fastjsonschema-2.16.2-py310hca03da5_0", + "features": "", + "files": [ + "lib/python3.10/site-packages/fastjsonschema-2.16.2.dist-info/AUTHORS", + "lib/python3.10/site-packages/fastjsonschema-2.16.2.dist-info/INSTALLER", + "lib/python3.10/site-packages/fastjsonschema-2.16.2.dist-info/LICENSE", + "lib/python3.10/site-packages/fastjsonschema-2.16.2.dist-info/METADATA", + "lib/python3.10/site-packages/fastjsonschema-2.16.2.dist-info/RECORD", + "lib/python3.10/site-packages/fastjsonschema-2.16.2.dist-info/REQUESTED", + "lib/python3.10/site-packages/fastjsonschema-2.16.2.dist-info/WHEEL", + "lib/python3.10/site-packages/fastjsonschema-2.16.2.dist-info/direct_url.json", + "lib/python3.10/site-packages/fastjsonschema-2.16.2.dist-info/top_level.txt", + "lib/python3.10/site-packages/fastjsonschema/__init__.py", + "lib/python3.10/site-packages/fastjsonschema/__main__.py", + "lib/python3.10/site-packages/fastjsonschema/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/fastjsonschema/__pycache__/__main__.cpython-310.pyc", + "lib/python3.10/site-packages/fastjsonschema/__pycache__/draft04.cpython-310.pyc", + "lib/python3.10/site-packages/fastjsonschema/__pycache__/draft06.cpython-310.pyc", + "lib/python3.10/site-packages/fastjsonschema/__pycache__/draft07.cpython-310.pyc", + "lib/python3.10/site-packages/fastjsonschema/__pycache__/exceptions.cpython-310.pyc", + "lib/python3.10/site-packages/fastjsonschema/__pycache__/generator.cpython-310.pyc", + "lib/python3.10/site-packages/fastjsonschema/__pycache__/indent.cpython-310.pyc", + "lib/python3.10/site-packages/fastjsonschema/__pycache__/ref_resolver.cpython-310.pyc", + "lib/python3.10/site-packages/fastjsonschema/__pycache__/version.cpython-310.pyc", + "lib/python3.10/site-packages/fastjsonschema/draft04.py", + "lib/python3.10/site-packages/fastjsonschema/draft06.py", + "lib/python3.10/site-packages/fastjsonschema/draft07.py", + "lib/python3.10/site-packages/fastjsonschema/exceptions.py", + "lib/python3.10/site-packages/fastjsonschema/generator.py", + "lib/python3.10/site-packages/fastjsonschema/indent.py", + "lib/python3.10/site-packages/fastjsonschema/ref_resolver.py", + "lib/python3.10/site-packages/fastjsonschema/version.py" + ], + "fn": "python-fastjsonschema-2.16.2-py310hca03da5_0.conda", + "legacy_bz2_md5": "fac5645515e04c5ac0e47d80133671e2", + "legacy_bz2_size": 267399, + "license": "BSD-3-Clause", + "license_family": "BSD", + "link": { + "source": "/Users/donjayamanne/.pyenv/versions/anaconda3-2023.03/pkgs/python-fastjsonschema-2.16.2-py310hca03da5_0", + "type": 1 + }, + "md5": "70d5db9481d95286a170b6ef099949ed", + "name": "python-fastjsonschema", + "package_tarball_full_path": "/Users/donjayamanne/.pyenv/versions/anaconda3-2023.03/pkgs/python-fastjsonschema-2.16.2-py310hca03da5_0.conda", + "paths_data": { + "paths": [], + "paths_version": 1 + }, + "requested_spec": "defaults/osx-arm64::python-fastjsonschema==2.16.2=py310hca03da5_0[md5=70d5db9481d95286a170b6ef099949ed]", + "sha256": "074dae8587f84038a5bd10cd37d389b663a812aa0e2115a106e6a6aa757cc3b9", + "size": 237477, + "subdir": "osx-arm64", + "timestamp": 1661368747513, + "track_features": "", + "url": "https://repo.anaconda.com/pkgs/main/osx-arm64/python-fastjsonschema-2.16.2-py310hca03da5_0.conda", + "version": "2.16.2" +} \ No newline at end of file diff --git a/crates/pet-conda/tests/unix/anaconda3-2023.03/condabin/conda b/crates/pet-conda/tests/unix/anaconda3-2023.03/condabin/conda new file mode 100644 index 00000000..e69de29b diff --git a/crates/pet-conda/tests/unix/anaconda3-2023.03/envs/env_python_3/bin/conda b/crates/pet-conda/tests/unix/anaconda3-2023.03/envs/env_python_3/bin/conda new file mode 100644 index 00000000..e69de29b diff --git a/crates/pet-conda/tests/unix/anaconda3-2023.03/envs/env_python_3/bin/python b/crates/pet-conda/tests/unix/anaconda3-2023.03/envs/env_python_3/bin/python new file mode 100644 index 00000000..e69de29b diff --git a/crates/pet-conda/tests/unix/anaconda3-2023.03/envs/env_python_3/bin/python3 b/crates/pet-conda/tests/unix/anaconda3-2023.03/envs/env_python_3/bin/python3 new file mode 100644 index 00000000..e69de29b diff --git a/crates/pet-conda/tests/unix/anaconda3-2023.03/envs/env_python_3/bin/python3.1 b/crates/pet-conda/tests/unix/anaconda3-2023.03/envs/env_python_3/bin/python3.1 new file mode 100644 index 00000000..e69de29b diff --git a/crates/pet-conda/tests/unix/anaconda3-2023.03/envs/env_python_3/bin/python3.12 b/crates/pet-conda/tests/unix/anaconda3-2023.03/envs/env_python_3/bin/python3.12 new file mode 100644 index 00000000..e69de29b diff --git a/crates/pet-conda/tests/unix/anaconda3-2023.03/envs/env_python_3/conda-meta/history b/crates/pet-conda/tests/unix/anaconda3-2023.03/envs/env_python_3/conda-meta/history new file mode 100644 index 00000000..993b4eae --- /dev/null +++ b/crates/pet-conda/tests/unix/anaconda3-2023.03/envs/env_python_3/conda-meta/history @@ -0,0 +1,62 @@ +==> 2024-02-28 23:05:07 <== +# cmd: /Users/donjayamanne/miniconda3/bin/conda create -n conda1 +# conda version: 23.11.0 +==> 2024-02-28 23:08:59 <== +# cmd: /Users/donjayamanne/miniconda3/bin/conda install -c conda-forge --name conda1 ipykernel -y +# conda version: 23.11.0 ++conda-forge/noarch::appnope-0.1.4-pyhd8ed1ab_0 ++conda-forge/noarch::asttokens-2.4.1-pyhd8ed1ab_0 ++conda-forge/noarch::comm-0.2.1-pyhd8ed1ab_0 ++conda-forge/noarch::decorator-5.1.1-pyhd8ed1ab_0 ++conda-forge/noarch::exceptiongroup-1.2.0-pyhd8ed1ab_2 ++conda-forge/noarch::executing-2.0.1-pyhd8ed1ab_0 ++conda-forge/noarch::importlib-metadata-7.0.1-pyha770c72_0 ++conda-forge/noarch::importlib_metadata-7.0.1-hd8ed1ab_0 ++conda-forge/noarch::ipykernel-6.29.3-pyh3cd1d5f_0 ++conda-forge/noarch::ipython-8.22.1-pyh707e725_0 ++conda-forge/noarch::jedi-0.19.1-pyhd8ed1ab_0 ++conda-forge/noarch::jupyter_client-8.6.0-pyhd8ed1ab_0 ++conda-forge/noarch::matplotlib-inline-0.1.6-pyhd8ed1ab_0 ++conda-forge/noarch::nest-asyncio-1.6.0-pyhd8ed1ab_0 ++conda-forge/noarch::packaging-23.2-pyhd8ed1ab_0 ++conda-forge/noarch::parso-0.8.3-pyhd8ed1ab_0 ++conda-forge/noarch::pexpect-4.9.0-pyhd8ed1ab_0 ++conda-forge/noarch::pickleshare-0.7.5-py_1003 ++conda-forge/noarch::pip-24.0-pyhd8ed1ab_0 ++conda-forge/noarch::platformdirs-4.2.0-pyhd8ed1ab_0 ++conda-forge/noarch::prompt-toolkit-3.0.42-pyha770c72_0 ++conda-forge/noarch::ptyprocess-0.7.0-pyhd3deb0d_0 ++conda-forge/noarch::pure_eval-0.2.2-pyhd8ed1ab_0 ++conda-forge/noarch::pygments-2.17.2-pyhd8ed1ab_0 ++conda-forge/noarch::python-dateutil-2.8.2-pyhd8ed1ab_0 ++conda-forge/noarch::setuptools-69.1.1-pyhd8ed1ab_0 ++conda-forge/noarch::six-1.16.0-pyh6c4a22f_0 ++conda-forge/noarch::stack_data-0.6.2-pyhd8ed1ab_0 ++conda-forge/noarch::traitlets-5.14.1-pyhd8ed1ab_0 ++conda-forge/noarch::typing_extensions-4.10.0-pyha770c72_0 ++conda-forge/noarch::tzdata-2024a-h0c530f3_0 ++conda-forge/noarch::wcwidth-0.2.13-pyhd8ed1ab_0 ++conda-forge/noarch::wheel-0.42.0-pyhd8ed1ab_0 ++conda-forge/noarch::zipp-3.17.0-pyhd8ed1ab_0 ++conda-forge/osx-arm64::bzip2-1.0.8-h93a5062_5 ++conda-forge/osx-arm64::ca-certificates-2024.2.2-hf0a4a13_0 ++conda-forge/osx-arm64::debugpy-1.8.1-py312h20a0b95_0 ++conda-forge/osx-arm64::jupyter_core-5.7.1-py312h81bd7bf_0 ++conda-forge/osx-arm64::libcxx-16.0.6-h4653b0c_0 ++conda-forge/osx-arm64::libexpat-2.5.0-hb7217d7_1 ++conda-forge/osx-arm64::libffi-3.4.2-h3422bc3_5 ++conda-forge/osx-arm64::libsodium-1.0.18-h27ca646_1 ++conda-forge/osx-arm64::libsqlite-3.45.1-h091b4b1_0 ++conda-forge/osx-arm64::libzlib-1.2.13-h53f4e23_5 ++conda-forge/osx-arm64::ncurses-6.4-h463b476_2 ++conda-forge/osx-arm64::openssl-3.2.1-h0d3ecfb_0 ++conda-forge/osx-arm64::psutil-5.9.8-py312he37b823_0 ++conda-forge/osx-arm64::python-3.12.2-hdf0ec26_0_cpython ++conda-forge/osx-arm64::python_abi-3.12-4_cp312 ++conda-forge/osx-arm64::pyzmq-25.1.2-py312h1edf716_0 ++conda-forge/osx-arm64::readline-8.2-h92ec313_1 ++conda-forge/osx-arm64::tk-8.6.13-h5083fa2_1 ++conda-forge/osx-arm64::tornado-6.4-py312he37b823_0 ++conda-forge/osx-arm64::xz-5.2.6-h57fd34a_0 ++conda-forge/osx-arm64::zeromq-4.3.5-h965bd2d_0 +# update specs: ['ipykernel'] diff --git a/crates/pet-conda/tests/unix/anaconda3-2023.03/envs/env_python_3/conda-meta/pygments-2.17.2-pyhd8ed1ab_0.json b/crates/pet-conda/tests/unix/anaconda3-2023.03/envs/env_python_3/conda-meta/pygments-2.17.2-pyhd8ed1ab_0.json new file mode 100644 index 00000000..9ae64493 --- /dev/null +++ b/crates/pet-conda/tests/unix/anaconda3-2023.03/envs/env_python_3/conda-meta/pygments-2.17.2-pyhd8ed1ab_0.json @@ -0,0 +1,4285 @@ +{ + "build": "pyhd8ed1ab_0", + "build_number": 0, + "channel": "https://conda.anaconda.org/conda-forge/noarch", + "constrains": [], + "depends": [ + "python >=3.7" + ], + "extracted_package_dir": "/Users/donjayamanne/miniconda3/pkgs/pygments-2.17.2-pyhd8ed1ab_0", + "files": [ + "lib/python3.12/site-packages/pygments-2.17.2.dist-info/INSTALLER", + "lib/python3.12/site-packages/pygments-2.17.2.dist-info/METADATA", + "lib/python3.12/site-packages/pygments-2.17.2.dist-info/RECORD", + "lib/python3.12/site-packages/pygments-2.17.2.dist-info/REQUESTED", + "lib/python3.12/site-packages/pygments-2.17.2.dist-info/WHEEL", + "lib/python3.12/site-packages/pygments-2.17.2.dist-info/direct_url.json", + "lib/python3.12/site-packages/pygments-2.17.2.dist-info/entry_points.txt", + "lib/python3.12/site-packages/pygments-2.17.2.dist-info/licenses/AUTHORS", + "lib/python3.12/site-packages/pygments-2.17.2.dist-info/licenses/LICENSE", + "lib/python3.12/site-packages/pygments/__init__.py", + "lib/python3.12/site-packages/pygments/__main__.py", + "lib/python3.12/site-packages/pygments/cmdline.py", + "lib/python3.12/site-packages/pygments/console.py", + "lib/python3.12/site-packages/pygments/filter.py", + "lib/python3.12/site-packages/pygments/filters/__init__.py", + "lib/python3.12/site-packages/pygments/formatter.py", + "lib/python3.12/site-packages/pygments/formatters/__init__.py", + "lib/python3.12/site-packages/pygments/formatters/_mapping.py", + "lib/python3.12/site-packages/pygments/formatters/bbcode.py", + "lib/python3.12/site-packages/pygments/formatters/groff.py", + "lib/python3.12/site-packages/pygments/formatters/html.py", + "lib/python3.12/site-packages/pygments/formatters/img.py", + "lib/python3.12/site-packages/pygments/formatters/irc.py", + "lib/python3.12/site-packages/pygments/formatters/latex.py", + "lib/python3.12/site-packages/pygments/formatters/other.py", + "lib/python3.12/site-packages/pygments/formatters/pangomarkup.py", + "lib/python3.12/site-packages/pygments/formatters/rtf.py", + "lib/python3.12/site-packages/pygments/formatters/svg.py", + "lib/python3.12/site-packages/pygments/formatters/terminal.py", + "lib/python3.12/site-packages/pygments/formatters/terminal256.py", + "lib/python3.12/site-packages/pygments/lexer.py", + "lib/python3.12/site-packages/pygments/lexers/__init__.py", + "lib/python3.12/site-packages/pygments/lexers/_ada_builtins.py", + "lib/python3.12/site-packages/pygments/lexers/_asy_builtins.py", + "lib/python3.12/site-packages/pygments/lexers/_cl_builtins.py", + "lib/python3.12/site-packages/pygments/lexers/_cocoa_builtins.py", + "lib/python3.12/site-packages/pygments/lexers/_csound_builtins.py", + "lib/python3.12/site-packages/pygments/lexers/_css_builtins.py", + "lib/python3.12/site-packages/pygments/lexers/_julia_builtins.py", + "lib/python3.12/site-packages/pygments/lexers/_lasso_builtins.py", + "lib/python3.12/site-packages/pygments/lexers/_lilypond_builtins.py", + "lib/python3.12/site-packages/pygments/lexers/_lua_builtins.py", + "lib/python3.12/site-packages/pygments/lexers/_mapping.py", + "lib/python3.12/site-packages/pygments/lexers/_mql_builtins.py", + "lib/python3.12/site-packages/pygments/lexers/_mysql_builtins.py", + "lib/python3.12/site-packages/pygments/lexers/_openedge_builtins.py", + "lib/python3.12/site-packages/pygments/lexers/_php_builtins.py", + "lib/python3.12/site-packages/pygments/lexers/_postgres_builtins.py", + "lib/python3.12/site-packages/pygments/lexers/_qlik_builtins.py", + "lib/python3.12/site-packages/pygments/lexers/_scheme_builtins.py", + "lib/python3.12/site-packages/pygments/lexers/_scilab_builtins.py", + "lib/python3.12/site-packages/pygments/lexers/_sourcemod_builtins.py", + "lib/python3.12/site-packages/pygments/lexers/_stan_builtins.py", + "lib/python3.12/site-packages/pygments/lexers/_stata_builtins.py", + "lib/python3.12/site-packages/pygments/lexers/_tsql_builtins.py", + "lib/python3.12/site-packages/pygments/lexers/_usd_builtins.py", + "lib/python3.12/site-packages/pygments/lexers/_vbscript_builtins.py", + "lib/python3.12/site-packages/pygments/lexers/_vim_builtins.py", + "lib/python3.12/site-packages/pygments/lexers/actionscript.py", + "lib/python3.12/site-packages/pygments/lexers/ada.py", + "lib/python3.12/site-packages/pygments/lexers/agile.py", + "lib/python3.12/site-packages/pygments/lexers/algebra.py", + "lib/python3.12/site-packages/pygments/lexers/ambient.py", + "lib/python3.12/site-packages/pygments/lexers/amdgpu.py", + "lib/python3.12/site-packages/pygments/lexers/ampl.py", + "lib/python3.12/site-packages/pygments/lexers/apdlexer.py", + "lib/python3.12/site-packages/pygments/lexers/apl.py", + "lib/python3.12/site-packages/pygments/lexers/archetype.py", + "lib/python3.12/site-packages/pygments/lexers/arrow.py", + "lib/python3.12/site-packages/pygments/lexers/arturo.py", + "lib/python3.12/site-packages/pygments/lexers/asc.py", + "lib/python3.12/site-packages/pygments/lexers/asm.py", + "lib/python3.12/site-packages/pygments/lexers/asn1.py", + "lib/python3.12/site-packages/pygments/lexers/automation.py", + "lib/python3.12/site-packages/pygments/lexers/bare.py", + "lib/python3.12/site-packages/pygments/lexers/basic.py", + "lib/python3.12/site-packages/pygments/lexers/bdd.py", + "lib/python3.12/site-packages/pygments/lexers/berry.py", + "lib/python3.12/site-packages/pygments/lexers/bibtex.py", + "lib/python3.12/site-packages/pygments/lexers/blueprint.py", + "lib/python3.12/site-packages/pygments/lexers/boa.py", + "lib/python3.12/site-packages/pygments/lexers/bqn.py", + "lib/python3.12/site-packages/pygments/lexers/business.py", + "lib/python3.12/site-packages/pygments/lexers/c_cpp.py", + "lib/python3.12/site-packages/pygments/lexers/c_like.py", + "lib/python3.12/site-packages/pygments/lexers/capnproto.py", + "lib/python3.12/site-packages/pygments/lexers/carbon.py", + "lib/python3.12/site-packages/pygments/lexers/cddl.py", + "lib/python3.12/site-packages/pygments/lexers/chapel.py", + "lib/python3.12/site-packages/pygments/lexers/clean.py", + "lib/python3.12/site-packages/pygments/lexers/comal.py", + "lib/python3.12/site-packages/pygments/lexers/compiled.py", + "lib/python3.12/site-packages/pygments/lexers/configs.py", + "lib/python3.12/site-packages/pygments/lexers/console.py", + "lib/python3.12/site-packages/pygments/lexers/cplint.py", + "lib/python3.12/site-packages/pygments/lexers/crystal.py", + "lib/python3.12/site-packages/pygments/lexers/csound.py", + "lib/python3.12/site-packages/pygments/lexers/css.py", + "lib/python3.12/site-packages/pygments/lexers/d.py", + "lib/python3.12/site-packages/pygments/lexers/dalvik.py", + "lib/python3.12/site-packages/pygments/lexers/data.py", + "lib/python3.12/site-packages/pygments/lexers/dax.py", + "lib/python3.12/site-packages/pygments/lexers/devicetree.py", + "lib/python3.12/site-packages/pygments/lexers/diff.py", + "lib/python3.12/site-packages/pygments/lexers/dns.py", + "lib/python3.12/site-packages/pygments/lexers/dotnet.py", + "lib/python3.12/site-packages/pygments/lexers/dsls.py", + "lib/python3.12/site-packages/pygments/lexers/dylan.py", + "lib/python3.12/site-packages/pygments/lexers/ecl.py", + "lib/python3.12/site-packages/pygments/lexers/eiffel.py", + "lib/python3.12/site-packages/pygments/lexers/elm.py", + "lib/python3.12/site-packages/pygments/lexers/elpi.py", + "lib/python3.12/site-packages/pygments/lexers/email.py", + "lib/python3.12/site-packages/pygments/lexers/erlang.py", + "lib/python3.12/site-packages/pygments/lexers/esoteric.py", + "lib/python3.12/site-packages/pygments/lexers/ezhil.py", + "lib/python3.12/site-packages/pygments/lexers/factor.py", + "lib/python3.12/site-packages/pygments/lexers/fantom.py", + "lib/python3.12/site-packages/pygments/lexers/felix.py", + "lib/python3.12/site-packages/pygments/lexers/fift.py", + "lib/python3.12/site-packages/pygments/lexers/floscript.py", + "lib/python3.12/site-packages/pygments/lexers/forth.py", + "lib/python3.12/site-packages/pygments/lexers/fortran.py", + "lib/python3.12/site-packages/pygments/lexers/foxpro.py", + "lib/python3.12/site-packages/pygments/lexers/freefem.py", + "lib/python3.12/site-packages/pygments/lexers/func.py", + "lib/python3.12/site-packages/pygments/lexers/functional.py", + "lib/python3.12/site-packages/pygments/lexers/futhark.py", + "lib/python3.12/site-packages/pygments/lexers/gcodelexer.py", + "lib/python3.12/site-packages/pygments/lexers/gdscript.py", + "lib/python3.12/site-packages/pygments/lexers/go.py", + "lib/python3.12/site-packages/pygments/lexers/grammar_notation.py", + "lib/python3.12/site-packages/pygments/lexers/graph.py", + "lib/python3.12/site-packages/pygments/lexers/graphics.py", + "lib/python3.12/site-packages/pygments/lexers/graphql.py", + "lib/python3.12/site-packages/pygments/lexers/graphviz.py", + "lib/python3.12/site-packages/pygments/lexers/gsql.py", + "lib/python3.12/site-packages/pygments/lexers/haskell.py", + "lib/python3.12/site-packages/pygments/lexers/haxe.py", + "lib/python3.12/site-packages/pygments/lexers/hdl.py", + "lib/python3.12/site-packages/pygments/lexers/hexdump.py", + "lib/python3.12/site-packages/pygments/lexers/html.py", + "lib/python3.12/site-packages/pygments/lexers/idl.py", + "lib/python3.12/site-packages/pygments/lexers/igor.py", + "lib/python3.12/site-packages/pygments/lexers/inferno.py", + "lib/python3.12/site-packages/pygments/lexers/installers.py", + "lib/python3.12/site-packages/pygments/lexers/int_fiction.py", + "lib/python3.12/site-packages/pygments/lexers/iolang.py", + "lib/python3.12/site-packages/pygments/lexers/j.py", + "lib/python3.12/site-packages/pygments/lexers/javascript.py", + "lib/python3.12/site-packages/pygments/lexers/jmespath.py", + "lib/python3.12/site-packages/pygments/lexers/jslt.py", + "lib/python3.12/site-packages/pygments/lexers/jsonnet.py", + "lib/python3.12/site-packages/pygments/lexers/jsx.py", + "lib/python3.12/site-packages/pygments/lexers/julia.py", + "lib/python3.12/site-packages/pygments/lexers/jvm.py", + "lib/python3.12/site-packages/pygments/lexers/kuin.py", + "lib/python3.12/site-packages/pygments/lexers/kusto.py", + "lib/python3.12/site-packages/pygments/lexers/ldap.py", + "lib/python3.12/site-packages/pygments/lexers/lean.py", + "lib/python3.12/site-packages/pygments/lexers/lilypond.py", + "lib/python3.12/site-packages/pygments/lexers/lisp.py", + "lib/python3.12/site-packages/pygments/lexers/macaulay2.py", + "lib/python3.12/site-packages/pygments/lexers/make.py", + "lib/python3.12/site-packages/pygments/lexers/markup.py", + "lib/python3.12/site-packages/pygments/lexers/math.py", + "lib/python3.12/site-packages/pygments/lexers/matlab.py", + "lib/python3.12/site-packages/pygments/lexers/maxima.py", + "lib/python3.12/site-packages/pygments/lexers/meson.py", + "lib/python3.12/site-packages/pygments/lexers/mime.py", + "lib/python3.12/site-packages/pygments/lexers/minecraft.py", + "lib/python3.12/site-packages/pygments/lexers/mips.py", + "lib/python3.12/site-packages/pygments/lexers/ml.py", + "lib/python3.12/site-packages/pygments/lexers/modeling.py", + "lib/python3.12/site-packages/pygments/lexers/modula2.py", + "lib/python3.12/site-packages/pygments/lexers/monte.py", + "lib/python3.12/site-packages/pygments/lexers/mosel.py", + "lib/python3.12/site-packages/pygments/lexers/ncl.py", + "lib/python3.12/site-packages/pygments/lexers/nimrod.py", + "lib/python3.12/site-packages/pygments/lexers/nit.py", + "lib/python3.12/site-packages/pygments/lexers/nix.py", + "lib/python3.12/site-packages/pygments/lexers/oberon.py", + "lib/python3.12/site-packages/pygments/lexers/objective.py", + "lib/python3.12/site-packages/pygments/lexers/ooc.py", + "lib/python3.12/site-packages/pygments/lexers/openscad.py", + "lib/python3.12/site-packages/pygments/lexers/other.py", + "lib/python3.12/site-packages/pygments/lexers/parasail.py", + "lib/python3.12/site-packages/pygments/lexers/parsers.py", + "lib/python3.12/site-packages/pygments/lexers/pascal.py", + "lib/python3.12/site-packages/pygments/lexers/pawn.py", + "lib/python3.12/site-packages/pygments/lexers/perl.py", + "lib/python3.12/site-packages/pygments/lexers/phix.py", + "lib/python3.12/site-packages/pygments/lexers/php.py", + "lib/python3.12/site-packages/pygments/lexers/pointless.py", + "lib/python3.12/site-packages/pygments/lexers/pony.py", + "lib/python3.12/site-packages/pygments/lexers/praat.py", + "lib/python3.12/site-packages/pygments/lexers/procfile.py", + "lib/python3.12/site-packages/pygments/lexers/prolog.py", + "lib/python3.12/site-packages/pygments/lexers/promql.py", + "lib/python3.12/site-packages/pygments/lexers/prql.py", + "lib/python3.12/site-packages/pygments/lexers/ptx.py", + "lib/python3.12/site-packages/pygments/lexers/python.py", + "lib/python3.12/site-packages/pygments/lexers/q.py", + "lib/python3.12/site-packages/pygments/lexers/qlik.py", + "lib/python3.12/site-packages/pygments/lexers/qvt.py", + "lib/python3.12/site-packages/pygments/lexers/r.py", + "lib/python3.12/site-packages/pygments/lexers/rdf.py", + "lib/python3.12/site-packages/pygments/lexers/rebol.py", + "lib/python3.12/site-packages/pygments/lexers/resource.py", + "lib/python3.12/site-packages/pygments/lexers/ride.py", + "lib/python3.12/site-packages/pygments/lexers/rita.py", + "lib/python3.12/site-packages/pygments/lexers/rnc.py", + "lib/python3.12/site-packages/pygments/lexers/roboconf.py", + "lib/python3.12/site-packages/pygments/lexers/robotframework.py", + "lib/python3.12/site-packages/pygments/lexers/ruby.py", + "lib/python3.12/site-packages/pygments/lexers/rust.py", + "lib/python3.12/site-packages/pygments/lexers/sas.py", + "lib/python3.12/site-packages/pygments/lexers/savi.py", + "lib/python3.12/site-packages/pygments/lexers/scdoc.py", + "lib/python3.12/site-packages/pygments/lexers/scripting.py", + "lib/python3.12/site-packages/pygments/lexers/sgf.py", + "lib/python3.12/site-packages/pygments/lexers/shell.py", + "lib/python3.12/site-packages/pygments/lexers/sieve.py", + "lib/python3.12/site-packages/pygments/lexers/slash.py", + "lib/python3.12/site-packages/pygments/lexers/smalltalk.py", + "lib/python3.12/site-packages/pygments/lexers/smithy.py", + "lib/python3.12/site-packages/pygments/lexers/smv.py", + "lib/python3.12/site-packages/pygments/lexers/snobol.py", + "lib/python3.12/site-packages/pygments/lexers/solidity.py", + "lib/python3.12/site-packages/pygments/lexers/sophia.py", + "lib/python3.12/site-packages/pygments/lexers/special.py", + "lib/python3.12/site-packages/pygments/lexers/spice.py", + "lib/python3.12/site-packages/pygments/lexers/sql.py", + "lib/python3.12/site-packages/pygments/lexers/srcinfo.py", + "lib/python3.12/site-packages/pygments/lexers/stata.py", + "lib/python3.12/site-packages/pygments/lexers/supercollider.py", + "lib/python3.12/site-packages/pygments/lexers/tal.py", + "lib/python3.12/site-packages/pygments/lexers/tcl.py", + "lib/python3.12/site-packages/pygments/lexers/teal.py", + "lib/python3.12/site-packages/pygments/lexers/templates.py", + "lib/python3.12/site-packages/pygments/lexers/teraterm.py", + "lib/python3.12/site-packages/pygments/lexers/testing.py", + "lib/python3.12/site-packages/pygments/lexers/text.py", + "lib/python3.12/site-packages/pygments/lexers/textedit.py", + "lib/python3.12/site-packages/pygments/lexers/textfmts.py", + "lib/python3.12/site-packages/pygments/lexers/theorem.py", + "lib/python3.12/site-packages/pygments/lexers/thingsdb.py", + "lib/python3.12/site-packages/pygments/lexers/tlb.py", + "lib/python3.12/site-packages/pygments/lexers/tls.py", + "lib/python3.12/site-packages/pygments/lexers/tnt.py", + "lib/python3.12/site-packages/pygments/lexers/trafficscript.py", + "lib/python3.12/site-packages/pygments/lexers/typoscript.py", + "lib/python3.12/site-packages/pygments/lexers/ul4.py", + "lib/python3.12/site-packages/pygments/lexers/unicon.py", + "lib/python3.12/site-packages/pygments/lexers/urbi.py", + "lib/python3.12/site-packages/pygments/lexers/usd.py", + "lib/python3.12/site-packages/pygments/lexers/varnish.py", + "lib/python3.12/site-packages/pygments/lexers/verification.py", + "lib/python3.12/site-packages/pygments/lexers/verifpal.py", + "lib/python3.12/site-packages/pygments/lexers/vip.py", + "lib/python3.12/site-packages/pygments/lexers/vyper.py", + "lib/python3.12/site-packages/pygments/lexers/web.py", + "lib/python3.12/site-packages/pygments/lexers/webassembly.py", + "lib/python3.12/site-packages/pygments/lexers/webidl.py", + "lib/python3.12/site-packages/pygments/lexers/webmisc.py", + "lib/python3.12/site-packages/pygments/lexers/wgsl.py", + "lib/python3.12/site-packages/pygments/lexers/whiley.py", + "lib/python3.12/site-packages/pygments/lexers/wowtoc.py", + "lib/python3.12/site-packages/pygments/lexers/wren.py", + "lib/python3.12/site-packages/pygments/lexers/x10.py", + "lib/python3.12/site-packages/pygments/lexers/xorg.py", + "lib/python3.12/site-packages/pygments/lexers/yang.py", + "lib/python3.12/site-packages/pygments/lexers/yara.py", + "lib/python3.12/site-packages/pygments/lexers/zig.py", + "lib/python3.12/site-packages/pygments/modeline.py", + "lib/python3.12/site-packages/pygments/plugin.py", + "lib/python3.12/site-packages/pygments/regexopt.py", + "lib/python3.12/site-packages/pygments/scanner.py", + "lib/python3.12/site-packages/pygments/sphinxext.py", + "lib/python3.12/site-packages/pygments/style.py", + "lib/python3.12/site-packages/pygments/styles/__init__.py", + "lib/python3.12/site-packages/pygments/styles/_mapping.py", + "lib/python3.12/site-packages/pygments/styles/abap.py", + "lib/python3.12/site-packages/pygments/styles/algol.py", + "lib/python3.12/site-packages/pygments/styles/algol_nu.py", + "lib/python3.12/site-packages/pygments/styles/arduino.py", + "lib/python3.12/site-packages/pygments/styles/autumn.py", + "lib/python3.12/site-packages/pygments/styles/borland.py", + "lib/python3.12/site-packages/pygments/styles/bw.py", + "lib/python3.12/site-packages/pygments/styles/colorful.py", + "lib/python3.12/site-packages/pygments/styles/default.py", + "lib/python3.12/site-packages/pygments/styles/dracula.py", + "lib/python3.12/site-packages/pygments/styles/emacs.py", + "lib/python3.12/site-packages/pygments/styles/friendly.py", + "lib/python3.12/site-packages/pygments/styles/friendly_grayscale.py", + "lib/python3.12/site-packages/pygments/styles/fruity.py", + "lib/python3.12/site-packages/pygments/styles/gh_dark.py", + "lib/python3.12/site-packages/pygments/styles/gruvbox.py", + "lib/python3.12/site-packages/pygments/styles/igor.py", + "lib/python3.12/site-packages/pygments/styles/inkpot.py", + "lib/python3.12/site-packages/pygments/styles/lightbulb.py", + "lib/python3.12/site-packages/pygments/styles/lilypond.py", + "lib/python3.12/site-packages/pygments/styles/lovelace.py", + "lib/python3.12/site-packages/pygments/styles/manni.py", + "lib/python3.12/site-packages/pygments/styles/material.py", + "lib/python3.12/site-packages/pygments/styles/monokai.py", + "lib/python3.12/site-packages/pygments/styles/murphy.py", + "lib/python3.12/site-packages/pygments/styles/native.py", + "lib/python3.12/site-packages/pygments/styles/nord.py", + "lib/python3.12/site-packages/pygments/styles/onedark.py", + "lib/python3.12/site-packages/pygments/styles/paraiso_dark.py", + "lib/python3.12/site-packages/pygments/styles/paraiso_light.py", + "lib/python3.12/site-packages/pygments/styles/pastie.py", + "lib/python3.12/site-packages/pygments/styles/perldoc.py", + "lib/python3.12/site-packages/pygments/styles/rainbow_dash.py", + "lib/python3.12/site-packages/pygments/styles/rrt.py", + "lib/python3.12/site-packages/pygments/styles/sas.py", + "lib/python3.12/site-packages/pygments/styles/solarized.py", + "lib/python3.12/site-packages/pygments/styles/staroffice.py", + "lib/python3.12/site-packages/pygments/styles/stata_dark.py", + "lib/python3.12/site-packages/pygments/styles/stata_light.py", + "lib/python3.12/site-packages/pygments/styles/tango.py", + "lib/python3.12/site-packages/pygments/styles/trac.py", + "lib/python3.12/site-packages/pygments/styles/vim.py", + "lib/python3.12/site-packages/pygments/styles/vs.py", + "lib/python3.12/site-packages/pygments/styles/xcode.py", + "lib/python3.12/site-packages/pygments/styles/zenburn.py", + "lib/python3.12/site-packages/pygments/token.py", + "lib/python3.12/site-packages/pygments/unistring.py", + "lib/python3.12/site-packages/pygments/util.py", + "lib/python3.12/site-packages/pygments/__pycache__/__init__.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/__pycache__/__main__.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/__pycache__/cmdline.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/__pycache__/console.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/__pycache__/filter.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/filters/__pycache__/__init__.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/__pycache__/formatter.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/formatters/__pycache__/__init__.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/formatters/__pycache__/_mapping.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/formatters/__pycache__/bbcode.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/formatters/__pycache__/groff.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/formatters/__pycache__/html.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/formatters/__pycache__/img.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/formatters/__pycache__/irc.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/formatters/__pycache__/latex.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/formatters/__pycache__/other.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/formatters/__pycache__/pangomarkup.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/formatters/__pycache__/rtf.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/formatters/__pycache__/svg.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/formatters/__pycache__/terminal.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/formatters/__pycache__/terminal256.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/__pycache__/lexer.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/__init__.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/_ada_builtins.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/_asy_builtins.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/_cl_builtins.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/_cocoa_builtins.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/_csound_builtins.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/_css_builtins.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/_julia_builtins.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/_lasso_builtins.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/_lilypond_builtins.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/_lua_builtins.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/_mapping.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/_mql_builtins.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/_mysql_builtins.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/_openedge_builtins.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/_php_builtins.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/_postgres_builtins.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/_qlik_builtins.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/_scheme_builtins.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/_scilab_builtins.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/_sourcemod_builtins.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/_stan_builtins.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/_stata_builtins.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/_tsql_builtins.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/_usd_builtins.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/_vbscript_builtins.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/_vim_builtins.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/actionscript.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/ada.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/agile.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/algebra.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/ambient.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/amdgpu.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/ampl.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/apdlexer.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/apl.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/archetype.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/arrow.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/arturo.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/asc.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/asm.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/asn1.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/automation.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/bare.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/basic.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/bdd.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/berry.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/bibtex.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/blueprint.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/boa.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/bqn.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/business.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/c_cpp.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/c_like.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/capnproto.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/carbon.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/cddl.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/chapel.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/clean.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/comal.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/compiled.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/configs.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/console.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/cplint.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/crystal.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/csound.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/css.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/d.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/dalvik.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/data.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/dax.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/devicetree.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/diff.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/dns.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/dotnet.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/dsls.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/dylan.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/ecl.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/eiffel.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/elm.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/elpi.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/email.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/erlang.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/esoteric.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/ezhil.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/factor.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/fantom.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/felix.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/fift.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/floscript.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/forth.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/fortran.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/foxpro.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/freefem.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/func.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/functional.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/futhark.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/gcodelexer.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/gdscript.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/go.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/grammar_notation.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/graph.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/graphics.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/graphql.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/graphviz.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/gsql.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/haskell.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/haxe.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/hdl.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/hexdump.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/html.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/idl.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/igor.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/inferno.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/installers.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/int_fiction.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/iolang.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/j.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/javascript.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/jmespath.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/jslt.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/jsonnet.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/jsx.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/julia.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/jvm.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/kuin.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/kusto.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/ldap.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/lean.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/lilypond.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/lisp.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/macaulay2.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/make.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/markup.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/math.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/matlab.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/maxima.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/meson.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/mime.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/minecraft.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/mips.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/ml.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/modeling.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/modula2.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/monte.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/mosel.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/ncl.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/nimrod.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/nit.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/nix.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/oberon.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/objective.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/ooc.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/openscad.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/other.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/parasail.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/parsers.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/pascal.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/pawn.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/perl.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/phix.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/php.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/pointless.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/pony.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/praat.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/procfile.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/prolog.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/promql.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/prql.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/ptx.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/python.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/q.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/qlik.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/qvt.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/r.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/rdf.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/rebol.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/resource.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/ride.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/rita.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/rnc.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/roboconf.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/robotframework.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/ruby.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/rust.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/sas.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/savi.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/scdoc.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/scripting.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/sgf.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/shell.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/sieve.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/slash.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/smalltalk.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/smithy.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/smv.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/snobol.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/solidity.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/sophia.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/special.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/spice.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/sql.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/srcinfo.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/stata.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/supercollider.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/tal.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/tcl.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/teal.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/templates.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/teraterm.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/testing.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/text.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/textedit.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/textfmts.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/theorem.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/thingsdb.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/tlb.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/tls.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/tnt.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/trafficscript.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/typoscript.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/ul4.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/unicon.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/urbi.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/usd.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/varnish.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/verification.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/verifpal.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/vip.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/vyper.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/web.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/webassembly.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/webidl.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/webmisc.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/wgsl.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/whiley.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/wowtoc.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/wren.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/x10.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/xorg.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/yang.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/yara.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/zig.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/__pycache__/modeline.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/__pycache__/plugin.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/__pycache__/regexopt.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/__pycache__/scanner.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/__pycache__/sphinxext.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/__pycache__/style.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/styles/__pycache__/__init__.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/styles/__pycache__/_mapping.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/styles/__pycache__/abap.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/styles/__pycache__/algol.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/styles/__pycache__/algol_nu.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/styles/__pycache__/arduino.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/styles/__pycache__/autumn.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/styles/__pycache__/borland.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/styles/__pycache__/bw.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/styles/__pycache__/colorful.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/styles/__pycache__/default.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/styles/__pycache__/dracula.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/styles/__pycache__/emacs.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/styles/__pycache__/friendly.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/styles/__pycache__/friendly_grayscale.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/styles/__pycache__/fruity.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/styles/__pycache__/gh_dark.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/styles/__pycache__/gruvbox.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/styles/__pycache__/igor.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/styles/__pycache__/inkpot.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/styles/__pycache__/lightbulb.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/styles/__pycache__/lilypond.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/styles/__pycache__/lovelace.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/styles/__pycache__/manni.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/styles/__pycache__/material.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/styles/__pycache__/monokai.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/styles/__pycache__/murphy.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/styles/__pycache__/native.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/styles/__pycache__/nord.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/styles/__pycache__/onedark.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/styles/__pycache__/paraiso_dark.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/styles/__pycache__/paraiso_light.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/styles/__pycache__/pastie.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/styles/__pycache__/perldoc.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/styles/__pycache__/rainbow_dash.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/styles/__pycache__/rrt.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/styles/__pycache__/sas.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/styles/__pycache__/solarized.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/styles/__pycache__/staroffice.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/styles/__pycache__/stata_dark.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/styles/__pycache__/stata_light.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/styles/__pycache__/tango.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/styles/__pycache__/trac.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/styles/__pycache__/vim.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/styles/__pycache__/vs.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/styles/__pycache__/xcode.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/styles/__pycache__/zenburn.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/__pycache__/token.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/__pycache__/unistring.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/__pycache__/util.cpython-312.pyc", + "bin/pygmentize" + ], + "fn": "pygments-2.17.2-pyhd8ed1ab_0.conda", + "license": "BSD-2-Clause", + "link": { + "source": "/Users/donjayamanne/miniconda3/pkgs/pygments-2.17.2-pyhd8ed1ab_0", + "type": 1 + }, + "md5": "140a7f159396547e9799aa98f9f0742e", + "name": "pygments", + "noarch": "python", + "package_tarball_full_path": "/Users/donjayamanne/miniconda3/pkgs/pygments-2.17.2-pyhd8ed1ab_0.conda", + "package_type": "noarch_python", + "paths_data": { + "paths": [ + { + "_path": "site-packages/pygments-2.17.2.dist-info/INSTALLER", + "path_type": "hardlink", + "sha256": "d0edee15f91b406f3f99726e44eb990be6e34fd0345b52b910c568e0eef6a2a8", + "sha256_in_prefix": "d0edee15f91b406f3f99726e44eb990be6e34fd0345b52b910c568e0eef6a2a8", + "size_in_bytes": 5 + }, + { + "_path": "site-packages/pygments-2.17.2.dist-info/METADATA", + "path_type": "hardlink", + "sha256": "cc7fbb14bb31cdd91a722f246ec1f35fc9f326fb0f3ced50908904c575797376", + "sha256_in_prefix": "cc7fbb14bb31cdd91a722f246ec1f35fc9f326fb0f3ced50908904c575797376", + "size_in_bytes": 2592 + }, + { + "_path": "site-packages/pygments-2.17.2.dist-info/RECORD", + "path_type": "hardlink", + "sha256": "dc4ac9fb9e165e4a0788ee337acb37e793f284ec4471535e068280bc2c30b116", + "sha256_in_prefix": "dc4ac9fb9e165e4a0788ee337acb37e793f284ec4471535e068280bc2c30b116", + "size_in_bytes": 45249 + }, + { + "_path": "site-packages/pygments-2.17.2.dist-info/REQUESTED", + "path_type": "hardlink", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size_in_bytes": 0 + }, + { + "_path": "site-packages/pygments-2.17.2.dist-info/WHEEL", + "path_type": "hardlink", + "sha256": "f5006e1e183a14d5bb969a5ba05daf2956c2193573b05ca48114238e56a3ae10", + "sha256_in_prefix": "f5006e1e183a14d5bb969a5ba05daf2956c2193573b05ca48114238e56a3ae10", + "size_in_bytes": 87 + }, + { + "_path": "site-packages/pygments-2.17.2.dist-info/direct_url.json", + "path_type": "hardlink", + "sha256": "85b953817e88fa65e1ccbf5d54cf0f2fa0c9ac127ab1cd23161706f0358cdd69", + "sha256_in_prefix": "85b953817e88fa65e1ccbf5d54cf0f2fa0c9ac127ab1cd23161706f0358cdd69", + "size_in_bytes": 104 + }, + { + "_path": "site-packages/pygments-2.17.2.dist-info/entry_points.txt", + "path_type": "hardlink", + "sha256": "b945f0f9784c281117e2959c0ada6e4d39cf84bde1ece104da35a2e75550b1af", + "sha256_in_prefix": "b945f0f9784c281117e2959c0ada6e4d39cf84bde1ece104da35a2e75550b1af", + "size_in_bytes": 53 + }, + { + "_path": "site-packages/pygments-2.17.2.dist-info/licenses/AUTHORS", + "path_type": "hardlink", + "sha256": "71408c264e8030a8ee751f76cd9ff75f0e66586b30b243c5418a54d46f184436", + "sha256_in_prefix": "71408c264e8030a8ee751f76cd9ff75f0e66586b30b243c5418a54d46f184436", + "size_in_bytes": 10281 + }, + { + "_path": "site-packages/pygments-2.17.2.dist-info/licenses/LICENSE", + "path_type": "hardlink", + "sha256": "a9d66f1d526df02e29dce73436d34e56e8632f46c275bbdffc70569e882f9f17", + "sha256_in_prefix": "a9d66f1d526df02e29dce73436d34e56e8632f46c275bbdffc70569e882f9f17", + "size_in_bytes": 1331 + }, + { + "_path": "site-packages/pygments/__init__.py", + "path_type": "hardlink", + "sha256": "84e562dc5c16bab7350a3e7b689432af5b42899e9d54cf7ce367985e414f9989", + "sha256_in_prefix": "84e562dc5c16bab7350a3e7b689432af5b42899e9d54cf7ce367985e414f9989", + "size_in_bytes": 2959 + }, + { + "_path": "site-packages/pygments/__main__.py", + "path_type": "hardlink", + "sha256": "c55ce4ef01bde24b2439f2d3e8e4575913d1659d0801abce7910ad1979f6c843", + "sha256_in_prefix": "c55ce4ef01bde24b2439f2d3e8e4575913d1659d0801abce7910ad1979f6c843", + "size_in_bytes": 348 + }, + { + "_path": "site-packages/pygments/cmdline.py", + "path_type": "hardlink", + "sha256": "e410eb29bfdc39cbf3a743ecf2baf8ac520ef2461bd792439448912a9a13c161", + "sha256_in_prefix": "e410eb29bfdc39cbf3a743ecf2baf8ac520ef2461bd792439448912a9a13c161", + "size_in_bytes": 23530 + }, + { + "_path": "site-packages/pygments/console.py", + "path_type": "hardlink", + "sha256": "db06795be53a4ee7490f5fcd2d4c237253296e898533dd6536fd75ffad2c7c66", + "sha256_in_prefix": "db06795be53a4ee7490f5fcd2d4c237253296e898533dd6536fd75ffad2c7c66", + "size_in_bytes": 1697 + }, + { + "_path": "site-packages/pygments/filter.py", + "path_type": "hardlink", + "sha256": "8f968b33d6bdc12c7a787d68cb8ef7a12909d3684658da6d065568e2cd60ff7d", + "sha256_in_prefix": "8f968b33d6bdc12c7a787d68cb8ef7a12909d3684658da6d065568e2cd60ff7d", + "size_in_bytes": 1938 + }, + { + "_path": "site-packages/pygments/filters/__init__.py", + "path_type": "hardlink", + "sha256": "abcafc19f2b774ed36d5348725da7037087a44729b00bedc782ce885abd668dd", + "sha256_in_prefix": "abcafc19f2b774ed36d5348725da7037087a44729b00bedc782ce885abd668dd", + "size_in_bytes": 40338 + }, + { + "_path": "site-packages/pygments/formatter.py", + "path_type": "hardlink", + "sha256": "633d35c93d4d4905d317c1afb0bc494a67b3ec4ad354eb319b733a1953ee1fec", + "sha256_in_prefix": "633d35c93d4d4905d317c1afb0bc494a67b3ec4ad354eb319b733a1953ee1fec", + "size_in_bytes": 4154 + }, + { + "_path": "site-packages/pygments/formatters/__init__.py", + "path_type": "hardlink", + "sha256": "d60005db5b7c1460290d7a43a71e5ba94d0caea23bc653c59cf320dae5e7d109", + "sha256_in_prefix": "d60005db5b7c1460290d7a43a71e5ba94d0caea23bc653c59cf320dae5e7d109", + "size_in_bytes": 5395 + }, + { + "_path": "site-packages/pygments/formatters/_mapping.py", + "path_type": "hardlink", + "sha256": "d42c37ec5b9094d69c9f144a9ad94f5f89f22e85fdfedb64a39670b1c354659e", + "sha256_in_prefix": "d42c37ec5b9094d69c9f144a9ad94f5f89f22e85fdfedb64a39670b1c354659e", + "size_in_bytes": 4176 + }, + { + "_path": "site-packages/pygments/formatters/bbcode.py", + "path_type": "hardlink", + "sha256": "ef370d727a0d8fe742c8996b1e79adab4576a3c6460f5e0de5a9c5578150e4f1", + "sha256_in_prefix": "ef370d727a0d8fe742c8996b1e79adab4576a3c6460f5e0de5a9c5578150e4f1", + "size_in_bytes": 3290 + }, + { + "_path": "site-packages/pygments/formatters/groff.py", + "path_type": "hardlink", + "sha256": "bdadb195208df9efe2d1cfc3cf4760dc757d023b7d1b8e4f5da0a2ec212c2dd8", + "sha256_in_prefix": "bdadb195208df9efe2d1cfc3cf4760dc757d023b7d1b8e4f5da0a2ec212c2dd8", + "size_in_bytes": 5070 + }, + { + "_path": "site-packages/pygments/formatters/html.py", + "path_type": "hardlink", + "sha256": "d4bd2a0616211e899ea835164394023dd69b841c23e482ff6e87ad42dad7b45e", + "sha256_in_prefix": "d4bd2a0616211e899ea835164394023dd69b841c23e482ff6e87ad42dad7b45e", + "size_in_bytes": 35640 + }, + { + "_path": "site-packages/pygments/formatters/img.py", + "path_type": "hardlink", + "sha256": "874ffbac1102322cf9625bb799cf380b9f4da908b272c65a9c13e087f8c9ba3a", + "sha256_in_prefix": "874ffbac1102322cf9625bb799cf380b9f4da908b272c65a9c13e087f8c9ba3a", + "size_in_bytes": 23116 + }, + { + "_path": "site-packages/pygments/formatters/irc.py", + "path_type": "hardlink", + "sha256": "264cdeef9ced6b222484d8a37e7148b2a39447e633e5fc0440cfe879674e9d15", + "sha256_in_prefix": "264cdeef9ced6b222484d8a37e7148b2a39447e633e5fc0440cfe879674e9d15", + "size_in_bytes": 4945 + }, + { + "_path": "site-packages/pygments/formatters/latex.py", + "path_type": "hardlink", + "sha256": "e3c80c6fcce2620c90549e0e7f1f31dca6b6974441a26818827e738de40afef3", + "sha256_in_prefix": "e3c80c6fcce2620c90549e0e7f1f31dca6b6974441a26818827e738de40afef3", + "size_in_bytes": 19303 + }, + { + "_path": "site-packages/pygments/formatters/other.py", + "path_type": "hardlink", + "sha256": "4732619577981f22f1882e6f112cb8d5650ad053aa24fc6f32247a5689f4cf94", + "sha256_in_prefix": "4732619577981f22f1882e6f112cb8d5650ad053aa24fc6f32247a5689f4cf94", + "size_in_bytes": 5025 + }, + { + "_path": "site-packages/pygments/formatters/pangomarkup.py", + "path_type": "hardlink", + "sha256": "d22e07ecd2ecc5cc73142254e4e3432668652efb122c29da167f855c0e523109", + "sha256_in_prefix": "d22e07ecd2ecc5cc73142254e4e3432668652efb122c29da167f855c0e523109", + "size_in_bytes": 2200 + }, + { + "_path": "site-packages/pygments/formatters/rtf.py", + "path_type": "hardlink", + "sha256": "f31821686301057ab65cd8fe656373600797fc6a880cca9406224b0c2ba5ccd2", + "sha256_in_prefix": "f31821686301057ab65cd8fe656373600797fc6a880cca9406224b0c2ba5ccd2", + "size_in_bytes": 4990 + }, + { + "_path": "site-packages/pygments/formatters/svg.py", + "path_type": "hardlink", + "sha256": "5718c4fa2a9aad05c9105462b2cb8b6eca285d40955d680e6d0edce2e6fee738", + "sha256_in_prefix": "5718c4fa2a9aad05c9105462b2cb8b6eca285d40955d680e6d0edce2e6fee738", + "size_in_bytes": 7299 + }, + { + "_path": "site-packages/pygments/formatters/terminal.py", + "path_type": "hardlink", + "sha256": "3ff76bec62f245320a83c2c471e08eaf9079786cc640110b03725038cbd9f150", + "sha256_in_prefix": "3ff76bec62f245320a83c2c471e08eaf9079786cc640110b03725038cbd9f150", + "size_in_bytes": 4626 + }, + { + "_path": "site-packages/pygments/formatters/terminal256.py", + "path_type": "hardlink", + "sha256": "ff162d3545130227b9061ed2f7c9ebb7b5c894b5144730f2928b0feed4fbd38e", + "sha256_in_prefix": "ff162d3545130227b9061ed2f7c9ebb7b5c894b5144730f2928b0feed4fbd38e", + "size_in_bytes": 11717 + }, + { + "_path": "site-packages/pygments/lexer.py", + "path_type": "hardlink", + "sha256": "72eec89179bfb2129d7e65d7ae52f26f14594bf451049a1a6cec1066a2cf50ee", + "sha256_in_prefix": "72eec89179bfb2129d7e65d7ae52f26f14594bf451049a1a6cec1066a2cf50ee", + "size_in_bytes": 35044 + }, + { + "_path": "site-packages/pygments/lexers/__init__.py", + "path_type": "hardlink", + "sha256": "b9db095dd79fca1c1451f8ac0b71366e35a1ddc00d4c4d195de5c188ab64f037", + "sha256_in_prefix": "b9db095dd79fca1c1451f8ac0b71366e35a1ddc00d4c4d195de5c188ab64f037", + "size_in_bytes": 12113 + }, + { + "_path": "site-packages/pygments/lexers/_ada_builtins.py", + "path_type": "hardlink", + "sha256": "6792224a976e81e294e07f9211ccd63d81ba10ed1ef91ee5c0feed85f391a285", + "sha256_in_prefix": "6792224a976e81e294e07f9211ccd63d81ba10ed1ef91ee5c0feed85f391a285", + "size_in_bytes": 1543 + }, + { + "_path": "site-packages/pygments/lexers/_asy_builtins.py", + "path_type": "hardlink", + "sha256": "aa7d4f9ae8a36743f9324775856987d5aad4b74df019647b40d65fec00817024", + "sha256_in_prefix": "aa7d4f9ae8a36743f9324775856987d5aad4b74df019647b40d65fec00817024", + "size_in_bytes": 27287 + }, + { + "_path": "site-packages/pygments/lexers/_cl_builtins.py", + "path_type": "hardlink", + "sha256": "9f46358de8bdb2cad9e7c12fe063310d3b29617539f13c8084b273040a4bb6d1", + "sha256_in_prefix": "9f46358de8bdb2cad9e7c12fe063310d3b29617539f13c8084b273040a4bb6d1", + "size_in_bytes": 13994 + }, + { + "_path": "site-packages/pygments/lexers/_cocoa_builtins.py", + "path_type": "hardlink", + "sha256": "2ef68fc1f8ccdabef7c89c1330dbb54a20cacd65aace12418cdfe48af9d8b32a", + "sha256_in_prefix": "2ef68fc1f8ccdabef7c89c1330dbb54a20cacd65aace12418cdfe48af9d8b32a", + "size_in_bytes": 105182 + }, + { + "_path": "site-packages/pygments/lexers/_csound_builtins.py", + "path_type": "hardlink", + "sha256": "218d87d0483c88115d996c1e7171b00c2e351a5af0fdb58b7a7402b69e831f38", + "sha256_in_prefix": "218d87d0483c88115d996c1e7171b00c2e351a5af0fdb58b7a7402b69e831f38", + "size_in_bytes": 18414 + }, + { + "_path": "site-packages/pygments/lexers/_css_builtins.py", + "path_type": "hardlink", + "sha256": "22e49557cf00f1bdfbf97b17185e3fe8fe971795afdf07774b160e4b57ce1b25", + "sha256_in_prefix": "22e49557cf00f1bdfbf97b17185e3fe8fe971795afdf07774b160e4b57ce1b25", + "size_in_bytes": 12446 + }, + { + "_path": "site-packages/pygments/lexers/_julia_builtins.py", + "path_type": "hardlink", + "sha256": "7afaef5098c028df1b09e068a17a807869d645cd2a06a1bf5b64cc44f5aaed0e", + "sha256_in_prefix": "7afaef5098c028df1b09e068a17a807869d645cd2a06a1bf5b64cc44f5aaed0e", + "size_in_bytes": 11883 + }, + { + "_path": "site-packages/pygments/lexers/_lasso_builtins.py", + "path_type": "hardlink", + "sha256": "f4b77cec2b31001f544d5efb23d5bab3f6efe29fa473682b3a773c130edccb7b", + "sha256_in_prefix": "f4b77cec2b31001f544d5efb23d5bab3f6efe29fa473682b3a773c130edccb7b", + "size_in_bytes": 134510 + }, + { + "_path": "site-packages/pygments/lexers/_lilypond_builtins.py", + "path_type": "hardlink", + "sha256": "ad598835062ade243dfb95bf8c6af05b843d397ff3117dfb23ea67e62f186b57", + "sha256_in_prefix": "ad598835062ade243dfb95bf8c6af05b843d397ff3117dfb23ea67e62f186b57", + "size_in_bytes": 108094 + }, + { + "_path": "site-packages/pygments/lexers/_lua_builtins.py", + "path_type": "hardlink", + "sha256": "c7c812389cc19703051fd5c5c70805d3ede4327d3ae984504cb27233f7e5db6b", + "sha256_in_prefix": "c7c812389cc19703051fd5c5c70805d3ede4327d3ae984504cb27233f7e5db6b", + "size_in_bytes": 8116 + }, + { + "_path": "site-packages/pygments/lexers/_mapping.py", + "path_type": "hardlink", + "sha256": "d820659686ca07d0eca3d91b91aabf2164ef0f767624eab1fc7b09ead04b0d76", + "sha256_in_prefix": "d820659686ca07d0eca3d91b91aabf2164ef0f767624eab1fc7b09ead04b0d76", + "size_in_bytes": 68026 + }, + { + "_path": "site-packages/pygments/lexers/_mql_builtins.py", + "path_type": "hardlink", + "sha256": "8f62b8b3761efed6047c913250ac6fa91de7b3f64e2c719a88f0e1906464e349", + "sha256_in_prefix": "8f62b8b3761efed6047c913250ac6fa91de7b3f64e2c719a88f0e1906464e349", + "size_in_bytes": 24713 + }, + { + "_path": "site-packages/pygments/lexers/_mysql_builtins.py", + "path_type": "hardlink", + "sha256": "f0ba8fb0cdfc47612dd54f2c83ea32d3d69e75bfa33b50e05469acb03530ea48", + "sha256_in_prefix": "f0ba8fb0cdfc47612dd54f2c83ea32d3d69e75bfa33b50e05469acb03530ea48", + "size_in_bytes": 25842 + }, + { + "_path": "site-packages/pygments/lexers/_openedge_builtins.py", + "path_type": "hardlink", + "sha256": "64ad15c23d0f7c2b60e56a4e5c2bc8d0e527a33acd6d0c58fc7341fc98405d07", + "sha256_in_prefix": "64ad15c23d0f7c2b60e56a4e5c2bc8d0e527a33acd6d0c58fc7341fc98405d07", + "size_in_bytes": 49398 + }, + { + "_path": "site-packages/pygments/lexers/_php_builtins.py", + "path_type": "hardlink", + "sha256": "9ecfc4d76c057b809edc43f7f01d034610278474eb761ed67e18e70d6827249e", + "sha256_in_prefix": "9ecfc4d76c057b809edc43f7f01d034610278474eb761ed67e18e70d6827249e", + "size_in_bytes": 107930 + }, + { + "_path": "site-packages/pygments/lexers/_postgres_builtins.py", + "path_type": "hardlink", + "sha256": "2d06f34dae4808fa93b297c193bff8255e9b923079973eeeb960143518fa5b81", + "sha256_in_prefix": "2d06f34dae4808fa93b297c193bff8255e9b923079973eeeb960143518fa5b81", + "size_in_bytes": 13355 + }, + { + "_path": "site-packages/pygments/lexers/_qlik_builtins.py", + "path_type": "hardlink", + "sha256": "cdcf9fabff265ec47f5d5cd31171518c66eec1d0022773bd42b3221067ee2b14", + "sha256_in_prefix": "cdcf9fabff265ec47f5d5cd31171518c66eec1d0022773bd42b3221067ee2b14", + "size_in_bytes": 12595 + }, + { + "_path": "site-packages/pygments/lexers/_scheme_builtins.py", + "path_type": "hardlink", + "sha256": "65d660ebe30aed9b76aaa3920544b90fd63350bb65248b94c6f937f6bf874cd7", + "sha256_in_prefix": "65d660ebe30aed9b76aaa3920544b90fd63350bb65248b94c6f937f6bf874cd7", + "size_in_bytes": 32564 + }, + { + "_path": "site-packages/pygments/lexers/_scilab_builtins.py", + "path_type": "hardlink", + "sha256": "89bfb06513b1b0a062f9cb0c565181147a730f3913d053e7db0659376f7ff51c", + "sha256_in_prefix": "89bfb06513b1b0a062f9cb0c565181147a730f3913d053e7db0659376f7ff51c", + "size_in_bytes": 52413 + }, + { + "_path": "site-packages/pygments/lexers/_sourcemod_builtins.py", + "path_type": "hardlink", + "sha256": "9d5d9970d4ef318ef1e284369e248d5755d31fd6e45db700b76f80e8e0ece799", + "sha256_in_prefix": "9d5d9970d4ef318ef1e284369e248d5755d31fd6e45db700b76f80e8e0ece799", + "size_in_bytes": 26781 + }, + { + "_path": "site-packages/pygments/lexers/_stan_builtins.py", + "path_type": "hardlink", + "sha256": "825fe9a34d6d9ef57fb468f7d63287a9a4a7c9b868c3d125bc58d8538bd6748b", + "sha256_in_prefix": "825fe9a34d6d9ef57fb468f7d63287a9a4a7c9b868c3d125bc58d8538bd6748b", + "size_in_bytes": 13445 + }, + { + "_path": "site-packages/pygments/lexers/_stata_builtins.py", + "path_type": "hardlink", + "sha256": "84818a22471a9507ad2303a8377d2e7e539881820e946de627a1fa7fcd9e76ba", + "sha256_in_prefix": "84818a22471a9507ad2303a8377d2e7e539881820e946de627a1fa7fcd9e76ba", + "size_in_bytes": 27227 + }, + { + "_path": "site-packages/pygments/lexers/_tsql_builtins.py", + "path_type": "hardlink", + "sha256": "c0329f0e47ed0148cf416d513e3030b1a2c4e9565e4c2c82cb6d73e38533ed57", + "sha256_in_prefix": "c0329f0e47ed0148cf416d513e3030b1a2c4e9565e4c2c82cb6d73e38533ed57", + "size_in_bytes": 15460 + }, + { + "_path": "site-packages/pygments/lexers/_usd_builtins.py", + "path_type": "hardlink", + "sha256": "1fb0181f391a8b3778985accb63bc8f75ddc5fd61d2b8aacf49ace94875c97b7", + "sha256_in_prefix": "1fb0181f391a8b3778985accb63bc8f75ddc5fd61d2b8aacf49ace94875c97b7", + "size_in_bytes": 1658 + }, + { + "_path": "site-packages/pygments/lexers/_vbscript_builtins.py", + "path_type": "hardlink", + "sha256": "121cc460893e0c122e534b0c83f75abd248bd70fa8dde9e54f54bdbb396365f3", + "sha256_in_prefix": "121cc460893e0c122e534b0c83f75abd248bd70fa8dde9e54f54bdbb396365f3", + "size_in_bytes": 4225 + }, + { + "_path": "site-packages/pygments/lexers/_vim_builtins.py", + "path_type": "hardlink", + "sha256": "046f76f4d0b2ea0dcb1e1a63f11fee7945aa2dbb88b74932089871475439489a", + "sha256_in_prefix": "046f76f4d0b2ea0dcb1e1a63f11fee7945aa2dbb88b74932089871475439489a", + "size_in_bytes": 57066 + }, + { + "_path": "site-packages/pygments/lexers/actionscript.py", + "path_type": "hardlink", + "sha256": "955af06d7d8e62737e28c19de23df2d33f9b58774dc430dc7fca5e14ca3dc761", + "sha256_in_prefix": "955af06d7d8e62737e28c19de23df2d33f9b58774dc430dc7fca5e14ca3dc761", + "size_in_bytes": 11676 + }, + { + "_path": "site-packages/pygments/lexers/ada.py", + "path_type": "hardlink", + "sha256": "dcf02f0d73cba6f9692c2492565de4d517013e6eccd8bcc8dd95353090cfa83e", + "sha256_in_prefix": "dcf02f0d73cba6f9692c2492565de4d517013e6eccd8bcc8dd95353090cfa83e", + "size_in_bytes": 5320 + }, + { + "_path": "site-packages/pygments/lexers/agile.py", + "path_type": "hardlink", + "sha256": "0b99b4eef22c0a2af6026aefd102b4021d476d372304e07031d17ec76affffa1", + "sha256_in_prefix": "0b99b4eef22c0a2af6026aefd102b4021d476d372304e07031d17ec76affffa1", + "size_in_bytes": 876 + }, + { + "_path": "site-packages/pygments/lexers/algebra.py", + "path_type": "hardlink", + "sha256": "d72a012faa47fea495add8378156cc27b1ee65bb2128bf8a8f9d26786dfb5cf9", + "sha256_in_prefix": "d72a012faa47fea495add8378156cc27b1ee65bb2128bf8a8f9d26786dfb5cf9", + "size_in_bytes": 9874 + }, + { + "_path": "site-packages/pygments/lexers/ambient.py", + "path_type": "hardlink", + "sha256": "bb7df7939992732ddc5140d0109771310bce117d7a6aaa537750e225e4d8cea1", + "sha256_in_prefix": "bb7df7939992732ddc5140d0109771310bce117d7a6aaa537750e225e4d8cea1", + "size_in_bytes": 2606 + }, + { + "_path": "site-packages/pygments/lexers/amdgpu.py", + "path_type": "hardlink", + "sha256": "7f8e98bf3575b03dde11f71d9116088e44b5613b47c95253e53d9ac0be3c765a", + "sha256_in_prefix": "7f8e98bf3575b03dde11f71d9116088e44b5613b47c95253e53d9ac0be3c765a", + "size_in_bytes": 1670 + }, + { + "_path": "site-packages/pygments/lexers/ampl.py", + "path_type": "hardlink", + "sha256": "95f1c0034646e03bf7f25e704d88ba2279575d727ae456972e3654d2d47fb16c", + "sha256_in_prefix": "95f1c0034646e03bf7f25e704d88ba2279575d727ae456972e3654d2d47fb16c", + "size_in_bytes": 4177 + }, + { + "_path": "site-packages/pygments/lexers/apdlexer.py", + "path_type": "hardlink", + "sha256": "11b82c96b58634560e6bc6be7cdf8f32fe3fa42bf729b768ed320737f0c25c08", + "sha256_in_prefix": "11b82c96b58634560e6bc6be7cdf8f32fe3fa42bf729b768ed320737f0c25c08", + "size_in_bytes": 30766 + }, + { + "_path": "site-packages/pygments/lexers/apl.py", + "path_type": "hardlink", + "sha256": "7f84302a97f332250f4570b399c05f37df535766152b2373674f44cb46ee6d87", + "sha256_in_prefix": "7f84302a97f332250f4570b399c05f37df535766152b2373674f44cb46ee6d87", + "size_in_bytes": 3405 + }, + { + "_path": "site-packages/pygments/lexers/archetype.py", + "path_type": "hardlink", + "sha256": "a69b34b643da2b554f25e3c98341f26867d34f0129029809faa83d309f5aeb21", + "sha256_in_prefix": "a69b34b643da2b554f25e3c98341f26867d34f0129029809faa83d309f5aeb21", + "size_in_bytes": 11469 + }, + { + "_path": "site-packages/pygments/lexers/arrow.py", + "path_type": "hardlink", + "sha256": "c2723717d668f47698226176a6092c768b32de1933b45c80e461b271bb50a083", + "sha256_in_prefix": "c2723717d668f47698226176a6092c768b32de1933b45c80e461b271bb50a083", + "size_in_bytes": 3565 + }, + { + "_path": "site-packages/pygments/lexers/arturo.py", + "path_type": "hardlink", + "sha256": "c08172b539d9024295b4756328ae452b65cb4627bf85cbfc612b356765001650", + "sha256_in_prefix": "c08172b539d9024295b4756328ae452b65cb4627bf85cbfc612b356765001650", + "size_in_bytes": 11417 + }, + { + "_path": "site-packages/pygments/lexers/asc.py", + "path_type": "hardlink", + "sha256": "35bd8f1d0656d77e75fafacb72d2115ffef4ce7871f0280693be72edbe1f8440", + "sha256_in_prefix": "35bd8f1d0656d77e75fafacb72d2115ffef4ce7871f0280693be72edbe1f8440", + "size_in_bytes": 1658 + }, + { + "_path": "site-packages/pygments/lexers/asm.py", + "path_type": "hardlink", + "sha256": "dac48f838b4b38fcd44d0a13021f292f9b566dd4bf2a6a904abf414d02d546dd", + "sha256_in_prefix": "dac48f838b4b38fcd44d0a13021f292f9b566dd4bf2a6a904abf414d02d546dd", + "size_in_bytes": 41243 + }, + { + "_path": "site-packages/pygments/lexers/asn1.py", + "path_type": "hardlink", + "sha256": "cf4d4d4e714f160574290c9d997bc502b8dc97e6cb0dff134639b71105f2fa45", + "sha256_in_prefix": "cf4d4d4e714f160574290c9d997bc502b8dc97e6cb0dff134639b71105f2fa45", + "size_in_bytes": 4263 + }, + { + "_path": "site-packages/pygments/lexers/automation.py", + "path_type": "hardlink", + "sha256": "6606a5edc292963d12687017c7df201e334cd6dbc25483b653292c785aae372e", + "sha256_in_prefix": "6606a5edc292963d12687017c7df201e334cd6dbc25483b653292c785aae372e", + "size_in_bytes": 19815 + }, + { + "_path": "site-packages/pygments/lexers/bare.py", + "path_type": "hardlink", + "sha256": "d16101c6ff854a0a30d51159cda5c6168d348b0925205e45a632590ce3966c3a", + "sha256_in_prefix": "d16101c6ff854a0a30d51159cda5c6168d348b0925205e45a632590ce3966c3a", + "size_in_bytes": 3021 + }, + { + "_path": "site-packages/pygments/lexers/basic.py", + "path_type": "hardlink", + "sha256": "73167ba0aabddb88fcfe00e894bfc80d5e0248ddaf5ca93a4bb0c8c365a54dcf", + "sha256_in_prefix": "73167ba0aabddb88fcfe00e894bfc80d5e0248ddaf5ca93a4bb0c8c365a54dcf", + "size_in_bytes": 27923 + }, + { + "_path": "site-packages/pygments/lexers/bdd.py", + "path_type": "hardlink", + "sha256": "26c03e5bffa820264aad94b58bb34d62b4660d155fde2b88d4fb9f51d3244215", + "sha256_in_prefix": "26c03e5bffa820264aad94b58bb34d62b4660d155fde2b88d4fb9f51d3244215", + "size_in_bytes": 1652 + }, + { + "_path": "site-packages/pygments/lexers/berry.py", + "path_type": "hardlink", + "sha256": "b30734118f9b11fd303455217ef76481698ff8f5d5f0f1af84d6a0aadb14aa60", + "sha256_in_prefix": "b30734118f9b11fd303455217ef76481698ff8f5d5f0f1af84d6a0aadb14aa60", + "size_in_bytes": 3211 + }, + { + "_path": "site-packages/pygments/lexers/bibtex.py", + "path_type": "hardlink", + "sha256": "8f3ba8f651191cf2b300032921e21690d4ebe48d4b3be4cc9f557d49dc874f5a", + "sha256_in_prefix": "8f3ba8f651191cf2b300032921e21690d4ebe48d4b3be4cc9f557d49dc874f5a", + "size_in_bytes": 4723 + }, + { + "_path": "site-packages/pygments/lexers/blueprint.py", + "path_type": "hardlink", + "sha256": "895c88d34810ef63c86e0ab65a49d5c4d39e09b45c232726db800788b139160d", + "sha256_in_prefix": "895c88d34810ef63c86e0ab65a49d5c4d39e09b45c232726db800788b139160d", + "size_in_bytes": 6189 + }, + { + "_path": "site-packages/pygments/lexers/boa.py", + "path_type": "hardlink", + "sha256": "6e2e5994f57ad577a1abc6e649d172aaddc13758c2d37a41e2de45a1ae2f28fc", + "sha256_in_prefix": "6e2e5994f57ad577a1abc6e649d172aaddc13758c2d37a41e2de45a1ae2f28fc", + "size_in_bytes": 3915 + }, + { + "_path": "site-packages/pygments/lexers/bqn.py", + "path_type": "hardlink", + "sha256": "7c9391a6aeb4521b56d0ddfc1a7998a80b2443f3ba419b5cfedc385dc6780f92", + "sha256_in_prefix": "7c9391a6aeb4521b56d0ddfc1a7998a80b2443f3ba419b5cfedc385dc6780f92", + "size_in_bytes": 3338 + }, + { + "_path": "site-packages/pygments/lexers/business.py", + "path_type": "hardlink", + "sha256": "f901d14d609d69b595f1221b299d682c7e4d437f9b9523c44bc8e321b12f0ff2", + "sha256_in_prefix": "f901d14d609d69b595f1221b299d682c7e4d437f9b9523c44bc8e321b12f0ff2", + "size_in_bytes": 28112 + }, + { + "_path": "site-packages/pygments/lexers/c_cpp.py", + "path_type": "hardlink", + "sha256": "d7b3bbb597e70c842a8e71446a31d572aa167f70a93fc2e85a5076c7c6afc061", + "sha256_in_prefix": "d7b3bbb597e70c842a8e71446a31d572aa167f70a93fc2e85a5076c7c6afc061", + "size_in_bytes": 17946 + }, + { + "_path": "site-packages/pygments/lexers/c_like.py", + "path_type": "hardlink", + "sha256": "b9639b5aac42e1df99cb2cc41b6c9a8ca660a6ae2220dc8072ac3b2cc9e7c595", + "sha256_in_prefix": "b9639b5aac42e1df99cb2cc41b6c9a8ca660a6ae2220dc8072ac3b2cc9e7c595", + "size_in_bytes": 29206 + }, + { + "_path": "site-packages/pygments/lexers/capnproto.py", + "path_type": "hardlink", + "sha256": "7c4df02bedd90733ec0da15ff44904d5d9c60d18496dc0aa8f2057466f06943e", + "sha256_in_prefix": "7c4df02bedd90733ec0da15ff44904d5d9c60d18496dc0aa8f2057466f06943e", + "size_in_bytes": 2175 + }, + { + "_path": "site-packages/pygments/lexers/carbon.py", + "path_type": "hardlink", + "sha256": "25a3b7b0f787f32299c23dfcb4252e8abcf57d217bd12d24a12aaed7f307f156", + "sha256_in_prefix": "25a3b7b0f787f32299c23dfcb4252e8abcf57d217bd12d24a12aaed7f307f156", + "size_in_bytes": 3222 + }, + { + "_path": "site-packages/pygments/lexers/cddl.py", + "path_type": "hardlink", + "sha256": "3d94baeb5d7ffe1637e8d663f27f50fff24c5cd2d29bf68c58ba42e756b173e3", + "sha256_in_prefix": "3d94baeb5d7ffe1637e8d663f27f50fff24c5cd2d29bf68c58ba42e756b173e3", + "size_in_bytes": 5182 + }, + { + "_path": "site-packages/pygments/lexers/chapel.py", + "path_type": "hardlink", + "sha256": "d6816dd21d1187b267176ab0d50b53d17ce451a9d5f976fd5e2f41f597076880", + "sha256_in_prefix": "d6816dd21d1187b267176ab0d50b53d17ce451a9d5f976fd5e2f41f597076880", + "size_in_bytes": 5157 + }, + { + "_path": "site-packages/pygments/lexers/clean.py", + "path_type": "hardlink", + "sha256": "69f25ed28ad4ed4c7fa669ab6d23583cbad30a463fcf43094e685406a3edc895", + "sha256_in_prefix": "69f25ed28ad4ed4c7fa669ab6d23583cbad30a463fcf43094e685406a3edc895", + "size_in_bytes": 6395 + }, + { + "_path": "site-packages/pygments/lexers/comal.py", + "path_type": "hardlink", + "sha256": "f48c317f154154c9fb523db1a3e582afb4612d10eb0deeb08d37408b98564f68", + "sha256_in_prefix": "f48c317f154154c9fb523db1a3e582afb4612d10eb0deeb08d37408b98564f68", + "size_in_bytes": 3156 + }, + { + "_path": "site-packages/pygments/lexers/compiled.py", + "path_type": "hardlink", + "sha256": "c6ff24ae0a0381dd3b4035d53da6b9ba2a75925f6d069ae4193d4ae7e0f08961", + "sha256_in_prefix": "c6ff24ae0a0381dd3b4035d53da6b9ba2a75925f6d069ae4193d4ae7e0f08961", + "size_in_bytes": 1407 + }, + { + "_path": "site-packages/pygments/lexers/configs.py", + "path_type": "hardlink", + "sha256": "18c3fc254078290eb9fdd1457f93f3e53c8d5c52397f5cd9b127aaf65ba3c99b", + "sha256_in_prefix": "18c3fc254078290eb9fdd1457f93f3e53c8d5c52397f5cd9b127aaf65ba3c99b", + "size_in_bytes": 50077 + }, + { + "_path": "site-packages/pygments/lexers/console.py", + "path_type": "hardlink", + "sha256": "d7b938360aecd04b1a260f74b9de9d95ef88d52be3a0e89827ec6e1a92deb132", + "sha256_in_prefix": "d7b938360aecd04b1a260f74b9de9d95ef88d52be3a0e89827ec6e1a92deb132", + "size_in_bytes": 4148 + }, + { + "_path": "site-packages/pygments/lexers/cplint.py", + "path_type": "hardlink", + "sha256": "1eb2ae8512a32be6adc3514a4ffceee0526394738ce41a69473a318ac5dba593", + "sha256_in_prefix": "1eb2ae8512a32be6adc3514a4ffceee0526394738ce41a69473a318ac5dba593", + "size_in_bytes": 1390 + }, + { + "_path": "site-packages/pygments/lexers/crystal.py", + "path_type": "hardlink", + "sha256": "af1c59a74137bffafd4ee5b07802e264eff820a206220e460898cfaba6707599", + "sha256_in_prefix": "af1c59a74137bffafd4ee5b07802e264eff820a206220e460898cfaba6707599", + "size_in_bytes": 15757 + }, + { + "_path": "site-packages/pygments/lexers/csound.py", + "path_type": "hardlink", + "sha256": "caece909d66e1c39abd9e68da1d8250eb0a05f55badb1b50be38ad9c79570bab", + "sha256_in_prefix": "caece909d66e1c39abd9e68da1d8250eb0a05f55badb1b50be38ad9c79570bab", + "size_in_bytes": 16994 + }, + { + "_path": "site-packages/pygments/lexers/css.py", + "path_type": "hardlink", + "sha256": "9592971125706516138e3464c81e1c6295e4f421dc57153f7a66f3151b4f8616", + "sha256_in_prefix": "9592971125706516138e3464c81e1c6295e4f421dc57153f7a66f3151b4f8616", + "size_in_bytes": 25322 + }, + { + "_path": "site-packages/pygments/lexers/d.py", + "path_type": "hardlink", + "sha256": "7f5745bf69805ea2ca489439f66ebabb5323f6eb377c3b24c65b65ac9f040663", + "sha256_in_prefix": "7f5745bf69805ea2ca489439f66ebabb5323f6eb377c3b24c65b65ac9f040663", + "size_in_bytes": 9875 + }, + { + "_path": "site-packages/pygments/lexers/dalvik.py", + "path_type": "hardlink", + "sha256": "d088bd2885164f91642642cab94707a073e16afe1e107aac5992f6fe290fd595", + "sha256_in_prefix": "d088bd2885164f91642642cab94707a073e16afe1e107aac5992f6fe290fd595", + "size_in_bytes": 4607 + }, + { + "_path": "site-packages/pygments/lexers/data.py", + "path_type": "hardlink", + "sha256": "8a0f030092b943c8642a88d0f518da58cb07f2388d6eecf0681693f8c61cf55a", + "sha256_in_prefix": "8a0f030092b943c8642a88d0f518da58cb07f2388d6eecf0681693f8c61cf55a", + "size_in_bytes": 27032 + }, + { + "_path": "site-packages/pygments/lexers/dax.py", + "path_type": "hardlink", + "sha256": "a1ddc3e737daaf223930ef7713f380f935297a401c8d7bfbde5ea4362b79ee82", + "sha256_in_prefix": "a1ddc3e737daaf223930ef7713f380f935297a401c8d7bfbde5ea4362b79ee82", + "size_in_bytes": 8099 + }, + { + "_path": "site-packages/pygments/lexers/devicetree.py", + "path_type": "hardlink", + "sha256": "e062a2b990b96d8c06fe0225df47d91fc555db3a3872ac1d7a642b420587ed94", + "sha256_in_prefix": "e062a2b990b96d8c06fe0225df47d91fc555db3a3872ac1d7a642b420587ed94", + "size_in_bytes": 4020 + }, + { + "_path": "site-packages/pygments/lexers/diff.py", + "path_type": "hardlink", + "sha256": "540c80151166c8c1fceb9ac4277ec8dd3a72ae92d4a04314f7976eaf0e872d17", + "sha256_in_prefix": "540c80151166c8c1fceb9ac4277ec8dd3a72ae92d4a04314f7976eaf0e872d17", + "size_in_bytes": 5278 + }, + { + "_path": "site-packages/pygments/lexers/dns.py", + "path_type": "hardlink", + "sha256": "fa5d57efe47700a0e27fae4922f2ff4dcfdd25d22368e06adfcfa141fd7b6568", + "sha256_in_prefix": "fa5d57efe47700a0e27fae4922f2ff4dcfdd25d22368e06adfcfa141fd7b6568", + "size_in_bytes": 3781 + }, + { + "_path": "site-packages/pygments/lexers/dotnet.py", + "path_type": "hardlink", + "sha256": "56325687bbec94c348a1074f14d525019234131b8b155e8476bcb061a223a905", + "sha256_in_prefix": "56325687bbec94c348a1074f14d525019234131b8b155e8476bcb061a223a905", + "size_in_bytes": 37623 + }, + { + "_path": "site-packages/pygments/lexers/dsls.py", + "path_type": "hardlink", + "sha256": "1553573fdf1fe5157e87faa20ad5beab29dfdd067e783e0db9da4963a70b895e", + "sha256_in_prefix": "1553573fdf1fe5157e87faa20ad5beab29dfdd067e783e0db9da4963a70b895e", + "size_in_bytes": 36786 + }, + { + "_path": "site-packages/pygments/lexers/dylan.py", + "path_type": "hardlink", + "sha256": "3dbae75d973da5aaa690e5498eca00c5fb39facd0c034f34573a22bb79d9ba6f", + "sha256_in_prefix": "3dbae75d973da5aaa690e5498eca00c5fb39facd0c034f34573a22bb79d9ba6f", + "size_in_bytes": 10319 + }, + { + "_path": "site-packages/pygments/lexers/ecl.py", + "path_type": "hardlink", + "sha256": "09ece5ead59ff9af213041147c9a9823710f7fab124b7911cf41a23ae1484386", + "sha256_in_prefix": "09ece5ead59ff9af213041147c9a9823710f7fab124b7911cf41a23ae1484386", + "size_in_bytes": 6372 + }, + { + "_path": "site-packages/pygments/lexers/eiffel.py", + "path_type": "hardlink", + "sha256": "3d7781171df14a26d3ad548303426a13fcac90b596ca79da2e9f4eec5579effe", + "sha256_in_prefix": "3d7781171df14a26d3ad548303426a13fcac90b596ca79da2e9f4eec5579effe", + "size_in_bytes": 2691 + }, + { + "_path": "site-packages/pygments/lexers/elm.py", + "path_type": "hardlink", + "sha256": "acaa440899930cd980419bba6025fdafe4c0a0fdefedaa4bd8745cbad1bace59", + "sha256_in_prefix": "acaa440899930cd980419bba6025fdafe4c0a0fdefedaa4bd8745cbad1bace59", + "size_in_bytes": 3153 + }, + { + "_path": "site-packages/pygments/lexers/elpi.py", + "path_type": "hardlink", + "sha256": "2e277ceb5ad634219fbfcdfd803f04d8910ff079213b480258658ab9cd2ca372", + "sha256_in_prefix": "2e277ceb5ad634219fbfcdfd803f04d8910ff079213b480258658ab9cd2ca372", + "size_in_bytes": 6710 + }, + { + "_path": "site-packages/pygments/lexers/email.py", + "path_type": "hardlink", + "sha256": "101dd8bd10c43fafc1e81d70cead2f4b8ff3ac15f9db37725f188d237287831b", + "sha256_in_prefix": "101dd8bd10c43fafc1e81d70cead2f4b8ff3ac15f9db37725f188d237287831b", + "size_in_bytes": 4742 + }, + { + "_path": "site-packages/pygments/lexers/erlang.py", + "path_type": "hardlink", + "sha256": "121171ff40fdc3ce4308947d172529ac53e2683bc9a6cdf1cbe2a7e30856723b", + "sha256_in_prefix": "121171ff40fdc3ce4308947d172529ac53e2683bc9a6cdf1cbe2a7e30856723b", + "size_in_bytes": 19170 + }, + { + "_path": "site-packages/pygments/lexers/esoteric.py", + "path_type": "hardlink", + "sha256": "57efb0d96f89ca5e3207c034d1fe068a455e6577bfe6558713444c9dfba82d36", + "sha256_in_prefix": "57efb0d96f89ca5e3207c034d1fe068a455e6577bfe6558713444c9dfba82d36", + "size_in_bytes": 10396 + }, + { + "_path": "site-packages/pygments/lexers/ezhil.py", + "path_type": "hardlink", + "sha256": "c6ef7030411255608b80d8ad492d084bce794d227761bd8a5c1af1998a87292a", + "sha256_in_prefix": "c6ef7030411255608b80d8ad492d084bce794d227761bd8a5c1af1998a87292a", + "size_in_bytes": 3273 + }, + { + "_path": "site-packages/pygments/lexers/factor.py", + "path_type": "hardlink", + "sha256": "89548865a4fbfaa008e35c0ffffa765e34d2c911014b2004acf2d518fe1b31e5", + "sha256_in_prefix": "89548865a4fbfaa008e35c0ffffa765e34d2c911014b2004acf2d518fe1b31e5", + "size_in_bytes": 19531 + }, + { + "_path": "site-packages/pygments/lexers/fantom.py", + "path_type": "hardlink", + "sha256": "d03ca550728278131f40ae107336af2f9ba0c8f4d5d2ee47d0b934613bfafe65", + "sha256_in_prefix": "d03ca550728278131f40ae107336af2f9ba0c8f4d5d2ee47d0b934613bfafe65", + "size_in_bytes": 10197 + }, + { + "_path": "site-packages/pygments/lexers/felix.py", + "path_type": "hardlink", + "sha256": "7c9b1dd2635a4b0923537dbed74dfef570f3cf3da58fe38d3e25bc264640ab13", + "sha256_in_prefix": "7c9b1dd2635a4b0923537dbed74dfef570f3cf3da58fe38d3e25bc264640ab13", + "size_in_bytes": 9646 + }, + { + "_path": "site-packages/pygments/lexers/fift.py", + "path_type": "hardlink", + "sha256": "2121f5d41bf3d7966c3234cc74b0ec1c5c761d88291b20d496f8b508df0c0bc4", + "sha256_in_prefix": "2121f5d41bf3d7966c3234cc74b0ec1c5c761d88291b20d496f8b508df0c0bc4", + "size_in_bytes": 1621 + }, + { + "_path": "site-packages/pygments/lexers/floscript.py", + "path_type": "hardlink", + "sha256": "5183c79766207b3ed17c13d3534d2150c5eb535d2607df7abf3eab162b00993b", + "sha256_in_prefix": "5183c79766207b3ed17c13d3534d2150c5eb535d2607df7abf3eab162b00993b", + "size_in_bytes": 2668 + }, + { + "_path": "site-packages/pygments/lexers/forth.py", + "path_type": "hardlink", + "sha256": "3f37d7921a6eb05206570af356ca8b8258e5c9b37dd8e794d3f137ac7ba9da6d", + "sha256_in_prefix": "3f37d7921a6eb05206570af356ca8b8258e5c9b37dd8e794d3f137ac7ba9da6d", + "size_in_bytes": 7194 + }, + { + "_path": "site-packages/pygments/lexers/fortran.py", + "path_type": "hardlink", + "sha256": "dc3024a1f5cd54fe71722e39022b16cb725adec9e1266ea58066b7a340674a4a", + "sha256_in_prefix": "dc3024a1f5cd54fe71722e39022b16cb725adec9e1266ea58066b7a340674a4a", + "size_in_bytes": 10346 + }, + { + "_path": "site-packages/pygments/lexers/foxpro.py", + "path_type": "hardlink", + "sha256": "5e655c5a0c3bd2f877d60ae2dcb85fac1d9843e4619149012a5cb4c47b7c550b", + "sha256_in_prefix": "5e655c5a0c3bd2f877d60ae2dcb85fac1d9843e4619149012a5cb4c47b7c550b", + "size_in_bytes": 26212 + }, + { + "_path": "site-packages/pygments/lexers/freefem.py", + "path_type": "hardlink", + "sha256": "7bf6238c766ef0fcd007290bce1a58d912478c29cbc67966a068fee518a73fa7", + "sha256_in_prefix": "7bf6238c766ef0fcd007290bce1a58d912478c29cbc67966a068fee518a73fa7", + "size_in_bytes": 26914 + }, + { + "_path": "site-packages/pygments/lexers/func.py", + "path_type": "hardlink", + "sha256": "87a20709dc9d58aa5071a982d570062636862be503be1f6233466e5902b4e5d4", + "sha256_in_prefix": "87a20709dc9d58aa5071a982d570062636862be503be1f6233466e5902b4e5d4", + "size_in_bytes": 3622 + }, + { + "_path": "site-packages/pygments/lexers/functional.py", + "path_type": "hardlink", + "sha256": "229bcf2a8991183a86b3f319663917e6788c1993bdb395f50e4d070f23bdcd63", + "sha256_in_prefix": "229bcf2a8991183a86b3f319663917e6788c1993bdb395f50e4d070f23bdcd63", + "size_in_bytes": 674 + }, + { + "_path": "site-packages/pygments/lexers/futhark.py", + "path_type": "hardlink", + "sha256": "3703582f14357de270b4f8c6e785664a6a3f66d713aad973af4410a699b15943", + "sha256_in_prefix": "3703582f14357de270b4f8c6e785664a6a3f66d713aad973af4410a699b15943", + "size_in_bytes": 3732 + }, + { + "_path": "site-packages/pygments/lexers/gcodelexer.py", + "path_type": "hardlink", + "sha256": "1fbe78b760ca92025817e9b39b8b88f5da9cd2a134d9f8e56597d73347a0e8b7", + "sha256_in_prefix": "1fbe78b760ca92025817e9b39b8b88f5da9cd2a134d9f8e56597d73347a0e8b7", + "size_in_bytes": 826 + }, + { + "_path": "site-packages/pygments/lexers/gdscript.py", + "path_type": "hardlink", + "sha256": "0c5bdff5e2602627390d41edda5ac992c4aee57e9e5d17eb877d2de720154b36", + "sha256_in_prefix": "0c5bdff5e2602627390d41edda5ac992c4aee57e9e5d17eb877d2de720154b36", + "size_in_bytes": 7543 + }, + { + "_path": "site-packages/pygments/lexers/go.py", + "path_type": "hardlink", + "sha256": "f034a0b139468d0d50906c34935158f07ceeafd07540e593200eb8daa6fd4476", + "sha256_in_prefix": "f034a0b139468d0d50906c34935158f07ceeafd07540e593200eb8daa6fd4476", + "size_in_bytes": 3784 + }, + { + "_path": "site-packages/pygments/lexers/grammar_notation.py", + "path_type": "hardlink", + "sha256": "48d40d8209a36020b4c913769b6affdf75f6a5af1bc340312c9b06d46e458dd4", + "sha256_in_prefix": "48d40d8209a36020b4c913769b6affdf75f6a5af1bc340312c9b06d46e458dd4", + "size_in_bytes": 7980 + }, + { + "_path": "site-packages/pygments/lexers/graph.py", + "path_type": "hardlink", + "sha256": "a0f5a76a2d436ceaa84bbc882aab82773673b40e9023c8fa475249fe00af244b", + "sha256_in_prefix": "a0f5a76a2d436ceaa84bbc882aab82773673b40e9023c8fa475249fe00af244b", + "size_in_bytes": 4109 + }, + { + "_path": "site-packages/pygments/lexers/graphics.py", + "path_type": "hardlink", + "sha256": "02a8737928e943093556b8ff393e6328324ca2707dd12af4d66337abdd161958", + "sha256_in_prefix": "02a8737928e943093556b8ff393e6328324ca2707dd12af4d66337abdd161958", + "size_in_bytes": 39026 + }, + { + "_path": "site-packages/pygments/lexers/graphql.py", + "path_type": "hardlink", + "sha256": "b301f79e71129201729de9c12438f3cca6922a438643dadb9be905b36f80bc83", + "sha256_in_prefix": "b301f79e71129201729de9c12438f3cca6922a438643dadb9be905b36f80bc83", + "size_in_bytes": 5602 + }, + { + "_path": "site-packages/pygments/lexers/graphviz.py", + "path_type": "hardlink", + "sha256": "ff225a476096fbeda58ef9cf74d8ec54ebe8b0fa14270d296f739fdf79d606d9", + "sha256_in_prefix": "ff225a476096fbeda58ef9cf74d8ec54ebe8b0fa14270d296f739fdf79d606d9", + "size_in_bytes": 1935 + }, + { + "_path": "site-packages/pygments/lexers/gsql.py", + "path_type": "hardlink", + "sha256": "ec60d6a355afb79526261002f0740d0f591b74e341444d5885d6b0073806ac70", + "sha256_in_prefix": "ec60d6a355afb79526261002f0740d0f591b74e341444d5885d6b0073806ac70", + "size_in_bytes": 3991 + }, + { + "_path": "site-packages/pygments/lexers/haskell.py", + "path_type": "hardlink", + "sha256": "46460487df9a9877914b4f9d539372cf844be0a289cf6ecfb1684da5ff82ecd0", + "sha256_in_prefix": "46460487df9a9877914b4f9d539372cf844be0a289cf6ecfb1684da5ff82ecd0", + "size_in_bytes": 32898 + }, + { + "_path": "site-packages/pygments/lexers/haxe.py", + "path_type": "hardlink", + "sha256": "5b820b955364d43e9448c6b62a4af4d0815aa2ab5423177970ef3fc56ce8db79", + "sha256_in_prefix": "5b820b955364d43e9448c6b62a4af4d0815aa2ab5423177970ef3fc56ce8db79", + "size_in_bytes": 30976 + }, + { + "_path": "site-packages/pygments/lexers/hdl.py", + "path_type": "hardlink", + "sha256": "c40e589f086068e4f3bcba44d5520ff23ee5e4b336163929b2c67231edec3ed6", + "sha256_in_prefix": "c40e589f086068e4f3bcba44d5520ff23ee5e4b336163929b2c67231edec3ed6", + "size_in_bytes": 22520 + }, + { + "_path": "site-packages/pygments/lexers/hexdump.py", + "path_type": "hardlink", + "sha256": "40bbd7cd69a8dbfc6a1cccb9e4e4d7501d790a893240b3331ef997bb0323eb3f", + "sha256_in_prefix": "40bbd7cd69a8dbfc6a1cccb9e4e4d7501d790a893240b3331ef997bb0323eb3f", + "size_in_bytes": 3603 + }, + { + "_path": "site-packages/pygments/lexers/html.py", + "path_type": "hardlink", + "sha256": "22f99b318bae1ec39d90e381bfb0d564bee8b8e34b7ddf5f56d8d1148080603d", + "sha256_in_prefix": "22f99b318bae1ec39d90e381bfb0d564bee8b8e34b7ddf5f56d8d1148080603d", + "size_in_bytes": 20260 + }, + { + "_path": "site-packages/pygments/lexers/idl.py", + "path_type": "hardlink", + "sha256": "6e14b8deeff270854df9dc652f4ae45435b42ae9eebf89c280c8b0e02ac45539", + "sha256_in_prefix": "6e14b8deeff270854df9dc652f4ae45435b42ae9eebf89c280c8b0e02ac45539", + "size_in_bytes": 15450 + }, + { + "_path": "site-packages/pygments/lexers/igor.py", + "path_type": "hardlink", + "sha256": "6057462c082aa129e9eb0a64db76f06e08fbb954916f2a86e2bdd7afb86df314", + "sha256_in_prefix": "6057462c082aa129e9eb0a64db76f06e08fbb954916f2a86e2bdd7afb86df314", + "size_in_bytes": 31658 + }, + { + "_path": "site-packages/pygments/lexers/inferno.py", + "path_type": "hardlink", + "sha256": "d29469a11ed6d4aa7cabff66c58e37ad8c3f45879fdebb89eb15752f061bcf70", + "sha256_in_prefix": "d29469a11ed6d4aa7cabff66c58e37ad8c3f45879fdebb89eb15752f061bcf70", + "size_in_bytes": 3136 + }, + { + "_path": "site-packages/pygments/lexers/installers.py", + "path_type": "hardlink", + "sha256": "e7f8e19735988bfe8b304afc067a5b8e0892719fc6dd0ec01fa7d31b85ab3d17", + "sha256_in_prefix": "e7f8e19735988bfe8b304afc067a5b8e0892719fc6dd0ec01fa7d31b85ab3d17", + "size_in_bytes": 13178 + }, + { + "_path": "site-packages/pygments/lexers/int_fiction.py", + "path_type": "hardlink", + "sha256": "0a4185acc3e2659e9a43ad3b138c9f6434dc629cf5a5dadb7786b3cb1ed7557f", + "sha256_in_prefix": "0a4185acc3e2659e9a43ad3b138c9f6434dc629cf5a5dadb7786b3cb1ed7557f", + "size_in_bytes": 57119 + }, + { + "_path": "site-packages/pygments/lexers/iolang.py", + "path_type": "hardlink", + "sha256": "89ea26fac73cc5d5db1e2e20e4b0e87ef2ddb8a65d54148e1305e870a9905368", + "sha256_in_prefix": "89ea26fac73cc5d5db1e2e20e4b0e87ef2ddb8a65d54148e1305e870a9905368", + "size_in_bytes": 1906 + }, + { + "_path": "site-packages/pygments/lexers/j.py", + "path_type": "hardlink", + "sha256": "29dd1181aff5bb053f6217d779bbc6b872a93973364951f4ff1fc2aa40895429", + "sha256_in_prefix": "29dd1181aff5bb053f6217d779bbc6b872a93973364951f4ff1fc2aa40895429", + "size_in_bytes": 4854 + }, + { + "_path": "site-packages/pygments/lexers/javascript.py", + "path_type": "hardlink", + "sha256": "cb8bdef6cda3ab851a4ebf4f86434444896ed83a5b3ff97ae0dfebd8924e055d", + "sha256_in_prefix": "cb8bdef6cda3ab851a4ebf4f86434444896ed83a5b3ff97ae0dfebd8924e055d", + "size_in_bytes": 62859 + }, + { + "_path": "site-packages/pygments/lexers/jmespath.py", + "path_type": "hardlink", + "sha256": "dcfe3f6105e1e08a28843421a21d29aaec85b941d577cf20eca6265588373683", + "sha256_in_prefix": "dcfe3f6105e1e08a28843421a21d29aaec85b941d577cf20eca6265588373683", + "size_in_bytes": 2059 + }, + { + "_path": "site-packages/pygments/lexers/jslt.py", + "path_type": "hardlink", + "sha256": "72f1f62c8b949e485aaa17d6be42234bbb12c761695d212f977ace178edde98d", + "sha256_in_prefix": "72f1f62c8b949e485aaa17d6be42234bbb12c761695d212f977ace178edde98d", + "size_in_bytes": 3701 + }, + { + "_path": "site-packages/pygments/lexers/jsonnet.py", + "path_type": "hardlink", + "sha256": "0a2253d344e9d25060f63ff5116f9debfa68ba6b47a0fd939844150e57f7713b", + "sha256_in_prefix": "0a2253d344e9d25060f63ff5116f9debfa68ba6b47a0fd939844150e57f7713b", + "size_in_bytes": 5635 + }, + { + "_path": "site-packages/pygments/lexers/jsx.py", + "path_type": "hardlink", + "sha256": "5c5439277554d58b3eca3c514eead41fe8187692247f84d5f3bcefb6c1f96fea", + "sha256_in_prefix": "5c5439277554d58b3eca3c514eead41fe8187692247f84d5f3bcefb6c1f96fea", + "size_in_bytes": 2234 + }, + { + "_path": "site-packages/pygments/lexers/julia.py", + "path_type": "hardlink", + "sha256": "179cee466ece49941e5759daee56acca91031ab78b03339d7da2a61f51c8c601", + "sha256_in_prefix": "179cee466ece49941e5759daee56acca91031ab78b03339d7da2a61f51c8c601", + "size_in_bytes": 11646 + }, + { + "_path": "site-packages/pygments/lexers/jvm.py", + "path_type": "hardlink", + "sha256": "9f246f205d76a13651994d2a0e180e431f00b14828663d73314f2d0c6c8e3fc5", + "sha256_in_prefix": "9f246f205d76a13651994d2a0e180e431f00b14828663d73314f2d0c6c8e3fc5", + "size_in_bytes": 72929 + }, + { + "_path": "site-packages/pygments/lexers/kuin.py", + "path_type": "hardlink", + "sha256": "01550377a240cb58c294861e4033dc57e3bbc467dbef1edfa2337b85bec03475", + "sha256_in_prefix": "01550377a240cb58c294861e4033dc57e3bbc467dbef1edfa2337b85bec03475", + "size_in_bytes": 11406 + }, + { + "_path": "site-packages/pygments/lexers/kusto.py", + "path_type": "hardlink", + "sha256": "26a936c71d2f55f65ae6e16ae4a19981445e67b147850e47bd3e817911b39a78", + "sha256_in_prefix": "26a936c71d2f55f65ae6e16ae4a19981445e67b147850e47bd3e817911b39a78", + "size_in_bytes": 3478 + }, + { + "_path": "site-packages/pygments/lexers/ldap.py", + "path_type": "hardlink", + "sha256": "54203438a93306ebd22873a917d4af940f02d6d7d1bda86ed0c361cfee0ba414", + "sha256_in_prefix": "54203438a93306ebd22873a917d4af940f02d6d7d1bda86ed0c361cfee0ba414", + "size_in_bytes": 6553 + }, + { + "_path": "site-packages/pygments/lexers/lean.py", + "path_type": "hardlink", + "sha256": "f14c619e071ae7b367269d4909a6c457107a49483341511410c9a69666dcf174", + "sha256_in_prefix": "f14c619e071ae7b367269d4909a6c457107a49483341511410c9a69666dcf174", + "size_in_bytes": 4297 + }, + { + "_path": "site-packages/pygments/lexers/lilypond.py", + "path_type": "hardlink", + "sha256": "fc0e4fecf6884cff023971bc772f674bb0b37dd298d9439ed572c6b6e72e8a9e", + "sha256_in_prefix": "fc0e4fecf6884cff023971bc772f674bb0b37dd298d9439ed572c6b6e72e8a9e", + "size_in_bytes": 9753 + }, + { + "_path": "site-packages/pygments/lexers/lisp.py", + "path_type": "hardlink", + "sha256": "2e4bae740d4ff5c651cc6a95df40bee5889c02b2e83fd50806e9741e27f8d6fe", + "sha256_in_prefix": "2e4bae740d4ff5c651cc6a95df40bee5889c02b2e83fd50806e9741e27f8d6fe", + "size_in_bytes": 144398 + }, + { + "_path": "site-packages/pygments/lexers/macaulay2.py", + "path_type": "hardlink", + "sha256": "684745ce3acfed15cfe4171103739089cf78ba686fab5b86c5414cbb9382eca3", + "sha256_in_prefix": "684745ce3acfed15cfe4171103739089cf78ba686fab5b86c5414cbb9382eca3", + "size_in_bytes": 32171 + }, + { + "_path": "site-packages/pygments/lexers/make.py", + "path_type": "hardlink", + "sha256": "ad660ca30139cc5ea6600dd5ac9849f92fe7db5e3e3ad59e5dd8c90ca8d70289", + "sha256_in_prefix": "ad660ca30139cc5ea6600dd5ac9849f92fe7db5e3e3ad59e5dd8c90ca8d70289", + "size_in_bytes": 7694 + }, + { + "_path": "site-packages/pygments/lexers/markup.py", + "path_type": "hardlink", + "sha256": "b102e490a4ba778d057b8df3faf151d9bbd6b8d4c9bee279e05f8564a920ccda", + "sha256_in_prefix": "b102e490a4ba778d057b8df3faf151d9bbd6b8d4c9bee279e05f8564a920ccda", + "size_in_bytes": 60257 + }, + { + "_path": "site-packages/pygments/lexers/math.py", + "path_type": "hardlink", + "sha256": "5a5ea55355567afb505f29adea37437aecfd2c43223ca9753a7dd99b741743c3", + "sha256_in_prefix": "5a5ea55355567afb505f29adea37437aecfd2c43223ca9753a7dd99b741743c3", + "size_in_bytes": 676 + }, + { + "_path": "site-packages/pygments/lexers/matlab.py", + "path_type": "hardlink", + "sha256": "5a9946e7bf3f981eac1e50c37e063cdd231a74272a0ffb0de496f9f77ad2afac", + "sha256_in_prefix": "5a9946e7bf3f981eac1e50c37e063cdd231a74272a0ffb0de496f9f77ad2afac", + "size_in_bytes": 132852 + }, + { + "_path": "site-packages/pygments/lexers/maxima.py", + "path_type": "hardlink", + "sha256": "b4b4a378320164a1d1a0c96e76017ba01773d714c01f2bc8106e81b21c815f23", + "sha256_in_prefix": "b4b4a378320164a1d1a0c96e76017ba01773d714c01f2bc8106e81b21c815f23", + "size_in_bytes": 2716 + }, + { + "_path": "site-packages/pygments/lexers/meson.py", + "path_type": "hardlink", + "sha256": "8a3d0281b1142dfa8b31c63f050ecfc660b058e60b73d5d9c2dac02c54a29c40", + "sha256_in_prefix": "8a3d0281b1142dfa8b31c63f050ecfc660b058e60b73d5d9c2dac02c54a29c40", + "size_in_bytes": 4337 + }, + { + "_path": "site-packages/pygments/lexers/mime.py", + "path_type": "hardlink", + "sha256": "fb08f7a6f010ccd4c2f1f4d993d015e10f8b21084c52871eb7e8f692a1a3e60b", + "sha256_in_prefix": "fb08f7a6f010ccd4c2f1f4d993d015e10f8b21084c52871eb7e8f692a1a3e60b", + "size_in_bytes": 7538 + }, + { + "_path": "site-packages/pygments/lexers/minecraft.py", + "path_type": "hardlink", + "sha256": "86de505e8aedfd987defc26d5bc14579d668860e6fbecd1085f82d9c0a1325bc", + "sha256_in_prefix": "86de505e8aedfd987defc26d5bc14579d668860e6fbecd1085f82d9c0a1325bc", + "size_in_bytes": 13810 + }, + { + "_path": "site-packages/pygments/lexers/mips.py", + "path_type": "hardlink", + "sha256": "2417ef38fa791d31a9e9bd24ca7923cee24e4d101d4ec2497633d62c0b6ed5fa", + "sha256_in_prefix": "2417ef38fa791d31a9e9bd24ca7923cee24e4d101d4ec2497633d62c0b6ed5fa", + "size_in_bytes": 4604 + }, + { + "_path": "site-packages/pygments/lexers/ml.py", + "path_type": "hardlink", + "sha256": "69c32aafd56a57fefdfa8f2bae573c3d265861cd509b2a25a377f5f15c7cd628", + "sha256_in_prefix": "69c32aafd56a57fefdfa8f2bae573c3d265861cd509b2a25a377f5f15c7cd628", + "size_in_bytes": 35315 + }, + { + "_path": "site-packages/pygments/lexers/modeling.py", + "path_type": "hardlink", + "sha256": "dcac6e22cd7e95bfc537ddb59020a08eaf3847af404c4a7a2b5110c966b1a7b3", + "sha256_in_prefix": "dcac6e22cd7e95bfc537ddb59020a08eaf3847af404c4a7a2b5110c966b1a7b3", + "size_in_bytes": 13524 + }, + { + "_path": "site-packages/pygments/lexers/modula2.py", + "path_type": "hardlink", + "sha256": "cfee106c6e0182377ed0e342f5269d825a825b642620c97eeb46ff9f7e55fbbd", + "sha256_in_prefix": "cfee106c6e0182377ed0e342f5269d825a825b642620c97eeb46ff9f7e55fbbd", + "size_in_bytes": 53073 + }, + { + "_path": "site-packages/pygments/lexers/monte.py", + "path_type": "hardlink", + "sha256": "a4a3ca3a4c31706cc92d58ac03e1fbc49256f49521d92b17c838b7da61799d24", + "sha256_in_prefix": "a4a3ca3a4c31706cc92d58ac03e1fbc49256f49521d92b17c838b7da61799d24", + "size_in_bytes": 6290 + }, + { + "_path": "site-packages/pygments/lexers/mosel.py", + "path_type": "hardlink", + "sha256": "fc979a68ae499f4afb25cb8b97adaed6c97ab889e4acff60e04a2c09ff59f884", + "sha256_in_prefix": "fc979a68ae499f4afb25cb8b97adaed6c97ab889e4acff60e04a2c09ff59f884", + "size_in_bytes": 9187 + }, + { + "_path": "site-packages/pygments/lexers/ncl.py", + "path_type": "hardlink", + "sha256": "3ba09c93253cc8004a9b1f319a3e2ae84da2b163919af34eed7975257e4dc154", + "sha256_in_prefix": "3ba09c93253cc8004a9b1f319a3e2ae84da2b163919af34eed7975257e4dc154", + "size_in_bytes": 63962 + }, + { + "_path": "site-packages/pygments/lexers/nimrod.py", + "path_type": "hardlink", + "sha256": "3bff1dc64f71def95814f623a5ef22a90702adc666367044fcb7759733bbc552", + "sha256_in_prefix": "3bff1dc64f71def95814f623a5ef22a90702adc666367044fcb7759733bbc552", + "size_in_bytes": 6416 + }, + { + "_path": "site-packages/pygments/lexers/nit.py", + "path_type": "hardlink", + "sha256": "1a18dafc05fc0c883f280fab9af8262fbea4648fa5ab7a4044c89e6d88bd36ac", + "sha256_in_prefix": "1a18dafc05fc0c883f280fab9af8262fbea4648fa5ab7a4044c89e6d88bd36ac", + "size_in_bytes": 2726 + }, + { + "_path": "site-packages/pygments/lexers/nix.py", + "path_type": "hardlink", + "sha256": "275866fabe0d583fcb7c490220e66abef1355215c1445db3262eb439ac684bfa", + "sha256_in_prefix": "275866fabe0d583fcb7c490220e66abef1355215c1445db3262eb439ac684bfa", + "size_in_bytes": 4398 + }, + { + "_path": "site-packages/pygments/lexers/oberon.py", + "path_type": "hardlink", + "sha256": "2e0620cc63eeb3bc359492d402ed9c9884501848108a2777e101f95296bb52ba", + "sha256_in_prefix": "2e0620cc63eeb3bc359492d402ed9c9884501848108a2777e101f95296bb52ba", + "size_in_bytes": 4169 + }, + { + "_path": "site-packages/pygments/lexers/objective.py", + "path_type": "hardlink", + "sha256": "56851e6586b568ee6b53af5d0e9bf839be45398cabde79be789de6d24bad8b45", + "sha256_in_prefix": "56851e6586b568ee6b53af5d0e9bf839be45398cabde79be789de6d24bad8b45", + "size_in_bytes": 22961 + }, + { + "_path": "site-packages/pygments/lexers/ooc.py", + "path_type": "hardlink", + "sha256": "0448fb91f3a2985fd08bad91f81f1b9981b2ff94081358d2db435fae7344f52b", + "sha256_in_prefix": "0448fb91f3a2985fd08bad91f81f1b9981b2ff94081358d2db435fae7344f52b", + "size_in_bytes": 2982 + }, + { + "_path": "site-packages/pygments/lexers/openscad.py", + "path_type": "hardlink", + "sha256": "245e1c524eab02c1fd0655c376475731294a6a3a6086d3a6d0dcbe422928899d", + "sha256_in_prefix": "245e1c524eab02c1fd0655c376475731294a6a3a6086d3a6d0dcbe422928899d", + "size_in_bytes": 3701 + }, + { + "_path": "site-packages/pygments/lexers/other.py", + "path_type": "hardlink", + "sha256": "a1756d4c42c23c5c70b89c4de63fe262bb7443d0289eaf86928b6771414fa5e1", + "sha256_in_prefix": "a1756d4c42c23c5c70b89c4de63fe262bb7443d0289eaf86928b6771414fa5e1", + "size_in_bytes": 1744 + }, + { + "_path": "site-packages/pygments/lexers/parasail.py", + "path_type": "hardlink", + "sha256": "3313b8d0e4e0ff9cff1273326fac1e4078e1b732f55a04b07e3097734ce5f366", + "sha256_in_prefix": "3313b8d0e4e0ff9cff1273326fac1e4078e1b732f55a04b07e3097734ce5f366", + "size_in_bytes": 2720 + }, + { + "_path": "site-packages/pygments/lexers/parsers.py", + "path_type": "hardlink", + "sha256": "262413dc832c7f67f424b6e20e9ba964d4ac1e73141f9ecea00af40ffdc0bdb6", + "sha256_in_prefix": "262413dc832c7f67f424b6e20e9ba964d4ac1e73141f9ecea00af40ffdc0bdb6", + "size_in_bytes": 25904 + }, + { + "_path": "site-packages/pygments/lexers/pascal.py", + "path_type": "hardlink", + "sha256": "107662fe687857b2ee197b5c6d3427aeb7ea0c35dc1b25700ef26637c5d1729b", + "sha256_in_prefix": "107662fe687857b2ee197b5c6d3427aeb7ea0c35dc1b25700ef26637c5d1729b", + "size_in_bytes": 30880 + }, + { + "_path": "site-packages/pygments/lexers/pawn.py", + "path_type": "hardlink", + "sha256": "7cdabbdd5c10a1778a89114a6082b3cce0a57146f678b3c9221ca6967c4a6658", + "sha256_in_prefix": "7cdabbdd5c10a1778a89114a6082b3cce0a57146f678b3c9221ca6967c4a6658", + "size_in_bytes": 8146 + }, + { + "_path": "site-packages/pygments/lexers/perl.py", + "path_type": "hardlink", + "sha256": "f36ffbb1a691dea0459529d663212d922afbbaf5d379466a1548637647534d7b", + "sha256_in_prefix": "f36ffbb1a691dea0459529d663212d922afbbaf5d379466a1548637647534d7b", + "size_in_bytes": 39170 + }, + { + "_path": "site-packages/pygments/lexers/phix.py", + "path_type": "hardlink", + "sha256": "e3c24440aff48a38e2a700e5d45fa293407f08650cb193af5e5bd7cc8a875669", + "sha256_in_prefix": "e3c24440aff48a38e2a700e5d45fa293407f08650cb193af5e5bd7cc8a875669", + "size_in_bytes": 23252 + }, + { + "_path": "site-packages/pygments/lexers/php.py", + "path_type": "hardlink", + "sha256": "6f8b155994ccab4b7618c95a166cd85899daf56b83405226faf76a5e46fcf71a", + "sha256_in_prefix": "6f8b155994ccab4b7618c95a166cd85899daf56b83405226faf76a5e46fcf71a", + "size_in_bytes": 13040 + }, + { + "_path": "site-packages/pygments/lexers/pointless.py", + "path_type": "hardlink", + "sha256": "7540139585546646e0810e8f5329832a107450aa83a3e2827f4169fc48d6b133", + "sha256_in_prefix": "7540139585546646e0810e8f5329832a107450aa83a3e2827f4169fc48d6b133", + "size_in_bytes": 1975 + }, + { + "_path": "site-packages/pygments/lexers/pony.py", + "path_type": "hardlink", + "sha256": "934dc30214befc6f1266c7d764e8c5e5891068c436f3fbb2ebcfc231ac6e502e", + "sha256_in_prefix": "934dc30214befc6f1266c7d764e8c5e5891068c436f3fbb2ebcfc231ac6e502e", + "size_in_bytes": 3244 + }, + { + "_path": "site-packages/pygments/lexers/praat.py", + "path_type": "hardlink", + "sha256": "ad3979192a09e7c2d0c517ff124d00d47e220a6d885501711304af6cc922eedc", + "sha256_in_prefix": "ad3979192a09e7c2d0c517ff124d00d47e220a6d885501711304af6cc922eedc", + "size_in_bytes": 12677 + }, + { + "_path": "site-packages/pygments/lexers/procfile.py", + "path_type": "hardlink", + "sha256": "9da41971dbf15548d3e7a47453afd8a6034281f98d13d5e3cf1f6e41eb25f828", + "sha256_in_prefix": "9da41971dbf15548d3e7a47453afd8a6034281f98d13d5e3cf1f6e41eb25f828", + "size_in_bytes": 1156 + }, + { + "_path": "site-packages/pygments/lexers/prolog.py", + "path_type": "hardlink", + "sha256": "4f35a44988f153ee490059789e0de4b0035bc8c22f0f25d6751e484ac05968ab", + "sha256_in_prefix": "4f35a44988f153ee490059789e0de4b0035bc8c22f0f25d6751e484ac05968ab", + "size_in_bytes": 12506 + }, + { + "_path": "site-packages/pygments/lexers/promql.py", + "path_type": "hardlink", + "sha256": "430d155c8246464c3a6624b3bed47428589698fbb223dc715e00e5fe5ddc1e67", + "sha256_in_prefix": "430d155c8246464c3a6624b3bed47428589698fbb223dc715e00e5fe5ddc1e67", + "size_in_bytes": 4715 + }, + { + "_path": "site-packages/pygments/lexers/prql.py", + "path_type": "hardlink", + "sha256": "317935bf43effb368355664755fdd1bc364d3e323ae4f17eb3b6b485452b5705", + "sha256_in_prefix": "317935bf43effb368355664755fdd1bc364d3e323ae4f17eb3b6b485452b5705", + "size_in_bytes": 8748 + }, + { + "_path": "site-packages/pygments/lexers/ptx.py", + "path_type": "hardlink", + "sha256": "c2ce608469ad4cb689db36a65948b109b764cdb8e7c5dc19c88e2dde682b7528", + "sha256_in_prefix": "c2ce608469ad4cb689db36a65948b109b764cdb8e7c5dc19c88e2dde682b7528", + "size_in_bytes": 4502 + }, + { + "_path": "site-packages/pygments/lexers/python.py", + "path_type": "hardlink", + "sha256": "7e9fa972f4bb29027bfe9c586e7e2cd0e34f14e15c584451c381767be08ffc0d", + "sha256_in_prefix": "7e9fa972f4bb29027bfe9c586e7e2cd0e34f14e15c584451c381767be08ffc0d", + "size_in_bytes": 53400 + }, + { + "_path": "site-packages/pygments/lexers/q.py", + "path_type": "hardlink", + "sha256": "570dfac7aac8a765356fc194b546cc95c0f4315a96dee9c264430112df8f7e54", + "sha256_in_prefix": "570dfac7aac8a765356fc194b546cc95c0f4315a96dee9c264430112df8f7e54", + "size_in_bytes": 6932 + }, + { + "_path": "site-packages/pygments/lexers/qlik.py", + "path_type": "hardlink", + "sha256": "80201009ed53bb2fdc308e27e7549bf1f1b9d0bef702099430458c9994477898", + "sha256_in_prefix": "80201009ed53bb2fdc308e27e7549bf1f1b9d0bef702099430458c9994477898", + "size_in_bytes": 3665 + }, + { + "_path": "site-packages/pygments/lexers/qvt.py", + "path_type": "hardlink", + "sha256": "2231f2a29903a1c86542dfdf21feccaf1c3ce29220fa08f80640c7b4488a6ff5", + "sha256_in_prefix": "2231f2a29903a1c86542dfdf21feccaf1c3ce29220fa08f80640c7b4488a6ff5", + "size_in_bytes": 6072 + }, + { + "_path": "site-packages/pygments/lexers/r.py", + "path_type": "hardlink", + "sha256": "c4c48da4d3771e6d16e75f9311fbf33de386b686ccda7223195988a15c9d95f5", + "sha256_in_prefix": "c4c48da4d3771e6d16e75f9311fbf33de386b686ccda7223195988a15c9d95f5", + "size_in_bytes": 6185 + }, + { + "_path": "site-packages/pygments/lexers/rdf.py", + "path_type": "hardlink", + "sha256": "44d20126104a330a71947cc5da99ca24f5283a36e23e6a056436a30dde264b31", + "sha256_in_prefix": "44d20126104a330a71947cc5da99ca24f5283a36e23e6a056436a30dde264b31", + "size_in_bytes": 15981 + }, + { + "_path": "site-packages/pygments/lexers/rebol.py", + "path_type": "hardlink", + "sha256": "4cc4f72655e85af25b67065d2ee7a4c20bf9f381c43f599fb03da0f4eaa3d085", + "sha256_in_prefix": "4cc4f72655e85af25b67065d2ee7a4c20bf9f381c43f599fb03da0f4eaa3d085", + "size_in_bytes": 18248 + }, + { + "_path": "site-packages/pygments/lexers/resource.py", + "path_type": "hardlink", + "sha256": "2b1c50262f4d3e6821a5ad667a4c5414177c79a89207da55fc5e0476ce242b49", + "sha256_in_prefix": "2b1c50262f4d3e6821a5ad667a4c5414177c79a89207da55fc5e0476ce242b49", + "size_in_bytes": 2902 + }, + { + "_path": "site-packages/pygments/lexers/ride.py", + "path_type": "hardlink", + "sha256": "d264fcf6896ea33e65513f1aafab8f892c13201c3231cea81d89eb339418ed5a", + "sha256_in_prefix": "d264fcf6896ea33e65513f1aafab8f892c13201c3231cea81d89eb339418ed5a", + "size_in_bytes": 5056 + }, + { + "_path": "site-packages/pygments/lexers/rita.py", + "path_type": "hardlink", + "sha256": "80f6cc8650b24bf7a4cd720a6e85c6126b46665492531d24eaa72e5841ee33ab", + "sha256_in_prefix": "80f6cc8650b24bf7a4cd720a6e85c6126b46665492531d24eaa72e5841ee33ab", + "size_in_bytes": 1128 + }, + { + "_path": "site-packages/pygments/lexers/rnc.py", + "path_type": "hardlink", + "sha256": "4a35ca2563627d34d6402f4d95c58d99d864967d11104a44bda63a9d5cba9f8c", + "sha256_in_prefix": "4a35ca2563627d34d6402f4d95c58d99d864967d11104a44bda63a9d5cba9f8c", + "size_in_bytes": 1973 + }, + { + "_path": "site-packages/pygments/lexers/roboconf.py", + "path_type": "hardlink", + "sha256": "1d8d1d48f27183b92743e70ce98a2d5fc128563b908be2de29829e5a943217de", + "sha256_in_prefix": "1d8d1d48f27183b92743e70ce98a2d5fc128563b908be2de29829e5a943217de", + "size_in_bytes": 1962 + }, + { + "_path": "site-packages/pygments/lexers/robotframework.py", + "path_type": "hardlink", + "sha256": "309e1c9d40d9583ad70a9622fa424ba9ed47a73276e0332d36cc037ae4a75427", + "sha256_in_prefix": "309e1c9d40d9583ad70a9622fa424ba9ed47a73276e0332d36cc037ae4a75427", + "size_in_bytes": 18449 + }, + { + "_path": "site-packages/pygments/lexers/ruby.py", + "path_type": "hardlink", + "sha256": "f4e7b1b7d6eac02ec4e121377c00782dd77dffd4dbabb0f80fde11400fbc6dc7", + "sha256_in_prefix": "f4e7b1b7d6eac02ec4e121377c00782dd77dffd4dbabb0f80fde11400fbc6dc7", + "size_in_bytes": 22672 + }, + { + "_path": "site-packages/pygments/lexers/rust.py", + "path_type": "hardlink", + "sha256": "3aae5b1607ff85c38bc6204b8733c0ad4157820dd475eff1a5e28f0b783e1c32", + "sha256_in_prefix": "3aae5b1607ff85c38bc6204b8733c0ad4157820dd475eff1a5e28f0b783e1c32", + "size_in_bytes": 8216 + }, + { + "_path": "site-packages/pygments/lexers/sas.py", + "path_type": "hardlink", + "sha256": "bb4be43cb7a15fb50446c288928a02e081497537f8e0bdbf42a769c750deef09", + "sha256_in_prefix": "bb4be43cb7a15fb50446c288928a02e081497537f8e0bdbf42a769c750deef09", + "size_in_bytes": 9400 + }, + { + "_path": "site-packages/pygments/lexers/savi.py", + "path_type": "hardlink", + "sha256": "dc0e7adc1f96ce9e401991b4aee49088f6def9cdee606c023d49a73c948428e9", + "sha256_in_prefix": "dc0e7adc1f96ce9e401991b4aee49088f6def9cdee606c023d49a73c948428e9", + "size_in_bytes": 4645 + }, + { + "_path": "site-packages/pygments/lexers/scdoc.py", + "path_type": "hardlink", + "sha256": "fd4292e55659e1e695a71992afa2ff3fc3abf2002df662265f81d6bb0d531a5a", + "sha256_in_prefix": "fd4292e55659e1e695a71992afa2ff3fc3abf2002df662265f81d6bb0d531a5a", + "size_in_bytes": 2525 + }, + { + "_path": "site-packages/pygments/lexers/scripting.py", + "path_type": "hardlink", + "sha256": "1245cacd62e0fa3a6c57cadea76616e9f0ec083cfe7777d8d6abf541513b308f", + "sha256_in_prefix": "1245cacd62e0fa3a6c57cadea76616e9f0ec083cfe7777d8d6abf541513b308f", + "size_in_bytes": 70014 + }, + { + "_path": "site-packages/pygments/lexers/sgf.py", + "path_type": "hardlink", + "sha256": "39add234bdf5c0df2b858d206f2eb591b3f1b6dbd14094d1377f0248c5223091", + "sha256_in_prefix": "39add234bdf5c0df2b858d206f2eb591b3f1b6dbd14094d1377f0248c5223091", + "size_in_bytes": 1986 + }, + { + "_path": "site-packages/pygments/lexers/shell.py", + "path_type": "hardlink", + "sha256": "a02d75e433661333d83dd28de63354cfe815e3873fa956f663939f18ede043f5", + "sha256_in_prefix": "a02d75e433661333d83dd28de63354cfe815e3873fa956f663939f18ede043f5", + "size_in_bytes": 36466 + }, + { + "_path": "site-packages/pygments/lexers/sieve.py", + "path_type": "hardlink", + "sha256": "94b7022ddbe3f807ae7621b6c6adb34cdd7abf4cd21172b9bdcaf591e8344f10", + "sha256_in_prefix": "94b7022ddbe3f807ae7621b6c6adb34cdd7abf4cd21172b9bdcaf591e8344f10", + "size_in_bytes": 2441 + }, + { + "_path": "site-packages/pygments/lexers/slash.py", + "path_type": "hardlink", + "sha256": "feca0fae6175ca5030ec859f4474cc3147627f0cb8a0d57916960c050b154b23", + "sha256_in_prefix": "feca0fae6175ca5030ec859f4474cc3147627f0cb8a0d57916960c050b154b23", + "size_in_bytes": 8482 + }, + { + "_path": "site-packages/pygments/lexers/smalltalk.py", + "path_type": "hardlink", + "sha256": "f5436a8c258e6b2de76f9055a8dd8cbb0f828badd69ec716eb125c1a735656ae", + "sha256_in_prefix": "f5436a8c258e6b2de76f9055a8dd8cbb0f828badd69ec716eb125c1a735656ae", + "size_in_bytes": 7206 + }, + { + "_path": "site-packages/pygments/lexers/smithy.py", + "path_type": "hardlink", + "sha256": "14cbd65cabe317f85436a23b0666586d546b3e0e7f0279f33911cfa77b24717b", + "sha256_in_prefix": "14cbd65cabe317f85436a23b0666586d546b3e0e7f0279f33911cfa77b24717b", + "size_in_bytes": 2660 + }, + { + "_path": "site-packages/pygments/lexers/smv.py", + "path_type": "hardlink", + "sha256": "5725ae4e3b4085a666bbaa191b73a6fe4537361a2b573f62bf37aefe67d18f0a", + "sha256_in_prefix": "5725ae4e3b4085a666bbaa191b73a6fe4537361a2b573f62bf37aefe67d18f0a", + "size_in_bytes": 2773 + }, + { + "_path": "site-packages/pygments/lexers/snobol.py", + "path_type": "hardlink", + "sha256": "5a9ed588c9dd772efdb56263b20481f6420f161fce85a338636b598d60eebcc2", + "sha256_in_prefix": "5a9ed588c9dd772efdb56263b20481f6420f161fce85a338636b598d60eebcc2", + "size_in_bytes": 2732 + }, + { + "_path": "site-packages/pygments/lexers/solidity.py", + "path_type": "hardlink", + "sha256": "3219b2a5be56cf119d05a429c9269ef4d6e21499659047b3762b631da8dded10", + "sha256_in_prefix": "3219b2a5be56cf119d05a429c9269ef4d6e21499659047b3762b631da8dded10", + "size_in_bytes": 3127 + }, + { + "_path": "site-packages/pygments/lexers/sophia.py", + "path_type": "hardlink", + "sha256": "d20011bf40db322ec359473bf77a5de1fec82b149e3a592393f79ecfcb4b8a1b", + "sha256_in_prefix": "d20011bf40db322ec359473bf77a5de1fec82b149e3a592393f79ecfcb4b8a1b", + "size_in_bytes": 3330 + }, + { + "_path": "site-packages/pygments/lexers/special.py", + "path_type": "hardlink", + "sha256": "4835aa04a99698acaf8bc54d7cfa56d55e20edeae069de117d4ba60e1e9b36b9", + "sha256_in_prefix": "4835aa04a99698acaf8bc54d7cfa56d55e20edeae069de117d4ba60e1e9b36b9", + "size_in_bytes": 3414 + }, + { + "_path": "site-packages/pygments/lexers/spice.py", + "path_type": "hardlink", + "sha256": "873030b73a1c3341988d96acaac5f552fea3624c20926f7022f69da64cb0dadc", + "sha256_in_prefix": "873030b73a1c3341988d96acaac5f552fea3624c20926f7022f69da64cb0dadc", + "size_in_bytes": 2735 + }, + { + "_path": "site-packages/pygments/lexers/sql.py", + "path_type": "hardlink", + "sha256": "222ac1ac3ba4b30dceb2f7b1a1bf745c2987ec744871a041803c8ad5acba06e0", + "sha256_in_prefix": "222ac1ac3ba4b30dceb2f7b1a1bf745c2987ec744871a041803c8ad5acba06e0", + "size_in_bytes": 42107 + }, + { + "_path": "site-packages/pygments/lexers/srcinfo.py", + "path_type": "hardlink", + "sha256": "c7fe83b19d262956c8feffc6e5b2c1425d16c85c23ded5e63aa7c7201eb3bdee", + "sha256_in_prefix": "c7fe83b19d262956c8feffc6e5b2c1425d16c85c23ded5e63aa7c7201eb3bdee", + "size_in_bytes": 1693 + }, + { + "_path": "site-packages/pygments/lexers/stata.py", + "path_type": "hardlink", + "sha256": "f8845f2e5feba6e3a22acd159e973a3842ae03a0176e4956e9104673bc731843", + "sha256_in_prefix": "f8845f2e5feba6e3a22acd159e973a3842ae03a0176e4956e9104673bc731843", + "size_in_bytes": 6416 + }, + { + "_path": "site-packages/pygments/lexers/supercollider.py", + "path_type": "hardlink", + "sha256": "51ae116e609160fcfb3dc4f5bb296801b7ca73d9198a6ee700aaf9e44dbab1c6", + "sha256_in_prefix": "51ae116e609160fcfb3dc4f5bb296801b7ca73d9198a6ee700aaf9e44dbab1c6", + "size_in_bytes": 3698 + }, + { + "_path": "site-packages/pygments/lexers/tal.py", + "path_type": "hardlink", + "sha256": "7d710999253be0898ec825671085b541aeeb58a2220c72a60e5a485b7394a7ec", + "sha256_in_prefix": "7d710999253be0898ec825671085b541aeeb58a2220c72a60e5a485b7394a7ec", + "size_in_bytes": 2898 + }, + { + "_path": "site-packages/pygments/lexers/tcl.py", + "path_type": "hardlink", + "sha256": "4938c74a555e5a8f84838b4aaa7ffb9b7ff779f7261cfd160a82f5fcf2b9b6dd", + "sha256_in_prefix": "4938c74a555e5a8f84838b4aaa7ffb9b7ff779f7261cfd160a82f5fcf2b9b6dd", + "size_in_bytes": 5513 + }, + { + "_path": "site-packages/pygments/lexers/teal.py", + "path_type": "hardlink", + "sha256": "b7c78eceb22222656e52d9019523e5f58e2896b080676d52401f93ebb5996ac4", + "sha256_in_prefix": "b7c78eceb22222656e52d9019523e5f58e2896b080676d52401f93ebb5996ac4", + "size_in_bytes": 3523 + }, + { + "_path": "site-packages/pygments/lexers/templates.py", + "path_type": "hardlink", + "sha256": "11ac2de4c5ce7b5576441fef869eb4f7b190323a0a1cf4845872a27e174c6b3c", + "sha256_in_prefix": "11ac2de4c5ce7b5576441fef869eb4f7b190323a0a1cf4845872a27e174c6b3c", + "size_in_bytes": 72610 + }, + { + "_path": "site-packages/pygments/lexers/teraterm.py", + "path_type": "hardlink", + "sha256": "ef53622de7f2e342fa47807eab2fa1a3c532e24010aac8bb88bc5ec420d2e6b5", + "sha256_in_prefix": "ef53622de7f2e342fa47807eab2fa1a3c532e24010aac8bb88bc5ec420d2e6b5", + "size_in_bytes": 9719 + }, + { + "_path": "site-packages/pygments/lexers/testing.py", + "path_type": "hardlink", + "sha256": "51ef77ba1dfa97b24a7347140e72e693e136db56f9cbbaadeb15c7bda251c6de", + "sha256_in_prefix": "51ef77ba1dfa97b24a7347140e72e693e136db56f9cbbaadeb15c7bda251c6de", + "size_in_bytes": 10767 + }, + { + "_path": "site-packages/pygments/lexers/text.py", + "path_type": "hardlink", + "sha256": "9ed17c430b2e86cab241dc4c07a1fb3183fba3c03bc52c477b450c4d92ca48af", + "sha256_in_prefix": "9ed17c430b2e86cab241dc4c07a1fb3183fba3c03bc52c477b450c4d92ca48af", + "size_in_bytes": 1029 + }, + { + "_path": "site-packages/pygments/lexers/textedit.py", + "path_type": "hardlink", + "sha256": "c5553edcae7ed0a1246f4a49e21263ae3a67cfd849688b8b40ec5f93d9cb5a33", + "sha256_in_prefix": "c5553edcae7ed0a1246f4a49e21263ae3a67cfd849688b8b40ec5f93d9cb5a33", + "size_in_bytes": 7609 + }, + { + "_path": "site-packages/pygments/lexers/textfmts.py", + "path_type": "hardlink", + "sha256": "77983c0160cae7f3173273e18fab7b4fb48e2ec93ac0fa6d46682701d6c09d47", + "sha256_in_prefix": "77983c0160cae7f3173273e18fab7b4fb48e2ec93ac0fa6d46682701d6c09d47", + "size_in_bytes": 15310 + }, + { + "_path": "site-packages/pygments/lexers/theorem.py", + "path_type": "hardlink", + "sha256": "05fcfdf34eeca47d0be10974ff4bb41c37d3e2de59d8f3e4ef56bd26ab97965a", + "sha256_in_prefix": "05fcfdf34eeca47d0be10974ff4bb41c37d3e2de59d8f3e4ef56bd26ab97965a", + "size_in_bytes": 16659 + }, + { + "_path": "site-packages/pygments/lexers/thingsdb.py", + "path_type": "hardlink", + "sha256": "1707a57215415ca7f79dcefc52003d4b225b1ed6b710c76b2e7422cc8c52e521", + "sha256_in_prefix": "1707a57215415ca7f79dcefc52003d4b225b1ed6b710c76b2e7422cc8c52e521", + "size_in_bytes": 4228 + }, + { + "_path": "site-packages/pygments/lexers/tlb.py", + "path_type": "hardlink", + "sha256": "b100ac2b78fccea19523f282baeaec98eaf8248b37b1fa6a17fc0fa50a7228cd", + "sha256_in_prefix": "b100ac2b78fccea19523f282baeaec98eaf8248b37b1fa6a17fc0fa50a7228cd", + "size_in_bytes": 1377 + }, + { + "_path": "site-packages/pygments/lexers/tls.py", + "path_type": "hardlink", + "sha256": "29f23ccbb69b619cc2fe3470bed8bf7e800052b5929a98dd4374463dc3fcca9b", + "sha256_in_prefix": "29f23ccbb69b619cc2fe3470bed8bf7e800052b5929a98dd4374463dc3fcca9b", + "size_in_bytes": 1541 + }, + { + "_path": "site-packages/pygments/lexers/tnt.py", + "path_type": "hardlink", + "sha256": "baf75cb30e4d4598db168b970444f7fb0f08ecb1bd86accc5e22bab3f18ad996", + "sha256_in_prefix": "baf75cb30e4d4598db168b970444f7fb0f08ecb1bd86accc5e22bab3f18ad996", + "size_in_bytes": 10457 + }, + { + "_path": "site-packages/pygments/lexers/trafficscript.py", + "path_type": "hardlink", + "sha256": "18397fedc4858add5a9d51fb28d1f4a95b6cd5e1dca7f186c69cc861665a6de8", + "sha256_in_prefix": "18397fedc4858add5a9d51fb28d1f4a95b6cd5e1dca7f186c69cc861665a6de8", + "size_in_bytes": 1474 + }, + { + "_path": "site-packages/pygments/lexers/typoscript.py", + "path_type": "hardlink", + "sha256": "9c80142256cbe6c56aa5312ddf861d5060cd9aeeb46bb8ad05869a50cbb3008b", + "sha256_in_prefix": "9c80142256cbe6c56aa5312ddf861d5060cd9aeeb46bb8ad05869a50cbb3008b", + "size_in_bytes": 8207 + }, + { + "_path": "site-packages/pygments/lexers/ul4.py", + "path_type": "hardlink", + "sha256": "5ce9b9756896b56377450329039547be5d49d63834d7848adbb6899d58ead42d", + "sha256_in_prefix": "5ce9b9756896b56377450329039547be5d49d63834d7848adbb6899d58ead42d", + "size_in_bytes": 8956 + }, + { + "_path": "site-packages/pygments/lexers/unicon.py", + "path_type": "hardlink", + "sha256": "e0c0e7c2c817ccb966d33683a98afdb8714db29802cd044dcf2c4295543e44c2", + "sha256_in_prefix": "e0c0e7c2c817ccb966d33683a98afdb8714db29802cd044dcf2c4295543e44c2", + "size_in_bytes": 18512 + }, + { + "_path": "site-packages/pygments/lexers/urbi.py", + "path_type": "hardlink", + "sha256": "dc29317cc3aaa52559a4eabbff862b59c9a3ab8077085fc80c623102c79d590d", + "sha256_in_prefix": "dc29317cc3aaa52559a4eabbff862b59c9a3ab8077085fc80c623102c79d590d", + "size_in_bytes": 6037 + }, + { + "_path": "site-packages/pygments/lexers/usd.py", + "path_type": "hardlink", + "sha256": "ec5892fca57543d0af7f9d5f00798caabe500f3d4eb63a93929d52fbc572413c", + "sha256_in_prefix": "ec5892fca57543d0af7f9d5f00798caabe500f3d4eb63a93929d52fbc572413c", + "size_in_bytes": 3513 + }, + { + "_path": "site-packages/pygments/lexers/varnish.py", + "path_type": "hardlink", + "sha256": "2d82faae1230f80a49453e2a93115ac46ef538f6c7b2216fe26b5faf49b538f6", + "sha256_in_prefix": "2d82faae1230f80a49453e2a93115ac46ef538f6c7b2216fe26b5faf49b538f6", + "size_in_bytes": 7273 + }, + { + "_path": "site-packages/pygments/lexers/verification.py", + "path_type": "hardlink", + "sha256": "d42d67b6abd99ab0adcc757d7832206b52ed4388e90256fa1a75a436e7042574", + "sha256_in_prefix": "d42d67b6abd99ab0adcc757d7832206b52ed4388e90256fa1a75a436e7042574", + "size_in_bytes": 3885 + }, + { + "_path": "site-packages/pygments/lexers/verifpal.py", + "path_type": "hardlink", + "sha256": "0c5d27425af0fd7b76dce385a4e0bcfcb4696165e5a27d52ef2c63e9e81bb436", + "sha256_in_prefix": "0c5d27425af0fd7b76dce385a4e0bcfcb4696165e5a27d52ef2c63e9e81bb436", + "size_in_bytes": 2662 + }, + { + "_path": "site-packages/pygments/lexers/vip.py", + "path_type": "hardlink", + "sha256": "327f1949454bb8682ab7508cb215c57a54b7a7c0c1a943b2a85ad9c960466e57", + "sha256_in_prefix": "327f1949454bb8682ab7508cb215c57a54b7a7c0c1a943b2a85ad9c960466e57", + "size_in_bytes": 5713 + }, + { + "_path": "site-packages/pygments/lexers/vyper.py", + "path_type": "hardlink", + "sha256": "54588ec68f4986b3d0285b560ce8d6cfa1dc708c23031107e361b34a433b2e10", + "sha256_in_prefix": "54588ec68f4986b3d0285b560ce8d6cfa1dc708c23031107e361b34a433b2e10", + "size_in_bytes": 5595 + }, + { + "_path": "site-packages/pygments/lexers/web.py", + "path_type": "hardlink", + "sha256": "96c722b7f3605ec1c32fcb23bcdbc016b88f05edb8733d1bdab046145a5896ff", + "sha256_in_prefix": "96c722b7f3605ec1c32fcb23bcdbc016b88f05edb8733d1bdab046145a5896ff", + "size_in_bytes": 894 + }, + { + "_path": "site-packages/pygments/lexers/webassembly.py", + "path_type": "hardlink", + "sha256": "1c6169e2a3002b47a3c74a26ad3844b48be5fc0aca39e4bb6f8c99922a6a988a", + "sha256_in_prefix": "1c6169e2a3002b47a3c74a26ad3844b48be5fc0aca39e4bb6f8c99922a6a988a", + "size_in_bytes": 5699 + }, + { + "_path": "site-packages/pygments/lexers/webidl.py", + "path_type": "hardlink", + "sha256": "55ea8eee2dd8f9ed0e6ed2f19f5b2788698bfc2bce59e91a3f65f2505cc394b4", + "sha256_in_prefix": "55ea8eee2dd8f9ed0e6ed2f19f5b2788698bfc2bce59e91a3f65f2505cc394b4", + "size_in_bytes": 10517 + }, + { + "_path": "site-packages/pygments/lexers/webmisc.py", + "path_type": "hardlink", + "sha256": "bde202b545cbdf779f7dc6035fcfc553517443915f65fcdc0b64f2bb94984fd0", + "sha256_in_prefix": "bde202b545cbdf779f7dc6035fcfc553517443915f65fcdc0b64f2bb94984fd0", + "size_in_bytes": 40549 + }, + { + "_path": "site-packages/pygments/lexers/wgsl.py", + "path_type": "hardlink", + "sha256": "31f7e08f7c79b45c2c2968a1c3691b8529a1bc634481073fa498ba0b79844317", + "sha256_in_prefix": "31f7e08f7c79b45c2c2968a1c3691b8529a1bc634481073fa498ba0b79844317", + "size_in_bytes": 11920 + }, + { + "_path": "site-packages/pygments/lexers/whiley.py", + "path_type": "hardlink", + "sha256": "49b6dfb5a22d4a021d733cd3f2a395f261f59ba743dda33612f464e2295ae82a", + "sha256_in_prefix": "49b6dfb5a22d4a021d733cd3f2a395f261f59ba743dda33612f464e2295ae82a", + "size_in_bytes": 4018 + }, + { + "_path": "site-packages/pygments/lexers/wowtoc.py", + "path_type": "hardlink", + "sha256": "a3fd354864c9de379c547129921a8777023ae974158bcc0d79a8d560f6dde01a", + "sha256_in_prefix": "a3fd354864c9de379c547129921a8777023ae974158bcc0d79a8d560f6dde01a", + "size_in_bytes": 4021 + }, + { + "_path": "site-packages/pygments/lexers/wren.py", + "path_type": "hardlink", + "sha256": "2372da233cb769ad1a0d725df4f269f92889b6024792d2121dd43fcd0b8c1cb6", + "sha256_in_prefix": "2372da233cb769ad1a0d725df4f269f92889b6024792d2121dd43fcd0b8c1cb6", + "size_in_bytes": 3239 + }, + { + "_path": "site-packages/pygments/lexers/x10.py", + "path_type": "hardlink", + "sha256": "a77570420ef47bc651da2c11da463eca88d3c83fecdf154930b4c25aba73e877", + "sha256_in_prefix": "a77570420ef47bc651da2c11da463eca88d3c83fecdf154930b4c25aba73e877", + "size_in_bytes": 1920 + }, + { + "_path": "site-packages/pygments/lexers/xorg.py", + "path_type": "hardlink", + "sha256": "ad72953508a29e236868ce154e42c58f5d3a34b75d081a35055e39053c53d471", + "sha256_in_prefix": "ad72953508a29e236868ce154e42c58f5d3a34b75d081a35055e39053c53d471", + "size_in_bytes": 902 + }, + { + "_path": "site-packages/pygments/lexers/yang.py", + "path_type": "hardlink", + "sha256": "af1d3ca2462f26058c7ba8cc464b7ecac12e6938bce57e431344391076fe1218", + "sha256_in_prefix": "af1d3ca2462f26058c7ba8cc464b7ecac12e6938bce57e431344391076fe1218", + "size_in_bytes": 4500 + }, + { + "_path": "site-packages/pygments/lexers/yara.py", + "path_type": "hardlink", + "sha256": "9c5c0fb66b8085ee6aae6fcf2a57559d602215968b7a2a608b9ab7fabd551b01", + "sha256_in_prefix": "9c5c0fb66b8085ee6aae6fcf2a57559d602215968b7a2a608b9ab7fabd551b01", + "size_in_bytes": 2428 + }, + { + "_path": "site-packages/pygments/lexers/zig.py", + "path_type": "hardlink", + "sha256": "07941919f128364a001b9119c47936f0c6759f64351afc75d6472f4d0e8de57f", + "sha256_in_prefix": "07941919f128364a001b9119c47936f0c6759f64351afc75d6472f4d0e8de57f", + "size_in_bytes": 3953 + }, + { + "_path": "site-packages/pygments/modeline.py", + "path_type": "hardlink", + "sha256": "785daf3b82e9386a0fbc828a91b3df9f2badf214f852279b64fa5bf8160641d2", + "sha256_in_prefix": "785daf3b82e9386a0fbc828a91b3df9f2badf214f852279b64fa5bf8160641d2", + "size_in_bytes": 986 + }, + { + "_path": "site-packages/pygments/plugin.py", + "path_type": "hardlink", + "sha256": "93f82d24706b8830d688d8a743e87faa70d49bb1273cbb97693187dc2779a59c", + "sha256_in_prefix": "93f82d24706b8830d688d8a743e87faa70d49bb1273cbb97693187dc2779a59c", + "size_in_bytes": 2579 + }, + { + "_path": "site-packages/pygments/regexopt.py", + "path_type": "hardlink", + "sha256": "8e0d402e881c60653de93412f62b0197a742aefc39cb9fbe04ffcafae164ffcb", + "sha256_in_prefix": "8e0d402e881c60653de93412f62b0197a742aefc39cb9fbe04ffcafae164ffcb", + "size_in_bytes": 3072 + }, + { + "_path": "site-packages/pygments/scanner.py", + "path_type": "hardlink", + "sha256": "6ff9eee7f7f71c2812769e52fda351050d4c4829b86630f079cd8e993462724c", + "sha256_in_prefix": "6ff9eee7f7f71c2812769e52fda351050d4c4829b86630f079cd8e993462724c", + "size_in_bytes": 3092 + }, + { + "_path": "site-packages/pygments/sphinxext.py", + "path_type": "hardlink", + "sha256": "946c3deebe4b42b06f79cb4c3732f4df04440ab8ecd474579bc2bf97b4fe2279", + "sha256_in_prefix": "946c3deebe4b42b06f79cb4c3732f4df04440ab8ecd474579bc2bf97b4fe2279", + "size_in_bytes": 7687 + }, + { + "_path": "site-packages/pygments/style.py", + "path_type": "hardlink", + "sha256": "6fd2f478f9e025b7491dcd8637495943e38645e552d8b2c9ec2c340adaaf6247", + "sha256_in_prefix": "6fd2f478f9e025b7491dcd8637495943e38645e552d8b2c9ec2c340adaaf6247", + "size_in_bytes": 6408 + }, + { + "_path": "site-packages/pygments/styles/__init__.py", + "path_type": "hardlink", + "sha256": "fef0f7922c5630656e050ac0d56cffac912d924f3dd56d040f9e62f044018420", + "sha256_in_prefix": "fef0f7922c5630656e050ac0d56cffac912d924f3dd56d040f9e62f044018420", + "size_in_bytes": 2006 + }, + { + "_path": "site-packages/pygments/styles/_mapping.py", + "path_type": "hardlink", + "sha256": "f2763d6dc105d59c3d5eed1b9aa7dfa981071db359bc24078add8e5652561f29", + "sha256_in_prefix": "f2763d6dc105d59c3d5eed1b9aa7dfa981071db359bc24078add8e5652561f29", + "size_in_bytes": 3251 + }, + { + "_path": "site-packages/pygments/styles/abap.py", + "path_type": "hardlink", + "sha256": "bbe42e4c2ea640aab86090389a4b42427d9c304956c299285f74bbbac6d838e0", + "sha256_in_prefix": "bbe42e4c2ea640aab86090389a4b42427d9c304956c299285f74bbbac6d838e0", + "size_in_bytes": 749 + }, + { + "_path": "site-packages/pygments/styles/algol.py", + "path_type": "hardlink", + "sha256": "3f740a85f3b395502aad4f76b23867691ec4a8239050ec3b2e4fc8f5ea4a6ed6", + "sha256_in_prefix": "3f740a85f3b395502aad4f76b23867691ec4a8239050ec3b2e4fc8f5ea4a6ed6", + "size_in_bytes": 2262 + }, + { + "_path": "site-packages/pygments/styles/algol_nu.py", + "path_type": "hardlink", + "sha256": "3ace12d05503310f74e4edd1acb55162c8efec0a55e93a45adfc0a9f0fa16604", + "sha256_in_prefix": "3ace12d05503310f74e4edd1acb55162c8efec0a55e93a45adfc0a9f0fa16604", + "size_in_bytes": 2283 + }, + { + "_path": "site-packages/pygments/styles/arduino.py", + "path_type": "hardlink", + "sha256": "fc2be01cddf5b8a0d0e3baefc39128ae0731ca5e4aa514211bf604b461087f1a", + "sha256_in_prefix": "fc2be01cddf5b8a0d0e3baefc39128ae0731ca5e4aa514211bf604b461087f1a", + "size_in_bytes": 4557 + }, + { + "_path": "site-packages/pygments/styles/autumn.py", + "path_type": "hardlink", + "sha256": "75d7a0d8e3f63741e79dfd44b530adb5afe5d4c11cf38265cfeab4bba0d560c9", + "sha256_in_prefix": "75d7a0d8e3f63741e79dfd44b530adb5afe5d4c11cf38265cfeab4bba0d560c9", + "size_in_bytes": 2195 + }, + { + "_path": "site-packages/pygments/styles/borland.py", + "path_type": "hardlink", + "sha256": "2bd0a165461e54257f527782f86bb06db16e1ac6ee24f4265d4e0ce623bdf900", + "sha256_in_prefix": "2bd0a165461e54257f527782f86bb06db16e1ac6ee24f4265d4e0ce623bdf900", + "size_in_bytes": 1611 + }, + { + "_path": "site-packages/pygments/styles/bw.py", + "path_type": "hardlink", + "sha256": "9bf69a51c29972814a7c233186dc7348223f5e61de523530e6f7593e3bd9a7e8", + "sha256_in_prefix": "9bf69a51c29972814a7c233186dc7348223f5e61de523530e6f7593e3bd9a7e8", + "size_in_bytes": 1406 + }, + { + "_path": "site-packages/pygments/styles/colorful.py", + "path_type": "hardlink", + "sha256": "f32723a218159e93223254b125c4b812518f12bed8cc61694b81d37cba9969b4", + "sha256_in_prefix": "f32723a218159e93223254b125c4b812518f12bed8cc61694b81d37cba9969b4", + "size_in_bytes": 2832 + }, + { + "_path": "site-packages/pygments/styles/default.py", + "path_type": "hardlink", + "sha256": "7e20fe3886e90a3abe494b5ddf1dee6e691537c9fb681578edfc280eb4de1245", + "sha256_in_prefix": "7e20fe3886e90a3abe494b5ddf1dee6e691537c9fb681578edfc280eb4de1245", + "size_in_bytes": 2588 + }, + { + "_path": "site-packages/pygments/styles/dracula.py", + "path_type": "hardlink", + "sha256": "e4bc9652650de70cb63211eec8470e6e967a68c68ba516003c21bbfd9d0c084e", + "sha256_in_prefix": "e4bc9652650de70cb63211eec8470e6e967a68c68ba516003c21bbfd9d0c084e", + "size_in_bytes": 2182 + }, + { + "_path": "site-packages/pygments/styles/emacs.py", + "path_type": "hardlink", + "sha256": "cff6a93741b70b10495824ee1e0a8b7f88271b6390a44a8f50d98cd8c21ccdef", + "sha256_in_prefix": "cff6a93741b70b10495824ee1e0a8b7f88271b6390a44a8f50d98cd8c21ccdef", + "size_in_bytes": 2535 + }, + { + "_path": "site-packages/pygments/styles/friendly.py", + "path_type": "hardlink", + "sha256": "73f39a912bc95710f9bd515016bcf6d1a549cd51c8856ddca2343be82226c6c7", + "sha256_in_prefix": "73f39a912bc95710f9bd515016bcf6d1a549cd51c8856ddca2343be82226c6c7", + "size_in_bytes": 2604 + }, + { + "_path": "site-packages/pygments/styles/friendly_grayscale.py", + "path_type": "hardlink", + "sha256": "1fa6ec4a7987a9ae2b500868a8f935da78106fcf874bd2e729ec309396d20e0f", + "sha256_in_prefix": "1fa6ec4a7987a9ae2b500868a8f935da78106fcf874bd2e729ec309396d20e0f", + "size_in_bytes": 2828 + }, + { + "_path": "site-packages/pygments/styles/fruity.py", + "path_type": "hardlink", + "sha256": "aeb40917bfb9819d2264356262ee2de83ae35b8188731e88947879d6eb3e25c0", + "sha256_in_prefix": "aeb40917bfb9819d2264356262ee2de83ae35b8188731e88947879d6eb3e25c0", + "size_in_bytes": 1324 + }, + { + "_path": "site-packages/pygments/styles/gh_dark.py", + "path_type": "hardlink", + "sha256": "38c4b01c59c037dadc8f061410bd93952f799e85a35b7ece6943e1c9abde2221", + "sha256_in_prefix": "38c4b01c59c037dadc8f061410bd93952f799e85a35b7ece6943e1c9abde2221", + "size_in_bytes": 3590 + }, + { + "_path": "site-packages/pygments/styles/gruvbox.py", + "path_type": "hardlink", + "sha256": "f75f8c39faaaa17ad83af077c76bd867792f17f9d2df8a2a369a2a0fb93861ce", + "sha256_in_prefix": "f75f8c39faaaa17ad83af077c76bd867792f17f9d2df8a2a369a2a0fb93861ce", + "size_in_bytes": 3387 + }, + { + "_path": "site-packages/pygments/styles/igor.py", + "path_type": "hardlink", + "sha256": "288ac1a38055f88033fb304ae2bd20c676eb21648715efd8b3ab92b9b7814387", + "sha256_in_prefix": "288ac1a38055f88033fb304ae2bd20c676eb21648715efd8b3ab92b9b7814387", + "size_in_bytes": 737 + }, + { + "_path": "site-packages/pygments/styles/inkpot.py", + "path_type": "hardlink", + "sha256": "3ae6b6e944152d7b196d27e87f2cfb67c68a4a227d853b9f037c45e879188c6a", + "sha256_in_prefix": "3ae6b6e944152d7b196d27e87f2cfb67c68a4a227d853b9f037c45e879188c6a", + "size_in_bytes": 2404 + }, + { + "_path": "site-packages/pygments/styles/lightbulb.py", + "path_type": "hardlink", + "sha256": "1c2658fa1f8235b672528808e6019047f778866166ab12f160d27ca9c652165b", + "sha256_in_prefix": "1c2658fa1f8235b672528808e6019047f778866166ab12f160d27ca9c652165b", + "size_in_bytes": 3172 + }, + { + "_path": "site-packages/pygments/styles/lilypond.py", + "path_type": "hardlink", + "sha256": "242d76c59dc4241e4d0fc10771369d7c69a09db6b21aaf2504e3d9b91daf532d", + "sha256_in_prefix": "242d76c59dc4241e4d0fc10771369d7c69a09db6b21aaf2504e3d9b91daf532d", + "size_in_bytes": 2066 + }, + { + "_path": "site-packages/pygments/styles/lovelace.py", + "path_type": "hardlink", + "sha256": "aadd021be148215c5f999a70fa9113670167800c0ca67abf19e480be6476e5a9", + "sha256_in_prefix": "aadd021be148215c5f999a70fa9113670167800c0ca67abf19e480be6476e5a9", + "size_in_bytes": 3178 + }, + { + "_path": "site-packages/pygments/styles/manni.py", + "path_type": "hardlink", + "sha256": "05385e7f0502512508e5f981daab4fa1b82e1a5ca834c624581160ee790dc930", + "sha256_in_prefix": "05385e7f0502512508e5f981daab4fa1b82e1a5ca834c624581160ee790dc930", + "size_in_bytes": 2443 + }, + { + "_path": "site-packages/pygments/styles/material.py", + "path_type": "hardlink", + "sha256": "f22ac35fd113a7d059dc896da112d83932dec5399acf4df57a2eeecafbb918da", + "sha256_in_prefix": "f22ac35fd113a7d059dc896da112d83932dec5399acf4df57a2eeecafbb918da", + "size_in_bytes": 4201 + }, + { + "_path": "site-packages/pygments/styles/monokai.py", + "path_type": "hardlink", + "sha256": "81318332736e2bc6475ea55c9792378a820595b8b03c3991cb5eeff867ada552", + "sha256_in_prefix": "81318332736e2bc6475ea55c9792378a820595b8b03c3991cb5eeff867ada552", + "size_in_bytes": 5184 + }, + { + "_path": "site-packages/pygments/styles/murphy.py", + "path_type": "hardlink", + "sha256": "244f5f06dfba305dc7e94118b442562bba7fb772f3e05bac49b9cfca736ee363", + "sha256_in_prefix": "244f5f06dfba305dc7e94118b442562bba7fb772f3e05bac49b9cfca736ee363", + "size_in_bytes": 2805 + }, + { + "_path": "site-packages/pygments/styles/native.py", + "path_type": "hardlink", + "sha256": "ad5056abec01836bc0780b3f8bf54d971816ce0f9e6d57e8ad35f37815f6268e", + "sha256_in_prefix": "ad5056abec01836bc0780b3f8bf54d971816ce0f9e6d57e8ad35f37815f6268e", + "size_in_bytes": 2043 + }, + { + "_path": "site-packages/pygments/styles/nord.py", + "path_type": "hardlink", + "sha256": "3bf9edd86acc2b93ac411d3c01ef70511cd9c796dc1b2b28c609966eaf3172a7", + "sha256_in_prefix": "3bf9edd86acc2b93ac411d3c01ef70511cd9c796dc1b2b28c609966eaf3172a7", + "size_in_bytes": 5391 + }, + { + "_path": "site-packages/pygments/styles/onedark.py", + "path_type": "hardlink", + "sha256": "e51aaf1167c4a85f28db0d0dffc97e53ea1f898497b47494ce4b57330028008a", + "sha256_in_prefix": "e51aaf1167c4a85f28db0d0dffc97e53ea1f898497b47494ce4b57330028008a", + "size_in_bytes": 1719 + }, + { + "_path": "site-packages/pygments/styles/paraiso_dark.py", + "path_type": "hardlink", + "sha256": "943779b9013bf70bc18469aba4b4b72889e9474b271715b00e6ff43b6c5398a6", + "sha256_in_prefix": "943779b9013bf70bc18469aba4b4b72889e9474b271715b00e6ff43b6c5398a6", + "size_in_bytes": 5662 + }, + { + "_path": "site-packages/pygments/styles/paraiso_light.py", + "path_type": "hardlink", + "sha256": "3f93e4953a8c50bea97281aa3aa58a065dbbb733cef7a11253e83af8aadd81a4", + "sha256_in_prefix": "3f93e4953a8c50bea97281aa3aa58a065dbbb733cef7a11253e83af8aadd81a4", + "size_in_bytes": 5668 + }, + { + "_path": "site-packages/pygments/styles/pastie.py", + "path_type": "hardlink", + "sha256": "75456839a8d60cbee01dbd8cd6c292bc8a6dd4d17202c11260f6917afb91556a", + "sha256_in_prefix": "75456839a8d60cbee01dbd8cd6c292bc8a6dd4d17202c11260f6917afb91556a", + "size_in_bytes": 2525 + }, + { + "_path": "site-packages/pygments/styles/perldoc.py", + "path_type": "hardlink", + "sha256": "a6d5942210377e163f6a7fd5bff3a5d22171768326066295982da3b09b2f95a9", + "sha256_in_prefix": "a6d5942210377e163f6a7fd5bff3a5d22171768326066295982da3b09b2f95a9", + "size_in_bytes": 2230 + }, + { + "_path": "site-packages/pygments/styles/rainbow_dash.py", + "path_type": "hardlink", + "sha256": "c2356cdfdd78233015db7767391e712c694ce14b82d6f0dde89e22a135a22436", + "sha256_in_prefix": "c2356cdfdd78233015db7767391e712c694ce14b82d6f0dde89e22a135a22436", + "size_in_bytes": 2540 + }, + { + "_path": "site-packages/pygments/styles/rrt.py", + "path_type": "hardlink", + "sha256": "53029e4dc604b44a4e47fa35e33b9d6a9a654f14f2057d433eac3623d454cb07", + "sha256_in_prefix": "53029e4dc604b44a4e47fa35e33b9d6a9a654f14f2057d433eac3623d454cb07", + "size_in_bytes": 964 + }, + { + "_path": "site-packages/pygments/styles/sas.py", + "path_type": "hardlink", + "sha256": "56729170956576ad8a96710ef2923b48539ab5b684e33d22d30ebfa99b4e53de", + "sha256_in_prefix": "56729170956576ad8a96710ef2923b48539ab5b684e33d22d30ebfa99b4e53de", + "size_in_bytes": 1440 + }, + { + "_path": "site-packages/pygments/styles/solarized.py", + "path_type": "hardlink", + "sha256": "9992c1ea08e7fd8fba2bfd2968d5495c8f656713daf47be440ca4144c498eb64", + "sha256_in_prefix": "9992c1ea08e7fd8fba2bfd2968d5495c8f656713daf47be440ca4144c498eb64", + "size_in_bytes": 4247 + }, + { + "_path": "site-packages/pygments/styles/staroffice.py", + "path_type": "hardlink", + "sha256": "44cf4a4ef33bc1179de4a5b8299f6705e29386b0dec6aa8b4b7667d8e87b1fab", + "sha256_in_prefix": "44cf4a4ef33bc1179de4a5b8299f6705e29386b0dec6aa8b4b7667d8e87b1fab", + "size_in_bytes": 831 + }, + { + "_path": "site-packages/pygments/styles/stata_dark.py", + "path_type": "hardlink", + "sha256": "3a0ce30c523435b1f896611ce12c5c7d4b103e1060921e4f875b09ff8c76f2d3", + "sha256_in_prefix": "3a0ce30c523435b1f896611ce12c5c7d4b103e1060921e4f875b09ff8c76f2d3", + "size_in_bytes": 1257 + }, + { + "_path": "site-packages/pygments/styles/stata_light.py", + "path_type": "hardlink", + "sha256": "65c7439cb873330cf7d478736f2f98f09fd400067404f3e0304ac7ab249103d4", + "sha256_in_prefix": "65c7439cb873330cf7d478736f2f98f09fd400067404f3e0304ac7ab249103d4", + "size_in_bytes": 1289 + }, + { + "_path": "site-packages/pygments/styles/tango.py", + "path_type": "hardlink", + "sha256": "ffde711a2529b8a20954d6f17e190f333c35f6fc1e2943df66c00f70804acfe9", + "sha256_in_prefix": "ffde711a2529b8a20954d6f17e190f333c35f6fc1e2943df66c00f70804acfe9", + "size_in_bytes": 7137 + }, + { + "_path": "site-packages/pygments/styles/trac.py", + "path_type": "hardlink", + "sha256": "f756e2ff38e81793387b436b17fa7bed891ad80e9f4849b1526755b3622e4503", + "sha256_in_prefix": "f756e2ff38e81793387b436b17fa7bed891ad80e9f4849b1526755b3622e4503", + "size_in_bytes": 1981 + }, + { + "_path": "site-packages/pygments/styles/vim.py", + "path_type": "hardlink", + "sha256": "ec333a6ee21ff724f2aafc8054628ca30f489e6977ae38a9699f51f0c6a29832", + "sha256_in_prefix": "ec333a6ee21ff724f2aafc8054628ca30f489e6977ae38a9699f51f0c6a29832", + "size_in_bytes": 2019 + }, + { + "_path": "site-packages/pygments/styles/vs.py", + "path_type": "hardlink", + "sha256": "c06220666ef31c111c53b30b99501e847f49c3fbb155fd465afa89b339f3ab57", + "sha256_in_prefix": "c06220666ef31c111c53b30b99501e847f49c3fbb155fd465afa89b339f3ab57", + "size_in_bytes": 1130 + }, + { + "_path": "site-packages/pygments/styles/xcode.py", + "path_type": "hardlink", + "sha256": "fa50d6f32de111770971e49dafd6cefd3555448c67fe141e55f070591ce453f4", + "sha256_in_prefix": "fa50d6f32de111770971e49dafd6cefd3555448c67fe141e55f070591ce453f4", + "size_in_bytes": 1504 + }, + { + "_path": "site-packages/pygments/styles/zenburn.py", + "path_type": "hardlink", + "sha256": "1e077e1c6782c1a35c0fe559fb06ec10bfe7bf6035d6e39756a1d7abe292cb79", + "sha256_in_prefix": "1e077e1c6782c1a35c0fe559fb06ec10bfe7bf6035d6e39756a1d7abe292cb79", + "size_in_bytes": 2203 + }, + { + "_path": "site-packages/pygments/token.py", + "path_type": "hardlink", + "sha256": "0d755070b50b567d392c6eb76da822a89776147dd4ce179550199d41e5e7d54f", + "sha256_in_prefix": "0d755070b50b567d392c6eb76da822a89776147dd4ce179550199d41e5e7d54f", + "size_in_bytes": 6226 + }, + { + "_path": "site-packages/pygments/unistring.py", + "path_type": "hardlink", + "sha256": "15a51f1b5e0d04910a2d0a18f6a8fa258797ae961c2e62ae96085dc4e18568e7", + "sha256_in_prefix": "15a51f1b5e0d04910a2d0a18f6a8fa258797ae961c2e62ae96085dc4e18568e7", + "size_in_bytes": 63223 + }, + { + "_path": "site-packages/pygments/util.py", + "path_type": "hardlink", + "sha256": "004558d2aa27cb210c82fe03a3674836baea500c149365d84aa1cceb9d2ecde9", + "sha256_in_prefix": "004558d2aa27cb210c82fe03a3674836baea500c149365d84aa1cceb9d2ecde9", + "size_in_bytes": 10230 + }, + { + "_path": "lib/python3.12/site-packages/pygments/__pycache__/__init__.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/__pycache__/__main__.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/__pycache__/cmdline.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/__pycache__/console.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/__pycache__/filter.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/filters/__pycache__/__init__.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/__pycache__/formatter.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/formatters/__pycache__/__init__.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/formatters/__pycache__/_mapping.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/formatters/__pycache__/bbcode.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/formatters/__pycache__/groff.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/formatters/__pycache__/html.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/formatters/__pycache__/img.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/formatters/__pycache__/irc.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/formatters/__pycache__/latex.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/formatters/__pycache__/other.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/formatters/__pycache__/pangomarkup.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/formatters/__pycache__/rtf.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/formatters/__pycache__/svg.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/formatters/__pycache__/terminal.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/formatters/__pycache__/terminal256.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/__pycache__/lexer.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/__init__.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/_ada_builtins.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/_asy_builtins.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/_cl_builtins.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/_cocoa_builtins.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/_csound_builtins.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/_css_builtins.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/_julia_builtins.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/_lasso_builtins.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/_lilypond_builtins.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/_lua_builtins.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/_mapping.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/_mql_builtins.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/_mysql_builtins.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/_openedge_builtins.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/_php_builtins.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/_postgres_builtins.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/_qlik_builtins.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/_scheme_builtins.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/_scilab_builtins.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/_sourcemod_builtins.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/_stan_builtins.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/_stata_builtins.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/_tsql_builtins.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/_usd_builtins.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/_vbscript_builtins.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/_vim_builtins.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/actionscript.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/ada.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/agile.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/algebra.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/ambient.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/amdgpu.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/ampl.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/apdlexer.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/apl.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/archetype.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/arrow.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/arturo.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/asc.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/asm.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/asn1.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/automation.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/bare.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/basic.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/bdd.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/berry.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/bibtex.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/blueprint.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/boa.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/bqn.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/business.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/c_cpp.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/c_like.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/capnproto.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/carbon.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/cddl.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/chapel.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/clean.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/comal.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/compiled.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/configs.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/console.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/cplint.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/crystal.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/csound.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/css.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/d.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/dalvik.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/data.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/dax.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/devicetree.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/diff.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/dns.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/dotnet.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/dsls.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/dylan.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/ecl.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/eiffel.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/elm.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/elpi.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/email.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/erlang.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/esoteric.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/ezhil.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/factor.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/fantom.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/felix.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/fift.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/floscript.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/forth.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/fortran.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/foxpro.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/freefem.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/func.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/functional.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/futhark.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/gcodelexer.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/gdscript.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/go.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/grammar_notation.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/graph.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/graphics.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/graphql.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/graphviz.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/gsql.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/haskell.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/haxe.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/hdl.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/hexdump.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/html.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/idl.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/igor.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/inferno.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/installers.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/int_fiction.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/iolang.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/j.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/javascript.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/jmespath.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/jslt.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/jsonnet.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/jsx.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/julia.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/jvm.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/kuin.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/kusto.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/ldap.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/lean.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/lilypond.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/lisp.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/macaulay2.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/make.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/markup.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/math.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/matlab.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/maxima.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/meson.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/mime.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/minecraft.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/mips.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/ml.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/modeling.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/modula2.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/monte.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/mosel.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/ncl.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/nimrod.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/nit.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/nix.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/oberon.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/objective.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/ooc.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/openscad.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/other.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/parasail.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/parsers.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/pascal.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/pawn.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/perl.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/phix.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/php.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/pointless.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/pony.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/praat.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/procfile.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/prolog.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/promql.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/prql.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/ptx.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/python.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/q.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/qlik.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/qvt.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/r.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/rdf.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/rebol.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/resource.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/ride.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/rita.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/rnc.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/roboconf.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/robotframework.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/ruby.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/rust.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/sas.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/savi.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/scdoc.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/scripting.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/sgf.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/shell.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/sieve.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/slash.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/smalltalk.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/smithy.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/smv.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/snobol.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/solidity.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/sophia.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/special.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/spice.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/sql.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/srcinfo.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/stata.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/supercollider.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/tal.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/tcl.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/teal.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/templates.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/teraterm.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/testing.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/text.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/textedit.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/textfmts.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/theorem.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/thingsdb.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/tlb.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/tls.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/tnt.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/trafficscript.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/typoscript.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/ul4.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/unicon.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/urbi.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/usd.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/varnish.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/verification.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/verifpal.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/vip.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/vyper.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/web.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/webassembly.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/webidl.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/webmisc.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/wgsl.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/whiley.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/wowtoc.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/wren.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/x10.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/xorg.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/yang.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/yara.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/zig.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/__pycache__/modeline.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/__pycache__/plugin.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/__pycache__/regexopt.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/__pycache__/scanner.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/__pycache__/sphinxext.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/__pycache__/style.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/styles/__pycache__/__init__.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/styles/__pycache__/_mapping.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/styles/__pycache__/abap.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/styles/__pycache__/algol.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/styles/__pycache__/algol_nu.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/styles/__pycache__/arduino.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/styles/__pycache__/autumn.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/styles/__pycache__/borland.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/styles/__pycache__/bw.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/styles/__pycache__/colorful.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/styles/__pycache__/default.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/styles/__pycache__/dracula.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/styles/__pycache__/emacs.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/styles/__pycache__/friendly.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/styles/__pycache__/friendly_grayscale.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/styles/__pycache__/fruity.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/styles/__pycache__/gh_dark.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/styles/__pycache__/gruvbox.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/styles/__pycache__/igor.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/styles/__pycache__/inkpot.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/styles/__pycache__/lightbulb.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/styles/__pycache__/lilypond.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/styles/__pycache__/lovelace.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/styles/__pycache__/manni.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/styles/__pycache__/material.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/styles/__pycache__/monokai.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/styles/__pycache__/murphy.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/styles/__pycache__/native.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/styles/__pycache__/nord.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/styles/__pycache__/onedark.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/styles/__pycache__/paraiso_dark.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/styles/__pycache__/paraiso_light.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/styles/__pycache__/pastie.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/styles/__pycache__/perldoc.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/styles/__pycache__/rainbow_dash.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/styles/__pycache__/rrt.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/styles/__pycache__/sas.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/styles/__pycache__/solarized.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/styles/__pycache__/staroffice.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/styles/__pycache__/stata_dark.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/styles/__pycache__/stata_light.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/styles/__pycache__/tango.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/styles/__pycache__/trac.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/styles/__pycache__/vim.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/styles/__pycache__/vs.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/styles/__pycache__/xcode.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/styles/__pycache__/zenburn.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/__pycache__/token.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/__pycache__/unistring.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/__pycache__/util.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "bin/pygmentize", + "path_type": "unix_python_entry_point" + } + ], + "paths_version": 1 + }, + "requested_spec": "None", + "sha256": "af5f8867450dc292f98ea387d4d8945fc574284677c8f60eaa9846ede7387257", + "size": 860425, + "subdir": "noarch", + "timestamp": 1700608076000, + "url": "https://conda.anaconda.org/conda-forge/noarch/pygments-2.17.2-pyhd8ed1ab_0.conda", + "version": "2.17.2" +} \ No newline at end of file diff --git a/crates/pet-conda/tests/unix/anaconda3-2023.03/envs/env_python_3/conda-meta/python-3.12.2-hdf0ec26_0_cpython.json b/crates/pet-conda/tests/unix/anaconda3-2023.03/envs/env_python_3/conda-meta/python-3.12.2-hdf0ec26_0_cpython.json new file mode 100644 index 00000000..7b6c566f --- /dev/null +++ b/crates/pet-conda/tests/unix/anaconda3-2023.03/envs/env_python_3/conda-meta/python-3.12.2-hdf0ec26_0_cpython.json @@ -0,0 +1,15444 @@ +{ + "build": "hdf0ec26_0_cpython", + "build_number": 0, + "channel": "https://conda.anaconda.org/conda-forge/osx-arm64", + "constrains": [ + "python_abi 3.12.* *_cp312" + ], + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "libexpat >=2.5.0,<3.0a0", + "libffi >=3.4,<4.0a0", + "libsqlite >=3.45.1,<4.0a0", + "libzlib >=1.2.13,<1.3.0a0", + "ncurses >=6.4,<7.0a0", + "openssl >=3.2.1,<4.0a0", + "readline >=8.2,<9.0a0", + "tk >=8.6.13,<8.7.0a0", + "tzdata", + "xz >=5.2.6,<6.0a0", + "pip" + ], + "extracted_package_dir": "/Users/donjayamanne/miniconda3/pkgs/python-3.12.2-hdf0ec26_0_cpython", + "files": [ + "bin/2to3", + "bin/2to3-3.12", + "bin/idle3", + "bin/idle3.12", + "bin/pydoc", + "bin/pydoc3", + "bin/pydoc3.12", + "bin/python", + "bin/python3", + "bin/python3-config", + "bin/python3.1", + "bin/python3.12", + "bin/python3.12-config", + "include/python3.12/Python.h", + "include/python3.12/abstract.h", + "include/python3.12/bltinmodule.h", + "include/python3.12/boolobject.h", + "include/python3.12/bytearrayobject.h", + "include/python3.12/bytesobject.h", + "include/python3.12/ceval.h", + "include/python3.12/codecs.h", + "include/python3.12/compile.h", + "include/python3.12/complexobject.h", + "include/python3.12/cpython/abstract.h", + "include/python3.12/cpython/bytearrayobject.h", + "include/python3.12/cpython/bytesobject.h", + "include/python3.12/cpython/cellobject.h", + "include/python3.12/cpython/ceval.h", + "include/python3.12/cpython/classobject.h", + "include/python3.12/cpython/code.h", + "include/python3.12/cpython/compile.h", + "include/python3.12/cpython/complexobject.h", + "include/python3.12/cpython/context.h", + "include/python3.12/cpython/descrobject.h", + "include/python3.12/cpython/dictobject.h", + "include/python3.12/cpython/fileobject.h", + "include/python3.12/cpython/fileutils.h", + "include/python3.12/cpython/floatobject.h", + "include/python3.12/cpython/frameobject.h", + "include/python3.12/cpython/funcobject.h", + "include/python3.12/cpython/genobject.h", + "include/python3.12/cpython/import.h", + "include/python3.12/cpython/initconfig.h", + "include/python3.12/cpython/interpreteridobject.h", + "include/python3.12/cpython/listobject.h", + "include/python3.12/cpython/longintrepr.h", + "include/python3.12/cpython/longobject.h", + "include/python3.12/cpython/memoryobject.h", + "include/python3.12/cpython/methodobject.h", + "include/python3.12/cpython/modsupport.h", + "include/python3.12/cpython/object.h", + "include/python3.12/cpython/objimpl.h", + "include/python3.12/cpython/odictobject.h", + "include/python3.12/cpython/picklebufobject.h", + "include/python3.12/cpython/pthread_stubs.h", + "include/python3.12/cpython/pyctype.h", + "include/python3.12/cpython/pydebug.h", + "include/python3.12/cpython/pyerrors.h", + "include/python3.12/cpython/pyfpe.h", + "include/python3.12/cpython/pyframe.h", + "include/python3.12/cpython/pylifecycle.h", + "include/python3.12/cpython/pymem.h", + "include/python3.12/cpython/pystate.h", + "include/python3.12/cpython/pythonrun.h", + "include/python3.12/cpython/pythread.h", + "include/python3.12/cpython/pytime.h", + "include/python3.12/cpython/setobject.h", + "include/python3.12/cpython/sysmodule.h", + "include/python3.12/cpython/traceback.h", + "include/python3.12/cpython/tupleobject.h", + "include/python3.12/cpython/unicodeobject.h", + "include/python3.12/cpython/warnings.h", + "include/python3.12/cpython/weakrefobject.h", + "include/python3.12/datetime.h", + "include/python3.12/descrobject.h", + "include/python3.12/dictobject.h", + "include/python3.12/dynamic_annotations.h", + "include/python3.12/enumobject.h", + "include/python3.12/errcode.h", + "include/python3.12/exports.h", + "include/python3.12/fileobject.h", + "include/python3.12/fileutils.h", + "include/python3.12/floatobject.h", + "include/python3.12/frameobject.h", + "include/python3.12/genericaliasobject.h", + "include/python3.12/import.h", + "include/python3.12/internal/pycore_abstract.h", + "include/python3.12/internal/pycore_asdl.h", + "include/python3.12/internal/pycore_ast.h", + "include/python3.12/internal/pycore_ast_state.h", + "include/python3.12/internal/pycore_atexit.h", + "include/python3.12/internal/pycore_atomic.h", + "include/python3.12/internal/pycore_atomic_funcs.h", + "include/python3.12/internal/pycore_bitutils.h", + "include/python3.12/internal/pycore_blocks_output_buffer.h", + "include/python3.12/internal/pycore_bytes_methods.h", + "include/python3.12/internal/pycore_bytesobject.h", + "include/python3.12/internal/pycore_call.h", + "include/python3.12/internal/pycore_ceval.h", + "include/python3.12/internal/pycore_ceval_state.h", + "include/python3.12/internal/pycore_code.h", + "include/python3.12/internal/pycore_compile.h", + "include/python3.12/internal/pycore_condvar.h", + "include/python3.12/internal/pycore_context.h", + "include/python3.12/internal/pycore_descrobject.h", + "include/python3.12/internal/pycore_dict.h", + "include/python3.12/internal/pycore_dict_state.h", + "include/python3.12/internal/pycore_dtoa.h", + "include/python3.12/internal/pycore_emscripten_signal.h", + "include/python3.12/internal/pycore_exceptions.h", + "include/python3.12/internal/pycore_faulthandler.h", + "include/python3.12/internal/pycore_fileutils.h", + "include/python3.12/internal/pycore_fileutils_windows.h", + "include/python3.12/internal/pycore_floatobject.h", + "include/python3.12/internal/pycore_flowgraph.h", + "include/python3.12/internal/pycore_format.h", + "include/python3.12/internal/pycore_frame.h", + "include/python3.12/internal/pycore_function.h", + "include/python3.12/internal/pycore_gc.h", + "include/python3.12/internal/pycore_genobject.h", + "include/python3.12/internal/pycore_getopt.h", + "include/python3.12/internal/pycore_gil.h", + "include/python3.12/internal/pycore_global_objects.h", + "include/python3.12/internal/pycore_global_objects_fini_generated.h", + "include/python3.12/internal/pycore_global_strings.h", + "include/python3.12/internal/pycore_hamt.h", + "include/python3.12/internal/pycore_hashtable.h", + "include/python3.12/internal/pycore_import.h", + "include/python3.12/internal/pycore_initconfig.h", + "include/python3.12/internal/pycore_instruments.h", + "include/python3.12/internal/pycore_interp.h", + "include/python3.12/internal/pycore_intrinsics.h", + "include/python3.12/internal/pycore_list.h", + "include/python3.12/internal/pycore_long.h", + "include/python3.12/internal/pycore_memoryobject.h", + "include/python3.12/internal/pycore_moduleobject.h", + "include/python3.12/internal/pycore_namespace.h", + "include/python3.12/internal/pycore_object.h", + "include/python3.12/internal/pycore_object_state.h", + "include/python3.12/internal/pycore_obmalloc.h", + "include/python3.12/internal/pycore_obmalloc_init.h", + "include/python3.12/internal/pycore_opcode.h", + "include/python3.12/internal/pycore_opcode_utils.h", + "include/python3.12/internal/pycore_parser.h", + "include/python3.12/internal/pycore_pathconfig.h", + "include/python3.12/internal/pycore_pyarena.h", + "include/python3.12/internal/pycore_pyerrors.h", + "include/python3.12/internal/pycore_pyhash.h", + "include/python3.12/internal/pycore_pylifecycle.h", + "include/python3.12/internal/pycore_pymath.h", + "include/python3.12/internal/pycore_pymem.h", + "include/python3.12/internal/pycore_pymem_init.h", + "include/python3.12/internal/pycore_pystate.h", + "include/python3.12/internal/pycore_pythread.h", + "include/python3.12/internal/pycore_range.h", + "include/python3.12/internal/pycore_runtime.h", + "include/python3.12/internal/pycore_runtime_init.h", + "include/python3.12/internal/pycore_runtime_init_generated.h", + "include/python3.12/internal/pycore_signal.h", + "include/python3.12/internal/pycore_sliceobject.h", + "include/python3.12/internal/pycore_strhex.h", + "include/python3.12/internal/pycore_structseq.h", + "include/python3.12/internal/pycore_symtable.h", + "include/python3.12/internal/pycore_sysmodule.h", + "include/python3.12/internal/pycore_time.h", + "include/python3.12/internal/pycore_token.h", + "include/python3.12/internal/pycore_traceback.h", + "include/python3.12/internal/pycore_tracemalloc.h", + "include/python3.12/internal/pycore_tuple.h", + "include/python3.12/internal/pycore_typeobject.h", + "include/python3.12/internal/pycore_typevarobject.h", + "include/python3.12/internal/pycore_ucnhash.h", + "include/python3.12/internal/pycore_unicodeobject.h", + "include/python3.12/internal/pycore_unicodeobject_generated.h", + "include/python3.12/internal/pycore_unionobject.h", + "include/python3.12/internal/pycore_warnings.h", + "include/python3.12/interpreteridobject.h", + "include/python3.12/intrcheck.h", + "include/python3.12/iterobject.h", + "include/python3.12/listobject.h", + "include/python3.12/longobject.h", + "include/python3.12/marshal.h", + "include/python3.12/memoryobject.h", + "include/python3.12/methodobject.h", + "include/python3.12/modsupport.h", + "include/python3.12/moduleobject.h", + "include/python3.12/object.h", + "include/python3.12/objimpl.h", + "include/python3.12/opcode.h", + "include/python3.12/osdefs.h", + "include/python3.12/osmodule.h", + "include/python3.12/patchlevel.h", + "include/python3.12/py_curses.h", + "include/python3.12/pybuffer.h", + "include/python3.12/pycapsule.h", + "include/python3.12/pyconfig.h", + "include/python3.12/pydtrace.h", + "include/python3.12/pyerrors.h", + "include/python3.12/pyexpat.h", + "include/python3.12/pyframe.h", + "include/python3.12/pyhash.h", + "include/python3.12/pylifecycle.h", + "include/python3.12/pymacconfig.h", + "include/python3.12/pymacro.h", + "include/python3.12/pymath.h", + "include/python3.12/pymem.h", + "include/python3.12/pyport.h", + "include/python3.12/pystate.h", + "include/python3.12/pystats.h", + "include/python3.12/pystrcmp.h", + "include/python3.12/pystrtod.h", + "include/python3.12/pythonrun.h", + "include/python3.12/pythread.h", + "include/python3.12/pytypedefs.h", + "include/python3.12/rangeobject.h", + "include/python3.12/setobject.h", + "include/python3.12/sliceobject.h", + "include/python3.12/structmember.h", + "include/python3.12/structseq.h", + "include/python3.12/sysmodule.h", + "include/python3.12/traceback.h", + "include/python3.12/tracemalloc.h", + "include/python3.12/tupleobject.h", + "include/python3.12/typeslots.h", + "include/python3.12/unicodeobject.h", + "include/python3.12/warnings.h", + "include/python3.12/weakrefobject.h", + "lib/libpython3.12.dylib", + "lib/pkgconfig/python-3.12-embed.pc", + "lib/pkgconfig/python-3.12.pc", + "lib/pkgconfig/python3-embed.pc", + "lib/pkgconfig/python3.pc", + "lib/python3.1", + "lib/python3.12/LICENSE.txt", + "lib/python3.12/__future__.py", + "lib/python3.12/__hello__.py", + "lib/python3.12/__phello__/__init__.py", + "lib/python3.12/__phello__/__pycache__/__init__.cpython-312.pyc", + "lib/python3.12/__phello__/__pycache__/spam.cpython-312.pyc", + "lib/python3.12/__phello__/spam.py", + "lib/python3.12/__pycache__/__future__.cpython-312.pyc", + "lib/python3.12/__pycache__/__hello__.cpython-312.pyc", + "lib/python3.12/__pycache__/_aix_support.cpython-312.pyc", + "lib/python3.12/__pycache__/_collections_abc.cpython-312.pyc", + "lib/python3.12/__pycache__/_compat_pickle.cpython-312.pyc", + "lib/python3.12/__pycache__/_compression.cpython-312.pyc", + "lib/python3.12/__pycache__/_markupbase.cpython-312.pyc", + "lib/python3.12/__pycache__/_osx_support.cpython-312.pyc", + "lib/python3.12/__pycache__/_py_abc.cpython-312.pyc", + "lib/python3.12/__pycache__/_pydatetime.cpython-312.pyc", + "lib/python3.12/__pycache__/_pydecimal.cpython-312.pyc", + "lib/python3.12/__pycache__/_pyio.cpython-312.pyc", + "lib/python3.12/__pycache__/_pylong.cpython-312.pyc", + "lib/python3.12/__pycache__/_sitebuiltins.cpython-312.pyc", + "lib/python3.12/__pycache__/_strptime.cpython-312.pyc", + "lib/python3.12/__pycache__/_sysconfigdata__darwin_darwin.cpython-312.pyc", + "lib/python3.12/__pycache__/_sysconfigdata_arm64_apple_darwin20_0_0.cpython-312.pyc", + "lib/python3.12/__pycache__/_threading_local.cpython-312.pyc", + "lib/python3.12/__pycache__/_weakrefset.cpython-312.pyc", + "lib/python3.12/__pycache__/abc.cpython-312.pyc", + "lib/python3.12/__pycache__/aifc.cpython-312.pyc", + "lib/python3.12/__pycache__/antigravity.cpython-312.pyc", + "lib/python3.12/__pycache__/argparse.cpython-312.pyc", + "lib/python3.12/__pycache__/ast.cpython-312.pyc", + "lib/python3.12/__pycache__/base64.cpython-312.pyc", + "lib/python3.12/__pycache__/bdb.cpython-312.pyc", + "lib/python3.12/__pycache__/bisect.cpython-312.pyc", + "lib/python3.12/__pycache__/bz2.cpython-312.pyc", + "lib/python3.12/__pycache__/cProfile.cpython-312.pyc", + "lib/python3.12/__pycache__/calendar.cpython-312.pyc", + "lib/python3.12/__pycache__/cgi.cpython-312.pyc", + "lib/python3.12/__pycache__/cgitb.cpython-312.pyc", + "lib/python3.12/__pycache__/chunk.cpython-312.pyc", + "lib/python3.12/__pycache__/cmd.cpython-312.pyc", + "lib/python3.12/__pycache__/code.cpython-312.pyc", + "lib/python3.12/__pycache__/codecs.cpython-312.pyc", + "lib/python3.12/__pycache__/codeop.cpython-312.pyc", + "lib/python3.12/__pycache__/colorsys.cpython-312.pyc", + "lib/python3.12/__pycache__/compileall.cpython-312.pyc", + "lib/python3.12/__pycache__/configparser.cpython-312.pyc", + "lib/python3.12/__pycache__/contextlib.cpython-312.pyc", + "lib/python3.12/__pycache__/contextvars.cpython-312.pyc", + "lib/python3.12/__pycache__/copy.cpython-312.pyc", + "lib/python3.12/__pycache__/copyreg.cpython-312.pyc", + "lib/python3.12/__pycache__/crypt.cpython-312.pyc", + "lib/python3.12/__pycache__/csv.cpython-312.pyc", + "lib/python3.12/__pycache__/dataclasses.cpython-312.pyc", + "lib/python3.12/__pycache__/datetime.cpython-312.pyc", + "lib/python3.12/__pycache__/decimal.cpython-312.pyc", + "lib/python3.12/__pycache__/difflib.cpython-312.pyc", + "lib/python3.12/__pycache__/dis.cpython-312.pyc", + "lib/python3.12/__pycache__/doctest.cpython-312.pyc", + "lib/python3.12/__pycache__/enum.cpython-312.pyc", + "lib/python3.12/__pycache__/filecmp.cpython-312.pyc", + "lib/python3.12/__pycache__/fileinput.cpython-312.pyc", + "lib/python3.12/__pycache__/fnmatch.cpython-312.pyc", + "lib/python3.12/__pycache__/fractions.cpython-312.pyc", + "lib/python3.12/__pycache__/ftplib.cpython-312.pyc", + "lib/python3.12/__pycache__/functools.cpython-312.pyc", + "lib/python3.12/__pycache__/genericpath.cpython-312.pyc", + "lib/python3.12/__pycache__/getopt.cpython-312.pyc", + "lib/python3.12/__pycache__/getpass.cpython-312.pyc", + "lib/python3.12/__pycache__/gettext.cpython-312.pyc", + "lib/python3.12/__pycache__/glob.cpython-312.pyc", + "lib/python3.12/__pycache__/graphlib.cpython-312.pyc", + "lib/python3.12/__pycache__/gzip.cpython-312.pyc", + "lib/python3.12/__pycache__/hashlib.cpython-312.pyc", + "lib/python3.12/__pycache__/heapq.cpython-312.pyc", + "lib/python3.12/__pycache__/hmac.cpython-312.pyc", + "lib/python3.12/__pycache__/imaplib.cpython-312.pyc", + "lib/python3.12/__pycache__/imghdr.cpython-312.pyc", + "lib/python3.12/__pycache__/inspect.cpython-312.pyc", + "lib/python3.12/__pycache__/io.cpython-312.pyc", + "lib/python3.12/__pycache__/ipaddress.cpython-312.pyc", + "lib/python3.12/__pycache__/keyword.cpython-312.pyc", + "lib/python3.12/__pycache__/linecache.cpython-312.pyc", + "lib/python3.12/__pycache__/locale.cpython-312.pyc", + "lib/python3.12/__pycache__/lzma.cpython-312.pyc", + "lib/python3.12/__pycache__/mailbox.cpython-312.pyc", + "lib/python3.12/__pycache__/mailcap.cpython-312.pyc", + "lib/python3.12/__pycache__/mimetypes.cpython-312.pyc", + "lib/python3.12/__pycache__/modulefinder.cpython-312.pyc", + "lib/python3.12/__pycache__/netrc.cpython-312.pyc", + "lib/python3.12/__pycache__/nntplib.cpython-312.pyc", + "lib/python3.12/__pycache__/ntpath.cpython-312.pyc", + "lib/python3.12/__pycache__/nturl2path.cpython-312.pyc", + "lib/python3.12/__pycache__/numbers.cpython-312.pyc", + "lib/python3.12/__pycache__/opcode.cpython-312.pyc", + "lib/python3.12/__pycache__/operator.cpython-312.pyc", + "lib/python3.12/__pycache__/optparse.cpython-312.pyc", + "lib/python3.12/__pycache__/os.cpython-312.pyc", + "lib/python3.12/__pycache__/pathlib.cpython-312.pyc", + "lib/python3.12/__pycache__/pdb.cpython-312.pyc", + "lib/python3.12/__pycache__/pickle.cpython-312.pyc", + "lib/python3.12/__pycache__/pickletools.cpython-312.pyc", + "lib/python3.12/__pycache__/pipes.cpython-312.pyc", + "lib/python3.12/__pycache__/pkgutil.cpython-312.pyc", + "lib/python3.12/__pycache__/platform.cpython-312.pyc", + "lib/python3.12/__pycache__/plistlib.cpython-312.pyc", + "lib/python3.12/__pycache__/poplib.cpython-312.pyc", + "lib/python3.12/__pycache__/posixpath.cpython-312.pyc", + "lib/python3.12/__pycache__/pprint.cpython-312.pyc", + "lib/python3.12/__pycache__/profile.cpython-312.pyc", + "lib/python3.12/__pycache__/pstats.cpython-312.pyc", + "lib/python3.12/__pycache__/pty.cpython-312.pyc", + "lib/python3.12/__pycache__/py_compile.cpython-312.pyc", + "lib/python3.12/__pycache__/pyclbr.cpython-312.pyc", + "lib/python3.12/__pycache__/pydoc.cpython-312.pyc", + "lib/python3.12/__pycache__/queue.cpython-312.pyc", + "lib/python3.12/__pycache__/quopri.cpython-312.pyc", + "lib/python3.12/__pycache__/random.cpython-312.pyc", + "lib/python3.12/__pycache__/reprlib.cpython-312.pyc", + "lib/python3.12/__pycache__/rlcompleter.cpython-312.pyc", + "lib/python3.12/__pycache__/runpy.cpython-312.pyc", + "lib/python3.12/__pycache__/sched.cpython-312.pyc", + "lib/python3.12/__pycache__/secrets.cpython-312.pyc", + "lib/python3.12/__pycache__/selectors.cpython-312.pyc", + "lib/python3.12/__pycache__/shelve.cpython-312.pyc", + "lib/python3.12/__pycache__/shlex.cpython-312.pyc", + "lib/python3.12/__pycache__/shutil.cpython-312.pyc", + "lib/python3.12/__pycache__/signal.cpython-312.pyc", + "lib/python3.12/__pycache__/site.cpython-312.pyc", + "lib/python3.12/__pycache__/smtplib.cpython-312.pyc", + "lib/python3.12/__pycache__/sndhdr.cpython-312.pyc", + "lib/python3.12/__pycache__/socket.cpython-312.pyc", + "lib/python3.12/__pycache__/socketserver.cpython-312.pyc", + "lib/python3.12/__pycache__/sre_compile.cpython-312.pyc", + "lib/python3.12/__pycache__/sre_constants.cpython-312.pyc", + "lib/python3.12/__pycache__/sre_parse.cpython-312.pyc", + "lib/python3.12/__pycache__/ssl.cpython-312.pyc", + "lib/python3.12/__pycache__/stat.cpython-312.pyc", + "lib/python3.12/__pycache__/statistics.cpython-312.pyc", + "lib/python3.12/__pycache__/string.cpython-312.pyc", + "lib/python3.12/__pycache__/stringprep.cpython-312.pyc", + "lib/python3.12/__pycache__/struct.cpython-312.pyc", + "lib/python3.12/__pycache__/subprocess.cpython-312.pyc", + "lib/python3.12/__pycache__/sunau.cpython-312.pyc", + "lib/python3.12/__pycache__/symtable.cpython-312.pyc", + "lib/python3.12/__pycache__/sysconfig.cpython-312.pyc", + "lib/python3.12/__pycache__/tabnanny.cpython-312.pyc", + "lib/python3.12/__pycache__/tarfile.cpython-312.pyc", + "lib/python3.12/__pycache__/telnetlib.cpython-312.pyc", + "lib/python3.12/__pycache__/tempfile.cpython-312.pyc", + "lib/python3.12/__pycache__/textwrap.cpython-312.pyc", + "lib/python3.12/__pycache__/this.cpython-312.pyc", + "lib/python3.12/__pycache__/threading.cpython-312.pyc", + "lib/python3.12/__pycache__/timeit.cpython-312.pyc", + "lib/python3.12/__pycache__/token.cpython-312.pyc", + "lib/python3.12/__pycache__/tokenize.cpython-312.pyc", + "lib/python3.12/__pycache__/trace.cpython-312.pyc", + "lib/python3.12/__pycache__/traceback.cpython-312.pyc", + "lib/python3.12/__pycache__/tracemalloc.cpython-312.pyc", + "lib/python3.12/__pycache__/tty.cpython-312.pyc", + "lib/python3.12/__pycache__/turtle.cpython-312.pyc", + "lib/python3.12/__pycache__/types.cpython-312.pyc", + "lib/python3.12/__pycache__/typing.cpython-312.pyc", + "lib/python3.12/__pycache__/uu.cpython-312.pyc", + "lib/python3.12/__pycache__/uuid.cpython-312.pyc", + "lib/python3.12/__pycache__/warnings.cpython-312.pyc", + "lib/python3.12/__pycache__/wave.cpython-312.pyc", + "lib/python3.12/__pycache__/weakref.cpython-312.pyc", + "lib/python3.12/__pycache__/webbrowser.cpython-312.pyc", + "lib/python3.12/__pycache__/xdrlib.cpython-312.pyc", + "lib/python3.12/__pycache__/zipapp.cpython-312.pyc", + "lib/python3.12/__pycache__/zipimport.cpython-312.pyc", + "lib/python3.12/_aix_support.py", + "lib/python3.12/_collections_abc.py", + "lib/python3.12/_compat_pickle.py", + "lib/python3.12/_compression.py", + "lib/python3.12/_markupbase.py", + "lib/python3.12/_osx_support.py", + "lib/python3.12/_py_abc.py", + "lib/python3.12/_pydatetime.py", + "lib/python3.12/_pydecimal.py", + "lib/python3.12/_pyio.py", + "lib/python3.12/_pylong.py", + "lib/python3.12/_sitebuiltins.py", + "lib/python3.12/_strptime.py", + "lib/python3.12/_sysconfigdata__darwin_darwin.py", + "lib/python3.12/_sysconfigdata__darwin_darwin.py.orig", + "lib/python3.12/_sysconfigdata_arm64_apple_darwin20_0_0.py", + "lib/python3.12/_threading_local.py", + "lib/python3.12/_weakrefset.py", + "lib/python3.12/abc.py", + "lib/python3.12/aifc.py", + "lib/python3.12/antigravity.py", + "lib/python3.12/argparse.py", + "lib/python3.12/ast.py", + "lib/python3.12/asyncio/__init__.py", + "lib/python3.12/asyncio/__main__.py", + "lib/python3.12/asyncio/__pycache__/__init__.cpython-312.pyc", + "lib/python3.12/asyncio/__pycache__/__main__.cpython-312.pyc", + "lib/python3.12/asyncio/__pycache__/base_events.cpython-312.pyc", + "lib/python3.12/asyncio/__pycache__/base_futures.cpython-312.pyc", + "lib/python3.12/asyncio/__pycache__/base_subprocess.cpython-312.pyc", + "lib/python3.12/asyncio/__pycache__/base_tasks.cpython-312.pyc", + "lib/python3.12/asyncio/__pycache__/constants.cpython-312.pyc", + "lib/python3.12/asyncio/__pycache__/coroutines.cpython-312.pyc", + "lib/python3.12/asyncio/__pycache__/events.cpython-312.pyc", + "lib/python3.12/asyncio/__pycache__/exceptions.cpython-312.pyc", + "lib/python3.12/asyncio/__pycache__/format_helpers.cpython-312.pyc", + "lib/python3.12/asyncio/__pycache__/futures.cpython-312.pyc", + "lib/python3.12/asyncio/__pycache__/locks.cpython-312.pyc", + "lib/python3.12/asyncio/__pycache__/log.cpython-312.pyc", + "lib/python3.12/asyncio/__pycache__/mixins.cpython-312.pyc", + "lib/python3.12/asyncio/__pycache__/proactor_events.cpython-312.pyc", + "lib/python3.12/asyncio/__pycache__/protocols.cpython-312.pyc", + "lib/python3.12/asyncio/__pycache__/queues.cpython-312.pyc", + "lib/python3.12/asyncio/__pycache__/runners.cpython-312.pyc", + "lib/python3.12/asyncio/__pycache__/selector_events.cpython-312.pyc", + "lib/python3.12/asyncio/__pycache__/sslproto.cpython-312.pyc", + "lib/python3.12/asyncio/__pycache__/staggered.cpython-312.pyc", + "lib/python3.12/asyncio/__pycache__/streams.cpython-312.pyc", + "lib/python3.12/asyncio/__pycache__/subprocess.cpython-312.pyc", + "lib/python3.12/asyncio/__pycache__/taskgroups.cpython-312.pyc", + "lib/python3.12/asyncio/__pycache__/tasks.cpython-312.pyc", + "lib/python3.12/asyncio/__pycache__/threads.cpython-312.pyc", + "lib/python3.12/asyncio/__pycache__/timeouts.cpython-312.pyc", + "lib/python3.12/asyncio/__pycache__/transports.cpython-312.pyc", + "lib/python3.12/asyncio/__pycache__/trsock.cpython-312.pyc", + "lib/python3.12/asyncio/__pycache__/unix_events.cpython-312.pyc", + "lib/python3.12/asyncio/__pycache__/windows_events.cpython-312.pyc", + "lib/python3.12/asyncio/__pycache__/windows_utils.cpython-312.pyc", + "lib/python3.12/asyncio/base_events.py", + "lib/python3.12/asyncio/base_futures.py", + "lib/python3.12/asyncio/base_subprocess.py", + "lib/python3.12/asyncio/base_tasks.py", + "lib/python3.12/asyncio/constants.py", + "lib/python3.12/asyncio/coroutines.py", + "lib/python3.12/asyncio/events.py", + "lib/python3.12/asyncio/exceptions.py", + "lib/python3.12/asyncio/format_helpers.py", + "lib/python3.12/asyncio/futures.py", + "lib/python3.12/asyncio/locks.py", + "lib/python3.12/asyncio/log.py", + "lib/python3.12/asyncio/mixins.py", + "lib/python3.12/asyncio/proactor_events.py", + "lib/python3.12/asyncio/protocols.py", + "lib/python3.12/asyncio/queues.py", + "lib/python3.12/asyncio/runners.py", + "lib/python3.12/asyncio/selector_events.py", + "lib/python3.12/asyncio/sslproto.py", + "lib/python3.12/asyncio/staggered.py", + "lib/python3.12/asyncio/streams.py", + "lib/python3.12/asyncio/subprocess.py", + "lib/python3.12/asyncio/taskgroups.py", + "lib/python3.12/asyncio/tasks.py", + "lib/python3.12/asyncio/threads.py", + "lib/python3.12/asyncio/timeouts.py", + "lib/python3.12/asyncio/transports.py", + "lib/python3.12/asyncio/trsock.py", + "lib/python3.12/asyncio/unix_events.py", + "lib/python3.12/asyncio/windows_events.py", + "lib/python3.12/asyncio/windows_utils.py", + "lib/python3.12/base64.py", + "lib/python3.12/bdb.py", + "lib/python3.12/bisect.py", + "lib/python3.12/bz2.py", + "lib/python3.12/cProfile.py", + "lib/python3.12/calendar.py", + "lib/python3.12/cgi.py", + "lib/python3.12/cgitb.py", + "lib/python3.12/chunk.py", + "lib/python3.12/cmd.py", + "lib/python3.12/code.py", + "lib/python3.12/codecs.py", + "lib/python3.12/codeop.py", + "lib/python3.12/collections/__init__.py", + "lib/python3.12/collections/__pycache__/__init__.cpython-312.pyc", + "lib/python3.12/collections/__pycache__/abc.cpython-312.pyc", + "lib/python3.12/collections/abc.py", + "lib/python3.12/colorsys.py", + "lib/python3.12/compileall.py", + "lib/python3.12/concurrent/__init__.py", + "lib/python3.12/concurrent/__pycache__/__init__.cpython-312.pyc", + "lib/python3.12/concurrent/futures/__init__.py", + "lib/python3.12/concurrent/futures/__pycache__/__init__.cpython-312.pyc", + "lib/python3.12/concurrent/futures/__pycache__/_base.cpython-312.pyc", + "lib/python3.12/concurrent/futures/__pycache__/process.cpython-312.pyc", + "lib/python3.12/concurrent/futures/__pycache__/thread.cpython-312.pyc", + "lib/python3.12/concurrent/futures/_base.py", + "lib/python3.12/concurrent/futures/process.py", + "lib/python3.12/concurrent/futures/thread.py", + "lib/python3.12/config-3.12-darwin/Makefile", + "lib/python3.12/config-3.12-darwin/Setup", + "lib/python3.12/config-3.12-darwin/Setup.bootstrap", + "lib/python3.12/config-3.12-darwin/Setup.local", + "lib/python3.12/config-3.12-darwin/Setup.stdlib", + "lib/python3.12/config-3.12-darwin/__pycache__/python-config.cpython-312.pyc", + "lib/python3.12/config-3.12-darwin/config.c", + "lib/python3.12/config-3.12-darwin/config.c.in", + "lib/python3.12/config-3.12-darwin/install-sh", + "lib/python3.12/config-3.12-darwin/makesetup", + "lib/python3.12/config-3.12-darwin/python-config.py", + "lib/python3.12/config-3.12-darwin/python.o", + "lib/python3.12/configparser.py", + "lib/python3.12/contextlib.py", + "lib/python3.12/contextvars.py", + "lib/python3.12/copy.py", + "lib/python3.12/copyreg.py", + "lib/python3.12/crypt.py", + "lib/python3.12/csv.py", + "lib/python3.12/ctypes/__init__.py", + "lib/python3.12/ctypes/__pycache__/__init__.cpython-312.pyc", + "lib/python3.12/ctypes/__pycache__/_aix.cpython-312.pyc", + "lib/python3.12/ctypes/__pycache__/_endian.cpython-312.pyc", + "lib/python3.12/ctypes/__pycache__/util.cpython-312.pyc", + "lib/python3.12/ctypes/__pycache__/wintypes.cpython-312.pyc", + "lib/python3.12/ctypes/_aix.py", + "lib/python3.12/ctypes/_endian.py", + "lib/python3.12/ctypes/macholib/README.ctypes", + "lib/python3.12/ctypes/macholib/__init__.py", + "lib/python3.12/ctypes/macholib/__pycache__/__init__.cpython-312.pyc", + "lib/python3.12/ctypes/macholib/__pycache__/dyld.cpython-312.pyc", + "lib/python3.12/ctypes/macholib/__pycache__/dylib.cpython-312.pyc", + "lib/python3.12/ctypes/macholib/__pycache__/framework.cpython-312.pyc", + "lib/python3.12/ctypes/macholib/dyld.py", + "lib/python3.12/ctypes/macholib/dylib.py", + "lib/python3.12/ctypes/macholib/fetch_macholib", + "lib/python3.12/ctypes/macholib/fetch_macholib.bat", + "lib/python3.12/ctypes/macholib/framework.py", + "lib/python3.12/ctypes/util.py", + "lib/python3.12/ctypes/wintypes.py", + "lib/python3.12/curses/__init__.py", + "lib/python3.12/curses/__pycache__/__init__.cpython-312.pyc", + "lib/python3.12/curses/__pycache__/ascii.cpython-312.pyc", + "lib/python3.12/curses/__pycache__/has_key.cpython-312.pyc", + "lib/python3.12/curses/__pycache__/panel.cpython-312.pyc", + "lib/python3.12/curses/__pycache__/textpad.cpython-312.pyc", + "lib/python3.12/curses/ascii.py", + "lib/python3.12/curses/has_key.py", + "lib/python3.12/curses/panel.py", + "lib/python3.12/curses/textpad.py", + "lib/python3.12/dataclasses.py", + "lib/python3.12/datetime.py", + "lib/python3.12/dbm/__init__.py", + "lib/python3.12/dbm/__pycache__/__init__.cpython-312.pyc", + "lib/python3.12/dbm/__pycache__/dumb.cpython-312.pyc", + "lib/python3.12/dbm/__pycache__/gnu.cpython-312.pyc", + "lib/python3.12/dbm/__pycache__/ndbm.cpython-312.pyc", + "lib/python3.12/dbm/dumb.py", + "lib/python3.12/dbm/gnu.py", + "lib/python3.12/dbm/ndbm.py", + "lib/python3.12/decimal.py", + "lib/python3.12/difflib.py", + "lib/python3.12/dis.py", + "lib/python3.12/doctest.py", + "lib/python3.12/email/__init__.py", + "lib/python3.12/email/__pycache__/__init__.cpython-312.pyc", + "lib/python3.12/email/__pycache__/_encoded_words.cpython-312.pyc", + "lib/python3.12/email/__pycache__/_header_value_parser.cpython-312.pyc", + "lib/python3.12/email/__pycache__/_parseaddr.cpython-312.pyc", + "lib/python3.12/email/__pycache__/_policybase.cpython-312.pyc", + "lib/python3.12/email/__pycache__/base64mime.cpython-312.pyc", + "lib/python3.12/email/__pycache__/charset.cpython-312.pyc", + "lib/python3.12/email/__pycache__/contentmanager.cpython-312.pyc", + "lib/python3.12/email/__pycache__/encoders.cpython-312.pyc", + "lib/python3.12/email/__pycache__/errors.cpython-312.pyc", + "lib/python3.12/email/__pycache__/feedparser.cpython-312.pyc", + "lib/python3.12/email/__pycache__/generator.cpython-312.pyc", + "lib/python3.12/email/__pycache__/header.cpython-312.pyc", + "lib/python3.12/email/__pycache__/headerregistry.cpython-312.pyc", + "lib/python3.12/email/__pycache__/iterators.cpython-312.pyc", + "lib/python3.12/email/__pycache__/message.cpython-312.pyc", + "lib/python3.12/email/__pycache__/parser.cpython-312.pyc", + "lib/python3.12/email/__pycache__/policy.cpython-312.pyc", + "lib/python3.12/email/__pycache__/quoprimime.cpython-312.pyc", + "lib/python3.12/email/__pycache__/utils.cpython-312.pyc", + "lib/python3.12/email/_encoded_words.py", + "lib/python3.12/email/_header_value_parser.py", + "lib/python3.12/email/_parseaddr.py", + "lib/python3.12/email/_policybase.py", + "lib/python3.12/email/architecture.rst", + "lib/python3.12/email/base64mime.py", + "lib/python3.12/email/charset.py", + "lib/python3.12/email/contentmanager.py", + "lib/python3.12/email/encoders.py", + "lib/python3.12/email/errors.py", + "lib/python3.12/email/feedparser.py", + "lib/python3.12/email/generator.py", + "lib/python3.12/email/header.py", + "lib/python3.12/email/headerregistry.py", + "lib/python3.12/email/iterators.py", + "lib/python3.12/email/message.py", + "lib/python3.12/email/mime/__init__.py", + "lib/python3.12/email/mime/__pycache__/__init__.cpython-312.pyc", + "lib/python3.12/email/mime/__pycache__/application.cpython-312.pyc", + "lib/python3.12/email/mime/__pycache__/audio.cpython-312.pyc", + "lib/python3.12/email/mime/__pycache__/base.cpython-312.pyc", + "lib/python3.12/email/mime/__pycache__/image.cpython-312.pyc", + "lib/python3.12/email/mime/__pycache__/message.cpython-312.pyc", + "lib/python3.12/email/mime/__pycache__/multipart.cpython-312.pyc", + "lib/python3.12/email/mime/__pycache__/nonmultipart.cpython-312.pyc", + "lib/python3.12/email/mime/__pycache__/text.cpython-312.pyc", + "lib/python3.12/email/mime/application.py", + "lib/python3.12/email/mime/audio.py", + "lib/python3.12/email/mime/base.py", + "lib/python3.12/email/mime/image.py", + "lib/python3.12/email/mime/message.py", + "lib/python3.12/email/mime/multipart.py", + "lib/python3.12/email/mime/nonmultipart.py", + "lib/python3.12/email/mime/text.py", + "lib/python3.12/email/parser.py", + "lib/python3.12/email/policy.py", + "lib/python3.12/email/quoprimime.py", + "lib/python3.12/email/utils.py", + "lib/python3.12/encodings/__init__.py", + "lib/python3.12/encodings/__pycache__/__init__.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/aliases.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/ascii.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/base64_codec.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/big5.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/big5hkscs.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/bz2_codec.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/charmap.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/cp037.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/cp1006.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/cp1026.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/cp1125.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/cp1140.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/cp1250.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/cp1251.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/cp1252.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/cp1253.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/cp1254.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/cp1255.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/cp1256.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/cp1257.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/cp1258.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/cp273.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/cp424.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/cp437.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/cp500.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/cp720.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/cp737.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/cp775.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/cp850.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/cp852.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/cp855.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/cp856.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/cp857.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/cp858.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/cp860.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/cp861.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/cp862.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/cp863.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/cp864.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/cp865.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/cp866.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/cp869.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/cp874.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/cp875.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/cp932.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/cp949.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/cp950.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/euc_jis_2004.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/euc_jisx0213.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/euc_jp.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/euc_kr.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/gb18030.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/gb2312.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/gbk.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/hex_codec.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/hp_roman8.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/hz.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/idna.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/iso2022_jp.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/iso2022_jp_1.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/iso2022_jp_2.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/iso2022_jp_2004.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/iso2022_jp_3.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/iso2022_jp_ext.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/iso2022_kr.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/iso8859_1.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/iso8859_10.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/iso8859_11.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/iso8859_13.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/iso8859_14.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/iso8859_15.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/iso8859_16.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/iso8859_2.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/iso8859_3.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/iso8859_4.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/iso8859_5.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/iso8859_6.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/iso8859_7.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/iso8859_8.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/iso8859_9.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/johab.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/koi8_r.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/koi8_t.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/koi8_u.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/kz1048.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/latin_1.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/mac_arabic.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/mac_croatian.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/mac_cyrillic.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/mac_farsi.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/mac_greek.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/mac_iceland.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/mac_latin2.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/mac_roman.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/mac_romanian.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/mac_turkish.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/mbcs.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/oem.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/palmos.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/ptcp154.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/punycode.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/quopri_codec.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/raw_unicode_escape.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/rot_13.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/shift_jis.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/shift_jis_2004.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/shift_jisx0213.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/tis_620.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/undefined.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/unicode_escape.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/utf_16.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/utf_16_be.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/utf_16_le.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/utf_32.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/utf_32_be.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/utf_32_le.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/utf_7.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/utf_8.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/utf_8_sig.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/uu_codec.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/zlib_codec.cpython-312.pyc", + "lib/python3.12/encodings/aliases.py", + "lib/python3.12/encodings/ascii.py", + "lib/python3.12/encodings/base64_codec.py", + "lib/python3.12/encodings/big5.py", + "lib/python3.12/encodings/big5hkscs.py", + "lib/python3.12/encodings/bz2_codec.py", + "lib/python3.12/encodings/charmap.py", + "lib/python3.12/encodings/cp037.py", + "lib/python3.12/encodings/cp1006.py", + "lib/python3.12/encodings/cp1026.py", + "lib/python3.12/encodings/cp1125.py", + "lib/python3.12/encodings/cp1140.py", + "lib/python3.12/encodings/cp1250.py", + "lib/python3.12/encodings/cp1251.py", + "lib/python3.12/encodings/cp1252.py", + "lib/python3.12/encodings/cp1253.py", + "lib/python3.12/encodings/cp1254.py", + "lib/python3.12/encodings/cp1255.py", + "lib/python3.12/encodings/cp1256.py", + "lib/python3.12/encodings/cp1257.py", + "lib/python3.12/encodings/cp1258.py", + "lib/python3.12/encodings/cp273.py", + "lib/python3.12/encodings/cp424.py", + "lib/python3.12/encodings/cp437.py", + "lib/python3.12/encodings/cp500.py", + "lib/python3.12/encodings/cp720.py", + "lib/python3.12/encodings/cp737.py", + "lib/python3.12/encodings/cp775.py", + "lib/python3.12/encodings/cp850.py", + "lib/python3.12/encodings/cp852.py", + "lib/python3.12/encodings/cp855.py", + "lib/python3.12/encodings/cp856.py", + "lib/python3.12/encodings/cp857.py", + "lib/python3.12/encodings/cp858.py", + "lib/python3.12/encodings/cp860.py", + "lib/python3.12/encodings/cp861.py", + "lib/python3.12/encodings/cp862.py", + "lib/python3.12/encodings/cp863.py", + "lib/python3.12/encodings/cp864.py", + "lib/python3.12/encodings/cp865.py", + "lib/python3.12/encodings/cp866.py", + "lib/python3.12/encodings/cp869.py", + "lib/python3.12/encodings/cp874.py", + "lib/python3.12/encodings/cp875.py", + "lib/python3.12/encodings/cp932.py", + "lib/python3.12/encodings/cp949.py", + "lib/python3.12/encodings/cp950.py", + "lib/python3.12/encodings/euc_jis_2004.py", + "lib/python3.12/encodings/euc_jisx0213.py", + "lib/python3.12/encodings/euc_jp.py", + "lib/python3.12/encodings/euc_kr.py", + "lib/python3.12/encodings/gb18030.py", + "lib/python3.12/encodings/gb2312.py", + "lib/python3.12/encodings/gbk.py", + "lib/python3.12/encodings/hex_codec.py", + "lib/python3.12/encodings/hp_roman8.py", + "lib/python3.12/encodings/hz.py", + "lib/python3.12/encodings/idna.py", + "lib/python3.12/encodings/iso2022_jp.py", + "lib/python3.12/encodings/iso2022_jp_1.py", + "lib/python3.12/encodings/iso2022_jp_2.py", + "lib/python3.12/encodings/iso2022_jp_2004.py", + "lib/python3.12/encodings/iso2022_jp_3.py", + "lib/python3.12/encodings/iso2022_jp_ext.py", + "lib/python3.12/encodings/iso2022_kr.py", + "lib/python3.12/encodings/iso8859_1.py", + "lib/python3.12/encodings/iso8859_10.py", + "lib/python3.12/encodings/iso8859_11.py", + "lib/python3.12/encodings/iso8859_13.py", + "lib/python3.12/encodings/iso8859_14.py", + "lib/python3.12/encodings/iso8859_15.py", + "lib/python3.12/encodings/iso8859_16.py", + "lib/python3.12/encodings/iso8859_2.py", + "lib/python3.12/encodings/iso8859_3.py", + "lib/python3.12/encodings/iso8859_4.py", + "lib/python3.12/encodings/iso8859_5.py", + "lib/python3.12/encodings/iso8859_6.py", + "lib/python3.12/encodings/iso8859_7.py", + "lib/python3.12/encodings/iso8859_8.py", + "lib/python3.12/encodings/iso8859_9.py", + "lib/python3.12/encodings/johab.py", + "lib/python3.12/encodings/koi8_r.py", + "lib/python3.12/encodings/koi8_t.py", + "lib/python3.12/encodings/koi8_u.py", + "lib/python3.12/encodings/kz1048.py", + "lib/python3.12/encodings/latin_1.py", + "lib/python3.12/encodings/mac_arabic.py", + "lib/python3.12/encodings/mac_croatian.py", + "lib/python3.12/encodings/mac_cyrillic.py", + "lib/python3.12/encodings/mac_farsi.py", + "lib/python3.12/encodings/mac_greek.py", + "lib/python3.12/encodings/mac_iceland.py", + "lib/python3.12/encodings/mac_latin2.py", + "lib/python3.12/encodings/mac_roman.py", + "lib/python3.12/encodings/mac_romanian.py", + "lib/python3.12/encodings/mac_turkish.py", + "lib/python3.12/encodings/mbcs.py", + "lib/python3.12/encodings/oem.py", + "lib/python3.12/encodings/palmos.py", + "lib/python3.12/encodings/ptcp154.py", + "lib/python3.12/encodings/punycode.py", + "lib/python3.12/encodings/quopri_codec.py", + "lib/python3.12/encodings/raw_unicode_escape.py", + "lib/python3.12/encodings/rot_13.py", + "lib/python3.12/encodings/shift_jis.py", + "lib/python3.12/encodings/shift_jis_2004.py", + "lib/python3.12/encodings/shift_jisx0213.py", + "lib/python3.12/encodings/tis_620.py", + "lib/python3.12/encodings/undefined.py", + "lib/python3.12/encodings/unicode_escape.py", + "lib/python3.12/encodings/utf_16.py", + "lib/python3.12/encodings/utf_16_be.py", + "lib/python3.12/encodings/utf_16_le.py", + "lib/python3.12/encodings/utf_32.py", + "lib/python3.12/encodings/utf_32_be.py", + "lib/python3.12/encodings/utf_32_le.py", + "lib/python3.12/encodings/utf_7.py", + "lib/python3.12/encodings/utf_8.py", + "lib/python3.12/encodings/utf_8_sig.py", + "lib/python3.12/encodings/uu_codec.py", + "lib/python3.12/encodings/zlib_codec.py", + "lib/python3.12/ensurepip/__init__.py", + "lib/python3.12/ensurepip/__main__.py", + "lib/python3.12/ensurepip/__pycache__/__init__.cpython-312.pyc", + "lib/python3.12/ensurepip/__pycache__/__main__.cpython-312.pyc", + "lib/python3.12/ensurepip/__pycache__/_uninstall.cpython-312.pyc", + "lib/python3.12/ensurepip/_bundled/pip-24.0-py3-none-any.whl", + "lib/python3.12/ensurepip/_uninstall.py", + "lib/python3.12/enum.py", + "lib/python3.12/filecmp.py", + "lib/python3.12/fileinput.py", + "lib/python3.12/fnmatch.py", + "lib/python3.12/fractions.py", + "lib/python3.12/ftplib.py", + "lib/python3.12/functools.py", + "lib/python3.12/genericpath.py", + "lib/python3.12/getopt.py", + "lib/python3.12/getpass.py", + "lib/python3.12/gettext.py", + "lib/python3.12/glob.py", + "lib/python3.12/graphlib.py", + "lib/python3.12/gzip.py", + "lib/python3.12/hashlib.py", + "lib/python3.12/heapq.py", + "lib/python3.12/hmac.py", + "lib/python3.12/html/__init__.py", + "lib/python3.12/html/__pycache__/__init__.cpython-312.pyc", + "lib/python3.12/html/__pycache__/entities.cpython-312.pyc", + "lib/python3.12/html/__pycache__/parser.cpython-312.pyc", + "lib/python3.12/html/entities.py", + "lib/python3.12/html/parser.py", + "lib/python3.12/http/__init__.py", + "lib/python3.12/http/__pycache__/__init__.cpython-312.pyc", + "lib/python3.12/http/__pycache__/client.cpython-312.pyc", + "lib/python3.12/http/__pycache__/cookiejar.cpython-312.pyc", + "lib/python3.12/http/__pycache__/cookies.cpython-312.pyc", + "lib/python3.12/http/__pycache__/server.cpython-312.pyc", + "lib/python3.12/http/client.py", + "lib/python3.12/http/cookiejar.py", + "lib/python3.12/http/cookies.py", + "lib/python3.12/http/server.py", + "lib/python3.12/idlelib/CREDITS.txt", + "lib/python3.12/idlelib/ChangeLog", + "lib/python3.12/idlelib/HISTORY.txt", + "lib/python3.12/idlelib/Icons/README.txt", + "lib/python3.12/idlelib/Icons/folder.gif", + "lib/python3.12/idlelib/Icons/idle.ico", + "lib/python3.12/idlelib/Icons/idle_16.gif", + "lib/python3.12/idlelib/Icons/idle_16.png", + "lib/python3.12/idlelib/Icons/idle_256.png", + "lib/python3.12/idlelib/Icons/idle_32.gif", + "lib/python3.12/idlelib/Icons/idle_32.png", + "lib/python3.12/idlelib/Icons/idle_48.gif", + "lib/python3.12/idlelib/Icons/idle_48.png", + "lib/python3.12/idlelib/Icons/minusnode.gif", + "lib/python3.12/idlelib/Icons/openfolder.gif", + "lib/python3.12/idlelib/Icons/plusnode.gif", + "lib/python3.12/idlelib/Icons/python.gif", + "lib/python3.12/idlelib/Icons/tk.gif", + "lib/python3.12/idlelib/NEWS2x.txt", + "lib/python3.12/idlelib/News3.txt", + "lib/python3.12/idlelib/README.txt", + "lib/python3.12/idlelib/TODO.txt", + "lib/python3.12/idlelib/__init__.py", + "lib/python3.12/idlelib/__main__.py", + "lib/python3.12/idlelib/__pycache__/__init__.cpython-312.pyc", + "lib/python3.12/idlelib/__pycache__/__main__.cpython-312.pyc", + "lib/python3.12/idlelib/__pycache__/autocomplete.cpython-312.pyc", + "lib/python3.12/idlelib/__pycache__/autocomplete_w.cpython-312.pyc", + "lib/python3.12/idlelib/__pycache__/autoexpand.cpython-312.pyc", + "lib/python3.12/idlelib/__pycache__/browser.cpython-312.pyc", + "lib/python3.12/idlelib/__pycache__/calltip.cpython-312.pyc", + "lib/python3.12/idlelib/__pycache__/calltip_w.cpython-312.pyc", + "lib/python3.12/idlelib/__pycache__/codecontext.cpython-312.pyc", + "lib/python3.12/idlelib/__pycache__/colorizer.cpython-312.pyc", + "lib/python3.12/idlelib/__pycache__/config.cpython-312.pyc", + "lib/python3.12/idlelib/__pycache__/config_key.cpython-312.pyc", + "lib/python3.12/idlelib/__pycache__/configdialog.cpython-312.pyc", + "lib/python3.12/idlelib/__pycache__/debugger.cpython-312.pyc", + "lib/python3.12/idlelib/__pycache__/debugger_r.cpython-312.pyc", + "lib/python3.12/idlelib/__pycache__/debugobj.cpython-312.pyc", + "lib/python3.12/idlelib/__pycache__/debugobj_r.cpython-312.pyc", + "lib/python3.12/idlelib/__pycache__/delegator.cpython-312.pyc", + "lib/python3.12/idlelib/__pycache__/dynoption.cpython-312.pyc", + "lib/python3.12/idlelib/__pycache__/editor.cpython-312.pyc", + "lib/python3.12/idlelib/__pycache__/filelist.cpython-312.pyc", + "lib/python3.12/idlelib/__pycache__/format.cpython-312.pyc", + "lib/python3.12/idlelib/__pycache__/grep.cpython-312.pyc", + "lib/python3.12/idlelib/__pycache__/help.cpython-312.pyc", + "lib/python3.12/idlelib/__pycache__/help_about.cpython-312.pyc", + "lib/python3.12/idlelib/__pycache__/history.cpython-312.pyc", + "lib/python3.12/idlelib/__pycache__/hyperparser.cpython-312.pyc", + "lib/python3.12/idlelib/__pycache__/idle.cpython-312.pyc", + "lib/python3.12/idlelib/__pycache__/iomenu.cpython-312.pyc", + "lib/python3.12/idlelib/__pycache__/macosx.cpython-312.pyc", + "lib/python3.12/idlelib/__pycache__/mainmenu.cpython-312.pyc", + "lib/python3.12/idlelib/__pycache__/multicall.cpython-312.pyc", + "lib/python3.12/idlelib/__pycache__/outwin.cpython-312.pyc", + "lib/python3.12/idlelib/__pycache__/parenmatch.cpython-312.pyc", + "lib/python3.12/idlelib/__pycache__/pathbrowser.cpython-312.pyc", + "lib/python3.12/idlelib/__pycache__/percolator.cpython-312.pyc", + "lib/python3.12/idlelib/__pycache__/pyparse.cpython-312.pyc", + "lib/python3.12/idlelib/__pycache__/pyshell.cpython-312.pyc", + "lib/python3.12/idlelib/__pycache__/query.cpython-312.pyc", + "lib/python3.12/idlelib/__pycache__/redirector.cpython-312.pyc", + "lib/python3.12/idlelib/__pycache__/replace.cpython-312.pyc", + "lib/python3.12/idlelib/__pycache__/rpc.cpython-312.pyc", + "lib/python3.12/idlelib/__pycache__/run.cpython-312.pyc", + "lib/python3.12/idlelib/__pycache__/runscript.cpython-312.pyc", + "lib/python3.12/idlelib/__pycache__/scrolledlist.cpython-312.pyc", + "lib/python3.12/idlelib/__pycache__/search.cpython-312.pyc", + "lib/python3.12/idlelib/__pycache__/searchbase.cpython-312.pyc", + "lib/python3.12/idlelib/__pycache__/searchengine.cpython-312.pyc", + "lib/python3.12/idlelib/__pycache__/sidebar.cpython-312.pyc", + "lib/python3.12/idlelib/__pycache__/squeezer.cpython-312.pyc", + "lib/python3.12/idlelib/__pycache__/stackviewer.cpython-312.pyc", + "lib/python3.12/idlelib/__pycache__/statusbar.cpython-312.pyc", + "lib/python3.12/idlelib/__pycache__/textview.cpython-312.pyc", + "lib/python3.12/idlelib/__pycache__/tooltip.cpython-312.pyc", + "lib/python3.12/idlelib/__pycache__/tree.cpython-312.pyc", + "lib/python3.12/idlelib/__pycache__/undo.cpython-312.pyc", + "lib/python3.12/idlelib/__pycache__/util.cpython-312.pyc", + "lib/python3.12/idlelib/__pycache__/window.cpython-312.pyc", + "lib/python3.12/idlelib/__pycache__/zoomheight.cpython-312.pyc", + "lib/python3.12/idlelib/__pycache__/zzdummy.cpython-312.pyc", + "lib/python3.12/idlelib/autocomplete.py", + "lib/python3.12/idlelib/autocomplete_w.py", + "lib/python3.12/idlelib/autoexpand.py", + "lib/python3.12/idlelib/browser.py", + "lib/python3.12/idlelib/calltip.py", + "lib/python3.12/idlelib/calltip_w.py", + "lib/python3.12/idlelib/codecontext.py", + "lib/python3.12/idlelib/colorizer.py", + "lib/python3.12/idlelib/config-extensions.def", + "lib/python3.12/idlelib/config-highlight.def", + "lib/python3.12/idlelib/config-keys.def", + "lib/python3.12/idlelib/config-main.def", + "lib/python3.12/idlelib/config.py", + "lib/python3.12/idlelib/config_key.py", + "lib/python3.12/idlelib/configdialog.py", + "lib/python3.12/idlelib/debugger.py", + "lib/python3.12/idlelib/debugger_r.py", + "lib/python3.12/idlelib/debugobj.py", + "lib/python3.12/idlelib/debugobj_r.py", + "lib/python3.12/idlelib/delegator.py", + "lib/python3.12/idlelib/dynoption.py", + "lib/python3.12/idlelib/editor.py", + "lib/python3.12/idlelib/extend.txt", + "lib/python3.12/idlelib/filelist.py", + "lib/python3.12/idlelib/format.py", + "lib/python3.12/idlelib/grep.py", + "lib/python3.12/idlelib/help.html", + "lib/python3.12/idlelib/help.py", + "lib/python3.12/idlelib/help_about.py", + "lib/python3.12/idlelib/history.py", + "lib/python3.12/idlelib/hyperparser.py", + "lib/python3.12/idlelib/idle.bat", + "lib/python3.12/idlelib/idle.py", + "lib/python3.12/idlelib/idle.pyw", + "lib/python3.12/idlelib/idle_test/README.txt", + "lib/python3.12/idlelib/idle_test/__init__.py", + "lib/python3.12/idlelib/idle_test/__pycache__/__init__.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/htest.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/mock_idle.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/mock_tk.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/template.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/test_autocomplete.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/test_autocomplete_w.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/test_autoexpand.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/test_browser.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/test_calltip.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/test_calltip_w.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/test_codecontext.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/test_colorizer.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/test_config.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/test_config_key.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/test_configdialog.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/test_debugger.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/test_debugger_r.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/test_debugobj.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/test_debugobj_r.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/test_delegator.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/test_editmenu.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/test_editor.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/test_filelist.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/test_format.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/test_grep.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/test_help.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/test_help_about.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/test_history.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/test_hyperparser.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/test_iomenu.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/test_macosx.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/test_mainmenu.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/test_multicall.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/test_outwin.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/test_parenmatch.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/test_pathbrowser.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/test_percolator.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/test_pyparse.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/test_pyshell.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/test_query.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/test_redirector.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/test_replace.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/test_rpc.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/test_run.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/test_runscript.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/test_scrolledlist.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/test_search.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/test_searchbase.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/test_searchengine.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/test_sidebar.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/test_squeezer.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/test_stackviewer.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/test_statusbar.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/test_text.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/test_textview.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/test_tooltip.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/test_tree.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/test_undo.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/test_util.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/test_warning.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/test_window.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/test_zoomheight.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/test_zzdummy.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/tkinter_testing_utils.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/example_noext", + "lib/python3.12/idlelib/idle_test/example_stub.pyi", + "lib/python3.12/idlelib/idle_test/htest.py", + "lib/python3.12/idlelib/idle_test/mock_idle.py", + "lib/python3.12/idlelib/idle_test/mock_tk.py", + "lib/python3.12/idlelib/idle_test/template.py", + "lib/python3.12/idlelib/idle_test/test_autocomplete.py", + "lib/python3.12/idlelib/idle_test/test_autocomplete_w.py", + "lib/python3.12/idlelib/idle_test/test_autoexpand.py", + "lib/python3.12/idlelib/idle_test/test_browser.py", + "lib/python3.12/idlelib/idle_test/test_calltip.py", + "lib/python3.12/idlelib/idle_test/test_calltip_w.py", + "lib/python3.12/idlelib/idle_test/test_codecontext.py", + "lib/python3.12/idlelib/idle_test/test_colorizer.py", + "lib/python3.12/idlelib/idle_test/test_config.py", + "lib/python3.12/idlelib/idle_test/test_config_key.py", + "lib/python3.12/idlelib/idle_test/test_configdialog.py", + "lib/python3.12/idlelib/idle_test/test_debugger.py", + "lib/python3.12/idlelib/idle_test/test_debugger_r.py", + "lib/python3.12/idlelib/idle_test/test_debugobj.py", + "lib/python3.12/idlelib/idle_test/test_debugobj_r.py", + "lib/python3.12/idlelib/idle_test/test_delegator.py", + "lib/python3.12/idlelib/idle_test/test_editmenu.py", + "lib/python3.12/idlelib/idle_test/test_editor.py", + "lib/python3.12/idlelib/idle_test/test_filelist.py", + "lib/python3.12/idlelib/idle_test/test_format.py", + "lib/python3.12/idlelib/idle_test/test_grep.py", + "lib/python3.12/idlelib/idle_test/test_help.py", + "lib/python3.12/idlelib/idle_test/test_help_about.py", + "lib/python3.12/idlelib/idle_test/test_history.py", + "lib/python3.12/idlelib/idle_test/test_hyperparser.py", + "lib/python3.12/idlelib/idle_test/test_iomenu.py", + "lib/python3.12/idlelib/idle_test/test_macosx.py", + "lib/python3.12/idlelib/idle_test/test_mainmenu.py", + "lib/python3.12/idlelib/idle_test/test_multicall.py", + "lib/python3.12/idlelib/idle_test/test_outwin.py", + "lib/python3.12/idlelib/idle_test/test_parenmatch.py", + "lib/python3.12/idlelib/idle_test/test_pathbrowser.py", + "lib/python3.12/idlelib/idle_test/test_percolator.py", + "lib/python3.12/idlelib/idle_test/test_pyparse.py", + "lib/python3.12/idlelib/idle_test/test_pyshell.py", + "lib/python3.12/idlelib/idle_test/test_query.py", + "lib/python3.12/idlelib/idle_test/test_redirector.py", + "lib/python3.12/idlelib/idle_test/test_replace.py", + "lib/python3.12/idlelib/idle_test/test_rpc.py", + "lib/python3.12/idlelib/idle_test/test_run.py", + "lib/python3.12/idlelib/idle_test/test_runscript.py", + "lib/python3.12/idlelib/idle_test/test_scrolledlist.py", + "lib/python3.12/idlelib/idle_test/test_search.py", + "lib/python3.12/idlelib/idle_test/test_searchbase.py", + "lib/python3.12/idlelib/idle_test/test_searchengine.py", + "lib/python3.12/idlelib/idle_test/test_sidebar.py", + "lib/python3.12/idlelib/idle_test/test_squeezer.py", + "lib/python3.12/idlelib/idle_test/test_stackviewer.py", + "lib/python3.12/idlelib/idle_test/test_statusbar.py", + "lib/python3.12/idlelib/idle_test/test_text.py", + "lib/python3.12/idlelib/idle_test/test_textview.py", + "lib/python3.12/idlelib/idle_test/test_tooltip.py", + "lib/python3.12/idlelib/idle_test/test_tree.py", + "lib/python3.12/idlelib/idle_test/test_undo.py", + "lib/python3.12/idlelib/idle_test/test_util.py", + "lib/python3.12/idlelib/idle_test/test_warning.py", + "lib/python3.12/idlelib/idle_test/test_window.py", + "lib/python3.12/idlelib/idle_test/test_zoomheight.py", + "lib/python3.12/idlelib/idle_test/test_zzdummy.py", + "lib/python3.12/idlelib/idle_test/tkinter_testing_utils.py", + "lib/python3.12/idlelib/iomenu.py", + "lib/python3.12/idlelib/macosx.py", + "lib/python3.12/idlelib/mainmenu.py", + "lib/python3.12/idlelib/multicall.py", + "lib/python3.12/idlelib/outwin.py", + "lib/python3.12/idlelib/parenmatch.py", + "lib/python3.12/idlelib/pathbrowser.py", + "lib/python3.12/idlelib/percolator.py", + "lib/python3.12/idlelib/pyparse.py", + "lib/python3.12/idlelib/pyshell.py", + "lib/python3.12/idlelib/query.py", + "lib/python3.12/idlelib/redirector.py", + "lib/python3.12/idlelib/replace.py", + "lib/python3.12/idlelib/rpc.py", + "lib/python3.12/idlelib/run.py", + "lib/python3.12/idlelib/runscript.py", + "lib/python3.12/idlelib/scrolledlist.py", + "lib/python3.12/idlelib/search.py", + "lib/python3.12/idlelib/searchbase.py", + "lib/python3.12/idlelib/searchengine.py", + "lib/python3.12/idlelib/sidebar.py", + "lib/python3.12/idlelib/squeezer.py", + "lib/python3.12/idlelib/stackviewer.py", + "lib/python3.12/idlelib/statusbar.py", + "lib/python3.12/idlelib/textview.py", + "lib/python3.12/idlelib/tooltip.py", + "lib/python3.12/idlelib/tree.py", + "lib/python3.12/idlelib/undo.py", + "lib/python3.12/idlelib/util.py", + "lib/python3.12/idlelib/window.py", + "lib/python3.12/idlelib/zoomheight.py", + "lib/python3.12/idlelib/zzdummy.py", + "lib/python3.12/imaplib.py", + "lib/python3.12/imghdr.py", + "lib/python3.12/importlib/__init__.py", + "lib/python3.12/importlib/__pycache__/__init__.cpython-312.pyc", + "lib/python3.12/importlib/__pycache__/_abc.cpython-312.pyc", + "lib/python3.12/importlib/__pycache__/_bootstrap.cpython-312.pyc", + "lib/python3.12/importlib/__pycache__/_bootstrap_external.cpython-312.pyc", + "lib/python3.12/importlib/__pycache__/abc.cpython-312.pyc", + "lib/python3.12/importlib/__pycache__/machinery.cpython-312.pyc", + "lib/python3.12/importlib/__pycache__/readers.cpython-312.pyc", + "lib/python3.12/importlib/__pycache__/simple.cpython-312.pyc", + "lib/python3.12/importlib/__pycache__/util.cpython-312.pyc", + "lib/python3.12/importlib/_abc.py", + "lib/python3.12/importlib/_bootstrap.py", + "lib/python3.12/importlib/_bootstrap_external.py", + "lib/python3.12/importlib/abc.py", + "lib/python3.12/importlib/machinery.py", + "lib/python3.12/importlib/metadata/__init__.py", + "lib/python3.12/importlib/metadata/__pycache__/__init__.cpython-312.pyc", + "lib/python3.12/importlib/metadata/__pycache__/_adapters.cpython-312.pyc", + "lib/python3.12/importlib/metadata/__pycache__/_collections.cpython-312.pyc", + "lib/python3.12/importlib/metadata/__pycache__/_functools.cpython-312.pyc", + "lib/python3.12/importlib/metadata/__pycache__/_itertools.cpython-312.pyc", + "lib/python3.12/importlib/metadata/__pycache__/_meta.cpython-312.pyc", + "lib/python3.12/importlib/metadata/__pycache__/_text.cpython-312.pyc", + "lib/python3.12/importlib/metadata/_adapters.py", + "lib/python3.12/importlib/metadata/_collections.py", + "lib/python3.12/importlib/metadata/_functools.py", + "lib/python3.12/importlib/metadata/_itertools.py", + "lib/python3.12/importlib/metadata/_meta.py", + "lib/python3.12/importlib/metadata/_text.py", + "lib/python3.12/importlib/readers.py", + "lib/python3.12/importlib/resources/__init__.py", + "lib/python3.12/importlib/resources/__pycache__/__init__.cpython-312.pyc", + "lib/python3.12/importlib/resources/__pycache__/_adapters.cpython-312.pyc", + "lib/python3.12/importlib/resources/__pycache__/_common.cpython-312.pyc", + "lib/python3.12/importlib/resources/__pycache__/_itertools.cpython-312.pyc", + "lib/python3.12/importlib/resources/__pycache__/_legacy.cpython-312.pyc", + "lib/python3.12/importlib/resources/__pycache__/abc.cpython-312.pyc", + "lib/python3.12/importlib/resources/__pycache__/readers.cpython-312.pyc", + "lib/python3.12/importlib/resources/__pycache__/simple.cpython-312.pyc", + "lib/python3.12/importlib/resources/_adapters.py", + "lib/python3.12/importlib/resources/_common.py", + "lib/python3.12/importlib/resources/_itertools.py", + "lib/python3.12/importlib/resources/_legacy.py", + "lib/python3.12/importlib/resources/abc.py", + "lib/python3.12/importlib/resources/readers.py", + "lib/python3.12/importlib/resources/simple.py", + "lib/python3.12/importlib/simple.py", + "lib/python3.12/importlib/util.py", + "lib/python3.12/inspect.py", + "lib/python3.12/io.py", + "lib/python3.12/ipaddress.py", + "lib/python3.12/json/__init__.py", + "lib/python3.12/json/__pycache__/__init__.cpython-312.pyc", + "lib/python3.12/json/__pycache__/decoder.cpython-312.pyc", + "lib/python3.12/json/__pycache__/encoder.cpython-312.pyc", + "lib/python3.12/json/__pycache__/scanner.cpython-312.pyc", + "lib/python3.12/json/__pycache__/tool.cpython-312.pyc", + "lib/python3.12/json/decoder.py", + "lib/python3.12/json/encoder.py", + "lib/python3.12/json/scanner.py", + "lib/python3.12/json/tool.py", + "lib/python3.12/keyword.py", + "lib/python3.12/lib-dynload/_asyncio.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/_bisect.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/_blake2.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/_bz2.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/_codecs_cn.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/_codecs_hk.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/_codecs_iso2022.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/_codecs_jp.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/_codecs_kr.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/_codecs_tw.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/_contextvars.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/_crypt.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/_csv.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/_ctypes.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/_ctypes_test.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/_curses.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/_curses_panel.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/_datetime.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/_dbm.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/_decimal.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/_elementtree.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/_hashlib.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/_heapq.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/_json.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/_lsprof.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/_lzma.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/_md5.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/_multibytecodec.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/_multiprocessing.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/_opcode.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/_pickle.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/_posixshmem.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/_posixsubprocess.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/_queue.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/_random.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/_scproxy.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/_sha1.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/_sha2.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/_sha3.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/_socket.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/_sqlite3.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/_ssl.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/_statistics.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/_struct.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/_testbuffer.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/_testcapi.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/_testclinic.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/_testimportmultiple.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/_testinternalcapi.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/_testmultiphase.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/_testsinglephase.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/_tkinter.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/_uuid.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/_xxinterpchannels.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/_xxsubinterpreters.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/_xxtestfuzz.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/_zoneinfo.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/array.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/audioop.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/binascii.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/cmath.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/fcntl.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/grp.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/math.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/mmap.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/nis.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/pyexpat.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/readline.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/resource.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/select.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/syslog.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/termios.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/unicodedata.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/xxlimited.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/xxlimited_35.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/xxsubtype.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/zlib.cpython-312-darwin.so", + "lib/python3.12/lib2to3/Grammar.txt", + "lib/python3.12/lib2to3/PatternGrammar.txt", + "lib/python3.12/lib2to3/__init__.py", + "lib/python3.12/lib2to3/__main__.py", + "lib/python3.12/lib2to3/__pycache__/__init__.cpython-312.pyc", + "lib/python3.12/lib2to3/__pycache__/__main__.cpython-312.pyc", + "lib/python3.12/lib2to3/__pycache__/btm_matcher.cpython-312.pyc", + "lib/python3.12/lib2to3/__pycache__/btm_utils.cpython-312.pyc", + "lib/python3.12/lib2to3/__pycache__/fixer_base.cpython-312.pyc", + "lib/python3.12/lib2to3/__pycache__/fixer_util.cpython-312.pyc", + "lib/python3.12/lib2to3/__pycache__/main.cpython-312.pyc", + "lib/python3.12/lib2to3/__pycache__/patcomp.cpython-312.pyc", + "lib/python3.12/lib2to3/__pycache__/pygram.cpython-312.pyc", + "lib/python3.12/lib2to3/__pycache__/pytree.cpython-312.pyc", + "lib/python3.12/lib2to3/__pycache__/refactor.cpython-312.pyc", + "lib/python3.12/lib2to3/btm_matcher.py", + "lib/python3.12/lib2to3/btm_utils.py", + "lib/python3.12/lib2to3/fixer_base.py", + "lib/python3.12/lib2to3/fixer_util.py", + "lib/python3.12/lib2to3/fixes/__init__.py", + "lib/python3.12/lib2to3/fixes/__pycache__/__init__.cpython-312.pyc", + "lib/python3.12/lib2to3/fixes/__pycache__/fix_apply.cpython-312.pyc", + "lib/python3.12/lib2to3/fixes/__pycache__/fix_asserts.cpython-312.pyc", + "lib/python3.12/lib2to3/fixes/__pycache__/fix_basestring.cpython-312.pyc", + "lib/python3.12/lib2to3/fixes/__pycache__/fix_buffer.cpython-312.pyc", + "lib/python3.12/lib2to3/fixes/__pycache__/fix_dict.cpython-312.pyc", + "lib/python3.12/lib2to3/fixes/__pycache__/fix_except.cpython-312.pyc", + "lib/python3.12/lib2to3/fixes/__pycache__/fix_exec.cpython-312.pyc", + "lib/python3.12/lib2to3/fixes/__pycache__/fix_execfile.cpython-312.pyc", + "lib/python3.12/lib2to3/fixes/__pycache__/fix_exitfunc.cpython-312.pyc", + "lib/python3.12/lib2to3/fixes/__pycache__/fix_filter.cpython-312.pyc", + "lib/python3.12/lib2to3/fixes/__pycache__/fix_funcattrs.cpython-312.pyc", + "lib/python3.12/lib2to3/fixes/__pycache__/fix_future.cpython-312.pyc", + "lib/python3.12/lib2to3/fixes/__pycache__/fix_getcwdu.cpython-312.pyc", + "lib/python3.12/lib2to3/fixes/__pycache__/fix_has_key.cpython-312.pyc", + "lib/python3.12/lib2to3/fixes/__pycache__/fix_idioms.cpython-312.pyc", + "lib/python3.12/lib2to3/fixes/__pycache__/fix_import.cpython-312.pyc", + "lib/python3.12/lib2to3/fixes/__pycache__/fix_imports.cpython-312.pyc", + "lib/python3.12/lib2to3/fixes/__pycache__/fix_imports2.cpython-312.pyc", + "lib/python3.12/lib2to3/fixes/__pycache__/fix_input.cpython-312.pyc", + "lib/python3.12/lib2to3/fixes/__pycache__/fix_intern.cpython-312.pyc", + "lib/python3.12/lib2to3/fixes/__pycache__/fix_isinstance.cpython-312.pyc", + "lib/python3.12/lib2to3/fixes/__pycache__/fix_itertools.cpython-312.pyc", + "lib/python3.12/lib2to3/fixes/__pycache__/fix_itertools_imports.cpython-312.pyc", + "lib/python3.12/lib2to3/fixes/__pycache__/fix_long.cpython-312.pyc", + "lib/python3.12/lib2to3/fixes/__pycache__/fix_map.cpython-312.pyc", + "lib/python3.12/lib2to3/fixes/__pycache__/fix_metaclass.cpython-312.pyc", + "lib/python3.12/lib2to3/fixes/__pycache__/fix_methodattrs.cpython-312.pyc", + "lib/python3.12/lib2to3/fixes/__pycache__/fix_ne.cpython-312.pyc", + "lib/python3.12/lib2to3/fixes/__pycache__/fix_next.cpython-312.pyc", + "lib/python3.12/lib2to3/fixes/__pycache__/fix_nonzero.cpython-312.pyc", + "lib/python3.12/lib2to3/fixes/__pycache__/fix_numliterals.cpython-312.pyc", + "lib/python3.12/lib2to3/fixes/__pycache__/fix_operator.cpython-312.pyc", + "lib/python3.12/lib2to3/fixes/__pycache__/fix_paren.cpython-312.pyc", + "lib/python3.12/lib2to3/fixes/__pycache__/fix_print.cpython-312.pyc", + "lib/python3.12/lib2to3/fixes/__pycache__/fix_raise.cpython-312.pyc", + "lib/python3.12/lib2to3/fixes/__pycache__/fix_raw_input.cpython-312.pyc", + "lib/python3.12/lib2to3/fixes/__pycache__/fix_reduce.cpython-312.pyc", + "lib/python3.12/lib2to3/fixes/__pycache__/fix_reload.cpython-312.pyc", + "lib/python3.12/lib2to3/fixes/__pycache__/fix_renames.cpython-312.pyc", + "lib/python3.12/lib2to3/fixes/__pycache__/fix_repr.cpython-312.pyc", + "lib/python3.12/lib2to3/fixes/__pycache__/fix_set_literal.cpython-312.pyc", + "lib/python3.12/lib2to3/fixes/__pycache__/fix_standarderror.cpython-312.pyc", + "lib/python3.12/lib2to3/fixes/__pycache__/fix_sys_exc.cpython-312.pyc", + "lib/python3.12/lib2to3/fixes/__pycache__/fix_throw.cpython-312.pyc", + "lib/python3.12/lib2to3/fixes/__pycache__/fix_tuple_params.cpython-312.pyc", + "lib/python3.12/lib2to3/fixes/__pycache__/fix_types.cpython-312.pyc", + "lib/python3.12/lib2to3/fixes/__pycache__/fix_unicode.cpython-312.pyc", + "lib/python3.12/lib2to3/fixes/__pycache__/fix_urllib.cpython-312.pyc", + "lib/python3.12/lib2to3/fixes/__pycache__/fix_ws_comma.cpython-312.pyc", + "lib/python3.12/lib2to3/fixes/__pycache__/fix_xrange.cpython-312.pyc", + "lib/python3.12/lib2to3/fixes/__pycache__/fix_xreadlines.cpython-312.pyc", + "lib/python3.12/lib2to3/fixes/__pycache__/fix_zip.cpython-312.pyc", + "lib/python3.12/lib2to3/fixes/fix_apply.py", + "lib/python3.12/lib2to3/fixes/fix_asserts.py", + "lib/python3.12/lib2to3/fixes/fix_basestring.py", + "lib/python3.12/lib2to3/fixes/fix_buffer.py", + "lib/python3.12/lib2to3/fixes/fix_dict.py", + "lib/python3.12/lib2to3/fixes/fix_except.py", + "lib/python3.12/lib2to3/fixes/fix_exec.py", + "lib/python3.12/lib2to3/fixes/fix_execfile.py", + "lib/python3.12/lib2to3/fixes/fix_exitfunc.py", + "lib/python3.12/lib2to3/fixes/fix_filter.py", + "lib/python3.12/lib2to3/fixes/fix_funcattrs.py", + "lib/python3.12/lib2to3/fixes/fix_future.py", + "lib/python3.12/lib2to3/fixes/fix_getcwdu.py", + "lib/python3.12/lib2to3/fixes/fix_has_key.py", + "lib/python3.12/lib2to3/fixes/fix_idioms.py", + "lib/python3.12/lib2to3/fixes/fix_import.py", + "lib/python3.12/lib2to3/fixes/fix_imports.py", + "lib/python3.12/lib2to3/fixes/fix_imports2.py", + "lib/python3.12/lib2to3/fixes/fix_input.py", + "lib/python3.12/lib2to3/fixes/fix_intern.py", + "lib/python3.12/lib2to3/fixes/fix_isinstance.py", + "lib/python3.12/lib2to3/fixes/fix_itertools.py", + "lib/python3.12/lib2to3/fixes/fix_itertools_imports.py", + "lib/python3.12/lib2to3/fixes/fix_long.py", + "lib/python3.12/lib2to3/fixes/fix_map.py", + "lib/python3.12/lib2to3/fixes/fix_metaclass.py", + "lib/python3.12/lib2to3/fixes/fix_methodattrs.py", + "lib/python3.12/lib2to3/fixes/fix_ne.py", + "lib/python3.12/lib2to3/fixes/fix_next.py", + "lib/python3.12/lib2to3/fixes/fix_nonzero.py", + "lib/python3.12/lib2to3/fixes/fix_numliterals.py", + "lib/python3.12/lib2to3/fixes/fix_operator.py", + "lib/python3.12/lib2to3/fixes/fix_paren.py", + "lib/python3.12/lib2to3/fixes/fix_print.py", + "lib/python3.12/lib2to3/fixes/fix_raise.py", + "lib/python3.12/lib2to3/fixes/fix_raw_input.py", + "lib/python3.12/lib2to3/fixes/fix_reduce.py", + "lib/python3.12/lib2to3/fixes/fix_reload.py", + "lib/python3.12/lib2to3/fixes/fix_renames.py", + "lib/python3.12/lib2to3/fixes/fix_repr.py", + "lib/python3.12/lib2to3/fixes/fix_set_literal.py", + "lib/python3.12/lib2to3/fixes/fix_standarderror.py", + "lib/python3.12/lib2to3/fixes/fix_sys_exc.py", + "lib/python3.12/lib2to3/fixes/fix_throw.py", + "lib/python3.12/lib2to3/fixes/fix_tuple_params.py", + "lib/python3.12/lib2to3/fixes/fix_types.py", + "lib/python3.12/lib2to3/fixes/fix_unicode.py", + "lib/python3.12/lib2to3/fixes/fix_urllib.py", + "lib/python3.12/lib2to3/fixes/fix_ws_comma.py", + "lib/python3.12/lib2to3/fixes/fix_xrange.py", + "lib/python3.12/lib2to3/fixes/fix_xreadlines.py", + "lib/python3.12/lib2to3/fixes/fix_zip.py", + "lib/python3.12/lib2to3/main.py", + "lib/python3.12/lib2to3/patcomp.py", + "lib/python3.12/lib2to3/pgen2/__init__.py", + "lib/python3.12/lib2to3/pgen2/__pycache__/__init__.cpython-312.pyc", + "lib/python3.12/lib2to3/pgen2/__pycache__/conv.cpython-312.pyc", + "lib/python3.12/lib2to3/pgen2/__pycache__/driver.cpython-312.pyc", + "lib/python3.12/lib2to3/pgen2/__pycache__/grammar.cpython-312.pyc", + "lib/python3.12/lib2to3/pgen2/__pycache__/literals.cpython-312.pyc", + "lib/python3.12/lib2to3/pgen2/__pycache__/parse.cpython-312.pyc", + "lib/python3.12/lib2to3/pgen2/__pycache__/pgen.cpython-312.pyc", + "lib/python3.12/lib2to3/pgen2/__pycache__/token.cpython-312.pyc", + "lib/python3.12/lib2to3/pgen2/__pycache__/tokenize.cpython-312.pyc", + "lib/python3.12/lib2to3/pgen2/conv.py", + "lib/python3.12/lib2to3/pgen2/driver.py", + "lib/python3.12/lib2to3/pgen2/grammar.py", + "lib/python3.12/lib2to3/pgen2/literals.py", + "lib/python3.12/lib2to3/pgen2/parse.py", + "lib/python3.12/lib2to3/pgen2/pgen.py", + "lib/python3.12/lib2to3/pgen2/token.py", + "lib/python3.12/lib2to3/pgen2/tokenize.py", + "lib/python3.12/lib2to3/pygram.py", + "lib/python3.12/lib2to3/pytree.py", + "lib/python3.12/lib2to3/refactor.py", + "lib/python3.12/linecache.py", + "lib/python3.12/locale.py", + "lib/python3.12/logging/__init__.py", + "lib/python3.12/logging/__pycache__/__init__.cpython-312.pyc", + "lib/python3.12/logging/__pycache__/config.cpython-312.pyc", + "lib/python3.12/logging/__pycache__/handlers.cpython-312.pyc", + "lib/python3.12/logging/config.py", + "lib/python3.12/logging/handlers.py", + "lib/python3.12/lzma.py", + "lib/python3.12/mailbox.py", + "lib/python3.12/mailcap.py", + "lib/python3.12/mimetypes.py", + "lib/python3.12/modulefinder.py", + "lib/python3.12/multiprocessing/__init__.py", + "lib/python3.12/multiprocessing/__pycache__/__init__.cpython-312.pyc", + "lib/python3.12/multiprocessing/__pycache__/connection.cpython-312.pyc", + "lib/python3.12/multiprocessing/__pycache__/context.cpython-312.pyc", + "lib/python3.12/multiprocessing/__pycache__/forkserver.cpython-312.pyc", + "lib/python3.12/multiprocessing/__pycache__/heap.cpython-312.pyc", + "lib/python3.12/multiprocessing/__pycache__/managers.cpython-312.pyc", + "lib/python3.12/multiprocessing/__pycache__/pool.cpython-312.pyc", + "lib/python3.12/multiprocessing/__pycache__/popen_fork.cpython-312.pyc", + "lib/python3.12/multiprocessing/__pycache__/popen_forkserver.cpython-312.pyc", + "lib/python3.12/multiprocessing/__pycache__/popen_spawn_posix.cpython-312.pyc", + "lib/python3.12/multiprocessing/__pycache__/popen_spawn_win32.cpython-312.pyc", + "lib/python3.12/multiprocessing/__pycache__/process.cpython-312.pyc", + "lib/python3.12/multiprocessing/__pycache__/queues.cpython-312.pyc", + "lib/python3.12/multiprocessing/__pycache__/reduction.cpython-312.pyc", + "lib/python3.12/multiprocessing/__pycache__/resource_sharer.cpython-312.pyc", + "lib/python3.12/multiprocessing/__pycache__/resource_tracker.cpython-312.pyc", + "lib/python3.12/multiprocessing/__pycache__/shared_memory.cpython-312.pyc", + "lib/python3.12/multiprocessing/__pycache__/sharedctypes.cpython-312.pyc", + "lib/python3.12/multiprocessing/__pycache__/spawn.cpython-312.pyc", + "lib/python3.12/multiprocessing/__pycache__/synchronize.cpython-312.pyc", + "lib/python3.12/multiprocessing/__pycache__/util.cpython-312.pyc", + "lib/python3.12/multiprocessing/connection.py", + "lib/python3.12/multiprocessing/context.py", + "lib/python3.12/multiprocessing/dummy/__init__.py", + "lib/python3.12/multiprocessing/dummy/__pycache__/__init__.cpython-312.pyc", + "lib/python3.12/multiprocessing/dummy/__pycache__/connection.cpython-312.pyc", + "lib/python3.12/multiprocessing/dummy/connection.py", + "lib/python3.12/multiprocessing/forkserver.py", + "lib/python3.12/multiprocessing/heap.py", + "lib/python3.12/multiprocessing/managers.py", + "lib/python3.12/multiprocessing/pool.py", + "lib/python3.12/multiprocessing/popen_fork.py", + "lib/python3.12/multiprocessing/popen_forkserver.py", + "lib/python3.12/multiprocessing/popen_spawn_posix.py", + "lib/python3.12/multiprocessing/popen_spawn_win32.py", + "lib/python3.12/multiprocessing/process.py", + "lib/python3.12/multiprocessing/queues.py", + "lib/python3.12/multiprocessing/reduction.py", + "lib/python3.12/multiprocessing/resource_sharer.py", + "lib/python3.12/multiprocessing/resource_tracker.py", + "lib/python3.12/multiprocessing/shared_memory.py", + "lib/python3.12/multiprocessing/sharedctypes.py", + "lib/python3.12/multiprocessing/spawn.py", + "lib/python3.12/multiprocessing/synchronize.py", + "lib/python3.12/multiprocessing/util.py", + "lib/python3.12/netrc.py", + "lib/python3.12/nntplib.py", + "lib/python3.12/ntpath.py", + "lib/python3.12/nturl2path.py", + "lib/python3.12/numbers.py", + "lib/python3.12/opcode.py", + "lib/python3.12/operator.py", + "lib/python3.12/optparse.py", + "lib/python3.12/os.py", + "lib/python3.12/pathlib.py", + "lib/python3.12/pdb.py", + "lib/python3.12/pickle.py", + "lib/python3.12/pickletools.py", + "lib/python3.12/pipes.py", + "lib/python3.12/pkgutil.py", + "lib/python3.12/platform.py", + "lib/python3.12/plistlib.py", + "lib/python3.12/poplib.py", + "lib/python3.12/posixpath.py", + "lib/python3.12/pprint.py", + "lib/python3.12/profile.py", + "lib/python3.12/pstats.py", + "lib/python3.12/pty.py", + "lib/python3.12/py_compile.py", + "lib/python3.12/pyclbr.py", + "lib/python3.12/pydoc.py", + "lib/python3.12/pydoc_data/__init__.py", + "lib/python3.12/pydoc_data/__pycache__/__init__.cpython-312.pyc", + "lib/python3.12/pydoc_data/__pycache__/topics.cpython-312.pyc", + "lib/python3.12/pydoc_data/_pydoc.css", + "lib/python3.12/pydoc_data/topics.py", + "lib/python3.12/queue.py", + "lib/python3.12/quopri.py", + "lib/python3.12/random.py", + "lib/python3.12/re/__init__.py", + "lib/python3.12/re/__pycache__/__init__.cpython-312.pyc", + "lib/python3.12/re/__pycache__/_casefix.cpython-312.pyc", + "lib/python3.12/re/__pycache__/_compiler.cpython-312.pyc", + "lib/python3.12/re/__pycache__/_constants.cpython-312.pyc", + "lib/python3.12/re/__pycache__/_parser.cpython-312.pyc", + "lib/python3.12/re/_casefix.py", + "lib/python3.12/re/_compiler.py", + "lib/python3.12/re/_constants.py", + "lib/python3.12/re/_parser.py", + "lib/python3.12/reprlib.py", + "lib/python3.12/rlcompleter.py", + "lib/python3.12/runpy.py", + "lib/python3.12/sched.py", + "lib/python3.12/secrets.py", + "lib/python3.12/selectors.py", + "lib/python3.12/shelve.py", + "lib/python3.12/shlex.py", + "lib/python3.12/shutil.py", + "lib/python3.12/signal.py", + "lib/python3.12/site-packages/README.txt", + "lib/python3.12/site.py", + "lib/python3.12/smtplib.py", + "lib/python3.12/sndhdr.py", + "lib/python3.12/socket.py", + "lib/python3.12/socketserver.py", + "lib/python3.12/sqlite3/__init__.py", + "lib/python3.12/sqlite3/__main__.py", + "lib/python3.12/sqlite3/__pycache__/__init__.cpython-312.pyc", + "lib/python3.12/sqlite3/__pycache__/__main__.cpython-312.pyc", + "lib/python3.12/sqlite3/__pycache__/dbapi2.cpython-312.pyc", + "lib/python3.12/sqlite3/__pycache__/dump.cpython-312.pyc", + "lib/python3.12/sqlite3/dbapi2.py", + "lib/python3.12/sqlite3/dump.py", + "lib/python3.12/sre_compile.py", + "lib/python3.12/sre_constants.py", + "lib/python3.12/sre_parse.py", + "lib/python3.12/ssl.py", + "lib/python3.12/stat.py", + "lib/python3.12/statistics.py", + "lib/python3.12/string.py", + "lib/python3.12/stringprep.py", + "lib/python3.12/struct.py", + "lib/python3.12/subprocess.py", + "lib/python3.12/sunau.py", + "lib/python3.12/symtable.py", + "lib/python3.12/sysconfig.py", + "lib/python3.12/tabnanny.py", + "lib/python3.12/tarfile.py", + "lib/python3.12/telnetlib.py", + "lib/python3.12/tempfile.py", + "lib/python3.12/test/__init__.py", + "lib/python3.12/test/__pycache__/__init__.cpython-312.pyc", + "lib/python3.12/test/__pycache__/test_script_helper.cpython-312.pyc", + "lib/python3.12/test/__pycache__/test_support.cpython-312.pyc", + "lib/python3.12/test/support/__init__.py", + "lib/python3.12/test/support/__pycache__/__init__.cpython-312.pyc", + "lib/python3.12/test/support/__pycache__/ast_helper.cpython-312.pyc", + "lib/python3.12/test/support/__pycache__/asynchat.cpython-312.pyc", + "lib/python3.12/test/support/__pycache__/asyncore.cpython-312.pyc", + "lib/python3.12/test/support/__pycache__/bytecode_helper.cpython-312.pyc", + "lib/python3.12/test/support/__pycache__/hashlib_helper.cpython-312.pyc", + "lib/python3.12/test/support/__pycache__/hypothesis_helper.cpython-312.pyc", + "lib/python3.12/test/support/__pycache__/import_helper.cpython-312.pyc", + "lib/python3.12/test/support/__pycache__/interpreters.cpython-312.pyc", + "lib/python3.12/test/support/__pycache__/logging_helper.cpython-312.pyc", + "lib/python3.12/test/support/__pycache__/os_helper.cpython-312.pyc", + "lib/python3.12/test/support/__pycache__/pty_helper.cpython-312.pyc", + "lib/python3.12/test/support/__pycache__/script_helper.cpython-312.pyc", + "lib/python3.12/test/support/__pycache__/smtpd.cpython-312.pyc", + "lib/python3.12/test/support/__pycache__/socket_helper.cpython-312.pyc", + "lib/python3.12/test/support/__pycache__/testcase.cpython-312.pyc", + "lib/python3.12/test/support/__pycache__/threading_helper.cpython-312.pyc", + "lib/python3.12/test/support/__pycache__/warnings_helper.cpython-312.pyc", + "lib/python3.12/test/support/_hypothesis_stubs/__init__.py", + "lib/python3.12/test/support/_hypothesis_stubs/__pycache__/__init__.cpython-312.pyc", + "lib/python3.12/test/support/_hypothesis_stubs/__pycache__/_helpers.cpython-312.pyc", + "lib/python3.12/test/support/_hypothesis_stubs/__pycache__/strategies.cpython-312.pyc", + "lib/python3.12/test/support/_hypothesis_stubs/_helpers.py", + "lib/python3.12/test/support/_hypothesis_stubs/strategies.py", + "lib/python3.12/test/support/ast_helper.py", + "lib/python3.12/test/support/asynchat.py", + "lib/python3.12/test/support/asyncore.py", + "lib/python3.12/test/support/bytecode_helper.py", + "lib/python3.12/test/support/hashlib_helper.py", + "lib/python3.12/test/support/hypothesis_helper.py", + "lib/python3.12/test/support/import_helper.py", + "lib/python3.12/test/support/interpreters.py", + "lib/python3.12/test/support/logging_helper.py", + "lib/python3.12/test/support/os_helper.py", + "lib/python3.12/test/support/pty_helper.py", + "lib/python3.12/test/support/script_helper.py", + "lib/python3.12/test/support/smtpd.py", + "lib/python3.12/test/support/socket_helper.py", + "lib/python3.12/test/support/testcase.py", + "lib/python3.12/test/support/threading_helper.py", + "lib/python3.12/test/support/warnings_helper.py", + "lib/python3.12/test/test_script_helper.py", + "lib/python3.12/test/test_support.py", + "lib/python3.12/textwrap.py", + "lib/python3.12/this.py", + "lib/python3.12/threading.py", + "lib/python3.12/timeit.py", + "lib/python3.12/tkinter/__init__.py", + "lib/python3.12/tkinter/__main__.py", + "lib/python3.12/tkinter/__pycache__/__init__.cpython-312.pyc", + "lib/python3.12/tkinter/__pycache__/__main__.cpython-312.pyc", + "lib/python3.12/tkinter/__pycache__/colorchooser.cpython-312.pyc", + "lib/python3.12/tkinter/__pycache__/commondialog.cpython-312.pyc", + "lib/python3.12/tkinter/__pycache__/constants.cpython-312.pyc", + "lib/python3.12/tkinter/__pycache__/dialog.cpython-312.pyc", + "lib/python3.12/tkinter/__pycache__/dnd.cpython-312.pyc", + "lib/python3.12/tkinter/__pycache__/filedialog.cpython-312.pyc", + "lib/python3.12/tkinter/__pycache__/font.cpython-312.pyc", + "lib/python3.12/tkinter/__pycache__/messagebox.cpython-312.pyc", + "lib/python3.12/tkinter/__pycache__/scrolledtext.cpython-312.pyc", + "lib/python3.12/tkinter/__pycache__/simpledialog.cpython-312.pyc", + "lib/python3.12/tkinter/__pycache__/tix.cpython-312.pyc", + "lib/python3.12/tkinter/__pycache__/ttk.cpython-312.pyc", + "lib/python3.12/tkinter/colorchooser.py", + "lib/python3.12/tkinter/commondialog.py", + "lib/python3.12/tkinter/constants.py", + "lib/python3.12/tkinter/dialog.py", + "lib/python3.12/tkinter/dnd.py", + "lib/python3.12/tkinter/filedialog.py", + "lib/python3.12/tkinter/font.py", + "lib/python3.12/tkinter/messagebox.py", + "lib/python3.12/tkinter/scrolledtext.py", + "lib/python3.12/tkinter/simpledialog.py", + "lib/python3.12/tkinter/tix.py", + "lib/python3.12/tkinter/ttk.py", + "lib/python3.12/token.py", + "lib/python3.12/tokenize.py", + "lib/python3.12/tomllib/__init__.py", + "lib/python3.12/tomllib/__pycache__/__init__.cpython-312.pyc", + "lib/python3.12/tomllib/__pycache__/_parser.cpython-312.pyc", + "lib/python3.12/tomllib/__pycache__/_re.cpython-312.pyc", + "lib/python3.12/tomllib/__pycache__/_types.cpython-312.pyc", + "lib/python3.12/tomllib/_parser.py", + "lib/python3.12/tomllib/_re.py", + "lib/python3.12/tomllib/_types.py", + "lib/python3.12/trace.py", + "lib/python3.12/traceback.py", + "lib/python3.12/tracemalloc.py", + "lib/python3.12/tty.py", + "lib/python3.12/turtle.py", + "lib/python3.12/turtledemo/__init__.py", + "lib/python3.12/turtledemo/__main__.py", + "lib/python3.12/turtledemo/__pycache__/__init__.cpython-312.pyc", + "lib/python3.12/turtledemo/__pycache__/__main__.cpython-312.pyc", + "lib/python3.12/turtledemo/__pycache__/bytedesign.cpython-312.pyc", + "lib/python3.12/turtledemo/__pycache__/chaos.cpython-312.pyc", + "lib/python3.12/turtledemo/__pycache__/clock.cpython-312.pyc", + "lib/python3.12/turtledemo/__pycache__/colormixer.cpython-312.pyc", + "lib/python3.12/turtledemo/__pycache__/forest.cpython-312.pyc", + "lib/python3.12/turtledemo/__pycache__/fractalcurves.cpython-312.pyc", + "lib/python3.12/turtledemo/__pycache__/lindenmayer.cpython-312.pyc", + "lib/python3.12/turtledemo/__pycache__/minimal_hanoi.cpython-312.pyc", + "lib/python3.12/turtledemo/__pycache__/nim.cpython-312.pyc", + "lib/python3.12/turtledemo/__pycache__/paint.cpython-312.pyc", + "lib/python3.12/turtledemo/__pycache__/peace.cpython-312.pyc", + "lib/python3.12/turtledemo/__pycache__/penrose.cpython-312.pyc", + "lib/python3.12/turtledemo/__pycache__/planet_and_moon.cpython-312.pyc", + "lib/python3.12/turtledemo/__pycache__/rosette.cpython-312.pyc", + "lib/python3.12/turtledemo/__pycache__/round_dance.cpython-312.pyc", + "lib/python3.12/turtledemo/__pycache__/sorting_animate.cpython-312.pyc", + "lib/python3.12/turtledemo/__pycache__/tree.cpython-312.pyc", + "lib/python3.12/turtledemo/__pycache__/two_canvases.cpython-312.pyc", + "lib/python3.12/turtledemo/__pycache__/yinyang.cpython-312.pyc", + "lib/python3.12/turtledemo/bytedesign.py", + "lib/python3.12/turtledemo/chaos.py", + "lib/python3.12/turtledemo/clock.py", + "lib/python3.12/turtledemo/colormixer.py", + "lib/python3.12/turtledemo/forest.py", + "lib/python3.12/turtledemo/fractalcurves.py", + "lib/python3.12/turtledemo/lindenmayer.py", + "lib/python3.12/turtledemo/minimal_hanoi.py", + "lib/python3.12/turtledemo/nim.py", + "lib/python3.12/turtledemo/paint.py", + "lib/python3.12/turtledemo/peace.py", + "lib/python3.12/turtledemo/penrose.py", + "lib/python3.12/turtledemo/planet_and_moon.py", + "lib/python3.12/turtledemo/rosette.py", + "lib/python3.12/turtledemo/round_dance.py", + "lib/python3.12/turtledemo/sorting_animate.py", + "lib/python3.12/turtledemo/tree.py", + "lib/python3.12/turtledemo/turtle.cfg", + "lib/python3.12/turtledemo/two_canvases.py", + "lib/python3.12/turtledemo/yinyang.py", + "lib/python3.12/types.py", + "lib/python3.12/typing.py", + "lib/python3.12/unittest/__init__.py", + "lib/python3.12/unittest/__main__.py", + "lib/python3.12/unittest/__pycache__/__init__.cpython-312.pyc", + "lib/python3.12/unittest/__pycache__/__main__.cpython-312.pyc", + "lib/python3.12/unittest/__pycache__/_log.cpython-312.pyc", + "lib/python3.12/unittest/__pycache__/async_case.cpython-312.pyc", + "lib/python3.12/unittest/__pycache__/case.cpython-312.pyc", + "lib/python3.12/unittest/__pycache__/loader.cpython-312.pyc", + "lib/python3.12/unittest/__pycache__/main.cpython-312.pyc", + "lib/python3.12/unittest/__pycache__/mock.cpython-312.pyc", + "lib/python3.12/unittest/__pycache__/result.cpython-312.pyc", + "lib/python3.12/unittest/__pycache__/runner.cpython-312.pyc", + "lib/python3.12/unittest/__pycache__/signals.cpython-312.pyc", + "lib/python3.12/unittest/__pycache__/suite.cpython-312.pyc", + "lib/python3.12/unittest/__pycache__/util.cpython-312.pyc", + "lib/python3.12/unittest/_log.py", + "lib/python3.12/unittest/async_case.py", + "lib/python3.12/unittest/case.py", + "lib/python3.12/unittest/loader.py", + "lib/python3.12/unittest/main.py", + "lib/python3.12/unittest/mock.py", + "lib/python3.12/unittest/result.py", + "lib/python3.12/unittest/runner.py", + "lib/python3.12/unittest/signals.py", + "lib/python3.12/unittest/suite.py", + "lib/python3.12/unittest/util.py", + "lib/python3.12/urllib/__init__.py", + "lib/python3.12/urllib/__pycache__/__init__.cpython-312.pyc", + "lib/python3.12/urllib/__pycache__/error.cpython-312.pyc", + "lib/python3.12/urllib/__pycache__/parse.cpython-312.pyc", + "lib/python3.12/urllib/__pycache__/request.cpython-312.pyc", + "lib/python3.12/urllib/__pycache__/response.cpython-312.pyc", + "lib/python3.12/urllib/__pycache__/robotparser.cpython-312.pyc", + "lib/python3.12/urllib/error.py", + "lib/python3.12/urllib/parse.py", + "lib/python3.12/urllib/request.py", + "lib/python3.12/urllib/response.py", + "lib/python3.12/urllib/robotparser.py", + "lib/python3.12/uu.py", + "lib/python3.12/uuid.py", + "lib/python3.12/venv/__init__.py", + "lib/python3.12/venv/__main__.py", + "lib/python3.12/venv/__pycache__/__init__.cpython-312.pyc", + "lib/python3.12/venv/__pycache__/__main__.cpython-312.pyc", + "lib/python3.12/venv/scripts/common/Activate.ps1", + "lib/python3.12/venv/scripts/common/activate", + "lib/python3.12/venv/scripts/posix/activate.csh", + "lib/python3.12/venv/scripts/posix/activate.fish", + "lib/python3.12/warnings.py", + "lib/python3.12/wave.py", + "lib/python3.12/weakref.py", + "lib/python3.12/webbrowser.py", + "lib/python3.12/wsgiref/__init__.py", + "lib/python3.12/wsgiref/__pycache__/__init__.cpython-312.pyc", + "lib/python3.12/wsgiref/__pycache__/handlers.cpython-312.pyc", + "lib/python3.12/wsgiref/__pycache__/headers.cpython-312.pyc", + "lib/python3.12/wsgiref/__pycache__/simple_server.cpython-312.pyc", + "lib/python3.12/wsgiref/__pycache__/types.cpython-312.pyc", + "lib/python3.12/wsgiref/__pycache__/util.cpython-312.pyc", + "lib/python3.12/wsgiref/__pycache__/validate.cpython-312.pyc", + "lib/python3.12/wsgiref/handlers.py", + "lib/python3.12/wsgiref/headers.py", + "lib/python3.12/wsgiref/simple_server.py", + "lib/python3.12/wsgiref/types.py", + "lib/python3.12/wsgiref/util.py", + "lib/python3.12/wsgiref/validate.py", + "lib/python3.12/xdrlib.py", + "lib/python3.12/xml/__init__.py", + "lib/python3.12/xml/__pycache__/__init__.cpython-312.pyc", + "lib/python3.12/xml/dom/NodeFilter.py", + "lib/python3.12/xml/dom/__init__.py", + "lib/python3.12/xml/dom/__pycache__/NodeFilter.cpython-312.pyc", + "lib/python3.12/xml/dom/__pycache__/__init__.cpython-312.pyc", + "lib/python3.12/xml/dom/__pycache__/domreg.cpython-312.pyc", + "lib/python3.12/xml/dom/__pycache__/expatbuilder.cpython-312.pyc", + "lib/python3.12/xml/dom/__pycache__/minicompat.cpython-312.pyc", + "lib/python3.12/xml/dom/__pycache__/minidom.cpython-312.pyc", + "lib/python3.12/xml/dom/__pycache__/pulldom.cpython-312.pyc", + "lib/python3.12/xml/dom/__pycache__/xmlbuilder.cpython-312.pyc", + "lib/python3.12/xml/dom/domreg.py", + "lib/python3.12/xml/dom/expatbuilder.py", + "lib/python3.12/xml/dom/minicompat.py", + "lib/python3.12/xml/dom/minidom.py", + "lib/python3.12/xml/dom/pulldom.py", + "lib/python3.12/xml/dom/xmlbuilder.py", + "lib/python3.12/xml/etree/ElementInclude.py", + "lib/python3.12/xml/etree/ElementPath.py", + "lib/python3.12/xml/etree/ElementTree.py", + "lib/python3.12/xml/etree/__init__.py", + "lib/python3.12/xml/etree/__pycache__/ElementInclude.cpython-312.pyc", + "lib/python3.12/xml/etree/__pycache__/ElementPath.cpython-312.pyc", + "lib/python3.12/xml/etree/__pycache__/ElementTree.cpython-312.pyc", + "lib/python3.12/xml/etree/__pycache__/__init__.cpython-312.pyc", + "lib/python3.12/xml/etree/__pycache__/cElementTree.cpython-312.pyc", + "lib/python3.12/xml/etree/cElementTree.py", + "lib/python3.12/xml/parsers/__init__.py", + "lib/python3.12/xml/parsers/__pycache__/__init__.cpython-312.pyc", + "lib/python3.12/xml/parsers/__pycache__/expat.cpython-312.pyc", + "lib/python3.12/xml/parsers/expat.py", + "lib/python3.12/xml/sax/__init__.py", + "lib/python3.12/xml/sax/__pycache__/__init__.cpython-312.pyc", + "lib/python3.12/xml/sax/__pycache__/_exceptions.cpython-312.pyc", + "lib/python3.12/xml/sax/__pycache__/expatreader.cpython-312.pyc", + "lib/python3.12/xml/sax/__pycache__/handler.cpython-312.pyc", + "lib/python3.12/xml/sax/__pycache__/saxutils.cpython-312.pyc", + "lib/python3.12/xml/sax/__pycache__/xmlreader.cpython-312.pyc", + "lib/python3.12/xml/sax/_exceptions.py", + "lib/python3.12/xml/sax/expatreader.py", + "lib/python3.12/xml/sax/handler.py", + "lib/python3.12/xml/sax/saxutils.py", + "lib/python3.12/xml/sax/xmlreader.py", + "lib/python3.12/xmlrpc/__init__.py", + "lib/python3.12/xmlrpc/__pycache__/__init__.cpython-312.pyc", + "lib/python3.12/xmlrpc/__pycache__/client.cpython-312.pyc", + "lib/python3.12/xmlrpc/__pycache__/server.cpython-312.pyc", + "lib/python3.12/xmlrpc/client.py", + "lib/python3.12/xmlrpc/server.py", + "lib/python3.12/zipapp.py", + "lib/python3.12/zipfile/__init__.py", + "lib/python3.12/zipfile/__main__.py", + "lib/python3.12/zipfile/__pycache__/__init__.cpython-312.pyc", + "lib/python3.12/zipfile/__pycache__/__main__.cpython-312.pyc", + "lib/python3.12/zipfile/_path/__init__.py", + "lib/python3.12/zipfile/_path/__pycache__/__init__.cpython-312.pyc", + "lib/python3.12/zipfile/_path/__pycache__/glob.cpython-312.pyc", + "lib/python3.12/zipfile/_path/glob.py", + "lib/python3.12/zipimport.py", + "lib/python3.12/zoneinfo/__init__.py", + "lib/python3.12/zoneinfo/__pycache__/__init__.cpython-312.pyc", + "lib/python3.12/zoneinfo/__pycache__/_common.cpython-312.pyc", + "lib/python3.12/zoneinfo/__pycache__/_tzpath.cpython-312.pyc", + "lib/python3.12/zoneinfo/__pycache__/_zoneinfo.cpython-312.pyc", + "lib/python3.12/zoneinfo/_common.py", + "lib/python3.12/zoneinfo/_tzpath.py", + "lib/python3.12/zoneinfo/_zoneinfo.py", + "share/man/man1/python3.1", + "share/man/man1/python3.12.1" + ], + "fn": "python-3.12.2-hdf0ec26_0_cpython.conda", + "license": "Python-2.0", + "link": { + "source": "/Users/donjayamanne/miniconda3/pkgs/python-3.12.2-hdf0ec26_0_cpython", + "type": 1 + }, + "md5": "85e91138ae921a2771f57a50120272bd", + "name": "python", + "package_tarball_full_path": "/Users/donjayamanne/miniconda3/pkgs/python-3.12.2-hdf0ec26_0_cpython.conda", + "paths_data": { + "paths": [ + { + "_path": "bin/2to3", + "path_type": "softlink", + "sha256": "ccc93e84439d9c18b5439dc270fb09d7b613d9eb30efa613b4d39452895a6872", + "size_in_bytes": 347 + }, + { + "_path": "bin/2to3-3.12", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/Users/runner/miniforge3/conda-bld/python-split_1708115848844/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placeh", + "sha256": "ccc93e84439d9c18b5439dc270fb09d7b613d9eb30efa613b4d39452895a6872", + "sha256_in_prefix": "2b479c896c7b5bbb3fb73ea1df6f0c33075107b830b0a802cad421dc36c9c187", + "size_in_bytes": 347 + }, + { + "_path": "bin/idle3", + "path_type": "softlink", + "sha256": "77cd853be1090440bcc8bd8b3d62e424f15140ff3a41b1eeb78f1309a4d4d951", + "size_in_bytes": 345 + }, + { + "_path": "bin/idle3.12", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/Users/runner/miniforge3/conda-bld/python-split_1708115848844/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placeh", + "sha256": "77cd853be1090440bcc8bd8b3d62e424f15140ff3a41b1eeb78f1309a4d4d951", + "sha256_in_prefix": "55b80175f900774f4aa4cedb8eff451042f37b2af1b9802ccfa99371e8d4d97a", + "size_in_bytes": 345 + }, + { + "_path": "bin/pydoc", + "path_type": "softlink", + "sha256": "be0a30e51f64a794b5a717171a5cb4ac3234321f6849b21bd0b18e2f8c160285", + "size_in_bytes": 330 + }, + { + "_path": "bin/pydoc3", + "path_type": "softlink", + "sha256": "be0a30e51f64a794b5a717171a5cb4ac3234321f6849b21bd0b18e2f8c160285", + "size_in_bytes": 330 + }, + { + "_path": "bin/pydoc3.12", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/Users/runner/miniforge3/conda-bld/python-split_1708115848844/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placeh", + "sha256": "be0a30e51f64a794b5a717171a5cb4ac3234321f6849b21bd0b18e2f8c160285", + "sha256_in_prefix": "08d4cea2665c0995bf292682ffad2c5d5549f8b2fafafe17be30991d7228fbb3", + "size_in_bytes": 330 + }, + { + "_path": "bin/python", + "path_type": "softlink", + "sha256": "2e5a6d2412ea4948a772ea3b325078c97a16cda01f99745df77f940adfd95841", + "size_in_bytes": 6473936 + }, + { + "_path": "bin/python3", + "path_type": "softlink", + "sha256": "2e5a6d2412ea4948a772ea3b325078c97a16cda01f99745df77f940adfd95841", + "size_in_bytes": 6473936 + }, + { + "_path": "bin/python3-config", + "path_type": "softlink", + "sha256": "d0ca9f1b59946e9c206eae18ff42521af18ada070a568d534c2e5f3ff4fe9598", + "size_in_bytes": 2289 + }, + { + "_path": "bin/python3.1", + "path_type": "softlink", + "sha256": "2e5a6d2412ea4948a772ea3b325078c97a16cda01f99745df77f940adfd95841", + "size_in_bytes": 6473936 + }, + { + "_path": "bin/python3.12", + "file_mode": "binary", + "path_type": "hardlink", + "prefix_placeholder": "/Users/runner/miniforge3/conda-bld/python-split_1708115848844/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placeh", + "sha256": "2e5a6d2412ea4948a772ea3b325078c97a16cda01f99745df77f940adfd95841", + "sha256_in_prefix": "68f3e91cee7775f714e7e663154298ce21850bc3da738e29ec689b7b4e54301c", + "size_in_bytes": 6473936 + }, + { + "_path": "bin/python3.12-config", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/Users/runner/miniforge3/conda-bld/python-split_1708115848844/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placeh", + "sha256": "d0ca9f1b59946e9c206eae18ff42521af18ada070a568d534c2e5f3ff4fe9598", + "sha256_in_prefix": "f0fbf2d550f63d4b6ca56d2609a89cb6647c71894010636fc6ddd305fd1c7cfb", + "size_in_bytes": 2289 + }, + { + "_path": "include/python3.12/Python.h", + "path_type": "hardlink", + "sha256": "0b4a45e50087a78e9a88a70e1b247a05dccc0e089164c7c8ece4331b80355fa6", + "sha256_in_prefix": "0b4a45e50087a78e9a88a70e1b247a05dccc0e089164c7c8ece4331b80355fa6", + "size_in_bytes": 2854 + }, + { + "_path": "include/python3.12/abstract.h", + "path_type": "hardlink", + "sha256": "8f0b27427f4e16b4295b2ab1a7bb499bf86748fafbd1959e220c506ed59f774f", + "sha256_in_prefix": "8f0b27427f4e16b4295b2ab1a7bb499bf86748fafbd1959e220c506ed59f774f", + "size_in_bytes": 32616 + }, + { + "_path": "include/python3.12/bltinmodule.h", + "path_type": "hardlink", + "sha256": "1b5101b4b85409fd910032713906800bbb83580503036469c2a60ac8e80b8f72", + "sha256_in_prefix": "1b5101b4b85409fd910032713906800bbb83580503036469c2a60ac8e80b8f72", + "size_in_bytes": 264 + }, + { + "_path": "include/python3.12/boolobject.h", + "path_type": "hardlink", + "sha256": "84289d5b1a1b7ed6c547f4f081fba70e90a9d60dfa2d2b3155c33cdd2af41340", + "sha256_in_prefix": "84289d5b1a1b7ed6c547f4f081fba70e90a9d60dfa2d2b3155c33cdd2af41340", + "size_in_bytes": 1136 + }, + { + "_path": "include/python3.12/bytearrayobject.h", + "path_type": "hardlink", + "sha256": "0e93963caf43a057fb293ae5183d1b8bb45c9f57926ce8308f67a0f452843e85", + "sha256_in_prefix": "0e93963caf43a057fb293ae5183d1b8bb45c9f57926ce8308f67a0f452843e85", + "size_in_bytes": 1466 + }, + { + "_path": "include/python3.12/bytesobject.h", + "path_type": "hardlink", + "sha256": "de8551db9323e7dc463717a624f2d35dacd17cdf0c7a7f6299128dd06348cf30", + "sha256_in_prefix": "de8551db9323e7dc463717a624f2d35dacd17cdf0c7a7f6299128dd06348cf30", + "size_in_bytes": 2619 + }, + { + "_path": "include/python3.12/ceval.h", + "path_type": "hardlink", + "sha256": "9531cce1b80e804d46a9ef31bd22605f54d0ae0609dc3470946a4d8d4270af3a", + "sha256_in_prefix": "9531cce1b80e804d46a9ef31bd22605f54d0ae0609dc3470946a4d8d4270af3a", + "size_in_bytes": 6267 + }, + { + "_path": "include/python3.12/codecs.h", + "path_type": "hardlink", + "sha256": "0ca3c6e55e7ff62872b47aeeb7379d784b03ebfc61bbd029b67485fe783baac5", + "sha256_in_prefix": "0ca3c6e55e7ff62872b47aeeb7379d784b03ebfc61bbd029b67485fe783baac5", + "size_in_bytes": 7071 + }, + { + "_path": "include/python3.12/compile.h", + "path_type": "hardlink", + "sha256": "1f10c818b29007e6a4446505a1140dd77ca6618ad81e87b502f4e22f4b274406", + "sha256_in_prefix": "1f10c818b29007e6a4446505a1140dd77ca6618ad81e87b502f4e22f4b274406", + "size_in_bytes": 448 + }, + { + "_path": "include/python3.12/complexobject.h", + "path_type": "hardlink", + "sha256": "9356805a24503256cd8914d7b7700357e01f471c211f9241c81981d89d6c3af8", + "sha256_in_prefix": "9356805a24503256cd8914d7b7700357e01f471c211f9241c81981d89d6c3af8", + "size_in_bytes": 728 + }, + { + "_path": "include/python3.12/cpython/abstract.h", + "path_type": "hardlink", + "sha256": "07d8b3b9c7db77e30adef4c4d9c7a4453b8eb1f48341ed5394bd5eebe239c9fd", + "sha256_in_prefix": "07d8b3b9c7db77e30adef4c4d9c7a4453b8eb1f48341ed5394bd5eebe239c9fd", + "size_in_bytes": 7870 + }, + { + "_path": "include/python3.12/cpython/bytearrayobject.h", + "path_type": "hardlink", + "sha256": "ae5e099856657f3b8606701df312866eaa88992f6cfd9f8567456e1588efceb1", + "sha256_in_prefix": "ae5e099856657f3b8606701df312866eaa88992f6cfd9f8567456e1588efceb1", + "size_in_bytes": 1163 + }, + { + "_path": "include/python3.12/cpython/bytesobject.h", + "path_type": "hardlink", + "sha256": "a7535615c2637b60e53c32355b489f49c6bc979be3a58adae5b0049231b43a6c", + "sha256_in_prefix": "a7535615c2637b60e53c32355b489f49c6bc979be3a58adae5b0049231b43a6c", + "size_in_bytes": 4426 + }, + { + "_path": "include/python3.12/cpython/cellobject.h", + "path_type": "hardlink", + "sha256": "844f06178bbce2e9377a46ccc80e2aae85a73750932576a6cc4de934cc508cea", + "sha256_in_prefix": "844f06178bbce2e9377a46ccc80e2aae85a73750932576a6cc4de934cc508cea", + "size_in_bytes": 1076 + }, + { + "_path": "include/python3.12/cpython/ceval.h", + "path_type": "hardlink", + "sha256": "b08c549971f1006e681267dd8a88481353ce4bd89b9d859f81b72cf9bf867895", + "sha256_in_prefix": "b08c549971f1006e681267dd8a88481353ce4bd89b9d859f81b72cf9bf867895", + "size_in_bytes": 1650 + }, + { + "_path": "include/python3.12/cpython/classobject.h", + "path_type": "hardlink", + "sha256": "b38a0ecdebeae2a4d28dfe8a5f2833f676d38be9561ca4bdfdf5087bbe2f9332", + "sha256_in_prefix": "b38a0ecdebeae2a4d28dfe8a5f2833f676d38be9561ca4bdfdf5087bbe2f9332", + "size_in_bytes": 2245 + }, + { + "_path": "include/python3.12/cpython/code.h", + "path_type": "hardlink", + "sha256": "2382c3cd9db5f1686e84c94ac8cd729fab81791c9de7fdbc045ac5d26a3d9d9c", + "sha256_in_prefix": "2382c3cd9db5f1686e84c94ac8cd729fab81791c9de7fdbc045ac5d26a3d9d9c", + "size_in_bytes": 16189 + }, + { + "_path": "include/python3.12/cpython/compile.h", + "path_type": "hardlink", + "sha256": "32d7397c6fa5478feb2a4101641fca6dba3ac77abe4deed5c0f713a6cd6564f5", + "sha256_in_prefix": "32d7397c6fa5478feb2a4101641fca6dba3ac77abe4deed5c0f713a6cd6564f5", + "size_in_bytes": 2660 + }, + { + "_path": "include/python3.12/cpython/complexobject.h", + "path_type": "hardlink", + "sha256": "a4c110008e4d791a4577ce6ebee33bc512ec3e3db918bd2c296f00dd79379fcb", + "sha256_in_prefix": "a4c110008e4d791a4577ce6ebee33bc512ec3e3db918bd2c296f00dd79379fcb", + "size_in_bytes": 1248 + }, + { + "_path": "include/python3.12/cpython/context.h", + "path_type": "hardlink", + "sha256": "9e34d54a789cbf0d78d5ebb126e8384342c08dd81d944d10e3d8f0de0bbba10a", + "sha256_in_prefix": "9e34d54a789cbf0d78d5ebb126e8384342c08dd81d944d10e3d8f0de0bbba10a", + "size_in_bytes": 1965 + }, + { + "_path": "include/python3.12/cpython/descrobject.h", + "path_type": "hardlink", + "sha256": "a1ee0124142fe91204d0c5e85169b55341b2167111a1447e3a8ed50f9bd5a12f", + "sha256_in_prefix": "a1ee0124142fe91204d0c5e85169b55341b2167111a1447e3a8ed50f9bd5a12f", + "size_in_bytes": 1642 + }, + { + "_path": "include/python3.12/cpython/dictobject.h", + "path_type": "hardlink", + "sha256": "5ac16d73f22038b12bd06904cf02a14bbdd723234d1d899354f1a041e8659505", + "sha256_in_prefix": "5ac16d73f22038b12bd06904cf02a14bbdd723234d1d899354f1a041e8659505", + "size_in_bytes": 4686 + }, + { + "_path": "include/python3.12/cpython/fileobject.h", + "path_type": "hardlink", + "sha256": "16ab872cbe2bb3351ce3090873440903b1460c1d68aed483c70c31edc4140ba2", + "sha256_in_prefix": "16ab872cbe2bb3351ce3090873440903b1460c1d68aed483c70c31edc4140ba2", + "size_in_bytes": 818 + }, + { + "_path": "include/python3.12/cpython/fileutils.h", + "path_type": "hardlink", + "sha256": "d7a2f703c6fba2efabd0b1cc916ad36074363a27a000987cfad17e21f04d44f1", + "sha256_in_prefix": "d7a2f703c6fba2efabd0b1cc916ad36074363a27a000987cfad17e21f04d44f1", + "size_in_bytes": 232 + }, + { + "_path": "include/python3.12/cpython/floatobject.h", + "path_type": "hardlink", + "sha256": "f1c53f5b87f221db66004b836aa2fc9462aa46c2fbe46b417a8ddc803ce2f585", + "sha256_in_prefix": "f1c53f5b87f221db66004b836aa2fc9462aa46c2fbe46b417a8ddc803ce2f585", + "size_in_bytes": 900 + }, + { + "_path": "include/python3.12/cpython/frameobject.h", + "path_type": "hardlink", + "sha256": "e1421b58c6a25efb56f423a749c313e3f5392f58cc0c7f4f09b0412217a4a734", + "sha256_in_prefix": "e1421b58c6a25efb56f423a749c313e3f5392f58cc0c7f4f09b0412217a4a734", + "size_in_bytes": 1108 + }, + { + "_path": "include/python3.12/cpython/funcobject.h", + "path_type": "hardlink", + "sha256": "744cd5bc453de548ec454f1fb26e58efa581f3a51dee2b09872cb45bc3a5f981", + "sha256_in_prefix": "744cd5bc453de548ec454f1fb26e58efa581f3a51dee2b09872cb45bc3a5f981", + "size_in_bytes": 7150 + }, + { + "_path": "include/python3.12/cpython/genobject.h", + "path_type": "hardlink", + "sha256": "24f9bd2f19341dc73c7deebca17117ea3a94fd89865c0c6548e1bf5882f51d95", + "sha256_in_prefix": "24f9bd2f19341dc73c7deebca17117ea3a94fd89865c0c6548e1bf5882f51d95", + "size_in_bytes": 3316 + }, + { + "_path": "include/python3.12/cpython/import.h", + "path_type": "hardlink", + "sha256": "f3a6cb7ea774d2ffcb64c834dffaf008e8f9f3f10b23600d5522d82176cb241c", + "sha256_in_prefix": "f3a6cb7ea774d2ffcb64c834dffaf008e8f9f3f10b23600d5522d82176cb241c", + "size_in_bytes": 1623 + }, + { + "_path": "include/python3.12/cpython/initconfig.h", + "path_type": "hardlink", + "sha256": "86e3b9d1de6f310415912e2cdfdc276e311c026ec7fdf6190893f6313cd860a3", + "sha256_in_prefix": "86e3b9d1de6f310415912e2cdfdc276e311c026ec7fdf6190893f6313cd860a3", + "size_in_bytes": 7820 + }, + { + "_path": "include/python3.12/cpython/interpreteridobject.h", + "path_type": "hardlink", + "sha256": "8fc79784d556245d7b7f382063ef3797e3aebd0a6b375a95027dd63a5dfa30b6", + "sha256_in_prefix": "8fc79784d556245d7b7f382063ef3797e3aebd0a6b375a95027dd63a5dfa30b6", + "size_in_bytes": 387 + }, + { + "_path": "include/python3.12/cpython/listobject.h", + "path_type": "hardlink", + "sha256": "0ccca44b405add7a8c19d7a5e7701e06ab904cce5c430016b50f7968aef296fe", + "sha256_in_prefix": "0ccca44b405add7a8c19d7a5e7701e06ab904cce5c430016b50f7968aef296fe", + "size_in_bytes": 1633 + }, + { + "_path": "include/python3.12/cpython/longintrepr.h", + "path_type": "hardlink", + "sha256": "65ca4c2129e3dce303029a70add853b1ed25520df71ad731853f520862a5ff70", + "sha256_in_prefix": "65ca4c2129e3dce303029a70add853b1ed25520df71ad731853f520862a5ff70", + "size_in_bytes": 4879 + }, + { + "_path": "include/python3.12/cpython/longobject.h", + "path_type": "hardlink", + "sha256": "b443782d6b69a2cfd141ac13ac8b7a8d69e47bfdae9df984de4991b2d248b8b8", + "sha256_in_prefix": "b443782d6b69a2cfd141ac13ac8b7a8d69e47bfdae9df984de4991b2d248b8b8", + "size_in_bytes": 4679 + }, + { + "_path": "include/python3.12/cpython/memoryobject.h", + "path_type": "hardlink", + "sha256": "62f414f21611a31f453af7c8326b309aad8f79166087a951844921c50cc84dc7", + "sha256_in_prefix": "62f414f21611a31f453af7c8326b309aad8f79166087a951844921c50cc84dc7", + "size_in_bytes": 2272 + }, + { + "_path": "include/python3.12/cpython/methodobject.h", + "path_type": "hardlink", + "sha256": "5beb9f3b68ac72efe403a1b0a3fbbb14a5606a49a2840b9c7e9ff243d82d79b9", + "sha256_in_prefix": "5beb9f3b68ac72efe403a1b0a3fbbb14a5606a49a2840b9c7e9ff243d82d79b9", + "size_in_bytes": 2276 + }, + { + "_path": "include/python3.12/cpython/modsupport.h", + "path_type": "hardlink", + "sha256": "a8d08132874d9d642ade82e62e87a510577b7bd4ab0685a90b044cc3b005232d", + "sha256_in_prefix": "a8d08132874d9d642ade82e62e87a510577b7bd4ab0685a90b044cc3b005232d", + "size_in_bytes": 4336 + }, + { + "_path": "include/python3.12/cpython/object.h", + "path_type": "hardlink", + "sha256": "f412fd84202ef228e6bf239c9a5a408b8d8623481a15452f8f3331dfc6342134", + "sha256_in_prefix": "f412fd84202ef228e6bf239c9a5a408b8d8623481a15452f8f3331dfc6342134", + "size_in_bytes": 21212 + }, + { + "_path": "include/python3.12/cpython/objimpl.h", + "path_type": "hardlink", + "sha256": "d99f0cff4297590a49f6616dbf1b04a06c745bed0a280ae35acc56fb3c47f2f3", + "sha256_in_prefix": "d99f0cff4297590a49f6616dbf1b04a06c745bed0a280ae35acc56fb3c47f2f3", + "size_in_bytes": 3316 + }, + { + "_path": "include/python3.12/cpython/odictobject.h", + "path_type": "hardlink", + "sha256": "97dc6296e890463fc6994247e885df65cd4024dc1b05facfdc984c37d646b919", + "sha256_in_prefix": "97dc6296e890463fc6994247e885df65cd4024dc1b05facfdc984c37d646b919", + "size_in_bytes": 1311 + }, + { + "_path": "include/python3.12/cpython/picklebufobject.h", + "path_type": "hardlink", + "sha256": "7040fb48462296c903f2f0d24d2b54e0de63cf7512dcf8d3048a0cadf7d94fd0", + "sha256_in_prefix": "7040fb48462296c903f2f0d24d2b54e0de63cf7512dcf8d3048a0cadf7d94fd0", + "size_in_bytes": 848 + }, + { + "_path": "include/python3.12/cpython/pthread_stubs.h", + "path_type": "hardlink", + "sha256": "0f3108e0430ee937098c86352d2ced6e3ec7f5cb5bc7e06eebee58cf779fcd89", + "sha256_in_prefix": "0f3108e0430ee937098c86352d2ced6e3ec7f5cb5bc7e06eebee58cf779fcd89", + "size_in_bytes": 3505 + }, + { + "_path": "include/python3.12/cpython/pyctype.h", + "path_type": "hardlink", + "sha256": "10b5ccbc210fd2832e9c34849a3952e8db75f0016add89188358b1da6a8f3dbb", + "sha256_in_prefix": "10b5ccbc210fd2832e9c34849a3952e8db75f0016add89188358b1da6a8f3dbb", + "size_in_bytes": 1387 + }, + { + "_path": "include/python3.12/cpython/pydebug.h", + "path_type": "hardlink", + "sha256": "83d72e867b4fc9ac87efdfcb41c3d30ec20fa239fe6a74d1b85aa92e1f8d9506", + "sha256_in_prefix": "83d72e867b4fc9ac87efdfcb41c3d30ec20fa239fe6a74d1b85aa92e1f8d9506", + "size_in_bytes": 1413 + }, + { + "_path": "include/python3.12/cpython/pyerrors.h", + "path_type": "hardlink", + "sha256": "1f5070d787263e3aa8845dc90b38aaeb0945be83ef2ba993a40b4af926daacad", + "sha256_in_prefix": "1f5070d787263e3aa8845dc90b38aaeb0945be83ef2ba993a40b4af926daacad", + "size_in_bytes": 4276 + }, + { + "_path": "include/python3.12/cpython/pyfpe.h", + "path_type": "hardlink", + "sha256": "ea7bfa7d891a0b5372d8b40a57d1b466b7824296e5c3f8d50b1a7cde084429b7", + "sha256_in_prefix": "ea7bfa7d891a0b5372d8b40a57d1b466b7824296e5c3f8d50b1a7cde084429b7", + "size_in_bytes": 444 + }, + { + "_path": "include/python3.12/cpython/pyframe.h", + "path_type": "hardlink", + "sha256": "0c7ea17874b967892de6f6623aa426d5eaf267a56e6bbb84b3fefa40e59ec1b8", + "sha256_in_prefix": "0c7ea17874b967892de6f6623aa426d5eaf267a56e6bbb84b3fefa40e59ec1b8", + "size_in_bytes": 1479 + }, + { + "_path": "include/python3.12/cpython/pylifecycle.h", + "path_type": "hardlink", + "sha256": "02505815b8bc3e33fe31a11f4f7f960826aa1dce2c4cee6d62d2a0394470c9bf", + "sha256_in_prefix": "02505815b8bc3e33fe31a11f4f7f960826aa1dce2c4cee6d62d2a0394470c9bf", + "size_in_bytes": 3423 + }, + { + "_path": "include/python3.12/cpython/pymem.h", + "path_type": "hardlink", + "sha256": "8a3795a9350b10548e8ad6d37dad69be2abd3870a751e67faa32a19a090608db", + "sha256_in_prefix": "8a3795a9350b10548e8ad6d37dad69be2abd3870a751e67faa32a19a090608db", + "size_in_bytes": 3379 + }, + { + "_path": "include/python3.12/cpython/pystate.h", + "path_type": "hardlink", + "sha256": "012cb810792852a79ac96af53fb92ee4beb543eace6d0e9934fb873de106d05d", + "sha256_in_prefix": "012cb810792852a79ac96af53fb92ee4beb543eace6d0e9934fb873de106d05d", + "size_in_bytes": 16921 + }, + { + "_path": "include/python3.12/cpython/pythonrun.h", + "path_type": "hardlink", + "sha256": "3290ea064e7450aaf43320a5fcac22d9b36acfab43d1d2c3381ade4b726ced8f", + "sha256_in_prefix": "3290ea064e7450aaf43320a5fcac22d9b36acfab43d1d2c3381ade4b726ced8f", + "size_in_bytes": 4903 + }, + { + "_path": "include/python3.12/cpython/pythread.h", + "path_type": "hardlink", + "sha256": "7239113064e41ba5a678b665af17bee1f878d51076f6d82f89d5d52151ebf573", + "sha256_in_prefix": "7239113064e41ba5a678b665af17bee1f878d51076f6d82f89d5d52151ebf573", + "size_in_bytes": 1426 + }, + { + "_path": "include/python3.12/cpython/pytime.h", + "path_type": "hardlink", + "sha256": "64b70f16b9e6845e0378f2f9108952731ca5bd43b33609781dccd5af70d60204", + "sha256_in_prefix": "64b70f16b9e6845e0378f2f9108952731ca5bd43b33609781dccd5af70d60204", + "size_in_bytes": 12375 + }, + { + "_path": "include/python3.12/cpython/setobject.h", + "path_type": "hardlink", + "sha256": "c965bf093325e20c319af5183a8e5723d4d0b373cb6d1b8781df8c1e588963c0", + "sha256_in_prefix": "c965bf093325e20c319af5183a8e5723d4d0b373cb6d1b8781df8c1e588963c0", + "size_in_bytes": 2146 + }, + { + "_path": "include/python3.12/cpython/sysmodule.h", + "path_type": "hardlink", + "sha256": "d4936db24692cccadb19c11accda260787f95e5658f88cfc752d9a49344ee051", + "sha256_in_prefix": "d4936db24692cccadb19c11accda260787f95e5658f88cfc752d9a49344ee051", + "size_in_bytes": 489 + }, + { + "_path": "include/python3.12/cpython/traceback.h", + "path_type": "hardlink", + "sha256": "7898a3c168973e1119fb3b57f144be627c1468082ab0b91d001dd876dd1dbcb6", + "sha256_in_prefix": "7898a3c168973e1119fb3b57f144be627c1468082ab0b91d001dd876dd1dbcb6", + "size_in_bytes": 444 + }, + { + "_path": "include/python3.12/cpython/tupleobject.h", + "path_type": "hardlink", + "sha256": "301c0720038f50d8e9087b38cf1392524abf9e28262b677d841fc1a7e172c3f3", + "sha256_in_prefix": "301c0720038f50d8e9087b38cf1392524abf9e28262b677d841fc1a7e172c3f3", + "size_in_bytes": 1377 + }, + { + "_path": "include/python3.12/cpython/unicodeobject.h", + "path_type": "hardlink", + "sha256": "1fece91b6ddd3b131e4c2783973b9226f1efe6e53a2530da21bb75f18ebad6c5", + "sha256_in_prefix": "1fece91b6ddd3b131e4c2783973b9226f1efe6e53a2530da21bb75f18ebad6c5", + "size_in_bytes": 34467 + }, + { + "_path": "include/python3.12/cpython/warnings.h", + "path_type": "hardlink", + "sha256": "b758a2e42b0c497ea811464f579603d14fc30b50bd6ebe064d8d2a7df7e2bd76", + "sha256_in_prefix": "b758a2e42b0c497ea811464f579603d14fc30b50bd6ebe064d8d2a7df7e2bd76", + "size_in_bytes": 564 + }, + { + "_path": "include/python3.12/cpython/weakrefobject.h", + "path_type": "hardlink", + "sha256": "be0ab05169da7efcd13aba0ddc58604a80328d4e60349df6d4efdd1bf363e1a2", + "sha256_in_prefix": "be0ab05169da7efcd13aba0ddc58604a80328d4e60349df6d4efdd1bf363e1a2", + "size_in_bytes": 2032 + }, + { + "_path": "include/python3.12/datetime.h", + "path_type": "hardlink", + "sha256": "f3d8192cada0f490a67233e615e5974f062501b2876147118ddb042ee4a7f988", + "sha256_in_prefix": "f3d8192cada0f490a67233e615e5974f062501b2876147118ddb042ee4a7f988", + "size_in_bytes": 9769 + }, + { + "_path": "include/python3.12/descrobject.h", + "path_type": "hardlink", + "sha256": "2956a488f4c4c61341e361dac949cfa4a217e0fbd0097892513b02363c9570a7", + "sha256_in_prefix": "2956a488f4c4c61341e361dac949cfa4a217e0fbd0097892513b02363c9570a7", + "size_in_bytes": 3080 + }, + { + "_path": "include/python3.12/dictobject.h", + "path_type": "hardlink", + "sha256": "08f92e2a4421d3e81fa0fa1b60cbe97f2d69897226368481b0ffc41eeb202356", + "sha256_in_prefix": "08f92e2a4421d3e81fa0fa1b60cbe97f2d69897226368481b0ffc41eeb202356", + "size_in_bytes": 3860 + }, + { + "_path": "include/python3.12/dynamic_annotations.h", + "path_type": "hardlink", + "sha256": "3e4366f7d082835049730358d277a5ad7a60e16d1601f5622f0a045a37c152ac", + "sha256_in_prefix": "3e4366f7d082835049730358d277a5ad7a60e16d1601f5622f0a045a37c152ac", + "size_in_bytes": 22471 + }, + { + "_path": "include/python3.12/enumobject.h", + "path_type": "hardlink", + "sha256": "2244fe250db9995068fe74dce0e23fd70c12b03fd94751d98b773be8f64896b6", + "sha256_in_prefix": "2244fe250db9995068fe74dce0e23fd70c12b03fd94751d98b773be8f64896b6", + "size_in_bytes": 253 + }, + { + "_path": "include/python3.12/errcode.h", + "path_type": "hardlink", + "sha256": "e09ffcbb80580103d52992eb5fd8fd01b9930fda5e8f3874bfb9ee7aa2fe99fa", + "sha256_in_prefix": "e09ffcbb80580103d52992eb5fd8fd01b9930fda5e8f3874bfb9ee7aa2fe99fa", + "size_in_bytes": 1779 + }, + { + "_path": "include/python3.12/exports.h", + "path_type": "hardlink", + "sha256": "d02e9937f747660b218062bcdab504b706cad264b4df993f749d9118f2f7b65c", + "sha256_in_prefix": "d02e9937f747660b218062bcdab504b706cad264b4df993f749d9118f2f7b65c", + "size_in_bytes": 1267 + }, + { + "_path": "include/python3.12/fileobject.h", + "path_type": "hardlink", + "sha256": "133e57cf705cbdaa79a0c115b27e748cc24dedb51ea17b441ff65d05df28a674", + "sha256_in_prefix": "133e57cf705cbdaa79a0c115b27e748cc24dedb51ea17b441ff65d05df28a674", + "size_in_bytes": 1650 + }, + { + "_path": "include/python3.12/fileutils.h", + "path_type": "hardlink", + "sha256": "51ae1c2ca70a8005206f653121d1ba3247f59421c96399739845d687980e9b01", + "sha256_in_prefix": "51ae1c2ca70a8005206f653121d1ba3247f59421c96399739845d687980e9b01", + "size_in_bytes": 507 + }, + { + "_path": "include/python3.12/floatobject.h", + "path_type": "hardlink", + "sha256": "2da72b48fa342e53f72848d468c3c11a9d5b62922f2bd71c286331f54f2364a1", + "sha256_in_prefix": "2da72b48fa342e53f72848d468c3c11a9d5b62922f2bd71c286331f54f2364a1", + "size_in_bytes": 1532 + }, + { + "_path": "include/python3.12/frameobject.h", + "path_type": "hardlink", + "sha256": "969cd93065ce79b81bbc67a65d31b742e23f30bf79d6e44a306963d552ed0c35", + "sha256_in_prefix": "969cd93065ce79b81bbc67a65d31b742e23f30bf79d6e44a306963d552ed0c35", + "size_in_bytes": 336 + }, + { + "_path": "include/python3.12/genericaliasobject.h", + "path_type": "hardlink", + "sha256": "0e53a0b18c114be68eccea9ffd1dd577e204b1f0ada4d3aedc8e7ee0c80fc7f8", + "sha256_in_prefix": "0e53a0b18c114be68eccea9ffd1dd577e204b1f0ada4d3aedc8e7ee0c80fc7f8", + "size_in_bytes": 334 + }, + { + "_path": "include/python3.12/import.h", + "path_type": "hardlink", + "sha256": "4113e1b6afa760c3decce2bb765835adda19861394974cfe301e1ccb482e2b94", + "sha256_in_prefix": "4113e1b6afa760c3decce2bb765835adda19861394974cfe301e1ccb482e2b94", + "size_in_bytes": 3033 + }, + { + "_path": "include/python3.12/internal/pycore_abstract.h", + "path_type": "hardlink", + "sha256": "75ecd34cdcd06fc64fcfa550f66975d755619e7cf06fdae8ecbe2de6ec49ce39", + "sha256_in_prefix": "75ecd34cdcd06fc64fcfa550f66975d755619e7cf06fdae8ecbe2de6ec49ce39", + "size_in_bytes": 611 + }, + { + "_path": "include/python3.12/internal/pycore_asdl.h", + "path_type": "hardlink", + "sha256": "b29dace0f84849c4a24bc3745523a36911cd192bad7ec6fb48aba8facff51d3e", + "sha256_in_prefix": "b29dace0f84849c4a24bc3745523a36911cd192bad7ec6fb48aba8facff51d3e", + "size_in_bytes": 3035 + }, + { + "_path": "include/python3.12/internal/pycore_ast.h", + "path_type": "hardlink", + "sha256": "064b6778fa758fb2580fb8770f77dd0d1eb19323df0e345373788c75754910cf", + "sha256_in_prefix": "064b6778fa758fb2580fb8770f77dd0d1eb19323df0e345373788c75754910cf", + "size_in_bytes": 31288 + }, + { + "_path": "include/python3.12/internal/pycore_ast_state.h", + "path_type": "hardlink", + "sha256": "1d76a7b5207c653a86dec97aab5ba1fcc5c75e94333662792a692cb68e5b26c6", + "sha256_in_prefix": "1d76a7b5207c653a86dec97aab5ba1fcc5c75e94333662792a692cb68e5b26c6", + "size_in_bytes": 6749 + }, + { + "_path": "include/python3.12/internal/pycore_atexit.h", + "path_type": "hardlink", + "sha256": "8c5c88b8452894cf8a5f243ceb9021060f0fe8f5689cbc3e705c19c5edc0798a", + "sha256_in_prefix": "8c5c88b8452894cf8a5f243ceb9021060f0fe8f5689cbc3e705c19c5edc0798a", + "size_in_bytes": 1149 + }, + { + "_path": "include/python3.12/internal/pycore_atomic.h", + "path_type": "hardlink", + "sha256": "95e7118e799ad3faafc8e58a29b2d1f1a4bb94e1aac3273e042f379f8e12d4e6", + "sha256_in_prefix": "95e7118e799ad3faafc8e58a29b2d1f1a4bb94e1aac3273e042f379f8e12d4e6", + "size_in_bytes": 16979 + }, + { + "_path": "include/python3.12/internal/pycore_atomic_funcs.h", + "path_type": "hardlink", + "sha256": "9d5cfa13ad863a0cc1b0ab06861c1f8cfbdc7d730b9c4603e5777a608263d399", + "sha256_in_prefix": "9d5cfa13ad863a0cc1b0ab06861c1f8cfbdc7d730b9c4603e5777a608263d399", + "size_in_bytes": 2438 + }, + { + "_path": "include/python3.12/internal/pycore_bitutils.h", + "path_type": "hardlink", + "sha256": "86628b9cbefe4ff000e1190cd36f37b70a2dad6a4e9231cc2466a84579cc2139", + "sha256_in_prefix": "86628b9cbefe4ff000e1190cd36f37b70a2dad6a4e9231cc2466a84579cc2139", + "size_in_bytes": 6062 + }, + { + "_path": "include/python3.12/internal/pycore_blocks_output_buffer.h", + "path_type": "hardlink", + "sha256": "03fed5054d0d78e3711e73995e484fefb81495c063a5b9ef555c0395d7fc1ebc", + "sha256_in_prefix": "03fed5054d0d78e3711e73995e484fefb81495c063a5b9ef555c0395d7fc1ebc", + "size_in_bytes": 8688 + }, + { + "_path": "include/python3.12/internal/pycore_bytes_methods.h", + "path_type": "hardlink", + "sha256": "1534326dbf027e9bb472be5ccf8b82fab48f3282cc7f6a61629b801fc80afc00", + "sha256_in_prefix": "1534326dbf027e9bb472be5ccf8b82fab48f3282cc7f6a61629b801fc80afc00", + "size_in_bytes": 3384 + }, + { + "_path": "include/python3.12/internal/pycore_bytesobject.h", + "path_type": "hardlink", + "sha256": "d3ecf25cf0f0e9815ac24f496e5ccbbf8d57a10e570da81e84f2b5f6e95b59b8", + "sha256_in_prefix": "d3ecf25cf0f0e9815ac24f496e5ccbbf8d57a10e570da81e84f2b5f6e95b59b8", + "size_in_bytes": 1339 + }, + { + "_path": "include/python3.12/internal/pycore_call.h", + "path_type": "hardlink", + "sha256": "5e780aed2dc991455a0e528fc7baca8df61d2e4bec4e137d7e788668b5750ec5", + "sha256_in_prefix": "5e780aed2dc991455a0e528fc7baca8df61d2e4bec4e137d7e788668b5750ec5", + "size_in_bytes": 3920 + }, + { + "_path": "include/python3.12/internal/pycore_ceval.h", + "path_type": "hardlink", + "sha256": "1af22b50c9ececfc4c3a5f37ecb70cc1c0eefad5a2656e6e22fc088cae54e226", + "sha256_in_prefix": "1af22b50c9ececfc4c3a5f37ecb70cc1c0eefad5a2656e6e22fc088cae54e226", + "size_in_bytes": 5265 + }, + { + "_path": "include/python3.12/internal/pycore_ceval_state.h", + "path_type": "hardlink", + "sha256": "f29e3d6dcac96b0067a17845df8483013230805db10c6f3c5ecd02b9134640e7", + "sha256_in_prefix": "f29e3d6dcac96b0067a17845df8483013230805db10c6f3c5ecd02b9134640e7", + "size_in_bytes": 2744 + }, + { + "_path": "include/python3.12/internal/pycore_code.h", + "path_type": "hardlink", + "sha256": "48e78dd1a12e6afa6e54e26f8e7c4f56e20689b84189d503507c7f6c36819092", + "sha256_in_prefix": "48e78dd1a12e6afa6e54e26f8e7c4f56e20689b84189d503507c7f6c36819092", + "size_in_bytes": 15835 + }, + { + "_path": "include/python3.12/internal/pycore_compile.h", + "path_type": "hardlink", + "sha256": "4d386629f5e0ea801a01122833f11363cf9f1584aef6e9692ffd0b95eda37cbc", + "sha256_in_prefix": "4d386629f5e0ea801a01122833f11363cf9f1584aef6e9692ffd0b95eda37cbc", + "size_in_bytes": 3453 + }, + { + "_path": "include/python3.12/internal/pycore_condvar.h", + "path_type": "hardlink", + "sha256": "89a5d9c366c2e1c312e1ace5067d184380242c944deb698b6a4f53b51abd5826", + "sha256_in_prefix": "89a5d9c366c2e1c312e1ace5067d184380242c944deb698b6a4f53b51abd5826", + "size_in_bytes": 2839 + }, + { + "_path": "include/python3.12/internal/pycore_context.h", + "path_type": "hardlink", + "sha256": "974d6bafbe0164d60dd1bc4f09b5eac9bcc9e2d9066924ba2a2ba6d502f115b5", + "sha256_in_prefix": "974d6bafbe0164d60dd1bc4f09b5eac9bcc9e2d9066924ba2a2ba6d502f115b5", + "size_in_bytes": 1301 + }, + { + "_path": "include/python3.12/internal/pycore_descrobject.h", + "path_type": "hardlink", + "sha256": "d9be424b5c2d109b51338016acab6132f299c0640fc069fb0e1d48575089574e", + "sha256_in_prefix": "d9be424b5c2d109b51338016acab6132f299c0640fc069fb0e1d48575089574e", + "size_in_bytes": 499 + }, + { + "_path": "include/python3.12/internal/pycore_dict.h", + "path_type": "hardlink", + "sha256": "4d51e7184d50a5f8785a1cbdc9f6eb36b86201158ae6e3527884ce2b5dd504bf", + "sha256_in_prefix": "4d51e7184d50a5f8785a1cbdc9f6eb36b86201158ae6e3527884ce2b5dd504bf", + "size_in_bytes": 6384 + }, + { + "_path": "include/python3.12/internal/pycore_dict_state.h", + "path_type": "hardlink", + "sha256": "5a15c2bb4020ce4a1d7a4c651e0f98b4becd910f89cd7c4089c80a0419ec4f1c", + "sha256_in_prefix": "5a15c2bb4020ce4a1d7a4c651e0f98b4becd910f89cd7c4089c80a0419ec4f1c", + "size_in_bytes": 1095 + }, + { + "_path": "include/python3.12/internal/pycore_dtoa.h", + "path_type": "hardlink", + "sha256": "a67261c7187a02a6d2ef7fef8207acb85ce5906f4ee970f4f06822f695f489ad", + "sha256_in_prefix": "a67261c7187a02a6d2ef7fef8207acb85ce5906f4ee970f4f06822f695f489ad", + "size_in_bytes": 1626 + }, + { + "_path": "include/python3.12/internal/pycore_emscripten_signal.h", + "path_type": "hardlink", + "sha256": "1acd47a1c09e365be8c7fa51db31307021cc2e471471fc199e26f317df58c4b8", + "sha256_in_prefix": "1acd47a1c09e365be8c7fa51db31307021cc2e471471fc199e26f317df58c4b8", + "size_in_bytes": 562 + }, + { + "_path": "include/python3.12/internal/pycore_exceptions.h", + "path_type": "hardlink", + "sha256": "4590af737d53afcbd7d559434190d2d8ff4f5cd0e923837721aea5ebb000ef68", + "sha256_in_prefix": "4590af737d53afcbd7d559434190d2d8ff4f5cd0e923837721aea5ebb000ef68", + "size_in_bytes": 842 + }, + { + "_path": "include/python3.12/internal/pycore_faulthandler.h", + "path_type": "hardlink", + "sha256": "6444dce1924eae011d27385183ad1a5de6908501cedce2e1531abd834c68cae7", + "sha256_in_prefix": "6444dce1924eae011d27385183ad1a5de6908501cedce2e1531abd834c68cae7", + "size_in_bytes": 2220 + }, + { + "_path": "include/python3.12/internal/pycore_fileutils.h", + "path_type": "hardlink", + "sha256": "ea9cac693c87dc049f199cecd2844592ee08d0283dc0b059c4caab517932af73", + "sha256_in_prefix": "ea9cac693c87dc049f199cecd2844592ee08d0283dc0b059c4caab517932af73", + "size_in_bytes": 7910 + }, + { + "_path": "include/python3.12/internal/pycore_fileutils_windows.h", + "path_type": "hardlink", + "sha256": "9e976ea0f3457c8b40db0a3b2cfea9e9684737f75282400ec0040ae0df1e6385", + "sha256_in_prefix": "9e976ea0f3457c8b40db0a3b2cfea9e9684737f75282400ec0040ae0df1e6385", + "size_in_bytes": 2724 + }, + { + "_path": "include/python3.12/internal/pycore_floatobject.h", + "path_type": "hardlink", + "sha256": "021fef24c4b7e7390c793af7ccf12ddd94b1871e27d26997b37eb3093d5380b5", + "sha256_in_prefix": "021fef24c4b7e7390c793af7ccf12ddd94b1871e27d26997b37eb3093d5380b5", + "size_in_bytes": 1578 + }, + { + "_path": "include/python3.12/internal/pycore_flowgraph.h", + "path_type": "hardlink", + "sha256": "c58cdc30ce8c853404f55881813ec69d6dbf921f2769ec9e289b5155b7a349db", + "sha256_in_prefix": "c58cdc30ce8c853404f55881813ec69d6dbf921f2769ec9e289b5155b7a349db", + "size_in_bytes": 4630 + }, + { + "_path": "include/python3.12/internal/pycore_format.h", + "path_type": "hardlink", + "sha256": "253cc77e6d11ba20d297813e064650fa965b3653f150bd85f805b94db5f3a98d", + "sha256_in_prefix": "253cc77e6d11ba20d297813e064650fa965b3653f150bd85f805b94db5f3a98d", + "size_in_bytes": 480 + }, + { + "_path": "include/python3.12/internal/pycore_frame.h", + "path_type": "hardlink", + "sha256": "97c7e2722af4c30c240b8b3c867a54b2fe49a4207d2e566c6a19a9d190fd0f8a", + "sha256_in_prefix": "97c7e2722af4c30c240b8b3c867a54b2fe49a4207d2e566c6a19a9d190fd0f8a", + "size_in_bytes": 9256 + }, + { + "_path": "include/python3.12/internal/pycore_function.h", + "path_type": "hardlink", + "sha256": "8fad970bd3f31347aed72b92acd17270dbb6ec5333ab5ed6fe43dc9cf2527841", + "sha256_in_prefix": "8fad970bd3f31347aed72b92acd17270dbb6ec5333ab5ed6fe43dc9cf2527841", + "size_in_bytes": 611 + }, + { + "_path": "include/python3.12/internal/pycore_gc.h", + "path_type": "hardlink", + "sha256": "d0349a94dafb16ec4c05ba5a94d3b9e6cec53fe7b5e0d74216ea31996546f9a3", + "sha256_in_prefix": "d0349a94dafb16ec4c05ba5a94d3b9e6cec53fe7b5e0d74216ea31996546f9a3", + "size_in_bytes": 7658 + }, + { + "_path": "include/python3.12/internal/pycore_genobject.h", + "path_type": "hardlink", + "sha256": "a940f41da1e8d9d12c9c438ea0b4f24e72abc494447bcecd9423b76f54e3402a", + "sha256_in_prefix": "a940f41da1e8d9d12c9c438ea0b4f24e72abc494447bcecd9423b76f54e3402a", + "size_in_bytes": 1186 + }, + { + "_path": "include/python3.12/internal/pycore_getopt.h", + "path_type": "hardlink", + "sha256": "e93393067b66b557b0300e05c10ee904d4be54cadfb214c5328a9225ad199452", + "sha256_in_prefix": "e93393067b66b557b0300e05c10ee904d4be54cadfb214c5328a9225ad199452", + "size_in_bytes": 490 + }, + { + "_path": "include/python3.12/internal/pycore_gil.h", + "path_type": "hardlink", + "sha256": "cf455aacd5651e5b43547ebe69bb324eab84238d92665df53c1df32434bd0d9b", + "sha256_in_prefix": "cf455aacd5651e5b43547ebe69bb324eab84238d92665df53c1df32434bd0d9b", + "size_in_bytes": 1565 + }, + { + "_path": "include/python3.12/internal/pycore_global_objects.h", + "path_type": "hardlink", + "sha256": "ce857a319514b1682eb054bf4a017974b0bf211092819b25f23e877a228090df", + "sha256_in_prefix": "ce857a319514b1682eb054bf4a017974b0bf211092819b25f23e877a228090df", + "size_in_bytes": 3035 + }, + { + "_path": "include/python3.12/internal/pycore_global_objects_fini_generated.h", + "path_type": "hardlink", + "sha256": "79fd2e366a02d8b39181f7466a32af1b1c69ec5566bf301b3d9943c552cf9206", + "sha256_in_prefix": "79fd2e366a02d8b39181f7466a32af1b1c69ec5566bf301b3d9943c552cf9206", + "size_in_bytes": 116175 + }, + { + "_path": "include/python3.12/internal/pycore_global_strings.h", + "path_type": "hardlink", + "sha256": "7991d72ba2c0d8c4cc58575bc29a53fb2a61a89f03335e60320df097d58f1adb", + "sha256_in_prefix": "7991d72ba2c0d8c4cc58575bc29a53fb2a61a89f03335e60320df097d58f1adb", + "size_in_bytes": 25665 + }, + { + "_path": "include/python3.12/internal/pycore_hamt.h", + "path_type": "hardlink", + "sha256": "074b31c2f5701cac43d8dc3e4ede40b2befc6dddfcaa2862cfc8f76234c30ae8", + "sha256_in_prefix": "074b31c2f5701cac43d8dc3e4ede40b2befc6dddfcaa2862cfc8f76234c30ae8", + "size_in_bytes": 3742 + }, + { + "_path": "include/python3.12/internal/pycore_hashtable.h", + "path_type": "hardlink", + "sha256": "690488a7e50ad743e1bb685702fbcfac866ace89d2417a247c1171afdc222261", + "sha256_in_prefix": "690488a7e50ad743e1bb685702fbcfac866ace89d2417a247c1171afdc222261", + "size_in_bytes": 4286 + }, + { + "_path": "include/python3.12/internal/pycore_import.h", + "path_type": "hardlink", + "sha256": "e5b179692f05707e7fb182b908ed46f9a75f4a751b20501a74de2a440c387e1d", + "sha256_in_prefix": "e5b179692f05707e7fb182b908ed46f9a75f4a751b20501a74de2a440c387e1d", + "size_in_bytes": 6358 + }, + { + "_path": "include/python3.12/internal/pycore_initconfig.h", + "path_type": "hardlink", + "sha256": "caf13e2c290ae8375636d0e1f3b1851a90396b3747da650d058c282b8743b558", + "sha256_in_prefix": "caf13e2c290ae8375636d0e1f3b1851a90396b3747da650d058c282b8743b558", + "size_in_bytes": 5706 + }, + { + "_path": "include/python3.12/internal/pycore_instruments.h", + "path_type": "hardlink", + "sha256": "b7358dcda113f7cca10abf8b257cc4aca2be0fe2e5293696c3601fa065731cb8", + "sha256_in_prefix": "b7358dcda113f7cca10abf8b257cc4aca2be0fe2e5293696c3601fa065731cb8", + "size_in_bytes": 2999 + }, + { + "_path": "include/python3.12/internal/pycore_interp.h", + "path_type": "hardlink", + "sha256": "23f5d7884f9e0b212fe79879bbcdc5a2c23c22283db38cadbac6f108bf0f1b75", + "sha256_in_prefix": "23f5d7884f9e0b212fe79879bbcdc5a2c23c22283db38cadbac6f108bf0f1b75", + "size_in_bytes": 9086 + }, + { + "_path": "include/python3.12/internal/pycore_intrinsics.h", + "path_type": "hardlink", + "sha256": "e6d6d1eae51b508196615094a4c17189e9822eacb5c0e94102e78aa7136dd9a8", + "sha256_in_prefix": "e6d6d1eae51b508196615094a4c17189e9822eacb5c0e94102e78aa7136dd9a8", + "size_in_bytes": 1397 + }, + { + "_path": "include/python3.12/internal/pycore_list.h", + "path_type": "hardlink", + "sha256": "470a62bb98b383b85ec738a6577424e6cdd51ae235f4e5ea06c5afdedb6e1652", + "sha256_in_prefix": "470a62bb98b383b85ec738a6577424e6cdd51ae235f4e5ea06c5afdedb6e1652", + "size_in_bytes": 1980 + }, + { + "_path": "include/python3.12/internal/pycore_long.h", + "path_type": "hardlink", + "sha256": "84c0c7bd7ba0c2fbbfb106561e32328e478d8350afe756af6a4862c95d921a06", + "sha256_in_prefix": "84c0c7bd7ba0c2fbbfb106561e32328e478d8350afe756af6a4862c95d921a06", + "size_in_bytes": 7805 + }, + { + "_path": "include/python3.12/internal/pycore_memoryobject.h", + "path_type": "hardlink", + "sha256": "c845bb546019ed9999403018740ee5b26f83f8d888c5288895897cb2bd1b5eec", + "sha256_in_prefix": "c845bb546019ed9999403018740ee5b26f83f8d888c5288895897cb2bd1b5eec", + "size_in_bytes": 383 + }, + { + "_path": "include/python3.12/internal/pycore_moduleobject.h", + "path_type": "hardlink", + "sha256": "55a8f42968545a349d8e0b43cd1822b22ae2cf9fa0fb098c6bb843e7af76e165", + "sha256_in_prefix": "55a8f42968545a349d8e0b43cd1822b22ae2cf9fa0fb098c6bb843e7af76e165", + "size_in_bytes": 1192 + }, + { + "_path": "include/python3.12/internal/pycore_namespace.h", + "path_type": "hardlink", + "sha256": "466fe0e3f48e954d8bfe9e0c73fc9378cf79ca37710778ba6698e1c365304956", + "sha256_in_prefix": "466fe0e3f48e954d8bfe9e0c73fc9378cf79ca37710778ba6698e1c365304956", + "size_in_bytes": 392 + }, + { + "_path": "include/python3.12/internal/pycore_object.h", + "path_type": "hardlink", + "sha256": "ce41bd5e4720ffe713fd4f36798c92ec23ca966799805a0e2d4607dfc1d9dc2e", + "sha256_in_prefix": "ce41bd5e4720ffe713fd4f36798c92ec23ca966799805a0e2d4607dfc1d9dc2e", + "size_in_bytes": 14429 + }, + { + "_path": "include/python3.12/internal/pycore_object_state.h", + "path_type": "hardlink", + "sha256": "3f8950c793e7121629508d4472c6b020f51d9eb583e317383b67da7f931c03ee", + "sha256_in_prefix": "3f8950c793e7121629508d4472c6b020f51d9eb583e317383b67da7f931c03ee", + "size_in_bytes": 737 + }, + { + "_path": "include/python3.12/internal/pycore_obmalloc.h", + "path_type": "hardlink", + "sha256": "d8738004c5dbb5520f401919ed55181a48a9e64a3b51930309fc99fb9d219576", + "sha256_in_prefix": "d8738004c5dbb5520f401919ed55181a48a9e64a3b51930309fc99fb9d219576", + "size_in_bytes": 27284 + }, + { + "_path": "include/python3.12/internal/pycore_obmalloc_init.h", + "path_type": "hardlink", + "sha256": "33853ff5ffac15a8622ff6920ff2bd0bf83d1df7ea6d1563916d05992b3203fb", + "sha256_in_prefix": "33853ff5ffac15a8622ff6920ff2bd0bf83d1df7ea6d1563916d05992b3203fb", + "size_in_bytes": 2085 + }, + { + "_path": "include/python3.12/internal/pycore_opcode.h", + "path_type": "hardlink", + "sha256": "432e30c6145dff72096325d17192d0eff9895b367d4590f782e2d8b9d5f78cd6", + "sha256_in_prefix": "432e30c6145dff72096325d17192d0eff9895b367d4590f782e2d8b9d5f78cd6", + "size_in_bytes": 20081 + }, + { + "_path": "include/python3.12/internal/pycore_opcode_utils.h", + "path_type": "hardlink", + "sha256": "98dfb250812d554278dedee98a2e9cb05b2583b22d2af8ba1aeda6b130a21b40", + "sha256_in_prefix": "98dfb250812d554278dedee98a2e9cb05b2583b22d2af8ba1aeda6b130a21b40", + "size_in_bytes": 2686 + }, + { + "_path": "include/python3.12/internal/pycore_parser.h", + "path_type": "hardlink", + "sha256": "91189a016020eb7de0b1ab8ae38145dbec6b561ae5c75cea15980cb76255ba5b", + "sha256_in_prefix": "91189a016020eb7de0b1ab8ae38145dbec6b561ae5c75cea15980cb76255ba5b", + "size_in_bytes": 1358 + }, + { + "_path": "include/python3.12/internal/pycore_pathconfig.h", + "path_type": "hardlink", + "sha256": "ff96c74aae60eba62bec8c6d52f34471caf07792186bc16d76e7a783f61aa0ed", + "sha256_in_prefix": "ff96c74aae60eba62bec8c6d52f34471caf07792186bc16d76e7a783f61aa0ed", + "size_in_bytes": 606 + }, + { + "_path": "include/python3.12/internal/pycore_pyarena.h", + "path_type": "hardlink", + "sha256": "d4f4e513bae78ff985f51ca48fb7d1a4d57055c59393a1eb661e55e6ec3ba61f", + "sha256_in_prefix": "d4f4e513bae78ff985f51ca48fb7d1a4d57055c59393a1eb661e55e6ec3ba61f", + "size_in_bytes": 2733 + }, + { + "_path": "include/python3.12/internal/pycore_pyerrors.h", + "path_type": "hardlink", + "sha256": "6668d80af8838faf87ff2e37a536c2586e1588d1b23a08f04992c58f6c0630a3", + "sha256_in_prefix": "6668d80af8838faf87ff2e37a536c2586e1588d1b23a08f04992c58f6c0630a3", + "size_in_bytes": 2783 + }, + { + "_path": "include/python3.12/internal/pycore_pyhash.h", + "path_type": "hardlink", + "sha256": "7c631d06afad90fa9c2ddc8dc04b7c2855ee5aa6e7ece0b22d0a966a702abf73", + "sha256_in_prefix": "7c631d06afad90fa9c2ddc8dc04b7c2855ee5aa6e7ece0b22d0a966a702abf73", + "size_in_bytes": 709 + }, + { + "_path": "include/python3.12/internal/pycore_pylifecycle.h", + "path_type": "hardlink", + "sha256": "f6a91e690b8e5d3dca52dcdff63d36a6ad9ad85b7ee1edfc14215cc0483059fa", + "sha256_in_prefix": "f6a91e690b8e5d3dca52dcdff63d36a6ad9ad85b7ee1edfc14215cc0483059fa", + "size_in_bytes": 3365 + }, + { + "_path": "include/python3.12/internal/pycore_pymath.h", + "path_type": "hardlink", + "sha256": "6dd3ea0f9a84bfa3a2eb0a2b7fa1af1dc8aadad3e74305e13f194a1586815376", + "sha256_in_prefix": "6dd3ea0f9a84bfa3a2eb0a2b7fa1af1dc8aadad3e74305e13f194a1586815376", + "size_in_bytes": 8600 + }, + { + "_path": "include/python3.12/internal/pycore_pymem.h", + "path_type": "hardlink", + "sha256": "ad0b35bbf5e665e90223499f8954bfcf36448b1634d54501b0c84d08680323ca", + "sha256_in_prefix": "ad0b35bbf5e665e90223499f8954bfcf36448b1634d54501b0c84d08680323ca", + "size_in_bytes": 3040 + }, + { + "_path": "include/python3.12/internal/pycore_pymem_init.h", + "path_type": "hardlink", + "sha256": "82a1418ee1867e5e9a2717e8a1acfec2e2ff3ef07225e30be7c8cd8f6e29a7ba", + "sha256_in_prefix": "82a1418ee1867e5e9a2717e8a1acfec2e2ff3ef07225e30be7c8cd8f6e29a7ba", + "size_in_bytes": 2654 + }, + { + "_path": "include/python3.12/internal/pycore_pystate.h", + "path_type": "hardlink", + "sha256": "c06823811bf5dd3d84f40d6a087452da5915e3ad277afef2202c9e86e833ce00", + "sha256_in_prefix": "c06823811bf5dd3d84f40d6a087452da5915e3ad277afef2202c9e86e833ce00", + "size_in_bytes": 4982 + }, + { + "_path": "include/python3.12/internal/pycore_pythread.h", + "path_type": "hardlink", + "sha256": "ba04eed4d18d6110982cc58800fda11f3899c61fed644ff9e52a4adedb7b750a", + "sha256_in_prefix": "ba04eed4d18d6110982cc58800fda11f3899c61fed644ff9e52a4adedb7b750a", + "size_in_bytes": 2075 + }, + { + "_path": "include/python3.12/internal/pycore_range.h", + "path_type": "hardlink", + "sha256": "824c5023a85a9c1c2dd50fecf442d12c7b2966e0e71a2d291f6f17f7fd8c29bc", + "sha256_in_prefix": "824c5023a85a9c1c2dd50fecf442d12c7b2966e0e71a2d291f6f17f7fd8c29bc", + "size_in_bytes": 346 + }, + { + "_path": "include/python3.12/internal/pycore_runtime.h", + "path_type": "hardlink", + "sha256": "d47fe4de4c245e2f90ce73792337565cae6ce95d8e2cd08bcda43ec92832b1ac", + "sha256_in_prefix": "d47fe4de4c245e2f90ce73792337565cae6ce95d8e2cd08bcda43ec92832b1ac", + "size_in_bytes": 8429 + }, + { + "_path": "include/python3.12/internal/pycore_runtime_init.h", + "path_type": "hardlink", + "sha256": "60d97c6edbd7eaf3841ce88d3f33794b4c3dfead870914f021e1425e11670321", + "sha256_in_prefix": "60d97c6edbd7eaf3841ce88d3f33794b4c3dfead870914f021e1425e11670321", + "size_in_bytes": 6087 + }, + { + "_path": "include/python3.12/internal/pycore_runtime_init_generated.h", + "path_type": "hardlink", + "sha256": "0c209438a3b41fbbfaffc76669325328d074be692d96c99eea255366689e4055", + "sha256_in_prefix": "0c209438a3b41fbbfaffc76669325328d074be692d96c99eea255366689e4055", + "size_in_bytes": 46045 + }, + { + "_path": "include/python3.12/internal/pycore_signal.h", + "path_type": "hardlink", + "sha256": "186835a8702a10bb1f3f63185d50874f24885716707717f620d3ffd0a2039679", + "sha256_in_prefix": "186835a8702a10bb1f3f63185d50874f24885716707717f620d3ffd0a2039679", + "size_in_bytes": 2611 + }, + { + "_path": "include/python3.12/internal/pycore_sliceobject.h", + "path_type": "hardlink", + "sha256": "e8b9ba794081a75bf73f0eb64089a766b5bd04b076d4368a14a83ff43ce909be", + "sha256_in_prefix": "e8b9ba794081a75bf73f0eb64089a766b5bd04b076d4368a14a83ff43ce909be", + "size_in_bytes": 414 + }, + { + "_path": "include/python3.12/internal/pycore_strhex.h", + "path_type": "hardlink", + "sha256": "45783d1137fc33a8d9e457692227e8395a93b27c76205f50ad7bd8f00fe7aefb", + "sha256_in_prefix": "45783d1137fc33a8d9e457692227e8395a93b27c76205f50ad7bd8f00fe7aefb", + "size_in_bytes": 937 + }, + { + "_path": "include/python3.12/internal/pycore_structseq.h", + "path_type": "hardlink", + "sha256": "e1c1be3681fec8c1146d5a084869c1bbabcbe68223382cdab8536c8b88958891", + "sha256_in_prefix": "e1c1be3681fec8c1146d5a084869c1bbabcbe68223382cdab8536c8b88958891", + "size_in_bytes": 923 + }, + { + "_path": "include/python3.12/internal/pycore_symtable.h", + "path_type": "hardlink", + "sha256": "15684455856daa80b67dd6e0abc322ad055c6bc64ef38d170f9aae26da54b83d", + "sha256_in_prefix": "15684455856daa80b67dd6e0abc322ad055c6bc64ef38d170f9aae26da54b83d", + "size_in_bytes": 6828 + }, + { + "_path": "include/python3.12/internal/pycore_sysmodule.h", + "path_type": "hardlink", + "sha256": "2c22c3f98c917dee3d954957f36713e2ddd96a27b076e05f7360c629f37e983d", + "sha256_in_prefix": "2c22c3f98c917dee3d954957f36713e2ddd96a27b076e05f7360c629f37e983d", + "size_in_bytes": 734 + }, + { + "_path": "include/python3.12/internal/pycore_time.h", + "path_type": "hardlink", + "sha256": "6838118a537e71edaf76290da15cbf2da19499df1ee4e30b15f35bb4b9257b70", + "sha256_in_prefix": "6838118a537e71edaf76290da15cbf2da19499df1ee4e30b15f35bb4b9257b70", + "size_in_bytes": 388 + }, + { + "_path": "include/python3.12/internal/pycore_token.h", + "path_type": "hardlink", + "sha256": "91c75ef718b8e8be2383fdcea502c1e63ebfa6d681afd45672e379ea7e5d3668", + "sha256_in_prefix": "91c75ef718b8e8be2383fdcea502c1e63ebfa6d681afd45672e379ea7e5d3668", + "size_in_bytes": 3050 + }, + { + "_path": "include/python3.12/internal/pycore_traceback.h", + "path_type": "hardlink", + "sha256": "3f9dfb009dc161f2d979f5af76d660611264b5d0b1b4adeeae10d30ee0999ede", + "sha256_in_prefix": "3f9dfb009dc161f2d979f5af76d660611264b5d0b1b4adeeae10d30ee0999ede", + "size_in_bytes": 3501 + }, + { + "_path": "include/python3.12/internal/pycore_tracemalloc.h", + "path_type": "hardlink", + "sha256": "61ac9b846ae579c667d20034c9c4004a07ab3ff039848ddeeec8d9c39ff1331a", + "sha256_in_prefix": "61ac9b846ae579c667d20034c9c4004a07ab3ff039848ddeeec8d9c39ff1331a", + "size_in_bytes": 3075 + }, + { + "_path": "include/python3.12/internal/pycore_tuple.h", + "path_type": "hardlink", + "sha256": "de5677ac0809abf2744ebdd94768b6974e75ea62cc2cee44c4f433e2b818f953", + "sha256_in_prefix": "de5677ac0809abf2744ebdd94768b6974e75ea62cc2cee44c4f433e2b818f953", + "size_in_bytes": 2197 + }, + { + "_path": "include/python3.12/internal/pycore_typeobject.h", + "path_type": "hardlink", + "sha256": "9af7c474e699753e6830949962176eab1f2e3ffa9616a24ab395001fc75db90b", + "sha256_in_prefix": "9af7c474e699753e6830949962176eab1f2e3ffa9616a24ab395001fc75db90b", + "size_in_bytes": 4669 + }, + { + "_path": "include/python3.12/internal/pycore_typevarobject.h", + "path_type": "hardlink", + "sha256": "b925204918e577bfb667a64f5f56e410cba0bc518207ed8535d1fcf1bdd6ab00", + "sha256_in_prefix": "b925204918e577bfb667a64f5f56e410cba0bc518207ed8535d1fcf1bdd6ab00", + "size_in_bytes": 763 + }, + { + "_path": "include/python3.12/internal/pycore_ucnhash.h", + "path_type": "hardlink", + "sha256": "6d9077e875703e5db7daf293a6c7ea3d43d1ee84dec137a950f17a26e9348eb5", + "sha256_in_prefix": "6d9077e875703e5db7daf293a6c7ea3d43d1ee84dec137a950f17a26e9348eb5", + "size_in_bytes": 898 + }, + { + "_path": "include/python3.12/internal/pycore_unicodeobject.h", + "path_type": "hardlink", + "sha256": "916e12522af51502be463a9e722e1e5017827e1d8da62ac68a03887185c1c278", + "sha256_in_prefix": "916e12522af51502be463a9e722e1e5017827e1d8da62ac68a03887185c1c278", + "size_in_bytes": 1966 + }, + { + "_path": "include/python3.12/internal/pycore_unicodeobject_generated.h", + "path_type": "hardlink", + "sha256": "40f9a9c1b38fff0c3b512dd518c8df9a34493775b3c2ffe14f5e854dc4660e06", + "sha256_in_prefix": "40f9a9c1b38fff0c3b512dd518c8df9a34493775b3c2ffe14f5e854dc4660e06", + "size_in_bytes": 91455 + }, + { + "_path": "include/python3.12/internal/pycore_unionobject.h", + "path_type": "hardlink", + "sha256": "f1c5bbdf5660e54872ff1555c179cf6c80f8e04cac41e974b7964e21f82be18c", + "sha256_in_prefix": "f1c5bbdf5660e54872ff1555c179cf6c80f8e04cac41e974b7964e21f82be18c", + "size_in_bytes": 682 + }, + { + "_path": "include/python3.12/internal/pycore_warnings.h", + "path_type": "hardlink", + "sha256": "3229b207245cb9442f09991df7084c8e4cb87cb073a14a2d520bd92634371fcb", + "sha256_in_prefix": "3229b207245cb9442f09991df7084c8e4cb87cb073a14a2d520bd92634371fcb", + "size_in_bytes": 740 + }, + { + "_path": "include/python3.12/interpreteridobject.h", + "path_type": "hardlink", + "sha256": "b497c869333bdf1f79a580a36e9a0ed64fee226daa1d2d45bdfe16c01e52d73c", + "sha256_in_prefix": "b497c869333bdf1f79a580a36e9a0ed64fee226daa1d2d45bdfe16c01e52d73c", + "size_in_bytes": 333 + }, + { + "_path": "include/python3.12/intrcheck.h", + "path_type": "hardlink", + "sha256": "696fe17618c579a8cbaad9b86175f60d43ea0b9e8aaaa1d65ad256d53dc163c1", + "sha256_in_prefix": "696fe17618c579a8cbaad9b86175f60d43ea0b9e8aaaa1d65ad256d53dc163c1", + "size_in_bytes": 772 + }, + { + "_path": "include/python3.12/iterobject.h", + "path_type": "hardlink", + "sha256": "6b16711d2bb6cee55e4288f84142d592eebf07321e32998a5abe2c06deeb77b0", + "sha256_in_prefix": "6b16711d2bb6cee55e4288f84142d592eebf07321e32998a5abe2c06deeb77b0", + "size_in_bytes": 597 + }, + { + "_path": "include/python3.12/listobject.h", + "path_type": "hardlink", + "sha256": "f4cad9a1f48d27a9a7f56702ab0fe785013eb336ea919197600d86a6e54fa5bf", + "sha256_in_prefix": "f4cad9a1f48d27a9a7f56702ab0fe785013eb336ea919197600d86a6e54fa5bf", + "size_in_bytes": 1782 + }, + { + "_path": "include/python3.12/longobject.h", + "path_type": "hardlink", + "sha256": "adf3d5af5dcf4ed3c465606678c7383cb8ddbef19af91851c90dc3db08c52ab4", + "sha256_in_prefix": "adf3d5af5dcf4ed3c465606678c7383cb8ddbef19af91851c90dc3db08c52ab4", + "size_in_bytes": 3275 + }, + { + "_path": "include/python3.12/marshal.h", + "path_type": "hardlink", + "sha256": "d7f5760ef6496776cee99aca5491789f6ab261a78b156b5758538ea15e1827e5", + "sha256_in_prefix": "d7f5760ef6496776cee99aca5491789f6ab261a78b156b5758538ea15e1827e5", + "size_in_bytes": 827 + }, + { + "_path": "include/python3.12/memoryobject.h", + "path_type": "hardlink", + "sha256": "efb734845a1366d77f6351cbb954c08681d4acfe6a53e41e82dd45fa881e0090", + "sha256_in_prefix": "efb734845a1366d77f6351cbb954c08681d4acfe6a53e41e82dd45fa881e0090", + "size_in_bytes": 1081 + }, + { + "_path": "include/python3.12/methodobject.h", + "path_type": "hardlink", + "sha256": "059e19bd8d418c8bf1481e301340f989317ba7b56de94729a19aae26fee3da62", + "sha256_in_prefix": "059e19bd8d418c8bf1481e301340f989317ba7b56de94729a19aae26fee3da62", + "size_in_bytes": 5076 + }, + { + "_path": "include/python3.12/modsupport.h", + "path_type": "hardlink", + "sha256": "064d1440d862d08f296c1cbe868e417af12b34f770be515461211f5beade04ff", + "sha256_in_prefix": "064d1440d862d08f296c1cbe868e417af12b34f770be515461211f5beade04ff", + "size_in_bytes": 6515 + }, + { + "_path": "include/python3.12/moduleobject.h", + "path_type": "hardlink", + "sha256": "5eb48f5d99322d7912a5c6f2b3a974e283c7a6045f79a503d7e09f3ac15b42ec", + "sha256_in_prefix": "5eb48f5d99322d7912a5c6f2b3a974e283c7a6045f79a503d7e09f3ac15b42ec", + "size_in_bytes": 3559 + }, + { + "_path": "include/python3.12/object.h", + "path_type": "hardlink", + "sha256": "33157179d385765172a160ce10e769196d3d8edf7a01ba3819c3259b57ffaee6", + "sha256_in_prefix": "33157179d385765172a160ce10e769196d3d8edf7a01ba3819c3259b57ffaee6", + "size_in_bytes": 37188 + }, + { + "_path": "include/python3.12/objimpl.h", + "path_type": "hardlink", + "sha256": "8828a8db3e9f14b5ca2d59b1d8c05f6bf54fae26736ae039b7420c886142dba2", + "sha256_in_prefix": "8828a8db3e9f14b5ca2d59b1d8c05f6bf54fae26736ae039b7420c886142dba2", + "size_in_bytes": 9238 + }, + { + "_path": "include/python3.12/opcode.h", + "path_type": "hardlink", + "sha256": "4e8c6eee859813845b3a9dfe9e08ca4cc607a7f884048f5a6cebef6bdcc5d33d", + "sha256_in_prefix": "4e8c6eee859813845b3a9dfe9e08ca4cc607a7f884048f5a6cebef6bdcc5d33d", + "size_in_bytes": 12808 + }, + { + "_path": "include/python3.12/osdefs.h", + "path_type": "hardlink", + "sha256": "8372e9c507949a88ed3cad5fd0a830190d60a1655e9a3f59ef4d0832c06a041c", + "sha256_in_prefix": "8372e9c507949a88ed3cad5fd0a830190d60a1655e9a3f59ef4d0832c06a041c", + "size_in_bytes": 737 + }, + { + "_path": "include/python3.12/osmodule.h", + "path_type": "hardlink", + "sha256": "c013935b48f48ca8ce249a4d482c55e3fb6f1cfe786c5a32a57969bb74a779d9", + "sha256_in_prefix": "c013935b48f48ca8ce249a4d482c55e3fb6f1cfe786c5a32a57969bb74a779d9", + "size_in_bytes": 291 + }, + { + "_path": "include/python3.12/patchlevel.h", + "path_type": "hardlink", + "sha256": "4b4224e30e11f6e0f37921f72acd4fa4336705f5e5dba36492782d636443d73a", + "sha256_in_prefix": "4b4224e30e11f6e0f37921f72acd4fa4336705f5e5dba36492782d636443d73a", + "size_in_bytes": 1299 + }, + { + "_path": "include/python3.12/py_curses.h", + "path_type": "hardlink", + "sha256": "1aa826cacb9f07611155906d711403a7675ce573d61c888786178bb574dc3087", + "sha256_in_prefix": "1aa826cacb9f07611155906d711403a7675ce573d61c888786178bb574dc3087", + "size_in_bytes": 2473 + }, + { + "_path": "include/python3.12/pybuffer.h", + "path_type": "hardlink", + "sha256": "c95edd830772e922f60f976ac0d98470b48a443ba198b0866a4096003c0740a4", + "sha256_in_prefix": "c95edd830772e922f60f976ac0d98470b48a443ba198b0866a4096003c0740a4", + "size_in_bytes": 5282 + }, + { + "_path": "include/python3.12/pycapsule.h", + "path_type": "hardlink", + "sha256": "6929a47483ea5bb1a7b9b490a876b21beefed11061c94b2963b2608b7f542728", + "sha256_in_prefix": "6929a47483ea5bb1a7b9b490a876b21beefed11061c94b2963b2608b7f542728", + "size_in_bytes": 1727 + }, + { + "_path": "include/python3.12/pyconfig.h", + "path_type": "hardlink", + "sha256": "334a03a783bac296567bb1810a219d8417cad11c18531b1447eb13c7c48502d8", + "sha256_in_prefix": "334a03a783bac296567bb1810a219d8417cad11c18531b1447eb13c7c48502d8", + "size_in_bytes": 56078 + }, + { + "_path": "include/python3.12/pydtrace.h", + "path_type": "hardlink", + "sha256": "7ac591e56e12936a32e3b0b85dae803f8f00bdc91abe01799ca2e4ce69548555", + "sha256_in_prefix": "7ac591e56e12936a32e3b0b85dae803f8f00bdc91abe01799ca2e4ce69548555", + "size_in_bytes": 2404 + }, + { + "_path": "include/python3.12/pyerrors.h", + "path_type": "hardlink", + "sha256": "59bf06c7ba877ec76d09a41aac75e385a2723545388b105864f48f295e2524e0", + "sha256_in_prefix": "59bf06c7ba877ec76d09a41aac75e385a2723545388b105864f48f295e2524e0", + "size_in_bytes": 13017 + }, + { + "_path": "include/python3.12/pyexpat.h", + "path_type": "hardlink", + "sha256": "4bde05b3b7d6dbff5b7565b71ef59a4ce1e796a549d28edb4c75a5cabd00fe96", + "sha256_in_prefix": "4bde05b3b7d6dbff5b7565b71ef59a4ce1e796a549d28edb4c75a5cabd00fe96", + "size_in_bytes": 2450 + }, + { + "_path": "include/python3.12/pyframe.h", + "path_type": "hardlink", + "sha256": "58513e7017805ee5c49a329a552f72a6be6d88ce2bcfa344f5130582fa75ecb6", + "sha256_in_prefix": "58513e7017805ee5c49a329a552f72a6be6d88ce2bcfa344f5130582fa75ecb6", + "size_in_bytes": 551 + }, + { + "_path": "include/python3.12/pyhash.h", + "path_type": "hardlink", + "sha256": "a6ea755ff42ec955feaf49b1d234a5c2935899309ea59925d1d30f3e62fed67d", + "sha256_in_prefix": "a6ea755ff42ec955feaf49b1d234a5c2935899309ea59925d1d30f3e62fed67d", + "size_in_bytes": 4154 + }, + { + "_path": "include/python3.12/pylifecycle.h", + "path_type": "hardlink", + "sha256": "d313c5f3fe805606061ea78982ca5d5a9f09e687210c8b0fbcb50db596106691", + "sha256_in_prefix": "d313c5f3fe805606061ea78982ca5d5a9f09e687210c8b0fbcb50db596106691", + "size_in_bytes": 2249 + }, + { + "_path": "include/python3.12/pymacconfig.h", + "path_type": "hardlink", + "sha256": "5dcd4fa505975be42c35a4707ab7cb5b6ddf2e896bb8fbb8c1fd9047e5183a3d", + "sha256_in_prefix": "5dcd4fa505975be42c35a4707ab7cb5b6ddf2e896bb8fbb8c1fd9047e5183a3d", + "size_in_bytes": 2810 + }, + { + "_path": "include/python3.12/pymacro.h", + "path_type": "hardlink", + "sha256": "30af4b1a8deb972e716f24d32985b79deadb7f638d0b576a46214962ac4055fa", + "sha256_in_prefix": "30af4b1a8deb972e716f24d32985b79deadb7f638d0b576a46214962ac4055fa", + "size_in_bytes": 6318 + }, + { + "_path": "include/python3.12/pymath.h", + "path_type": "hardlink", + "sha256": "eeea8396e1acd271ba83a568ba572ead47493e492ce998756fe1256bf917b3f9", + "sha256_in_prefix": "eeea8396e1acd271ba83a568ba572ead47493e492ce998756fe1256bf917b3f9", + "size_in_bytes": 1688 + }, + { + "_path": "include/python3.12/pymem.h", + "path_type": "hardlink", + "sha256": "54a5315d7861e989c5099f168d946f5a421337efcd5d44896201016e92a81348", + "sha256_in_prefix": "54a5315d7861e989c5099f168d946f5a421337efcd5d44896201016e92a81348", + "size_in_bytes": 3914 + }, + { + "_path": "include/python3.12/pyport.h", + "path_type": "hardlink", + "sha256": "40ff45246d7e02bd248172881ddcddd4d0fc237ed18ad1b2a63651a6e8757be6", + "sha256_in_prefix": "40ff45246d7e02bd248172881ddcddd4d0fc237ed18ad1b2a63651a6e8757be6", + "size_in_bytes": 25384 + }, + { + "_path": "include/python3.12/pystate.h", + "path_type": "hardlink", + "sha256": "065426aaa5fada90d61a17757fbc2e8ce3fb9cc203992990c4ca3cee7f9f80be", + "sha256_in_prefix": "065426aaa5fada90d61a17757fbc2e8ce3fb9cc203992990c4ca3cee7f9f80be", + "size_in_bytes": 4635 + }, + { + "_path": "include/python3.12/pystats.h", + "path_type": "hardlink", + "sha256": "b93db83e29f09ff06b15bf39a21e53de82858ba92cbf48332d1ada1ac028d6f8", + "sha256_in_prefix": "b93db83e29f09ff06b15bf39a21e53de82858ba92cbf48332d1ada1ac028d6f8", + "size_in_bytes": 2741 + }, + { + "_path": "include/python3.12/pystrcmp.h", + "path_type": "hardlink", + "sha256": "f401d8338fb6ecf5f12768ee95cd09c262f880b2ee522ca344b890dbdcde4c88", + "sha256_in_prefix": "f401d8338fb6ecf5f12768ee95cd09c262f880b2ee522ca344b890dbdcde4c88", + "size_in_bytes": 436 + }, + { + "_path": "include/python3.12/pystrtod.h", + "path_type": "hardlink", + "sha256": "8c8e9d1d279216f1c08f0aedac5de49a9b8852a3f838f21e298300e969474ef4", + "sha256_in_prefix": "8c8e9d1d279216f1c08f0aedac5de49a9b8852a3f838f21e298300e969474ef4", + "size_in_bytes": 1557 + }, + { + "_path": "include/python3.12/pythonrun.h", + "path_type": "hardlink", + "sha256": "4749ef95e910632a1d04b912c4f1d615c9d10567cbaf52a2ab2c68c7c3a38d94", + "sha256_in_prefix": "4749ef95e910632a1d04b912c4f1d615c9d10567cbaf52a2ab2c68c7c3a38d94", + "size_in_bytes": 1313 + }, + { + "_path": "include/python3.12/pythread.h", + "path_type": "hardlink", + "sha256": "cd063073710988ea21b54588473542e5f3b2be06f637dc5a028aefd5a7949144", + "sha256_in_prefix": "cd063073710988ea21b54588473542e5f3b2be06f637dc5a028aefd5a7949144", + "size_in_bytes": 4875 + }, + { + "_path": "include/python3.12/pytypedefs.h", + "path_type": "hardlink", + "sha256": "26d09a78c44998e8c0a74ed2d14e5346e4b922892eb79288049b7ac5b6a1e751", + "sha256_in_prefix": "26d09a78c44998e8c0a74ed2d14e5346e4b922892eb79288049b7ac5b6a1e751", + "size_in_bytes": 851 + }, + { + "_path": "include/python3.12/rangeobject.h", + "path_type": "hardlink", + "sha256": "36547ab5862e82b09cbed7b786a4cfc86af1dec5a3778c50825bb266c9a6aec9", + "sha256_in_prefix": "36547ab5862e82b09cbed7b786a4cfc86af1dec5a3778c50825bb266c9a6aec9", + "size_in_bytes": 630 + }, + { + "_path": "include/python3.12/setobject.h", + "path_type": "hardlink", + "sha256": "7ff1b984647598b19ff593b0fa40d44cf5d7bc37d386dd9fac059e560f4a31ca", + "sha256_in_prefix": "7ff1b984647598b19ff593b0fa40d44cf5d7bc37d386dd9fac059e560f4a31ca", + "size_in_bytes": 1557 + }, + { + "_path": "include/python3.12/sliceobject.h", + "path_type": "hardlink", + "sha256": "527719b92e4fa9d5b371c30bc87bc0304ec20099b18c446ad1aa49fd61e5e387", + "sha256_in_prefix": "527719b92e4fa9d5b371c30bc87bc0304ec20099b18c446ad1aa49fd61e5e387", + "size_in_bytes": 2518 + }, + { + "_path": "include/python3.12/structmember.h", + "path_type": "hardlink", + "sha256": "9d4c39dee96e228f60cc8a6960b9e7049875ddbee15541a75629c07777916342", + "sha256_in_prefix": "9d4c39dee96e228f60cc8a6960b9e7049875ddbee15541a75629c07777916342", + "size_in_bytes": 1645 + }, + { + "_path": "include/python3.12/structseq.h", + "path_type": "hardlink", + "sha256": "067f8663a922eb142a3fd12ff18eaa756553bef8a68eaa863f80419dbb8d1ffe", + "sha256_in_prefix": "067f8663a922eb142a3fd12ff18eaa756553bef8a68eaa863f80419dbb8d1ffe", + "size_in_bytes": 1398 + }, + { + "_path": "include/python3.12/sysmodule.h", + "path_type": "hardlink", + "sha256": "09b6f415d4054fee4eb8375a94a724e102bc9a40633d16a437960671b1a9a1b4", + "sha256_in_prefix": "09b6f415d4054fee4eb8375a94a724e102bc9a40633d16a437960671b1a9a1b4", + "size_in_bytes": 1729 + }, + { + "_path": "include/python3.12/traceback.h", + "path_type": "hardlink", + "sha256": "ea59d511687f7f8643c7b8b0996e26f2c92bcc954639c6f98d08f6564b61d06d", + "sha256_in_prefix": "ea59d511687f7f8643c7b8b0996e26f2c92bcc954639c6f98d08f6564b61d06d", + "size_in_bytes": 585 + }, + { + "_path": "include/python3.12/tracemalloc.h", + "path_type": "hardlink", + "sha256": "296084c2140af69ee39e672feab2027411c7b0397a5719aa513802cd6a849d93", + "sha256_in_prefix": "296084c2140af69ee39e672feab2027411c7b0397a5719aa513802cd6a849d93", + "size_in_bytes": 2192 + }, + { + "_path": "include/python3.12/tupleobject.h", + "path_type": "hardlink", + "sha256": "d8de8d64e4b5c466c3bdd04f5664f0eba64a9198b30b5a29409d74a5b5f1def7", + "sha256_in_prefix": "d8de8d64e4b5c466c3bdd04f5664f0eba64a9198b30b5a29409d74a5b5f1def7", + "size_in_bytes": 1615 + }, + { + "_path": "include/python3.12/typeslots.h", + "path_type": "hardlink", + "sha256": "77fe4a71f5e5974c40fd3485d3c9aeb8b7ccf33969cd26feb58c64eda5f86f1d", + "sha256_in_prefix": "77fe4a71f5e5974c40fd3485d3c9aeb8b7ccf33969cd26feb58c64eda5f86f1d", + "size_in_bytes": 2342 + }, + { + "_path": "include/python3.12/unicodeobject.h", + "path_type": "hardlink", + "sha256": "5cc1350da2b00f5187065004a1f5d66764e86a0f20f8faba7d0eadf913297d93", + "sha256_in_prefix": "5cc1350da2b00f5187065004a1f5d66764e86a0f20f8faba7d0eadf913297d93", + "size_in_bytes": 35164 + }, + { + "_path": "include/python3.12/warnings.h", + "path_type": "hardlink", + "sha256": "18fde34b12247460de805fc259ea7f14305fce4779d244c0a7bdc7c73b8f6b51", + "sha256_in_prefix": "18fde34b12247460de805fc259ea7f14305fce4779d244c0a7bdc7c73b8f6b51", + "size_in_bytes": 1129 + }, + { + "_path": "include/python3.12/weakrefobject.h", + "path_type": "hardlink", + "sha256": "031b4bc091cf442b4305f7c5ac9713f32101a5e40617f3cb56c632cb7b15fb5b", + "sha256_in_prefix": "031b4bc091cf442b4305f7c5ac9713f32101a5e40617f3cb56c632cb7b15fb5b", + "size_in_bytes": 1234 + }, + { + "_path": "lib/libpython3.12.dylib", + "file_mode": "binary", + "path_type": "hardlink", + "prefix_placeholder": "/Users/runner/miniforge3/conda-bld/python-split_1708115848844/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placeh", + "sha256": "af5de531a19e9779c0864b8353fe85dc72be348db57691346f10474fae384dbb", + "sha256_in_prefix": "5449481c81a6b1358eaf35c350446accfc396223a718c86f9f152fc3ac828899", + "size_in_bytes": 6440816 + }, + { + "_path": "lib/pkgconfig/python-3.12-embed.pc", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/Users/runner/miniforge3/conda-bld/python-split_1708115848844/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placeh", + "sha256": "6f1573b6bc2f8624c550a4131b95e315bb8859da61a0d958afad0b88c7fd8636", + "sha256_in_prefix": "7b8f6311fb9350f6dca6d75cbb1e63d1564f31b268ec06cd7aa60e3ba91295d3", + "size_in_bytes": 558 + }, + { + "_path": "lib/pkgconfig/python-3.12.pc", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/Users/runner/miniforge3/conda-bld/python-split_1708115848844/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placeh", + "sha256": "74d595e214a5a3903369097b315e4979451cd3309256f0d3b4afb7ae2632e706", + "sha256_in_prefix": "b92070be45dc96c9896da28d4ce767fca31d4c4e5582b71a429ec8d63d71e7e7", + "size_in_bytes": 544 + }, + { + "_path": "lib/pkgconfig/python3-embed.pc", + "path_type": "softlink", + "sha256": "6f1573b6bc2f8624c550a4131b95e315bb8859da61a0d958afad0b88c7fd8636", + "size_in_bytes": 558 + }, + { + "_path": "lib/pkgconfig/python3.pc", + "path_type": "softlink", + "sha256": "74d595e214a5a3903369097b315e4979451cd3309256f0d3b4afb7ae2632e706", + "size_in_bytes": 544 + }, + { + "_path": "lib/python3.1", + "path_type": "softlink", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size_in_bytes": 0 + }, + { + "_path": "lib/python3.12/LICENSE.txt", + "path_type": "hardlink", + "sha256": "3b2f81fe21d181c499c59a256c8e1968455d6689d269aa85373bfb6af41da3bf", + "sha256_in_prefix": "3b2f81fe21d181c499c59a256c8e1968455d6689d269aa85373bfb6af41da3bf", + "size_in_bytes": 13936 + }, + { + "_path": "lib/python3.12/__future__.py", + "path_type": "hardlink", + "sha256": "981d4c398849f9ebcab72300d9c1fe288fd6d7f28957b3b3fa3a493a5836d95c", + "sha256_in_prefix": "981d4c398849f9ebcab72300d9c1fe288fd6d7f28957b3b3fa3a493a5836d95c", + "size_in_bytes": 5218 + }, + { + "_path": "lib/python3.12/__hello__.py", + "path_type": "hardlink", + "sha256": "a8ce70b199497950f0f06def93115a6814daf1f961934457f59046909901487f", + "sha256_in_prefix": "a8ce70b199497950f0f06def93115a6814daf1f961934457f59046909901487f", + "size_in_bytes": 227 + }, + { + "_path": "lib/python3.12/__phello__/__init__.py", + "path_type": "hardlink", + "sha256": "56f7ed595e767c558ded05def14b682893105daf504500c3443b458ca2431bc6", + "sha256_in_prefix": "56f7ed595e767c558ded05def14b682893105daf504500c3443b458ca2431bc6", + "size_in_bytes": 97 + }, + { + "_path": "lib/python3.12/__phello__/__pycache__/__init__.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "0511c722097b19e473159cef1711e4941d7b2a97e72a6b4e17b5629a42a7e965", + "sha256_in_prefix": "0511c722097b19e473159cef1711e4941d7b2a97e72a6b4e17b5629a42a7e965", + "size_in_bytes": 623 + }, + { + "_path": "lib/python3.12/__phello__/__pycache__/spam.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "b988e2c80314516379c8fa31dde0e3b7a9de3ce8394f26d4cfcf8d91bde24e99", + "sha256_in_prefix": "b988e2c80314516379c8fa31dde0e3b7a9de3ce8394f26d4cfcf8d91bde24e99", + "size_in_bytes": 619 + }, + { + "_path": "lib/python3.12/__phello__/spam.py", + "path_type": "hardlink", + "sha256": "56f7ed595e767c558ded05def14b682893105daf504500c3443b458ca2431bc6", + "sha256_in_prefix": "56f7ed595e767c558ded05def14b682893105daf504500c3443b458ca2431bc6", + "size_in_bytes": 97 + }, + { + "_path": "lib/python3.12/__pycache__/__future__.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "ab3e46389aca2b5314271fe3396dcacf82612906e0f601cd8471f7b51584a0f3", + "sha256_in_prefix": "ab3e46389aca2b5314271fe3396dcacf82612906e0f601cd8471f7b51584a0f3", + "size_in_bytes": 4958 + }, + { + "_path": "lib/python3.12/__pycache__/__hello__.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "95470493eb68ff43f40a5235d6d6ba6c15950676c2e478ae3697bb78db6b1d25", + "sha256_in_prefix": "95470493eb68ff43f40a5235d6d6ba6c15950676c2e478ae3697bb78db6b1d25", + "size_in_bytes": 1124 + }, + { + "_path": "lib/python3.12/__pycache__/_aix_support.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "0deb8001f44f871d389702dd5db9b71d008dd972ee7f8f24efc810e7ecb4b0e8", + "sha256_in_prefix": "0deb8001f44f871d389702dd5db9b71d008dd972ee7f8f24efc810e7ecb4b0e8", + "size_in_bytes": 5013 + }, + { + "_path": "lib/python3.12/__pycache__/_collections_abc.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "b592a91d11f4e2219346e91e3786493b0d6722d9935782cdeca6347b3e605fa3", + "sha256_in_prefix": "b592a91d11f4e2219346e91e3786493b0d6722d9935782cdeca6347b3e605fa3", + "size_in_bytes": 46166 + }, + { + "_path": "lib/python3.12/__pycache__/_compat_pickle.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "eb9d1d53e5e91bdb57d1028df76d6214928b36450abbeb94887376eed1eb5e18", + "sha256_in_prefix": "eb9d1d53e5e91bdb57d1028df76d6214928b36450abbeb94887376eed1eb5e18", + "size_in_bytes": 7469 + }, + { + "_path": "lib/python3.12/__pycache__/_compression.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "9732636e0c2f79a67858ae6219bc46a42a806157f83ff73886ed63880d1e44db", + "sha256_in_prefix": "9732636e0c2f79a67858ae6219bc46a42a806157f83ff73886ed63880d1e44db", + "size_in_bytes": 7751 + }, + { + "_path": "lib/python3.12/__pycache__/_markupbase.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "d3ca5b1448f30e30d88009428015c1033954ee8985d2b964932be44c873b3315", + "sha256_in_prefix": "d3ca5b1448f30e30d88009428015c1033954ee8985d2b964932be44c873b3315", + "size_in_bytes": 12527 + }, + { + "_path": "lib/python3.12/__pycache__/_osx_support.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "12e7746b7b97bb8993f8336eda80425582a8c326a74f1e2e08b2922d24fa441a", + "sha256_in_prefix": "12e7746b7b97bb8993f8336eda80425582a8c326a74f1e2e08b2922d24fa441a", + "size_in_bytes": 17985 + }, + { + "_path": "lib/python3.12/__pycache__/_py_abc.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "a55fd2c5b55f160c0a51677111d2245b040e8163d1094fe115d0ba6f9f6fc6dc", + "sha256_in_prefix": "a55fd2c5b55f160c0a51677111d2245b040e8163d1094fe115d0ba6f9f6fc6dc", + "size_in_bytes": 7305 + }, + { + "_path": "lib/python3.12/__pycache__/_pydatetime.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "a216807aeac46dbb5f16ece05a3da09d5690d9876dc65920fdd182efc282780a", + "sha256_in_prefix": "a216807aeac46dbb5f16ece05a3da09d5690d9876dc65920fdd182efc282780a", + "size_in_bytes": 94311 + }, + { + "_path": "lib/python3.12/__pycache__/_pydecimal.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "24374a4faa1b667cb2c0fe011d12199dca68c6ddda8f75ed2c70e1245abfabea", + "sha256_in_prefix": "24374a4faa1b667cb2c0fe011d12199dca68c6ddda8f75ed2c70e1245abfabea", + "size_in_bytes": 228061 + }, + { + "_path": "lib/python3.12/__pycache__/_pyio.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "dbd28192395620ff24ec7d63e5952ee292a8c35cab9d389aa6c6289a59243fc2", + "sha256_in_prefix": "dbd28192395620ff24ec7d63e5952ee292a8c35cab9d389aa6c6289a59243fc2", + "size_in_bytes": 110486 + }, + { + "_path": "lib/python3.12/__pycache__/_pylong.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "1e48d0af6198506be1c5978d915c30ff3e4637e05b3fac63ac9ca592ddeacd01", + "sha256_in_prefix": "1e48d0af6198506be1c5978d915c30ff3e4637e05b3fac63ac9ca592ddeacd01", + "size_in_bytes": 10237 + }, + { + "_path": "lib/python3.12/__pycache__/_sitebuiltins.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "3699ce6f90865726f5ccb97e0783151264f1d230e582afc735b807e20ce74ab1", + "sha256_in_prefix": "3699ce6f90865726f5ccb97e0783151264f1d230e582afc735b807e20ce74ab1", + "size_in_bytes": 5014 + }, + { + "_path": "lib/python3.12/__pycache__/_strptime.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "8b9888c7db77b982f8b2f3f7dc3fa6104b586525880324b0fa43fdc3613764ad", + "sha256_in_prefix": "8b9888c7db77b982f8b2f3f7dc3fa6104b586525880324b0fa43fdc3613764ad", + "size_in_bytes": 24370 + }, + { + "_path": "lib/python3.12/__pycache__/_sysconfigdata__darwin_darwin.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "7f00b3ff3b26a5dc655e4560cc1eedc9fbee77cbe46a8b1587662d5bac8fe247", + "sha256_in_prefix": "7f00b3ff3b26a5dc655e4560cc1eedc9fbee77cbe46a8b1587662d5bac8fe247", + "size_in_bytes": 100455 + }, + { + "_path": "lib/python3.12/__pycache__/_sysconfigdata_arm64_apple_darwin20_0_0.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "b6952e252430a32f2d508461eeb723e45b016f8d8777f3ea0433785f2b3f17b6", + "sha256_in_prefix": "b6952e252430a32f2d508461eeb723e45b016f8d8777f3ea0433785f2b3f17b6", + "size_in_bytes": 99992 + }, + { + "_path": "lib/python3.12/__pycache__/_threading_local.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "a87b6d9314ad55cd9d4a9a9be8954238d2bcec17b2e8b5f44cd1ed3bba2ff466", + "sha256_in_prefix": "a87b6d9314ad55cd9d4a9a9be8954238d2bcec17b2e8b5f44cd1ed3bba2ff466", + "size_in_bytes": 8549 + }, + { + "_path": "lib/python3.12/__pycache__/_weakrefset.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "ece73739c1095d2213599bd2f284a3b4bb349a0593453afe5ef6ec0d2d418e8f", + "sha256_in_prefix": "ece73739c1095d2213599bd2f284a3b4bb349a0593453afe5ef6ec0d2d418e8f", + "size_in_bytes": 12005 + }, + { + "_path": "lib/python3.12/__pycache__/abc.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "6b32eb5d8df9d35ca9d6076bc6fcbe4c786ae53608295fb3addb728465ce16fc", + "sha256_in_prefix": "6b32eb5d8df9d35ca9d6076bc6fcbe4c786ae53608295fb3addb728465ce16fc", + "size_in_bytes": 8309 + }, + { + "_path": "lib/python3.12/__pycache__/aifc.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "3dffd5598308f8401c1704630738c0fdc05c6b3fe6f5bd0949a346111a3bc816", + "sha256_in_prefix": "3dffd5598308f8401c1704630738c0fdc05c6b3fe6f5bd0949a346111a3bc816", + "size_in_bytes": 43117 + }, + { + "_path": "lib/python3.12/__pycache__/antigravity.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "87b07e4c8f87d5f28d0247a133c6d7e1f1b6f677c559ef765be997bbc3fe4bcc", + "sha256_in_prefix": "87b07e4c8f87d5f28d0247a133c6d7e1f1b6f677c559ef765be997bbc3fe4bcc", + "size_in_bytes": 1257 + }, + { + "_path": "lib/python3.12/__pycache__/argparse.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "e9c0ec0a4e3dbad23e7cf31f9332b45423f5e65d9072644913edc97f34c84ff6", + "sha256_in_prefix": "e9c0ec0a4e3dbad23e7cf31f9332b45423f5e65d9072644913edc97f34c84ff6", + "size_in_bytes": 101085 + }, + { + "_path": "lib/python3.12/__pycache__/ast.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "e29cad14f8da27e8b0eb2c2d342f77f0c3aa26c1896a67a93f47ca15722fb5e1", + "sha256_in_prefix": "e29cad14f8da27e8b0eb2c2d342f77f0c3aa26c1896a67a93f47ca15722fb5e1", + "size_in_bytes": 100343 + }, + { + "_path": "lib/python3.12/__pycache__/base64.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "8ba49c3a87fb56962333d979384039ba19cf7087f3cecdfa3eb850b3e432e3b0", + "sha256_in_prefix": "8ba49c3a87fb56962333d979384039ba19cf7087f3cecdfa3eb850b3e432e3b0", + "size_in_bytes": 24654 + }, + { + "_path": "lib/python3.12/__pycache__/bdb.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "81a3a1fd27aeb06045e1f25bdb22e547b2578c186340acad02c2bde899fc2bfc", + "sha256_in_prefix": "81a3a1fd27aeb06045e1f25bdb22e547b2578c186340acad02c2bde899fc2bfc", + "size_in_bytes": 37613 + }, + { + "_path": "lib/python3.12/__pycache__/bisect.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "08f9ac95c6a737bec7ba978962ca7c8f57d331b7760b36c2be1959e6b69f3125", + "sha256_in_prefix": "08f9ac95c6a737bec7ba978962ca7c8f57d331b7760b36c2be1959e6b69f3125", + "size_in_bytes": 3895 + }, + { + "_path": "lib/python3.12/__pycache__/bz2.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "f43586adb2e944f3df876897ad45de08a1b188e2ab23bab3eaac3c6d74292d9c", + "sha256_in_prefix": "f43586adb2e944f3df876897ad45de08a1b188e2ab23bab3eaac3c6d74292d9c", + "size_in_bytes": 15387 + }, + { + "_path": "lib/python3.12/__pycache__/cProfile.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "486f00be02ffaef0d6b6ba97f484797ba74b3fa86d2b4c0ee30a49bda5b1e961", + "sha256_in_prefix": "486f00be02ffaef0d6b6ba97f484797ba74b3fa86d2b4c0ee30a49bda5b1e961", + "size_in_bytes": 8847 + }, + { + "_path": "lib/python3.12/__pycache__/calendar.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "307b1fe9beea69735a30864847592fc17899887c93acde72d341987c6fe168a7", + "sha256_in_prefix": "307b1fe9beea69735a30864847592fc17899887c93acde72d341987c6fe168a7", + "size_in_bytes": 39875 + }, + { + "_path": "lib/python3.12/__pycache__/cgi.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "34daec72bd48541833a2d9365cf0725f41dcd02c804a7f981145bff6076ae524", + "sha256_in_prefix": "34daec72bd48541833a2d9365cf0725f41dcd02c804a7f981145bff6076ae524", + "size_in_bytes": 40482 + }, + { + "_path": "lib/python3.12/__pycache__/cgitb.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "3f672cc4a236bea75bbc05377a4aa86b7dd4beabdb7dd6580689574ac0e15514", + "sha256_in_prefix": "3f672cc4a236bea75bbc05377a4aa86b7dd4beabdb7dd6580689574ac0e15514", + "size_in_bytes": 17586 + }, + { + "_path": "lib/python3.12/__pycache__/chunk.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "56c0f58f735d0b05cd01ebd0d95172e1fe81e556882654def2ecdd30a5640d8f", + "sha256_in_prefix": "56c0f58f735d0b05cd01ebd0d95172e1fe81e556882654def2ecdd30a5640d8f", + "size_in_bytes": 7564 + }, + { + "_path": "lib/python3.12/__pycache__/cmd.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "bee33714d892fd451ef5ff184a4c7bcb82b6351bb1bcc1043406677841a912b0", + "sha256_in_prefix": "bee33714d892fd451ef5ff184a4c7bcb82b6351bb1bcc1043406677841a912b0", + "size_in_bytes": 18873 + }, + { + "_path": "lib/python3.12/__pycache__/code.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "6213de09385cf206b6c640f54dde7fc29e0de38f7ec5d1478efa107ef5851914", + "sha256_in_prefix": "6213de09385cf206b6c640f54dde7fc29e0de38f7ec5d1478efa107ef5851914", + "size_in_bytes": 13305 + }, + { + "_path": "lib/python3.12/__pycache__/codecs.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "a883cb2f631c6d2c0429d16edc2efa4eea5054063c8e63581bf687cf089bd384", + "sha256_in_prefix": "a883cb2f631c6d2c0429d16edc2efa4eea5054063c8e63581bf687cf089bd384", + "size_in_bytes": 42528 + }, + { + "_path": "lib/python3.12/__pycache__/codeop.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "61aa2116223476f167d10b162e11a74fd6ad04ad13d1b7844def1b9cddc4e3fa", + "sha256_in_prefix": "61aa2116223476f167d10b162e11a74fd6ad04ad13d1b7844def1b9cddc4e3fa", + "size_in_bytes": 7170 + }, + { + "_path": "lib/python3.12/__pycache__/colorsys.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "84de0c074c2c10042faffdff8ab62dabb921e0dc7a8bfc256dc6d52a6a7ecf45", + "sha256_in_prefix": "84de0c074c2c10042faffdff8ab62dabb921e0dc7a8bfc256dc6d52a6a7ecf45", + "size_in_bytes": 4896 + }, + { + "_path": "lib/python3.12/__pycache__/compileall.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "84262c8cb1bd02f7d3bc8792bb3368f241ba08215392e33566419388412fcee8", + "sha256_in_prefix": "84262c8cb1bd02f7d3bc8792bb3368f241ba08215392e33566419388412fcee8", + "size_in_bytes": 20656 + }, + { + "_path": "lib/python3.12/__pycache__/configparser.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "98e48accc24bb4b8711fc00ade7a4367dcdaad48e5d719dc7420bc163a04c259", + "sha256_in_prefix": "98e48accc24bb4b8711fc00ade7a4367dcdaad48e5d719dc7420bc163a04c259", + "size_in_bytes": 63717 + }, + { + "_path": "lib/python3.12/__pycache__/contextlib.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "9b6fe2921536ea65f3dcb098ea97072e73cc6c383eb96555b29e5a52b274ef65", + "sha256_in_prefix": "9b6fe2921536ea65f3dcb098ea97072e73cc6c383eb96555b29e5a52b274ef65", + "size_in_bytes": 30628 + }, + { + "_path": "lib/python3.12/__pycache__/contextvars.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "05153cf6310051d94a303cf30afc01ab1ff45faa43e31fcc532bf85ccc8f8ff4", + "sha256_in_prefix": "05153cf6310051d94a303cf30afc01ab1ff45faa43e31fcc532bf85ccc8f8ff4", + "size_in_bytes": 515 + }, + { + "_path": "lib/python3.12/__pycache__/copy.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "4eb671c7543187dddeb329a1bbe5115245a766f57a374d72b01e93be4bc2884a", + "sha256_in_prefix": "4eb671c7543187dddeb329a1bbe5115245a766f57a374d72b01e93be4bc2884a", + "size_in_bytes": 10054 + }, + { + "_path": "lib/python3.12/__pycache__/copyreg.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "d4a2aa1833b4cff194068b1cb9afc09034dbf2d3c842bcbb54864d79809f15f3", + "sha256_in_prefix": "d4a2aa1833b4cff194068b1cb9afc09034dbf2d3c842bcbb54864d79809f15f3", + "size_in_bytes": 7666 + }, + { + "_path": "lib/python3.12/__pycache__/crypt.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "6c979937be4cb70199d8afa970a31318d17738f18eea5ece757bd7359ca461ce", + "sha256_in_prefix": "6c979937be4cb70199d8afa970a31318d17738f18eea5ece757bd7359ca461ce", + "size_in_bytes": 5615 + }, + { + "_path": "lib/python3.12/__pycache__/csv.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "8aa8fa7755c7333f66c88270a5ec2b1c95c0a083b63305eeeb49a6e41cc1cfa8", + "sha256_in_prefix": "8aa8fa7755c7333f66c88270a5ec2b1c95c0a083b63305eeeb49a6e41cc1cfa8", + "size_in_bytes": 18042 + }, + { + "_path": "lib/python3.12/__pycache__/dataclasses.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "cfc8cb74dde756d0df5f2633b442399b8b375d94914306e617d760c5fdd99000", + "sha256_in_prefix": "cfc8cb74dde756d0df5f2633b442399b8b375d94914306e617d760c5fdd99000", + "size_in_bytes": 44864 + }, + { + "_path": "lib/python3.12/__pycache__/datetime.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "2187448341b74034ede7b48b46d1526cc1f90b56f234b3dabfde826931ff1318", + "sha256_in_prefix": "2187448341b74034ede7b48b46d1526cc1f90b56f234b3dabfde826931ff1318", + "size_in_bytes": 663 + }, + { + "_path": "lib/python3.12/__pycache__/decimal.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "f128291aa5abc4f7f90c20231c4aa24f3c996e9fa7959c8f082678968efae13e", + "sha256_in_prefix": "f128291aa5abc4f7f90c20231c4aa24f3c996e9fa7959c8f082678968efae13e", + "size_in_bytes": 660 + }, + { + "_path": "lib/python3.12/__pycache__/difflib.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "f5ac2b81bde6c4411dd3e9b007d27d4c594f4bb83f782fbe3d73a49eae8fbd02", + "sha256_in_prefix": "f5ac2b81bde6c4411dd3e9b007d27d4c594f4bb83f782fbe3d73a49eae8fbd02", + "size_in_bytes": 75750 + }, + { + "_path": "lib/python3.12/__pycache__/dis.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "05b736ce1d357a46871b86ff952fc75874b217919a6d6c63ed3386b778939ea8", + "sha256_in_prefix": "05b736ce1d357a46871b86ff952fc75874b217919a6d6c63ed3386b778939ea8", + "size_in_bytes": 34812 + }, + { + "_path": "lib/python3.12/__pycache__/doctest.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "6d695063b4445390c6ef9882a739cf12274af61fcb27d99810aa2c040c88383f", + "sha256_in_prefix": "6d695063b4445390c6ef9882a739cf12274af61fcb27d99810aa2c040c88383f", + "size_in_bytes": 105875 + }, + { + "_path": "lib/python3.12/__pycache__/enum.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "554974a67556748b02b4bf2c886cc5dcdc3288d3c39d795d883d4a2488ffa2d3", + "sha256_in_prefix": "554974a67556748b02b4bf2c886cc5dcdc3288d3c39d795d883d4a2488ffa2d3", + "size_in_bytes": 79736 + }, + { + "_path": "lib/python3.12/__pycache__/filecmp.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "b91fdc07d36bb60feb09dbccb03bd0c03728e2b86c2e76ba90fb31f5228cdc26", + "sha256_in_prefix": "b91fdc07d36bb60feb09dbccb03bd0c03728e2b86c2e76ba90fb31f5228cdc26", + "size_in_bytes": 14915 + }, + { + "_path": "lib/python3.12/__pycache__/fileinput.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "065a78886e9594b4623ec8b5fa368fec8d64d8158ee2086f585e3a2b65896f7a", + "sha256_in_prefix": "065a78886e9594b4623ec8b5fa368fec8d64d8158ee2086f585e3a2b65896f7a", + "size_in_bytes": 20534 + }, + { + "_path": "lib/python3.12/__pycache__/fnmatch.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "c0541fd21cbaadb84aff3cfb54744233b292db766622a96056549ee935f0e1e8", + "sha256_in_prefix": "c0541fd21cbaadb84aff3cfb54744233b292db766622a96056549ee935f0e1e8", + "size_in_bytes": 6740 + }, + { + "_path": "lib/python3.12/__pycache__/fractions.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "7bd6ade821c25d4c0b7568f79eda3b11877e756bfb455d1f1b4d854740096ed9", + "sha256_in_prefix": "7bd6ade821c25d4c0b7568f79eda3b11877e756bfb455d1f1b4d854740096ed9", + "size_in_bytes": 36921 + }, + { + "_path": "lib/python3.12/__pycache__/ftplib.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "39d1064275202c5d207f133775999ec25e729e773a1ab1daf06b10bee2306d2c", + "sha256_in_prefix": "39d1064275202c5d207f133775999ec25e729e773a1ab1daf06b10bee2306d2c", + "size_in_bytes": 42890 + }, + { + "_path": "lib/python3.12/__pycache__/functools.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "42ce108558ebb7a787bad7b709187a7d63ad2aed33b047e55e4345d4b617cf9c", + "sha256_in_prefix": "42ce108558ebb7a787bad7b709187a7d63ad2aed33b047e55e4345d4b617cf9c", + "size_in_bytes": 40760 + }, + { + "_path": "lib/python3.12/__pycache__/genericpath.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "0e8a5ca34ed606fbc2d4b91d789ee08583ccddc94ba30fee100883322c27478b", + "sha256_in_prefix": "0e8a5ca34ed606fbc2d4b91d789ee08583ccddc94ba30fee100883322c27478b", + "size_in_bytes": 6447 + }, + { + "_path": "lib/python3.12/__pycache__/getopt.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "038b9c927889819977fb7a07bacb903c44d1a1afb874fe933209048d78150148", + "sha256_in_prefix": "038b9c927889819977fb7a07bacb903c44d1a1afb874fe933209048d78150148", + "size_in_bytes": 8614 + }, + { + "_path": "lib/python3.12/__pycache__/getpass.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "d890b021f7d90109e4f5f4da7470612e3ba53d63fb5433478446bc3c2417daa5", + "sha256_in_prefix": "d890b021f7d90109e4f5f4da7470612e3ba53d63fb5433478446bc3c2417daa5", + "size_in_bytes": 7104 + }, + { + "_path": "lib/python3.12/__pycache__/gettext.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "f9bad2381ba1cd7bf328f0a9714ae73bfd59cff51054e2d4ae5fcf648fb44e38", + "sha256_in_prefix": "f9bad2381ba1cd7bf328f0a9714ae73bfd59cff51054e2d4ae5fcf648fb44e38", + "size_in_bytes": 22106 + }, + { + "_path": "lib/python3.12/__pycache__/glob.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "13a5efb8c6aca9c9752cd1c6732f180d16c33aae0c9d89a33780dfee4d8d4db0", + "sha256_in_prefix": "13a5efb8c6aca9c9752cd1c6732f180d16c33aae0c9d89a33780dfee4d8d4db0", + "size_in_bytes": 10045 + }, + { + "_path": "lib/python3.12/__pycache__/graphlib.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "129f479b2a16807ca8f5a8e328e20abc406b215b8945cbc66b86f997187b44d3", + "sha256_in_prefix": "129f479b2a16807ca8f5a8e328e20abc406b215b8945cbc66b86f997187b44d3", + "size_in_bytes": 10579 + }, + { + "_path": "lib/python3.12/__pycache__/gzip.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "89c1e2340302bb23e4c2576cfae1bedb62c4619f245855a16cdffadd8b0b59da", + "sha256_in_prefix": "89c1e2340302bb23e4c2576cfae1bedb62c4619f245855a16cdffadd8b0b59da", + "size_in_bytes": 32269 + }, + { + "_path": "lib/python3.12/__pycache__/hashlib.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "4863740fa2cda13b28bd252d56e7ecee0ec12119f5642a548fc3bff43d81e438", + "sha256_in_prefix": "4863740fa2cda13b28bd252d56e7ecee0ec12119f5642a548fc3bff43d81e438", + "size_in_bytes": 8341 + }, + { + "_path": "lib/python3.12/__pycache__/heapq.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "80f90c3db903d41e4782e3eedad2c37f832377554c5b2f9ca3abfc8ed7637d6f", + "sha256_in_prefix": "80f90c3db903d41e4782e3eedad2c37f832377554c5b2f9ca3abfc8ed7637d6f", + "size_in_bytes": 18210 + }, + { + "_path": "lib/python3.12/__pycache__/hmac.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "c1bb903fe2b75fcc644b70c0d36ef76d709b6e070b58bb8ec1e82ead073a3b3b", + "sha256_in_prefix": "c1bb903fe2b75fcc644b70c0d36ef76d709b6e070b58bb8ec1e82ead073a3b3b", + "size_in_bytes": 10952 + }, + { + "_path": "lib/python3.12/__pycache__/imaplib.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "a385c42f106a389f2a8e918fe47cb3670314ce122c29b026aef84ef09c12fed5", + "sha256_in_prefix": "a385c42f106a389f2a8e918fe47cb3670314ce122c29b026aef84ef09c12fed5", + "size_in_bytes": 63143 + }, + { + "_path": "lib/python3.12/__pycache__/imghdr.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "41fd8233d6a6e05fc1f8346e6e25e3fe8afacf45a74c1295ea0f91b4b0ac3317", + "sha256_in_prefix": "41fd8233d6a6e05fc1f8346e6e25e3fe8afacf45a74c1295ea0f91b4b0ac3317", + "size_in_bytes": 7198 + }, + { + "_path": "lib/python3.12/__pycache__/inspect.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "39b556a01747a3ecaf7302894d8d21633d18c30b750c763e5ba9e08abfe12020", + "sha256_in_prefix": "39b556a01747a3ecaf7302894d8d21633d18c30b750c763e5ba9e08abfe12020", + "size_in_bytes": 133954 + }, + { + "_path": "lib/python3.12/__pycache__/io.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "7d98a2d0a46ab6a0e97b76e883143bfca90a4bd5e91b2e543cd433820a8c0136", + "sha256_in_prefix": "7d98a2d0a46ab6a0e97b76e883143bfca90a4bd5e91b2e543cd433820a8c0136", + "size_in_bytes": 4393 + }, + { + "_path": "lib/python3.12/__pycache__/ipaddress.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "30fae2de3e21bc31f9dd881987bdcd873fe62f1538aafad6adb9aa239308d931", + "sha256_in_prefix": "30fae2de3e21bc31f9dd881987bdcd873fe62f1538aafad6adb9aa239308d931", + "size_in_bytes": 88949 + }, + { + "_path": "lib/python3.12/__pycache__/keyword.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "b967ae5cd7a038a0e40f5a88b7c02b99392967a99f9e21fa937381eb5b9c1630", + "sha256_in_prefix": "b967ae5cd7a038a0e40f5a88b7c02b99392967a99f9e21fa937381eb5b9c1630", + "size_in_bytes": 1295 + }, + { + "_path": "lib/python3.12/__pycache__/linecache.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "804d24ebabfdb48a191e0644772254b9de5867171299ab93db18593a20f8f9fe", + "sha256_in_prefix": "804d24ebabfdb48a191e0644772254b9de5867171299ab93db18593a20f8f9fe", + "size_in_bytes": 6692 + }, + { + "_path": "lib/python3.12/__pycache__/locale.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "f508f0127cce5b4085d5292e1beaeb3dde180c8696bd7884f27c7f0876e02f1f", + "sha256_in_prefix": "f508f0127cce5b4085d5292e1beaeb3dde180c8696bd7884f27c7f0876e02f1f", + "size_in_bytes": 59801 + }, + { + "_path": "lib/python3.12/__pycache__/lzma.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "54e8552f731a28dee0560a58a1b2c3efe6ac6e416fd57e9897e5bc17c7de5763", + "sha256_in_prefix": "54e8552f731a28dee0560a58a1b2c3efe6ac6e416fd57e9897e5bc17c7de5763", + "size_in_bytes": 16109 + }, + { + "_path": "lib/python3.12/__pycache__/mailbox.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "2491041bc8f6bc5c4e16bb535db5f4c5bc1edb0f580c78876c92fbb311307699", + "sha256_in_prefix": "2491041bc8f6bc5c4e16bb535db5f4c5bc1edb0f580c78876c92fbb311307699", + "size_in_bytes": 111609 + }, + { + "_path": "lib/python3.12/__pycache__/mailcap.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "625904b23278217411e0a9a95f0cd6eac04df3993d16dd711a81858d4f74b43a", + "sha256_in_prefix": "625904b23278217411e0a9a95f0cd6eac04df3993d16dd711a81858d4f74b43a", + "size_in_bytes": 11409 + }, + { + "_path": "lib/python3.12/__pycache__/mimetypes.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "d70de3642ac02ef04f2b7f9c28103da6b0efb879287637bfc090bf0d589f7d8a", + "sha256_in_prefix": "d70de3642ac02ef04f2b7f9c28103da6b0efb879287637bfc090bf0d589f7d8a", + "size_in_bytes": 24150 + }, + { + "_path": "lib/python3.12/__pycache__/modulefinder.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "19e16fe033c41c7935e1b29536e52ab986764774351a749391c622efb7b9c1d0", + "sha256_in_prefix": "19e16fe033c41c7935e1b29536e52ab986764774351a749391c622efb7b9c1d0", + "size_in_bytes": 28189 + }, + { + "_path": "lib/python3.12/__pycache__/netrc.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "a2a96eb8b3b8c492f3a9f7b69bd5659b4247d4760d78e18187c94097ade92f53", + "sha256_in_prefix": "a2a96eb8b3b8c492f3a9f7b69bd5659b4247d4760d78e18187c94097ade92f53", + "size_in_bytes": 9157 + }, + { + "_path": "lib/python3.12/__pycache__/nntplib.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "9de83c2576777ae0593217888e21d43e91b67bb49944fe2731dc7f449b0ec58d", + "sha256_in_prefix": "9de83c2576777ae0593217888e21d43e91b67bb49944fe2731dc7f449b0ec58d", + "size_in_bytes": 45193 + }, + { + "_path": "lib/python3.12/__pycache__/ntpath.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "9157fdd203d9d91545e68cd731381e9f232a76bca126fa3fe62966f00a1becff", + "sha256_in_prefix": "9157fdd203d9d91545e68cd731381e9f232a76bca126fa3fe62966f00a1becff", + "size_in_bytes": 27348 + }, + { + "_path": "lib/python3.12/__pycache__/nturl2path.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "8c091c90ffcf5f53c6df54df65af936c995dbb23f42692d7c59a52c247aa19c3", + "sha256_in_prefix": "8c091c90ffcf5f53c6df54df65af936c995dbb23f42692d7c59a52c247aa19c3", + "size_in_bytes": 3288 + }, + { + "_path": "lib/python3.12/__pycache__/numbers.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "2756729556c19d9e3ad368a0795f7c3d40d5f035c7848a53598dfeb6120202e8", + "sha256_in_prefix": "2756729556c19d9e3ad368a0795f7c3d40d5f035c7848a53598dfeb6120202e8", + "size_in_bytes": 14221 + }, + { + "_path": "lib/python3.12/__pycache__/opcode.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "abb16419613313fb42bbe82797d8cf0a4490137a6542efa6dab3a399410134d4", + "sha256_in_prefix": "abb16419613313fb42bbe82797d8cf0a4490137a6542efa6dab3a399410134d4", + "size_in_bytes": 14968 + }, + { + "_path": "lib/python3.12/__pycache__/operator.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "40abc7dd3e28f51e87a1bdd0595e23dd2e1304a4fab1a4aaac18e9acb8858c9c", + "sha256_in_prefix": "40abc7dd3e28f51e87a1bdd0595e23dd2e1304a4fab1a4aaac18e9acb8858c9c", + "size_in_bytes": 17618 + }, + { + "_path": "lib/python3.12/__pycache__/optparse.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "b373470f27f1f71b8d07ada8e294c2209448ce9cab3802955003edf2c6eaac39", + "sha256_in_prefix": "b373470f27f1f71b8d07ada8e294c2209448ce9cab3802955003edf2c6eaac39", + "size_in_bytes": 67797 + }, + { + "_path": "lib/python3.12/__pycache__/os.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "3dbdaa0179db4d05533220466d69b90a4f49c56b8a3d782ada144b9129a059c1", + "sha256_in_prefix": "3dbdaa0179db4d05533220466d69b90a4f49c56b8a3d782ada144b9129a059c1", + "size_in_bytes": 43670 + }, + { + "_path": "lib/python3.12/__pycache__/pathlib.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "ee417be4ec3e343b9595f623edcac1a9cc42b1f83eec4cd5c8bbc6307081b354", + "sha256_in_prefix": "ee417be4ec3e343b9595f623edcac1a9cc42b1f83eec4cd5c8bbc6307081b354", + "size_in_bytes": 62316 + }, + { + "_path": "lib/python3.12/__pycache__/pdb.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "7a0faa405cfca9caa41c1b52c7932d681fa67d690ccddd4413c62be1c62bc442", + "sha256_in_prefix": "7a0faa405cfca9caa41c1b52c7932d681fa67d690ccddd4413c62be1c62bc442", + "size_in_bytes": 85503 + }, + { + "_path": "lib/python3.12/__pycache__/pickle.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "89e654a86a8a5ef02af71d5d7a40dc37f5d89b16e97c64b141a1208ff4604c84", + "sha256_in_prefix": "89e654a86a8a5ef02af71d5d7a40dc37f5d89b16e97c64b141a1208ff4604c84", + "size_in_bytes": 76419 + }, + { + "_path": "lib/python3.12/__pycache__/pickletools.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "c0590239a75606f3ee9cc342bbe6c2d7482effbd93ec39996f6aca5edf76f780", + "sha256_in_prefix": "c0590239a75606f3ee9cc342bbe6c2d7482effbd93ec39996f6aca5edf76f780", + "size_in_bytes": 81294 + }, + { + "_path": "lib/python3.12/__pycache__/pipes.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "ae410207052c537b3abe17910ca4efc41c387618c21a089cbf0d58cb15cfb632", + "sha256_in_prefix": "ae410207052c537b3abe17910ca4efc41c387618c21a089cbf0d58cb15cfb632", + "size_in_bytes": 11168 + }, + { + "_path": "lib/python3.12/__pycache__/pkgutil.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "74e16bd659842f0015ee2a4d5339f590ff958a87dd1ed0ab2c1d1fa84e4ce059", + "sha256_in_prefix": "74e16bd659842f0015ee2a4d5339f590ff958a87dd1ed0ab2c1d1fa84e4ce059", + "size_in_bytes": 20213 + }, + { + "_path": "lib/python3.12/__pycache__/platform.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "6b3504d4f30ef253c1a813d3aa6166cd3d7338a263d51dfe28d55c8a8848442f", + "sha256_in_prefix": "6b3504d4f30ef253c1a813d3aa6166cd3d7338a263d51dfe28d55c8a8848442f", + "size_in_bytes": 42108 + }, + { + "_path": "lib/python3.12/__pycache__/plistlib.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "8e2aa17ccdb13c391efcd0ea52ed7a7976c637b9818877c84994b50772a748d4", + "sha256_in_prefix": "8e2aa17ccdb13c391efcd0ea52ed7a7976c637b9818877c84994b50772a748d4", + "size_in_bytes": 41318 + }, + { + "_path": "lib/python3.12/__pycache__/poplib.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "df31d2aebad0bff5e4c94022013c8215a2226b44dbb20236b0a3f6aa5d9c8a93", + "sha256_in_prefix": "df31d2aebad0bff5e4c94022013c8215a2226b44dbb20236b0a3f6aa5d9c8a93", + "size_in_bytes": 18700 + }, + { + "_path": "lib/python3.12/__pycache__/posixpath.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "a7428f3217bfa011e60e7bcb8b848a7175a7b6bcce0a4d49c28a68970fafcfff", + "sha256_in_prefix": "a7428f3217bfa011e60e7bcb8b848a7175a7b6bcce0a4d49c28a68970fafcfff", + "size_in_bytes": 18285 + }, + { + "_path": "lib/python3.12/__pycache__/pprint.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "2e3d89d98fba891f000b3a0e1f5e4727e21d1b290fdc63243e1f81f4b9697615", + "sha256_in_prefix": "2e3d89d98fba891f000b3a0e1f5e4727e21d1b290fdc63243e1f81f4b9697615", + "size_in_bytes": 29724 + }, + { + "_path": "lib/python3.12/__pycache__/profile.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "0af90d6092b78b6f7a1526f636c11c34e1692b0846050355cd1fbb3d86c5ba43", + "sha256_in_prefix": "0af90d6092b78b6f7a1526f636c11c34e1692b0846050355cd1fbb3d86c5ba43", + "size_in_bytes": 22783 + }, + { + "_path": "lib/python3.12/__pycache__/pstats.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "3250e64180b85cf272b91bbd89f5c7630ad2acd548b7e77568bbe6505db75f7c", + "sha256_in_prefix": "3250e64180b85cf272b91bbd89f5c7630ad2acd548b7e77568bbe6505db75f7c", + "size_in_bytes": 38176 + }, + { + "_path": "lib/python3.12/__pycache__/pty.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "692df37cbc6bdf5ecbeb23d331c47d644175f9c9d767a8f6037f3d2327c1555b", + "sha256_in_prefix": "692df37cbc6bdf5ecbeb23d331c47d644175f9c9d767a8f6037f3d2327c1555b", + "size_in_bytes": 7617 + }, + { + "_path": "lib/python3.12/__pycache__/py_compile.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "432ea1d66e52edb36a77bf9e38b13d0d73205562ea607080ad8e6761ca860828", + "sha256_in_prefix": "432ea1d66e52edb36a77bf9e38b13d0d73205562ea607080ad8e6761ca860828", + "size_in_bytes": 10284 + }, + { + "_path": "lib/python3.12/__pycache__/pyclbr.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "1190eb77ed5190eb3b212fbccab99327da404483c305481ba9a222f38eaaff20", + "sha256_in_prefix": "1190eb77ed5190eb3b212fbccab99327da404483c305481ba9a222f38eaaff20", + "size_in_bytes": 15141 + }, + { + "_path": "lib/python3.12/__pycache__/pydoc.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "0391fc6f0cf6ec35fffae93fbf382c46a90105d526e41e7b56f15a9b0dad24fd", + "sha256_in_prefix": "0391fc6f0cf6ec35fffae93fbf382c46a90105d526e41e7b56f15a9b0dad24fd", + "size_in_bytes": 139211 + }, + { + "_path": "lib/python3.12/__pycache__/queue.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "8235b76dcf8495bcc1147c80ed8821a5bf233bb10df88074d982a01b363615f4", + "sha256_in_prefix": "8235b76dcf8495bcc1147c80ed8821a5bf233bb10df88074d982a01b363615f4", + "size_in_bytes": 14986 + }, + { + "_path": "lib/python3.12/__pycache__/quopri.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "ab8c9644dd0cbae5d94835d7e90ddfa222b4d891473f3e79f3bdecb17e25e90f", + "sha256_in_prefix": "ab8c9644dd0cbae5d94835d7e90ddfa222b4d891473f3e79f3bdecb17e25e90f", + "size_in_bytes": 9566 + }, + { + "_path": "lib/python3.12/__pycache__/random.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "e71439f5dd15687876613fe7e818d251eab57a48ecfe5e0c6163b47dd5d31e34", + "sha256_in_prefix": "e71439f5dd15687876613fe7e818d251eab57a48ecfe5e0c6163b47dd5d31e34", + "size_in_bytes": 33404 + }, + { + "_path": "lib/python3.12/__pycache__/reprlib.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "96d5dfa253644cb6da6f79a4cbeb88a83d7372fff5cda27b850815a97887d365", + "sha256_in_prefix": "96d5dfa253644cb6da6f79a4cbeb88a83d7372fff5cda27b850815a97887d365", + "size_in_bytes": 10163 + }, + { + "_path": "lib/python3.12/__pycache__/rlcompleter.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "b20790538d919664f364e09563f24bee1de4ae7dd4bf5074d7178fa03ad8f487", + "sha256_in_prefix": "b20790538d919664f364e09563f24bee1de4ae7dd4bf5074d7178fa03ad8f487", + "size_in_bytes": 8536 + }, + { + "_path": "lib/python3.12/__pycache__/runpy.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "8e1844eb88e51c6a8bc6708ef001e6d332f906bc941a8e8bbaa62567c58cf71c", + "sha256_in_prefix": "8e1844eb88e51c6a8bc6708ef001e6d332f906bc941a8e8bbaa62567c58cf71c", + "size_in_bytes": 14639 + }, + { + "_path": "lib/python3.12/__pycache__/sched.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "5234c418977ae98e6a69db915c7f43939b880bc14c26b6d51d9e527feee7ae05", + "sha256_in_prefix": "5234c418977ae98e6a69db915c7f43939b880bc14c26b6d51d9e527feee7ae05", + "size_in_bytes": 7989 + }, + { + "_path": "lib/python3.12/__pycache__/secrets.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "7b2af0280525bc6f9130bd98c93a2148919e53a91852640dc15fc3d396619132", + "sha256_in_prefix": "7b2af0280525bc6f9130bd98c93a2148919e53a91852640dc15fc3d396619132", + "size_in_bytes": 2810 + }, + { + "_path": "lib/python3.12/__pycache__/selectors.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "54ab36eace0b391247ad39eecb308bf389e32eed32814c603757e4b97e7f576d", + "sha256_in_prefix": "54ab36eace0b391247ad39eecb308bf389e32eed32814c603757e4b97e7f576d", + "size_in_bytes": 26382 + }, + { + "_path": "lib/python3.12/__pycache__/shelve.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "da4667dd5c663c5b4b93710581975ed80bc4346dc5729d7e2fbb25878c279c56", + "sha256_in_prefix": "da4667dd5c663c5b4b93710581975ed80bc4346dc5729d7e2fbb25878c279c56", + "size_in_bytes": 13167 + }, + { + "_path": "lib/python3.12/__pycache__/shlex.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "0c306d4eaaf59335994aad826cf837df1b9a693d9fbbe9d0750e9b1e1f9aa73e", + "sha256_in_prefix": "0c306d4eaaf59335994aad826cf837df1b9a693d9fbbe9d0750e9b1e1f9aa73e", + "size_in_bytes": 14416 + }, + { + "_path": "lib/python3.12/__pycache__/shutil.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "dbe5a7a14b3bcac8d622e9ec80c082c4cb6103ab78a17a616e8ceb51cdf36ce1", + "sha256_in_prefix": "dbe5a7a14b3bcac8d622e9ec80c082c4cb6103ab78a17a616e8ceb51cdf36ce1", + "size_in_bytes": 68260 + }, + { + "_path": "lib/python3.12/__pycache__/signal.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "a05d02da75e4e4d069b19a2152d89f8423b9f2190819d2aab474b1acfdcb3530", + "sha256_in_prefix": "a05d02da75e4e4d069b19a2152d89f8423b9f2190819d2aab474b1acfdcb3530", + "size_in_bytes": 4702 + }, + { + "_path": "lib/python3.12/__pycache__/site.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "5e0380c9116c09275f663a1ae59f1e67c95ca35ed437a28653ae149173c90096", + "sha256_in_prefix": "5e0380c9116c09275f663a1ae59f1e67c95ca35ed437a28653ae149173c90096", + "size_in_bytes": 28243 + }, + { + "_path": "lib/python3.12/__pycache__/smtplib.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "d1cda4d07093e21eb077265dd115828c031349ecbb256e78d9d5d7db94c5a71d", + "sha256_in_prefix": "d1cda4d07093e21eb077265dd115828c031349ecbb256e78d9d5d7db94c5a71d", + "size_in_bytes": 48472 + }, + { + "_path": "lib/python3.12/__pycache__/sndhdr.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "a16c65cc13bcef95a47a6c87bc9ca8ecef4ce8115899ff2045fe15c240b8b3e6", + "sha256_in_prefix": "a16c65cc13bcef95a47a6c87bc9ca8ecef4ce8115899ff2045fe15c240b8b3e6", + "size_in_bytes": 10966 + }, + { + "_path": "lib/python3.12/__pycache__/socket.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "9429349fb2fc4734cb6c2e2d897f6ed77cce7b5e29b5a38a17e8061b478794fe", + "sha256_in_prefix": "9429349fb2fc4734cb6c2e2d897f6ed77cce7b5e29b5a38a17e8061b478794fe", + "size_in_bytes": 42066 + }, + { + "_path": "lib/python3.12/__pycache__/socketserver.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "8936a0a80c4e82c86308691a4205dff2e75d0e822161d46f3043a9cf8efb88a2", + "sha256_in_prefix": "8936a0a80c4e82c86308691a4205dff2e75d0e822161d46f3043a9cf8efb88a2", + "size_in_bytes": 34512 + }, + { + "_path": "lib/python3.12/__pycache__/sre_compile.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "7de21c2faff7287ef099e8ac628281860726dd4f3d85a6a153bada6e3c805ef6", + "sha256_in_prefix": "7de21c2faff7287ef099e8ac628281860726dd4f3d85a6a153bada6e3c805ef6", + "size_in_bytes": 879 + }, + { + "_path": "lib/python3.12/__pycache__/sre_constants.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "fc93e6752aa58979aabc368ba59f044d6db4361ea328f725e029b37ef11c5d60", + "sha256_in_prefix": "fc93e6752aa58979aabc368ba59f044d6db4361ea328f725e029b37ef11c5d60", + "size_in_bytes": 882 + }, + { + "_path": "lib/python3.12/__pycache__/sre_parse.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "6a6db2e93c67a75b09d8dc6a79a65116450658ee6248669692ddff051e3b1d23", + "sha256_in_prefix": "6a6db2e93c67a75b09d8dc6a79a65116450658ee6248669692ddff051e3b1d23", + "size_in_bytes": 875 + }, + { + "_path": "lib/python3.12/__pycache__/ssl.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "72cbe990979c8af76ba34e1ee991c4c19ed79de4c174c66d4605aac034fd4504", + "sha256_in_prefix": "72cbe990979c8af76ba34e1ee991c4c19ed79de4c174c66d4605aac034fd4504", + "size_in_bytes": 63265 + }, + { + "_path": "lib/python3.12/__pycache__/stat.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "b5463859efa5268ecad3b6523d2ddaaff8b7c8dd3b4a140cc79567f1f4200ffe", + "sha256_in_prefix": "b5463859efa5268ecad3b6523d2ddaaff8b7c8dd3b4a140cc79567f1f4200ffe", + "size_in_bytes": 5485 + }, + { + "_path": "lib/python3.12/__pycache__/statistics.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "c89aafe350f75d54e9a145db5ea24b7c59f425bca1d7aa17156758e1723a199d", + "sha256_in_prefix": "c89aafe350f75d54e9a145db5ea24b7c59f425bca1d7aa17156758e1723a199d", + "size_in_bytes": 55666 + }, + { + "_path": "lib/python3.12/__pycache__/string.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "b5f4259126fa71ed1c9dc943f6ba404ea1812699414d9f9ffb058c9fed1d6e37", + "sha256_in_prefix": "b5f4259126fa71ed1c9dc943f6ba404ea1812699414d9f9ffb058c9fed1d6e37", + "size_in_bytes": 11736 + }, + { + "_path": "lib/python3.12/__pycache__/stringprep.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "61542d78f076df50c3513076409ca96d5c02367888032afca3835f42f14975ba", + "sha256_in_prefix": "61542d78f076df50c3513076409ca96d5c02367888032afca3835f42f14975ba", + "size_in_bytes": 25411 + }, + { + "_path": "lib/python3.12/__pycache__/struct.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "cfa7c1342400244201f824a419a014d74dbf5268016f309b6768c13c7a5a76cb", + "sha256_in_prefix": "cfa7c1342400244201f824a419a014d74dbf5268016f309b6768c13c7a5a76cb", + "size_in_bytes": 579 + }, + { + "_path": "lib/python3.12/__pycache__/subprocess.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "b36bc948a95d31fa0d5c10713cef015a13966133013156d94a7759904c4f2e5e", + "sha256_in_prefix": "b36bc948a95d31fa0d5c10713cef015a13966133013156d94a7759904c4f2e5e", + "size_in_bytes": 79403 + }, + { + "_path": "lib/python3.12/__pycache__/sunau.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "24557d131af9ef40edad20504794f068a0d5e4a5465382cecbd05ef400591790", + "sha256_in_prefix": "24557d131af9ef40edad20504794f068a0d5e4a5465382cecbd05ef400591790", + "size_in_bytes": 25677 + }, + { + "_path": "lib/python3.12/__pycache__/symtable.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "da9aef6a1ae28852edb30c254b2dca7cf6fece7cfc92f2e7983bb6fb6fad87a6", + "sha256_in_prefix": "da9aef6a1ae28852edb30c254b2dca7cf6fece7cfc92f2e7983bb6fb6fad87a6", + "size_in_bytes": 19033 + }, + { + "_path": "lib/python3.12/__pycache__/sysconfig.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "69b04e9dcd68923da1ba62d3f12eb0f5584bd69f0674981a83523adba3675f3d", + "sha256_in_prefix": "69b04e9dcd68923da1ba62d3f12eb0f5584bd69f0674981a83523adba3675f3d", + "size_in_bytes": 29456 + }, + { + "_path": "lib/python3.12/__pycache__/tabnanny.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "d3f666bb7b4bf69b3d0690e10b2bf1f30e5ed4bc0b9b4a3b6095f2f4e77b277c", + "sha256_in_prefix": "d3f666bb7b4bf69b3d0690e10b2bf1f30e5ed4bc0b9b4a3b6095f2f4e77b277c", + "size_in_bytes": 12410 + }, + { + "_path": "lib/python3.12/__pycache__/tarfile.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "b94641ac7911b28751c50b423354615506febcf15bf0a6960b9a98601125b9a1", + "sha256_in_prefix": "b94641ac7911b28751c50b423354615506febcf15bf0a6960b9a98601125b9a1", + "size_in_bytes": 119591 + }, + { + "_path": "lib/python3.12/__pycache__/telnetlib.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "4570087a57afe81a76bea4a600a421f92a1497fed3cc64fadf0b44e3d0b42efa", + "sha256_in_prefix": "4570087a57afe81a76bea4a600a421f92a1497fed3cc64fadf0b44e3d0b42efa", + "size_in_bytes": 28677 + }, + { + "_path": "lib/python3.12/__pycache__/tempfile.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "69149172f1071de6401f686792359895693a43305a5675769d7c218cfcdcd017", + "sha256_in_prefix": "69149172f1071de6401f686792359895693a43305a5675769d7c218cfcdcd017", + "size_in_bytes": 40652 + }, + { + "_path": "lib/python3.12/__pycache__/textwrap.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "28b4db074202163321cf7f69d4f4a0ce01cece3dd8aecef362bc29d2ac0a37cd", + "sha256_in_prefix": "28b4db074202163321cf7f69d4f4a0ce01cece3dd8aecef362bc29d2ac0a37cd", + "size_in_bytes": 18547 + }, + { + "_path": "lib/python3.12/__pycache__/this.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "d33cce775824c660093790d6a785e4c55a84776ab5ae67761ba5773e9ec3839a", + "sha256_in_prefix": "d33cce775824c660093790d6a785e4c55a84776ab5ae67761ba5773e9ec3839a", + "size_in_bytes": 1662 + }, + { + "_path": "lib/python3.12/__pycache__/threading.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "e72078e228aab377282e4215790bb339b61a0bc55382a3af9ee699a92b46c756", + "sha256_in_prefix": "e72078e228aab377282e4215790bb339b61a0bc55382a3af9ee699a92b46c756", + "size_in_bytes": 65561 + }, + { + "_path": "lib/python3.12/__pycache__/timeit.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "ad4e5ee3a092f8f422cf4feab2bf207e49c4872dd69e26cc358305447c5b57f6", + "sha256_in_prefix": "ad4e5ee3a092f8f422cf4feab2bf207e49c4872dd69e26cc358305447c5b57f6", + "size_in_bytes": 15118 + }, + { + "_path": "lib/python3.12/__pycache__/token.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "e859b421e1f95d815463fa0680b33186855f26e1ccde7e44e1a31a62e0bc1e11", + "sha256_in_prefix": "e859b421e1f95d815463fa0680b33186855f26e1ccde7e44e1a31a62e0bc1e11", + "size_in_bytes": 3811 + }, + { + "_path": "lib/python3.12/__pycache__/tokenize.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "b587b551ca144fdacc61e65d1d1f6e1e452ce299412db70d13dfad38a54bbf3a", + "sha256_in_prefix": "b587b551ca144fdacc61e65d1d1f6e1e452ce299412db70d13dfad38a54bbf3a", + "size_in_bytes": 23414 + }, + { + "_path": "lib/python3.12/__pycache__/trace.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "73dc439e1f4ff15da526996e97840c5c9f2fa47eefd645b39998d9e48067c938", + "sha256_in_prefix": "73dc439e1f4ff15da526996e97840c5c9f2fa47eefd645b39998d9e48067c938", + "size_in_bytes": 33278 + }, + { + "_path": "lib/python3.12/__pycache__/traceback.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "331df83f033d0adbbaa1fb51d119a9d02a11f39648c3ca36b4de6999a7fc2757", + "sha256_in_prefix": "331df83f033d0adbbaa1fb51d119a9d02a11f39648c3ca36b4de6999a7fc2757", + "size_in_bytes": 51771 + }, + { + "_path": "lib/python3.12/__pycache__/tracemalloc.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "0b7e0492b6346b67479699a70a14c0b3300cc98a00e1cf1feb48969a26d81baf", + "sha256_in_prefix": "0b7e0492b6346b67479699a70a14c0b3300cc98a00e1cf1feb48969a26d81baf", + "size_in_bytes": 27161 + }, + { + "_path": "lib/python3.12/__pycache__/tty.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "3b4fbce948c92596debabbccd086b6b022058494322dcd5c1507a83ade4d84a3", + "sha256_in_prefix": "3b4fbce948c92596debabbccd086b6b022058494322dcd5c1507a83ade4d84a3", + "size_in_bytes": 2922 + }, + { + "_path": "lib/python3.12/__pycache__/turtle.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "87b3d065e8b602937e5289e112fa2b750d322976d623aad93388e8de795b6bb4", + "sha256_in_prefix": "87b3d065e8b602937e5289e112fa2b750d322976d623aad93388e8de795b6bb4", + "size_in_bytes": 184886 + }, + { + "_path": "lib/python3.12/__pycache__/types.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "8d8320d33fa1cdefaf5e0093a3b05deae9f2e0b598af76730247420493d9c43c", + "sha256_in_prefix": "8d8320d33fa1cdefaf5e0093a3b05deae9f2e0b598af76730247420493d9c43c", + "size_in_bytes": 15193 + }, + { + "_path": "lib/python3.12/__pycache__/typing.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "126d524557aaf1a5a9e0137b94e92a469b8fc5e5346ea651476949838f520682", + "sha256_in_prefix": "126d524557aaf1a5a9e0137b94e92a469b8fc5e5346ea651476949838f520682", + "size_in_bytes": 141082 + }, + { + "_path": "lib/python3.12/__pycache__/uu.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "17a602f96847d9c1d7ca0aa3fa93148610db60ff91593897580dc061fd34f7dc", + "sha256_in_prefix": "17a602f96847d9c1d7ca0aa3fa93148610db60ff91593897580dc061fd34f7dc", + "size_in_bytes": 8070 + }, + { + "_path": "lib/python3.12/__pycache__/uuid.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "50ad45fa1da1babd4ef914709ad8532e9c4851a265afaef49f9312635da8c5f4", + "sha256_in_prefix": "50ad45fa1da1babd4ef914709ad8532e9c4851a265afaef49f9312635da8c5f4", + "size_in_bytes": 33256 + }, + { + "_path": "lib/python3.12/__pycache__/warnings.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "8d29385374212c86f5177daa02bf2f4739169489fbe99264fd970e43a3134c77", + "sha256_in_prefix": "8d29385374212c86f5177daa02bf2f4739169489fbe99264fd970e43a3134c77", + "size_in_bytes": 24018 + }, + { + "_path": "lib/python3.12/__pycache__/wave.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "6b4f4463d4048574b9a762b1e13f821d99d1e866e1dd5f021d164c3f16dcd5ad", + "sha256_in_prefix": "6b4f4463d4048574b9a762b1e13f821d99d1e866e1dd5f021d164c3f16dcd5ad", + "size_in_bytes": 32332 + }, + { + "_path": "lib/python3.12/__pycache__/weakref.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "5e9a7e796cecda687b75d7da0df7665179427439cbf8b1ae13db293420aab133", + "sha256_in_prefix": "5e9a7e796cecda687b75d7da0df7665179427439cbf8b1ae13db293420aab133", + "size_in_bytes": 31599 + }, + { + "_path": "lib/python3.12/__pycache__/webbrowser.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "71efc81e8c59220386b3d07d1546b028971abca026adcae7e86cd4c94236c58c", + "sha256_in_prefix": "71efc81e8c59220386b3d07d1546b028971abca026adcae7e86cd4c94236c58c", + "size_in_bytes": 26605 + }, + { + "_path": "lib/python3.12/__pycache__/xdrlib.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "0a911d6f6b570eac19194b570a121829e6a633f5a20c628173505370a79d2bf9", + "sha256_in_prefix": "0a911d6f6b570eac19194b570a121829e6a633f5a20c628173505370a79d2bf9", + "size_in_bytes": 12095 + }, + { + "_path": "lib/python3.12/__pycache__/zipapp.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "089e9e686a5235f7347c8c90eab80d88384116437339048a821fa8719c8a7731", + "sha256_in_prefix": "089e9e686a5235f7347c8c90eab80d88384116437339048a821fa8719c8a7731", + "size_in_bytes": 10231 + }, + { + "_path": "lib/python3.12/__pycache__/zipimport.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "272c0a510382434586210e994ff00f6fa7697fd3a04a07c65f0ccc8a59c929b2", + "sha256_in_prefix": "272c0a510382434586210e994ff00f6fa7697fd3a04a07c65f0ccc8a59c929b2", + "size_in_bytes": 24723 + }, + { + "_path": "lib/python3.12/_aix_support.py", + "path_type": "hardlink", + "sha256": "0982f187c62fbfc1e8d368c8eb4104b56df71009a6b2823565a699e7b4cd945c", + "sha256_in_prefix": "0982f187c62fbfc1e8d368c8eb4104b56df71009a6b2823565a699e7b4cd945c", + "size_in_bytes": 4021 + }, + { + "_path": "lib/python3.12/_collections_abc.py", + "path_type": "hardlink", + "sha256": "90324ee3e1c4ca5319f7242d4b7c1e90eb8418b3f999d07c853aa488356282e6", + "sha256_in_prefix": "90324ee3e1c4ca5319f7242d4b7c1e90eb8418b3f999d07c853aa488356282e6", + "size_in_bytes": 32082 + }, + { + "_path": "lib/python3.12/_compat_pickle.py", + "path_type": "hardlink", + "sha256": "12c8356a3d40bd0a336f13d7c6e2bed50d5c1a876563766a3175a6b328b5855e", + "sha256_in_prefix": "12c8356a3d40bd0a336f13d7c6e2bed50d5c1a876563766a3175a6b328b5855e", + "size_in_bytes": 8761 + }, + { + "_path": "lib/python3.12/_compression.py", + "path_type": "hardlink", + "sha256": "3ad5d60627477a60939ee44fc1bb3a05dbe8fb52f0f75039b8f5d8f1a278b981", + "sha256_in_prefix": "3ad5d60627477a60939ee44fc1bb3a05dbe8fb52f0f75039b8f5d8f1a278b981", + "size_in_bytes": 5681 + }, + { + "_path": "lib/python3.12/_markupbase.py", + "path_type": "hardlink", + "sha256": "cb14dd6f2e2439eb70b806cd49d19911363d424c2b6b9f4b73c9c08022d47030", + "sha256_in_prefix": "cb14dd6f2e2439eb70b806cd49d19911363d424c2b6b9f4b73c9c08022d47030", + "size_in_bytes": 14653 + }, + { + "_path": "lib/python3.12/_osx_support.py", + "path_type": "hardlink", + "sha256": "363d3240acbba18a270bd3161f1ddb478f8492dc14fc451b2dc314db5c5ee09c", + "sha256_in_prefix": "363d3240acbba18a270bd3161f1ddb478f8492dc14fc451b2dc314db5c5ee09c", + "size_in_bytes": 22023 + }, + { + "_path": "lib/python3.12/_py_abc.py", + "path_type": "hardlink", + "sha256": "f9c6fe3dd9b51bd7d93f867356e9d362600c924febfd903ee1c6e298860dca92", + "sha256_in_prefix": "f9c6fe3dd9b51bd7d93f867356e9d362600c924febfd903ee1c6e298860dca92", + "size_in_bytes": 6189 + }, + { + "_path": "lib/python3.12/_pydatetime.py", + "path_type": "hardlink", + "sha256": "8d5c6bb703d9b47f87bc20cb8003aaeee2dae7562a381e1623735f1ff8abccd3", + "sha256_in_prefix": "8d5c6bb703d9b47f87bc20cb8003aaeee2dae7562a381e1623735f1ff8abccd3", + "size_in_bytes": 92097 + }, + { + "_path": "lib/python3.12/_pydecimal.py", + "path_type": "hardlink", + "sha256": "c7108f0dc0beedb245daede78c9be602a64d47d3fb988e166e0474aa5bf317ea", + "sha256_in_prefix": "c7108f0dc0beedb245daede78c9be602a64d47d3fb988e166e0474aa5bf317ea", + "size_in_bytes": 229220 + }, + { + "_path": "lib/python3.12/_pyio.py", + "path_type": "hardlink", + "sha256": "0da5fe94519541c16bffd10992dbc2348a80701242b9eae4a21398052b9dd7f9", + "sha256_in_prefix": "0da5fe94519541c16bffd10992dbc2348a80701242b9eae4a21398052b9dd7f9", + "size_in_bytes": 93534 + }, + { + "_path": "lib/python3.12/_pylong.py", + "path_type": "hardlink", + "sha256": "79e219a7d1cab0b3d954fab7937c58ef965a3a132bdb885dda17bbb9fdfab16c", + "sha256_in_prefix": "79e219a7d1cab0b3d954fab7937c58ef965a3a132bdb885dda17bbb9fdfab16c", + "size_in_bytes": 9047 + }, + { + "_path": "lib/python3.12/_sitebuiltins.py", + "path_type": "hardlink", + "sha256": "b9388bc1d6d12ed6be12da420ab1feca40f99c0e33ec315d92b1e01cb69b25bc", + "sha256_in_prefix": "b9388bc1d6d12ed6be12da420ab1feca40f99c0e33ec315d92b1e01cb69b25bc", + "size_in_bytes": 3128 + }, + { + "_path": "lib/python3.12/_strptime.py", + "path_type": "hardlink", + "sha256": "302a4b9cf8fa7511c9142b110601f069fe195fec8217a49de46b340df2eafc32", + "sha256_in_prefix": "302a4b9cf8fa7511c9142b110601f069fe195fec8217a49de46b340df2eafc32", + "size_in_bytes": 24615 + }, + { + "_path": "lib/python3.12/_sysconfigdata__darwin_darwin.py", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/Users/runner/miniforge3/conda-bld/python-split_1708115848844/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placeh", + "sha256": "1dd578aa2ee9724e2c4e83cd0e4f991a4bd4899e613bb18b849f810d77f9c89f", + "sha256_in_prefix": "b81d9c9a98464f486fe81fdaf4fa52aa305218a4df2c179c7a21c040ab5b8d83", + "size_in_bytes": 104810 + }, + { + "_path": "lib/python3.12/_sysconfigdata__darwin_darwin.py.orig", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/Users/runner/miniforge3/conda-bld/python-split_1708115848844/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placeh", + "sha256": "894bee17f1519bbf1b9e5d792e9f55be3b07d0dc59edc5e0ebd12f07cefb40e0", + "sha256_in_prefix": "1fff0c5ab4cf976fe8bac215108cb108784e8e999c1f2895961a49bdf610800f", + "size_in_bytes": 119819 + }, + { + "_path": "lib/python3.12/_sysconfigdata_arm64_apple_darwin20_0_0.py", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/Users/runner/miniforge3/conda-bld/python-split_1708115848844/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placeh", + "sha256": "3cefabcf2fd4eb3eacd2da5585bab82946f74df228c30e59d0e5f82dafe04d49", + "sha256_in_prefix": "a62302673d8a71d473e88ea2b704c18ce4294377b0238f50704141b6a62e2bcc", + "size_in_bytes": 106879 + }, + { + "_path": "lib/python3.12/_threading_local.py", + "path_type": "hardlink", + "sha256": "e1bf3dae66d0bfa63c8bb8a1d10c611203c35c636f7f5191fd56105788ef29cb", + "sha256_in_prefix": "e1bf3dae66d0bfa63c8bb8a1d10c611203c35c636f7f5191fd56105788ef29cb", + "size_in_bytes": 7220 + }, + { + "_path": "lib/python3.12/_weakrefset.py", + "path_type": "hardlink", + "sha256": "91895a451d06e9f521a1171b31b9b19bc9740f35af00d4fa106338ab7167c9ac", + "sha256_in_prefix": "91895a451d06e9f521a1171b31b9b19bc9740f35af00d4fa106338ab7167c9ac", + "size_in_bytes": 5893 + }, + { + "_path": "lib/python3.12/abc.py", + "path_type": "hardlink", + "sha256": "e558702a95cdce3febd289da021715d2b92bc43995b8a1bc58dfa1c3d8010287", + "sha256_in_prefix": "e558702a95cdce3febd289da021715d2b92bc43995b8a1bc58dfa1c3d8010287", + "size_in_bytes": 6538 + }, + { + "_path": "lib/python3.12/aifc.py", + "path_type": "hardlink", + "sha256": "e027e8a33567890ad7f84fea3be423cc0f6e49a33a31bbf279c2d0f64b6f8345", + "sha256_in_prefix": "e027e8a33567890ad7f84fea3be423cc0f6e49a33a31bbf279c2d0f64b6f8345", + "size_in_bytes": 34211 + }, + { + "_path": "lib/python3.12/antigravity.py", + "path_type": "hardlink", + "sha256": "8a5ee63e1b79ba2733e7ff4290b6eefea60e7f3a1ccb6bb519535aaf92b44967", + "sha256_in_prefix": "8a5ee63e1b79ba2733e7ff4290b6eefea60e7f3a1ccb6bb519535aaf92b44967", + "size_in_bytes": 500 + }, + { + "_path": "lib/python3.12/argparse.py", + "path_type": "hardlink", + "sha256": "a2014aea48aa2260b7bafb4c64642da67bdb1dadb47046652c941b30972243a7", + "sha256_in_prefix": "a2014aea48aa2260b7bafb4c64642da67bdb1dadb47046652c941b30972243a7", + "size_in_bytes": 100862 + }, + { + "_path": "lib/python3.12/ast.py", + "path_type": "hardlink", + "sha256": "e1715db349b759971515776f665c2991189c8801340979667a1b1f07f85f0d51", + "sha256_in_prefix": "e1715db349b759971515776f665c2991189c8801340979667a1b1f07f85f0d51", + "size_in_bytes": 64165 + }, + { + "_path": "lib/python3.12/asyncio/__init__.py", + "path_type": "hardlink", + "sha256": "61102f2b5f8fb832f0558cb66391f227970b3dd34ea2a621455587b4295e89a1", + "sha256_in_prefix": "61102f2b5f8fb832f0558cb66391f227970b3dd34ea2a621455587b4295e89a1", + "size_in_bytes": 1220 + }, + { + "_path": "lib/python3.12/asyncio/__main__.py", + "path_type": "hardlink", + "sha256": "eb22d0fa0c480025270feb1e7f962510666287fe2ccaeb7f309d32637507d061", + "sha256_in_prefix": "eb22d0fa0c480025270feb1e7f962510666287fe2ccaeb7f309d32637507d061", + "size_in_bytes": 3343 + }, + { + "_path": "lib/python3.12/asyncio/__pycache__/__init__.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "7a94f1f1eea18902b0d4cd6bef8a50a516120ccfe577ca8a63d52320c55e7c71", + "sha256_in_prefix": "7a94f1f1eea18902b0d4cd6bef8a50a516120ccfe577ca8a63d52320c55e7c71", + "size_in_bytes": 1711 + }, + { + "_path": "lib/python3.12/asyncio/__pycache__/__main__.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "dde86f085b6800b708b26d9bb0f49b29555f94569577b0571ee94d7b2c298957", + "sha256_in_prefix": "dde86f085b6800b708b26d9bb0f49b29555f94569577b0571ee94d7b2c298957", + "size_in_bytes": 5429 + }, + { + "_path": "lib/python3.12/asyncio/__pycache__/base_events.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "11aefa2c2e242bb81f9fea53675e36953a772823ec0632c5eb01dc832d532b3c", + "sha256_in_prefix": "11aefa2c2e242bb81f9fea53675e36953a772823ec0632c5eb01dc832d532b3c", + "size_in_bytes": 86483 + }, + { + "_path": "lib/python3.12/asyncio/__pycache__/base_futures.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "33c8d55c56d9bb7a2858996a2f27d379be9b2031ffcf475bb339892f265e2c12", + "sha256_in_prefix": "33c8d55c56d9bb7a2858996a2f27d379be9b2031ffcf475bb339892f265e2c12", + "size_in_bytes": 3340 + }, + { + "_path": "lib/python3.12/asyncio/__pycache__/base_subprocess.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "32d2ce2692ffc7c3294d99c0070c9f0fc21ff7e499e0d994942de3a35b516d69", + "sha256_in_prefix": "32d2ce2692ffc7c3294d99c0070c9f0fc21ff7e499e0d994942de3a35b516d69", + "size_in_bytes": 16344 + }, + { + "_path": "lib/python3.12/asyncio/__pycache__/base_tasks.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "8911b67a72c354ac53337f321f43b89d2a51fde001a5ea84e1582a8701702475", + "sha256_in_prefix": "8911b67a72c354ac53337f321f43b89d2a51fde001a5ea84e1582a8701702475", + "size_in_bytes": 4341 + }, + { + "_path": "lib/python3.12/asyncio/__pycache__/constants.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "035ed09e0f601ed0897b6b51aa2980ca19c78749906c47edaf2df3b6900650f1", + "sha256_in_prefix": "035ed09e0f601ed0897b6b51aa2980ca19c78749906c47edaf2df3b6900650f1", + "size_in_bytes": 1209 + }, + { + "_path": "lib/python3.12/asyncio/__pycache__/coroutines.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "39b5ab5339bbcaa7c41fb11f3492ff5ec018dc0d91b04321a0322c785634d1af", + "sha256_in_prefix": "39b5ab5339bbcaa7c41fb11f3492ff5ec018dc0d91b04321a0322c785634d1af", + "size_in_bytes": 4020 + }, + { + "_path": "lib/python3.12/asyncio/__pycache__/events.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "0a3519efb71f4fbe2878f5a879a89148edd7ce29df7663d148863157516ac1a2", + "sha256_in_prefix": "0a3519efb71f4fbe2878f5a879a89148edd7ce29df7663d148863157516ac1a2", + "size_in_bytes": 37007 + }, + { + "_path": "lib/python3.12/asyncio/__pycache__/exceptions.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "0030cfa4a095328c41ca76563464d453861eb2b87cd4953b8d91cf8b5b431f5b", + "sha256_in_prefix": "0030cfa4a095328c41ca76563464d453861eb2b87cd4953b8d91cf8b5b431f5b", + "size_in_bytes": 3335 + }, + { + "_path": "lib/python3.12/asyncio/__pycache__/format_helpers.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "625ff2c85d2f2ccde844c7af8d70c29ab788b14862fc69f71b878819530a2079", + "sha256_in_prefix": "625ff2c85d2f2ccde844c7af8d70c29ab788b14862fc69f71b878819530a2079", + "size_in_bytes": 4119 + }, + { + "_path": "lib/python3.12/asyncio/__pycache__/futures.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "f5a7506d3031ac833683a21d32beef65793eb4422839ce414eee8b1a8b7c26d2", + "sha256_in_prefix": "f5a7506d3031ac833683a21d32beef65793eb4422839ce414eee8b1a8b7c26d2", + "size_in_bytes": 17501 + }, + { + "_path": "lib/python3.12/asyncio/__pycache__/locks.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "ac447fd1c9bda1d2203c9d036588e59fc95ccfeeb96647935e0148417c152287", + "sha256_in_prefix": "ac447fd1c9bda1d2203c9d036588e59fc95ccfeeb96647935e0148417c152287", + "size_in_bytes": 27756 + }, + { + "_path": "lib/python3.12/asyncio/__pycache__/log.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "f461e07cbeb05e6b5bcc5ceda0e5de0adf4e959744c8f32894594e842bf5c825", + "sha256_in_prefix": "f461e07cbeb05e6b5bcc5ceda0e5de0adf4e959744c8f32894594e842bf5c825", + "size_in_bytes": 535 + }, + { + "_path": "lib/python3.12/asyncio/__pycache__/mixins.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "94efea023440c556a9fe967115b8c14cb650cf0c4402b71ef62040c19b39cf9a", + "sha256_in_prefix": "94efea023440c556a9fe967115b8c14cb650cf0c4402b71ef62040c19b39cf9a", + "size_in_bytes": 1290 + }, + { + "_path": "lib/python3.12/asyncio/__pycache__/proactor_events.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "540136aeb9ab31ed7a99f7e3d6e7fc01643af36cbccede4c93ad207c8bbd8c80", + "sha256_in_prefix": "540136aeb9ab31ed7a99f7e3d6e7fc01643af36cbccede4c93ad207c8bbd8c80", + "size_in_bytes": 44777 + }, + { + "_path": "lib/python3.12/asyncio/__pycache__/protocols.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "eb4694d439aaffd69e1b4c93828660b7408488e67c6dfc741669bc176d247e44", + "sha256_in_prefix": "eb4694d439aaffd69e1b4c93828660b7408488e67c6dfc741669bc176d247e44", + "size_in_bytes": 9036 + }, + { + "_path": "lib/python3.12/asyncio/__pycache__/queues.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "fa09f286132d584096f8005391313f92a90a043f300d7f8bdba40842094cbe74", + "sha256_in_prefix": "fa09f286132d584096f8005391313f92a90a043f300d7f8bdba40842094cbe74", + "size_in_bytes": 12195 + }, + { + "_path": "lib/python3.12/asyncio/__pycache__/runners.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "045eb5175d197d557cf892accc210e6eac2e14cf5f9b913485a778ee02754676", + "sha256_in_prefix": "045eb5175d197d557cf892accc210e6eac2e14cf5f9b913485a778ee02754676", + "size_in_bytes": 10190 + }, + { + "_path": "lib/python3.12/asyncio/__pycache__/selector_events.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "ee20611d769f889b74905dc8359d7aefa939a5df401aa8dccace960a82e70d50", + "sha256_in_prefix": "ee20611d769f889b74905dc8359d7aefa939a5df401aa8dccace960a82e70d50", + "size_in_bytes": 63326 + }, + { + "_path": "lib/python3.12/asyncio/__pycache__/sslproto.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "8eaec36f92fdd6ab84beb5766b23e23fc034d382311a31cb819f4a001f4ef1f5", + "sha256_in_prefix": "8eaec36f92fdd6ab84beb5766b23e23fc034d382311a31cb819f4a001f4ef1f5", + "size_in_bytes": 41795 + }, + { + "_path": "lib/python3.12/asyncio/__pycache__/staggered.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "12e9aa645b452b4820d4d75ee85e6fb954f871850f90b2bd41133a1fa7284488", + "sha256_in_prefix": "12e9aa645b452b4820d4d75ee85e6fb954f871850f90b2bd41133a1fa7284488", + "size_in_bytes": 6485 + }, + { + "_path": "lib/python3.12/asyncio/__pycache__/streams.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "c7cafb5b43e6bea95247ba0de45290b1880801b9a0ed95ad8e99f5849ae445d0", + "sha256_in_prefix": "c7cafb5b43e6bea95247ba0de45290b1880801b9a0ed95ad8e99f5849ae445d0", + "size_in_bytes": 33619 + }, + { + "_path": "lib/python3.12/asyncio/__pycache__/subprocess.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "8670244a6aaf73bf4a3d0fef0d20613db9f041828bf5b8a5a3c7da3d26055eed", + "sha256_in_prefix": "8670244a6aaf73bf4a3d0fef0d20613db9f041828bf5b8a5a3c7da3d26055eed", + "size_in_bytes": 12348 + }, + { + "_path": "lib/python3.12/asyncio/__pycache__/taskgroups.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "f379b4e3124eae0f726cc6e0f9c4c1d4b191fd5b1b2b77752b4ad85be7564fe2", + "sha256_in_prefix": "f379b4e3124eae0f726cc6e0f9c4c1d4b191fd5b1b2b77752b4ad85be7564fe2", + "size_in_bytes": 8176 + }, + { + "_path": "lib/python3.12/asyncio/__pycache__/tasks.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "714383c35e7595e608bf2b22f6c5f5edd445be4b599553bee3939a41fee499ea", + "sha256_in_prefix": "714383c35e7595e608bf2b22f6c5f5edd445be4b599553bee3939a41fee499ea", + "size_in_bytes": 40619 + }, + { + "_path": "lib/python3.12/asyncio/__pycache__/threads.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "959508947e974246571b68bf9962bb482680b0829c2390873711af7a3543b222", + "sha256_in_prefix": "959508947e974246571b68bf9962bb482680b0829c2390873711af7a3543b222", + "size_in_bytes": 1512 + }, + { + "_path": "lib/python3.12/asyncio/__pycache__/timeouts.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "acb1e0dbacf090ac1ebb0e492f2f666cd9f189a4cb84036c0afd7d1961867096", + "sha256_in_prefix": "acb1e0dbacf090ac1ebb0e492f2f666cd9f189a4cb84036c0afd7d1961867096", + "size_in_bytes": 8045 + }, + { + "_path": "lib/python3.12/asyncio/__pycache__/transports.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "dca56373dcda5e0396040060fab8026a9c9ab6b500db31e06173a7091dd6ae8a", + "sha256_in_prefix": "dca56373dcda5e0396040060fab8026a9c9ab6b500db31e06173a7091dd6ae8a", + "size_in_bytes": 14255 + }, + { + "_path": "lib/python3.12/asyncio/__pycache__/trsock.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "98597f8ba6a5b0f7ce398f4a6fb902aa13aa7058c9a565b0b5ac85d26178ce49", + "sha256_in_prefix": "98597f8ba6a5b0f7ce398f4a6fb902aa13aa7058c9a565b0b5ac85d26178ce49", + "size_in_bytes": 5333 + }, + { + "_path": "lib/python3.12/asyncio/__pycache__/unix_events.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "091e1319a058017712fee791b8d2b1b418b775074adf34c50de3e47477f7a4a0", + "sha256_in_prefix": "091e1319a058017712fee791b8d2b1b418b775074adf34c50de3e47477f7a4a0", + "size_in_bytes": 68041 + }, + { + "_path": "lib/python3.12/asyncio/__pycache__/windows_events.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "a6d5e0077a1ad16a3e2a65316bffced7638d1586a40f10ee1e32c1ba3702b219", + "sha256_in_prefix": "a6d5e0077a1ad16a3e2a65316bffced7638d1586a40f10ee1e32c1ba3702b219", + "size_in_bytes": 41499 + }, + { + "_path": "lib/python3.12/asyncio/__pycache__/windows_utils.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "68a966863133562bb0a838d6e8465115846fa453cf7b1163b2e6ecc0e44bba84", + "sha256_in_prefix": "68a966863133562bb0a838d6e8465115846fa453cf7b1163b2e6ecc0e44bba84", + "size_in_bytes": 7586 + }, + { + "_path": "lib/python3.12/asyncio/base_events.py", + "path_type": "hardlink", + "sha256": "db26f1196c8be9a4a6dd78cf3ed883f18c9a7a59523e4da63bff417df0ee6c90", + "sha256_in_prefix": "db26f1196c8be9a4a6dd78cf3ed883f18c9a7a59523e4da63bff417df0ee6c90", + "size_in_bytes": 77816 + }, + { + "_path": "lib/python3.12/asyncio/base_futures.py", + "path_type": "hardlink", + "sha256": "2f3798c4b82f5ac77647908b157c924f734f36871d98970e72849ea9a9a07856", + "sha256_in_prefix": "2f3798c4b82f5ac77647908b157c924f734f36871d98970e72849ea9a9a07856", + "size_in_bytes": 1974 + }, + { + "_path": "lib/python3.12/asyncio/base_subprocess.py", + "path_type": "hardlink", + "sha256": "d69ba8f97bf8c89564cadce49427574ddb98103a5db6f04b98798240332e7adf", + "sha256_in_prefix": "d69ba8f97bf8c89564cadce49427574ddb98103a5db6f04b98798240332e7adf", + "size_in_bytes": 8869 + }, + { + "_path": "lib/python3.12/asyncio/base_tasks.py", + "path_type": "hardlink", + "sha256": "56efac65b63db927af336fa55eb5bda93c97a2defa4734ea8d695ed20fd6712a", + "sha256_in_prefix": "56efac65b63db927af336fa55eb5bda93c97a2defa4734ea8d695ed20fd6712a", + "size_in_bytes": 2672 + }, + { + "_path": "lib/python3.12/asyncio/constants.py", + "path_type": "hardlink", + "sha256": "873fc2f9e66313c3c19c337269e704f204b59f9e91d6ecbec59f68335484d338", + "sha256_in_prefix": "873fc2f9e66313c3c19c337269e704f204b59f9e91d6ecbec59f68335484d338", + "size_in_bytes": 1413 + }, + { + "_path": "lib/python3.12/asyncio/coroutines.py", + "path_type": "hardlink", + "sha256": "2feec17557c230a80cc2a6391bbb1c44b9f3341820b05667e36a4eb12b749436", + "sha256_in_prefix": "2feec17557c230a80cc2a6391bbb1c44b9f3341820b05667e36a4eb12b749436", + "size_in_bytes": 3342 + }, + { + "_path": "lib/python3.12/asyncio/events.py", + "path_type": "hardlink", + "sha256": "6a18b7eee5926622c146e61a7eb39726b4656e07ca41d36b06936ffb2354f0ed", + "sha256_in_prefix": "6a18b7eee5926622c146e61a7eb39726b4656e07ca41d36b06936ffb2354f0ed", + "size_in_bytes": 29339 + }, + { + "_path": "lib/python3.12/asyncio/exceptions.py", + "path_type": "hardlink", + "sha256": "a5971f88be14cd1417d59adf539ae48c5d818f95362a4e0eb00017e3690ab37b", + "sha256_in_prefix": "a5971f88be14cd1417d59adf539ae48c5d818f95362a4e0eb00017e3690ab37b", + "size_in_bytes": 1752 + }, + { + "_path": "lib/python3.12/asyncio/format_helpers.py", + "path_type": "hardlink", + "sha256": "6377b672b3f4ba8b6f0f7a5f0ea00cde24c8cddc0ca764e3329f302763477f59", + "sha256_in_prefix": "6377b672b3f4ba8b6f0f7a5f0ea00cde24c8cddc0ca764e3329f302763477f59", + "size_in_bytes": 2404 + }, + { + "_path": "lib/python3.12/asyncio/futures.py", + "path_type": "hardlink", + "sha256": "7308533f98987fd96acb2cef27d16e2b05ff3efad406db4b0d4d39a2a8f6971d", + "sha256_in_prefix": "7308533f98987fd96acb2cef27d16e2b05ff3efad406db4b0d4d39a2a8f6971d", + "size_in_bytes": 14210 + }, + { + "_path": "lib/python3.12/asyncio/locks.py", + "path_type": "hardlink", + "sha256": "808bece72e0a4c6ab34299ffe555c927a8db475066ce8dc4ba614588fff720db", + "sha256_in_prefix": "808bece72e0a4c6ab34299ffe555c927a8db475066ce8dc4ba614588fff720db", + "size_in_bytes": 18994 + }, + { + "_path": "lib/python3.12/asyncio/log.py", + "path_type": "hardlink", + "sha256": "80e4cc3ded4b138baba486519e7444801a23d6ac35f229d336a407a96af7e8d2", + "sha256_in_prefix": "80e4cc3ded4b138baba486519e7444801a23d6ac35f229d336a407a96af7e8d2", + "size_in_bytes": 124 + }, + { + "_path": "lib/python3.12/asyncio/mixins.py", + "path_type": "hardlink", + "sha256": "8f4a3e16eca845ebfba422550cbcee7340ec8166d2bff6b750a8ed0de6b9ae3c", + "sha256_in_prefix": "8f4a3e16eca845ebfba422550cbcee7340ec8166d2bff6b750a8ed0de6b9ae3c", + "size_in_bytes": 481 + }, + { + "_path": "lib/python3.12/asyncio/proactor_events.py", + "path_type": "hardlink", + "sha256": "199d554fda7ec1a7e6a53e78f3f00f6e84dff27f0ed74107846d63106c895955", + "sha256_in_prefix": "199d554fda7ec1a7e6a53e78f3f00f6e84dff27f0ed74107846d63106c895955", + "size_in_bytes": 33385 + }, + { + "_path": "lib/python3.12/asyncio/protocols.py", + "path_type": "hardlink", + "sha256": "1d1b49988c338b4ef06e30f9e92d9db2e00080c341f0a3f573bb8312deb8aff6", + "sha256_in_prefix": "1d1b49988c338b4ef06e30f9e92d9db2e00080c341f0a3f573bb8312deb8aff6", + "size_in_bytes": 6957 + }, + { + "_path": "lib/python3.12/asyncio/queues.py", + "path_type": "hardlink", + "sha256": "8f020744ebd1f557dcb051a1530b504447660df906c2127a94bbcc8450ea7ef9", + "sha256_in_prefix": "8f020744ebd1f557dcb051a1530b504447660df906c2127a94bbcc8450ea7ef9", + "size_in_bytes": 7974 + }, + { + "_path": "lib/python3.12/asyncio/runners.py", + "path_type": "hardlink", + "sha256": "005535b70acf976133dda890b7c7f9076401fd7b532afeb27a1a68e863219072", + "sha256_in_prefix": "005535b70acf976133dda890b7c7f9076401fd7b532afeb27a1a68e863219072", + "size_in_bytes": 7159 + }, + { + "_path": "lib/python3.12/asyncio/selector_events.py", + "path_type": "hardlink", + "sha256": "a32d9cc6afcc03d3004ce07379cc1875f749111d2e3478e59260a3b82256b9b6", + "sha256_in_prefix": "a32d9cc6afcc03d3004ce07379cc1875f749111d2e3478e59260a3b82256b9b6", + "size_in_bytes": 48241 + }, + { + "_path": "lib/python3.12/asyncio/sslproto.py", + "path_type": "hardlink", + "sha256": "c747273038c3d27d0447f84eace19faf6c0e2730a0aa89639f9a40af41b5d180", + "sha256_in_prefix": "c747273038c3d27d0447f84eace19faf6c0e2730a0aa89639f9a40af41b5d180", + "size_in_bytes": 31739 + }, + { + "_path": "lib/python3.12/asyncio/staggered.py", + "path_type": "hardlink", + "sha256": "ff289bdc20a50ad9620393479d785bc653e71c2e3298f53ab27907cd136498e9", + "sha256_in_prefix": "ff289bdc20a50ad9620393479d785bc653e71c2e3298f53ab27907cd136498e9", + "size_in_bytes": 5992 + }, + { + "_path": "lib/python3.12/asyncio/streams.py", + "path_type": "hardlink", + "sha256": "6ec5c70fd95b0d51cc1e81cd21e8abe8c1b69650148d6bb75ab4aa4797319bd4", + "sha256_in_prefix": "6ec5c70fd95b0d51cc1e81cd21e8abe8c1b69650148d6bb75ab4aa4797319bd4", + "size_in_bytes": 27619 + }, + { + "_path": "lib/python3.12/asyncio/subprocess.py", + "path_type": "hardlink", + "sha256": "7b70605716334f63cc482123b2aaa3b7c5bb7138eeab63a037bd8068d43307c1", + "sha256_in_prefix": "7b70605716334f63cc482123b2aaa3b7c5bb7138eeab63a037bd8068d43307c1", + "size_in_bytes": 7737 + }, + { + "_path": "lib/python3.12/asyncio/taskgroups.py", + "path_type": "hardlink", + "sha256": "04895039b4870219ba5b94d42f3dccf996b4bf26108a54c47f30326eae4af0cc", + "sha256_in_prefix": "04895039b4870219ba5b94d42f3dccf996b4bf26108a54c47f30326eae4af0cc", + "size_in_bytes": 8747 + }, + { + "_path": "lib/python3.12/asyncio/tasks.py", + "path_type": "hardlink", + "sha256": "6efe02c08631e9ef52066c2edd4b575257b7b902c196d2831de838f2170a41ef", + "sha256_in_prefix": "6efe02c08631e9ef52066c2edd4b575257b7b902c196d2831de838f2170a41ef", + "size_in_bytes": 37361 + }, + { + "_path": "lib/python3.12/asyncio/threads.py", + "path_type": "hardlink", + "sha256": "39d37295383641565f0c08bd992e2f661dc8051eb17e890b834fce96bde0910e", + "sha256_in_prefix": "39d37295383641565f0c08bd992e2f661dc8051eb17e890b834fce96bde0910e", + "size_in_bytes": 790 + }, + { + "_path": "lib/python3.12/asyncio/timeouts.py", + "path_type": "hardlink", + "sha256": "3e40ca0dca3e54776579797837cd4936d73d04aae09fe0cf83ce1e5449d00163", + "sha256_in_prefix": "3e40ca0dca3e54776579797837cd4936d73d04aae09fe0cf83ce1e5449d00163", + "size_in_bytes": 5321 + }, + { + "_path": "lib/python3.12/asyncio/transports.py", + "path_type": "hardlink", + "sha256": "940108bc133de399f38928cad3274f463096168d8a3ee5148f2478d3cb636f1c", + "sha256_in_prefix": "940108bc133de399f38928cad3274f463096168d8a3ee5148f2478d3cb636f1c", + "size_in_bytes": 10722 + }, + { + "_path": "lib/python3.12/asyncio/trsock.py", + "path_type": "hardlink", + "sha256": "c0eac37debcc51b702b808f6b7ed3e417343f5ff5f57125dad600a27eb082328", + "sha256_in_prefix": "c0eac37debcc51b702b808f6b7ed3e417343f5ff5f57125dad600a27eb082328", + "size_in_bytes": 2475 + }, + { + "_path": "lib/python3.12/asyncio/unix_events.py", + "path_type": "hardlink", + "sha256": "1fff06cce78763800f05f4d2bebfcdbc07ebf9564ca7e7222e0d91e39dee08c9", + "sha256_in_prefix": "1fff06cce78763800f05f4d2bebfcdbc07ebf9564ca7e7222e0d91e39dee08c9", + "size_in_bytes": 53124 + }, + { + "_path": "lib/python3.12/asyncio/windows_events.py", + "path_type": "hardlink", + "sha256": "c4c30238bda9e8abde7b677117117cc2531931237dc720983f520748ac6dbb51", + "sha256_in_prefix": "c4c30238bda9e8abde7b677117117cc2531931237dc720983f520748ac6dbb51", + "size_in_bytes": 32252 + }, + { + "_path": "lib/python3.12/asyncio/windows_utils.py", + "path_type": "hardlink", + "sha256": "e6fcffefa2521666bc2aed0f5caf8e862c1c1014ad12d2ab5fbce09c2df9c6f0", + "sha256_in_prefix": "e6fcffefa2521666bc2aed0f5caf8e862c1c1014ad12d2ab5fbce09c2df9c6f0", + "size_in_bytes": 5060 + }, + { + "_path": "lib/python3.12/base64.py", + "path_type": "hardlink", + "sha256": "8a07aa038a9a36984d07a6703aea20a477477fdd4f24dc2c8763e493adca653b", + "sha256_in_prefix": "8a07aa038a9a36984d07a6703aea20a477477fdd4f24dc2c8763e493adca653b", + "size_in_bytes": 20603 + }, + { + "_path": "lib/python3.12/bdb.py", + "path_type": "hardlink", + "sha256": "314d8bf11b4824d47471ad25dab64bda895e39673fb744e88e7f622a3dd374f2", + "sha256_in_prefix": "314d8bf11b4824d47471ad25dab64bda895e39673fb744e88e7f622a3dd374f2", + "size_in_bytes": 32463 + }, + { + "_path": "lib/python3.12/bisect.py", + "path_type": "hardlink", + "sha256": "f1cf7b85fc36b5da249813fc5ab97d9464f8cc1bc817f7146206fa2713e35999", + "sha256_in_prefix": "f1cf7b85fc36b5da249813fc5ab97d9464f8cc1bc817f7146206fa2713e35999", + "size_in_bytes": 3423 + }, + { + "_path": "lib/python3.12/bz2.py", + "path_type": "hardlink", + "sha256": "76ab3252924e71e859d7d90e8d3db13b6554975cfcac0fdadced4de7f8779330", + "sha256_in_prefix": "76ab3252924e71e859d7d90e8d3db13b6554975cfcac0fdadced4de7f8779330", + "size_in_bytes": 11847 + }, + { + "_path": "lib/python3.12/cProfile.py", + "path_type": "hardlink", + "sha256": "c4c3edb84862431dffd6c044f5c02bb27f94e5b79a708bce195a7981efcb43bc", + "sha256_in_prefix": "c4c3edb84862431dffd6c044f5c02bb27f94e5b79a708bce195a7981efcb43bc", + "size_in_bytes": 6556 + }, + { + "_path": "lib/python3.12/calendar.py", + "path_type": "hardlink", + "sha256": "fb3fbcc0a0c8f33941153c425e5c39aedae687c86fcb001bf3a9526a9584459c", + "sha256_in_prefix": "fb3fbcc0a0c8f33941153c425e5c39aedae687c86fcb001bf3a9526a9584459c", + "size_in_bytes": 25418 + }, + { + "_path": "lib/python3.12/cgi.py", + "path_type": "hardlink", + "sha256": "f132666784c29a3e275f50596f87bb8abc388a94fcdb70be130000e01a9a6b78", + "sha256_in_prefix": "f132666784c29a3e275f50596f87bb8abc388a94fcdb70be130000e01a9a6b78", + "size_in_bytes": 34420 + }, + { + "_path": "lib/python3.12/cgitb.py", + "path_type": "hardlink", + "sha256": "08bbcca13a431551da73a2144c13f21e68cb79ac82223fbe5e60fcf89ce10f9c", + "sha256_in_prefix": "08bbcca13a431551da73a2144c13f21e68cb79ac82223fbe5e60fcf89ce10f9c", + "size_in_bytes": 12421 + }, + { + "_path": "lib/python3.12/chunk.py", + "path_type": "hardlink", + "sha256": "4817eb94eeb8835c3325433f68f17e0ebbf7c96065ecf6aba3af7852f9a5314b", + "sha256_in_prefix": "4817eb94eeb8835c3325433f68f17e0ebbf7c96065ecf6aba3af7852f9a5314b", + "size_in_bytes": 5500 + }, + { + "_path": "lib/python3.12/cmd.py", + "path_type": "hardlink", + "sha256": "fb82a8c4e44e5b559c88d516d79051534cec69a463df97defe05ac8a261f0a0d", + "sha256_in_prefix": "fb82a8c4e44e5b559c88d516d79051534cec69a463df97defe05ac8a261f0a0d", + "size_in_bytes": 14873 + }, + { + "_path": "lib/python3.12/code.py", + "path_type": "hardlink", + "sha256": "b191c6d6190382bcbb2826d7faf5521479abd733deb25d3cf3fba879b65b6953", + "sha256_in_prefix": "b191c6d6190382bcbb2826d7faf5521479abd733deb25d3cf3fba879b65b6953", + "size_in_bytes": 10695 + }, + { + "_path": "lib/python3.12/codecs.py", + "path_type": "hardlink", + "sha256": "7b7839e53a77961153240aecfe11edc8054d05b1dedd83894450dae21ec05785", + "sha256_in_prefix": "7b7839e53a77961153240aecfe11edc8054d05b1dedd83894450dae21ec05785", + "size_in_bytes": 36870 + }, + { + "_path": "lib/python3.12/codeop.py", + "path_type": "hardlink", + "sha256": "3fb545862a1f9030c0d8f1ae6c72457d14a26d67a9b45de455e49900ff84a3a9", + "sha256_in_prefix": "3fb545862a1f9030c0d8f1ae6c72457d14a26d67a9b45de455e49900ff84a3a9", + "size_in_bytes": 5908 + }, + { + "_path": "lib/python3.12/collections/__init__.py", + "path_type": "hardlink", + "sha256": "d298975e5069d5944316e45d80fa68b495baccba504eb877a5ca3b0200c2b4a8", + "sha256_in_prefix": "d298975e5069d5944316e45d80fa68b495baccba504eb877a5ca3b0200c2b4a8", + "size_in_bytes": 52379 + }, + { + "_path": "lib/python3.12/collections/__pycache__/__init__.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "2b4f3ff2fa9d2c67a14317259ab8ab4dc373dabb53b8af83291c9a6449c3f29c", + "sha256_in_prefix": "2b4f3ff2fa9d2c67a14317259ab8ab4dc373dabb53b8af83291c9a6449c3f29c", + "size_in_bytes": 73344 + }, + { + "_path": "lib/python3.12/collections/__pycache__/abc.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "a6d6ff8424309327792c299d4d2bd92cae50068be93a607b7a86eb01633e9220", + "sha256_in_prefix": "a6d6ff8424309327792c299d4d2bd92cae50068be93a607b7a86eb01633e9220", + "size_in_bytes": 503 + }, + { + "_path": "lib/python3.12/collections/abc.py", + "path_type": "hardlink", + "sha256": "9cb4208f99128a0489b6c8e6c61637617dd7d4250c59e065491957eda084dd10", + "sha256_in_prefix": "9cb4208f99128a0489b6c8e6c61637617dd7d4250c59e065491957eda084dd10", + "size_in_bytes": 119 + }, + { + "_path": "lib/python3.12/colorsys.py", + "path_type": "hardlink", + "sha256": "d9800f8e81d46e63ca6f2e7d6ac5f344d85afb92c3cf6d103b5f977f1ad66ac2", + "sha256_in_prefix": "d9800f8e81d46e63ca6f2e7d6ac5f344d85afb92c3cf6d103b5f977f1ad66ac2", + "size_in_bytes": 4062 + }, + { + "_path": "lib/python3.12/compileall.py", + "path_type": "hardlink", + "sha256": "588f003bb5088ce380f3c335febaec1318811d275e5554b106655c4ceebabcfb", + "sha256_in_prefix": "588f003bb5088ce380f3c335febaec1318811d275e5554b106655c4ceebabcfb", + "size_in_bytes": 20507 + }, + { + "_path": "lib/python3.12/concurrent/__init__.py", + "path_type": "hardlink", + "sha256": "87ad5c8954dd56fbbca04517bf87477ff4dce575170c7dd1281d7ef1f4214ac8", + "sha256_in_prefix": "87ad5c8954dd56fbbca04517bf87477ff4dce575170c7dd1281d7ef1f4214ac8", + "size_in_bytes": 38 + }, + { + "_path": "lib/python3.12/concurrent/__pycache__/__init__.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "e49226863ba5eb750ea4b6497d16acad455c9293afe11bba90112d418981439b", + "sha256_in_prefix": "e49226863ba5eb750ea4b6497d16acad455c9293afe11bba90112d418981439b", + "size_in_bytes": 393 + }, + { + "_path": "lib/python3.12/concurrent/futures/__init__.py", + "path_type": "hardlink", + "sha256": "9bcec785db3eddc6d462883957ba6d3ff4370501fece505101444bae542883e8", + "sha256_in_prefix": "9bcec785db3eddc6d462883957ba6d3ff4370501fece505101444bae542883e8", + "size_in_bytes": 1558 + }, + { + "_path": "lib/python3.12/concurrent/futures/__pycache__/__init__.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "01dca458394e1947f257face60fc7bd7931afb85d45cf04f27b927b80b4a6bda", + "sha256_in_prefix": "01dca458394e1947f257face60fc7bd7931afb85d45cf04f27b927b80b4a6bda", + "size_in_bytes": 1504 + }, + { + "_path": "lib/python3.12/concurrent/futures/__pycache__/_base.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "f86b883e67bcb2eb69cd90fa0c9fb1a264a6548733cbc4a9955fc5a36152a91e", + "sha256_in_prefix": "f86b883e67bcb2eb69cd90fa0c9fb1a264a6548733cbc4a9955fc5a36152a91e", + "size_in_bytes": 32442 + }, + { + "_path": "lib/python3.12/concurrent/futures/__pycache__/process.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "112c83715590753541e70762d6a386eefa405482b7bb588834e20a08113722ab", + "sha256_in_prefix": "112c83715590753541e70762d6a386eefa405482b7bb588834e20a08113722ab", + "size_in_bytes": 35982 + }, + { + "_path": "lib/python3.12/concurrent/futures/__pycache__/thread.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "d9b2b9b432d1a6e82c4c8b785ba51fcfef7c30c059c27bea69270ffeded7f0d1", + "sha256_in_prefix": "d9b2b9b432d1a6e82c4c8b785ba51fcfef7c30c059c27bea69270ffeded7f0d1", + "size_in_bytes": 10455 + }, + { + "_path": "lib/python3.12/concurrent/futures/_base.py", + "path_type": "hardlink", + "sha256": "8c6d5f09f7c535d40fa1c30ebfcb35e0601c2abf32286a82cf151af7ddf72473", + "sha256_in_prefix": "8c6d5f09f7c535d40fa1c30ebfcb35e0601c2abf32286a82cf151af7ddf72473", + "size_in_bytes": 22833 + }, + { + "_path": "lib/python3.12/concurrent/futures/process.py", + "path_type": "hardlink", + "sha256": "d902a4365e8380d839b2dda00419e286b6d292ca17a00a56bee7b7dac8ad5aa7", + "sha256_in_prefix": "d902a4365e8380d839b2dda00419e286b6d292ca17a00a56bee7b7dac8ad5aa7", + "size_in_bytes": 36351 + }, + { + "_path": "lib/python3.12/concurrent/futures/thread.py", + "path_type": "hardlink", + "sha256": "33f69dd18c908992bce91ad3aa6bd809a42684e2b66caaa09ad4934ca0a29f58", + "sha256_in_prefix": "33f69dd18c908992bce91ad3aa6bd809a42684e2b66caaa09ad4934ca0a29f58", + "size_in_bytes": 8884 + }, + { + "_path": "lib/python3.12/config-3.12-darwin/Makefile", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/Users/runner/miniforge3/conda-bld/python-split_1708115848844/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placeh", + "sha256": "18968ebc96637010caadc2dafd0c40b9927a729fcba4b55373ee75ecf600dd31", + "sha256_in_prefix": "1ab71a3962ea808b5700f43346425d154977779b0206132c9d4c643c69b04c5f", + "size_in_bytes": 195578 + }, + { + "_path": "lib/python3.12/config-3.12-darwin/Setup", + "path_type": "hardlink", + "sha256": "17c83234ffe6302e7eaf62a363571fe6cc240b8b97bed7e503b85429fd10a5ca", + "sha256_in_prefix": "17c83234ffe6302e7eaf62a363571fe6cc240b8b97bed7e503b85429fd10a5ca", + "size_in_bytes": 11525 + }, + { + "_path": "lib/python3.12/config-3.12-darwin/Setup.bootstrap", + "path_type": "hardlink", + "sha256": "2917936af36bd7d641c737f72f68599fd13c26a28faebba7c07799879b1b9b31", + "sha256_in_prefix": "2917936af36bd7d641c737f72f68599fd13c26a28faebba7c07799879b1b9b31", + "size_in_bytes": 902 + }, + { + "_path": "lib/python3.12/config-3.12-darwin/Setup.local", + "path_type": "hardlink", + "sha256": "d29e734b34f3f8cb4a8c2b9305b6e7f378214ecd13928f2671db2c7ee0f7b378", + "sha256_in_prefix": "d29e734b34f3f8cb4a8c2b9305b6e7f378214ecd13928f2671db2c7ee0f7b378", + "size_in_bytes": 41 + }, + { + "_path": "lib/python3.12/config-3.12-darwin/Setup.stdlib", + "path_type": "hardlink", + "sha256": "cf8d0a99bb7be92fe01b8855a2a5612f5f321505661dff833401bd71c89330ee", + "sha256_in_prefix": "cf8d0a99bb7be92fe01b8855a2a5612f5f321505661dff833401bd71c89330ee", + "size_in_bytes": 6291 + }, + { + "_path": "lib/python3.12/config-3.12-darwin/__pycache__/python-config.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "ddcfd3d916451927c2d0c73c4fd85ba82831356931ee3f142316de6e688948cd", + "sha256_in_prefix": "ddcfd3d916451927c2d0c73c4fd85ba82831356931ee3f142316de6e688948cd", + "size_in_bytes": 3425 + }, + { + "_path": "lib/python3.12/config-3.12-darwin/config.c", + "path_type": "hardlink", + "sha256": "6b067dc2a1b43c7cf78fca8effe0e59560f3572cc4c97e911d9cd7719f0a8c2f", + "sha256_in_prefix": "6b067dc2a1b43c7cf78fca8effe0e59560f3572cc4c97e911d9cd7719f0a8c2f", + "size_in_bytes": 3477 + }, + { + "_path": "lib/python3.12/config-3.12-darwin/config.c.in", + "path_type": "hardlink", + "sha256": "5c76ef60a799f420b09b047dc1087728e5ed08ba82f6c7664c4d4f1d1d715b21", + "sha256_in_prefix": "5c76ef60a799f420b09b047dc1087728e5ed08ba82f6c7664c4d4f1d1d715b21", + "size_in_bytes": 1752 + }, + { + "_path": "lib/python3.12/config-3.12-darwin/install-sh", + "path_type": "hardlink", + "sha256": "3d7488bebd0cfc9b5c440c55d5b44f1c6e2e3d3e19894821bae4a27f9307f1d2", + "sha256_in_prefix": "3d7488bebd0cfc9b5c440c55d5b44f1c6e2e3d3e19894821bae4a27f9307f1d2", + "size_in_bytes": 15358 + }, + { + "_path": "lib/python3.12/config-3.12-darwin/makesetup", + "path_type": "hardlink", + "sha256": "0615264cbe9f3a4fce27de0054839ea814f2fe6f6091a0e17b18b5b15c665cfa", + "sha256_in_prefix": "0615264cbe9f3a4fce27de0054839ea814f2fe6f6091a0e17b18b5b15c665cfa", + "size_in_bytes": 9312 + }, + { + "_path": "lib/python3.12/config-3.12-darwin/python-config.py", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/Users/runner/miniforge3/conda-bld/python-split_1708115848844/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placeh", + "sha256": "d0ca9f1b59946e9c206eae18ff42521af18ada070a568d534c2e5f3ff4fe9598", + "sha256_in_prefix": "f0fbf2d550f63d4b6ca56d2609a89cb6647c71894010636fc6ddd305fd1c7cfb", + "size_in_bytes": 2289 + }, + { + "_path": "lib/python3.12/config-3.12-darwin/python.o", + "path_type": "hardlink", + "sha256": "04422f2f211798d0f48494358baf5fd99fb4cd20148e553cc9ff793f13a895bb", + "sha256_in_prefix": "04422f2f211798d0f48494358baf5fd99fb4cd20148e553cc9ff793f13a895bb", + "size_in_bytes": 2864 + }, + { + "_path": "lib/python3.12/configparser.py", + "path_type": "hardlink", + "sha256": "6a16889607e4e5eec6d8b336377417e70dd4ad3e944eb808d82a8145e428b145", + "sha256_in_prefix": "6a16889607e4e5eec6d8b336377417e70dd4ad3e944eb808d82a8145e428b145", + "size_in_bytes": 53383 + }, + { + "_path": "lib/python3.12/contextlib.py", + "path_type": "hardlink", + "sha256": "8b7a477f978a8532852fd81e241c78182516bc4975d672d580a5848a76e11eb6", + "sha256_in_prefix": "8b7a477f978a8532852fd81e241c78182516bc4975d672d580a5848a76e11eb6", + "size_in_bytes": 27637 + }, + { + "_path": "lib/python3.12/contextvars.py", + "path_type": "hardlink", + "sha256": "5ed260be8d1f4fe92261b7810b4bb1e8539c42093d7493f677d076e1a87f459a", + "sha256_in_prefix": "5ed260be8d1f4fe92261b7810b4bb1e8539c42093d7493f677d076e1a87f459a", + "size_in_bytes": 129 + }, + { + "_path": "lib/python3.12/copy.py", + "path_type": "hardlink", + "sha256": "cbd25547933176fcf6bb05c2adc9f4796d15ac20b9b82dcf890daea7203daeab", + "sha256_in_prefix": "cbd25547933176fcf6bb05c2adc9f4796d15ac20b9b82dcf890daea7203daeab", + "size_in_bytes": 8412 + }, + { + "_path": "lib/python3.12/copyreg.py", + "path_type": "hardlink", + "sha256": "c8eda41f05c6bf95a4da4726a530409d2485ae060b8d019b3a8034389a15d3e9", + "sha256_in_prefix": "c8eda41f05c6bf95a4da4726a530409d2485ae060b8d019b3a8034389a15d3e9", + "size_in_bytes": 7614 + }, + { + "_path": "lib/python3.12/crypt.py", + "path_type": "hardlink", + "sha256": "208df2ff33c19056345dcf5474abef1a58da799e2f3bab09d1d28b77ad3c623d", + "sha256_in_prefix": "208df2ff33c19056345dcf5474abef1a58da799e2f3bab09d1d28b77ad3c623d", + "size_in_bytes": 3913 + }, + { + "_path": "lib/python3.12/csv.py", + "path_type": "hardlink", + "sha256": "46004923196e98a67f87d30da64d070027c81f144f5ac91242fbfae33507dda8", + "sha256_in_prefix": "46004923196e98a67f87d30da64d070027c81f144f5ac91242fbfae33507dda8", + "size_in_bytes": 16386 + }, + { + "_path": "lib/python3.12/ctypes/__init__.py", + "path_type": "hardlink", + "sha256": "0782592567ad71097198a3afe985ac3e2ea0b9b5e75452402c9460c89a86318a", + "sha256_in_prefix": "0782592567ad71097198a3afe985ac3e2ea0b9b5e75452402c9460c89a86318a", + "size_in_bytes": 18182 + }, + { + "_path": "lib/python3.12/ctypes/__pycache__/__init__.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "0b13e28a4e9e2ab6835d7ea8c534a90fdd88ebb2c36082a3098931d1065d4581", + "sha256_in_prefix": "0b13e28a4e9e2ab6835d7ea8c534a90fdd88ebb2c36082a3098931d1065d4581", + "size_in_bytes": 23703 + }, + { + "_path": "lib/python3.12/ctypes/__pycache__/_aix.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "5eaab93f3287d337de44cdd5b977c23330c57e908f05217f88814091951149e7", + "sha256_in_prefix": "5eaab93f3287d337de44cdd5b977c23330c57e908f05217f88814091951149e7", + "size_in_bytes": 12605 + }, + { + "_path": "lib/python3.12/ctypes/__pycache__/_endian.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "f508706abda0fa08c4537a6c28f4c7e2e36be1dac0f09dbd347e635764900348", + "sha256_in_prefix": "f508706abda0fa08c4537a6c28f4c7e2e36be1dac0f09dbd347e635764900348", + "size_in_bytes": 3634 + }, + { + "_path": "lib/python3.12/ctypes/__pycache__/util.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "27e00bbddca19a763ac01efe11aff479d25b203a37d81b5f157ff324b4f9007d", + "sha256_in_prefix": "27e00bbddca19a763ac01efe11aff479d25b203a37d81b5f157ff324b4f9007d", + "size_in_bytes": 17503 + }, + { + "_path": "lib/python3.12/ctypes/__pycache__/wintypes.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "75694d23ef8c0e7a4dccf7342a7eee9baa67e77079584355f5f383cf492f86b2", + "sha256_in_prefix": "75694d23ef8c0e7a4dccf7342a7eee9baa67e77079584355f5f383cf492f86b2", + "size_in_bytes": 8749 + }, + { + "_path": "lib/python3.12/ctypes/_aix.py", + "path_type": "hardlink", + "sha256": "540e2821fa36981bde5c6ffb8f972474b06db4a37c1854c0e0e379b75d2b0fa3", + "sha256_in_prefix": "540e2821fa36981bde5c6ffb8f972474b06db4a37c1854c0e0e379b75d2b0fa3", + "size_in_bytes": 12505 + }, + { + "_path": "lib/python3.12/ctypes/_endian.py", + "path_type": "hardlink", + "sha256": "c5d692bdce10dfee242752620061bab684633bc72445a3def484961ef1bdbf3a", + "sha256_in_prefix": "c5d692bdce10dfee242752620061bab684633bc72445a3def484961ef1bdbf3a", + "size_in_bytes": 2535 + }, + { + "_path": "lib/python3.12/ctypes/macholib/README.ctypes", + "path_type": "hardlink", + "sha256": "dc29d1da83b6a0a09a41647e4111eee878ed079c2d6b54a98fd6d8b88dd581f2", + "sha256_in_prefix": "dc29d1da83b6a0a09a41647e4111eee878ed079c2d6b54a98fd6d8b88dd581f2", + "size_in_bytes": 296 + }, + { + "_path": "lib/python3.12/ctypes/macholib/__init__.py", + "path_type": "hardlink", + "sha256": "1e77c01eec8f167ed10b754f153c0c743c8e5196ae9c81dffc08f129ab56dbfd", + "sha256_in_prefix": "1e77c01eec8f167ed10b754f153c0c743c8e5196ae9c81dffc08f129ab56dbfd", + "size_in_bytes": 154 + }, + { + "_path": "lib/python3.12/ctypes/macholib/__pycache__/__init__.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "fdbc6a702ec04a1d30fd647c42c6bf79a6db1aa67e09ca601d3f2d42be1d92b4", + "sha256_in_prefix": "fdbc6a702ec04a1d30fd647c42c6bf79a6db1aa67e09ca601d3f2d42be1d92b4", + "size_in_bytes": 570 + }, + { + "_path": "lib/python3.12/ctypes/macholib/__pycache__/dyld.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "5085f76c7e5869f9d5d8d88008a30912634268e87721b5c7ee4008935a91f67b", + "sha256_in_prefix": "5085f76c7e5869f9d5d8d88008a30912634268e87721b5c7ee4008935a91f67b", + "size_in_bytes": 7232 + }, + { + "_path": "lib/python3.12/ctypes/macholib/__pycache__/dylib.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "b9688c779d516c51c1140fd5a934cbfc9d75b643b19fb4e326586117d39f51f9", + "sha256_in_prefix": "b9688c779d516c51c1140fd5a934cbfc9d75b643b19fb4e326586117d39f51f9", + "size_in_bytes": 1533 + }, + { + "_path": "lib/python3.12/ctypes/macholib/__pycache__/framework.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "8852f9e4c9294d552a95b4ff6da80f9476a754f3c0a3655c3f81760b4b2a0feb", + "sha256_in_prefix": "8852f9e4c9294d552a95b4ff6da80f9476a754f3c0a3655c3f81760b4b2a0feb", + "size_in_bytes": 1663 + }, + { + "_path": "lib/python3.12/ctypes/macholib/dyld.py", + "path_type": "hardlink", + "sha256": "f43f287127958d63815859486720c9a703ed9dd2371261e74e88cf7d9c45a2cd", + "sha256_in_prefix": "f43f287127958d63815859486720c9a703ed9dd2371261e74e88cf7d9c45a2cd", + "size_in_bytes": 5156 + }, + { + "_path": "lib/python3.12/ctypes/macholib/dylib.py", + "path_type": "hardlink", + "sha256": "f19ee056b18165cc6735efab0b4ca3508be9405b9646c38113316c15e8278a6f", + "sha256_in_prefix": "f19ee056b18165cc6735efab0b4ca3508be9405b9646c38113316c15e8278a6f", + "size_in_bytes": 960 + }, + { + "_path": "lib/python3.12/ctypes/macholib/fetch_macholib", + "path_type": "hardlink", + "sha256": "a9f6faacdb1aa00ac2f68043cd445171de9639a732b861bd5e64090a2865ab23", + "sha256_in_prefix": "a9f6faacdb1aa00ac2f68043cd445171de9639a732b861bd5e64090a2865ab23", + "size_in_bytes": 84 + }, + { + "_path": "lib/python3.12/ctypes/macholib/fetch_macholib.bat", + "path_type": "hardlink", + "sha256": "7497fbdbb98afca4ac455e3a057c59bcdebaf1280e25c94741dc301f05cb53e5", + "sha256_in_prefix": "7497fbdbb98afca4ac455e3a057c59bcdebaf1280e25c94741dc301f05cb53e5", + "size_in_bytes": 75 + }, + { + "_path": "lib/python3.12/ctypes/macholib/framework.py", + "path_type": "hardlink", + "sha256": "302439e40d9cbdd61b8b7cffd0b7e1278a6811b635044ee366a36e0d991f62da", + "sha256_in_prefix": "302439e40d9cbdd61b8b7cffd0b7e1278a6811b635044ee366a36e0d991f62da", + "size_in_bytes": 1105 + }, + { + "_path": "lib/python3.12/ctypes/util.py", + "path_type": "hardlink", + "sha256": "35e5eda9cac8f82b922bcc4a7d303a8dae9216444158a7c21f8b96b7309f3bc7", + "sha256_in_prefix": "35e5eda9cac8f82b922bcc4a7d303a8dae9216444158a7c21f8b96b7309f3bc7", + "size_in_bytes": 14936 + }, + { + "_path": "lib/python3.12/ctypes/wintypes.py", + "path_type": "hardlink", + "sha256": "5c4d9ba1a21683838ed1d1f007b6038304e42aacf34c576e820311d26cb243f3", + "sha256_in_prefix": "5c4d9ba1a21683838ed1d1f007b6038304e42aacf34c576e820311d26cb243f3", + "size_in_bytes": 5629 + }, + { + "_path": "lib/python3.12/curses/__init__.py", + "path_type": "hardlink", + "sha256": "d8730e360dd00ec046bdd85cae41fe83c907c6ae3716a964158fce8f31ab28b0", + "sha256_in_prefix": "d8730e360dd00ec046bdd85cae41fe83c907c6ae3716a964158fce8f31ab28b0", + "size_in_bytes": 3369 + }, + { + "_path": "lib/python3.12/curses/__pycache__/__init__.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "fa81e81043cd904d0223542e20f98be900329388745e5fa2058fba79342b848b", + "sha256_in_prefix": "fa81e81043cd904d0223542e20f98be900329388745e5fa2058fba79342b848b", + "size_in_bytes": 3055 + }, + { + "_path": "lib/python3.12/curses/__pycache__/ascii.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "05dc5dbdeeaecf8407425b6f928748bfe6231403e5d955e06269875e849effa9", + "sha256_in_prefix": "05dc5dbdeeaecf8407425b6f928748bfe6231403e5d955e06269875e849effa9", + "size_in_bytes": 5276 + }, + { + "_path": "lib/python3.12/curses/__pycache__/has_key.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "5d09e74a071a6e643d6ab9d2499a00d5003613e10f226fcadca6f430f2a2f0c7", + "sha256_in_prefix": "5d09e74a071a6e643d6ab9d2499a00d5003613e10f226fcadca6f430f2a2f0c7", + "size_in_bytes": 10629 + }, + { + "_path": "lib/python3.12/curses/__pycache__/panel.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "55b3a2d2adda4b2aeb2f1d8c4ec5f27e853333379576adfdb895cde8b368b16e", + "sha256_in_prefix": "55b3a2d2adda4b2aeb2f1d8c4ec5f27e853333379576adfdb895cde8b368b16e", + "size_in_bytes": 494 + }, + { + "_path": "lib/python3.12/curses/__pycache__/textpad.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "2f00ba810652ba1d8ddc40d764e9c674128f6b3db123e4861e2a7f66cc094c5c", + "sha256_in_prefix": "2f00ba810652ba1d8ddc40d764e9c674128f6b3db123e4861e2a7f66cc094c5c", + "size_in_bytes": 12483 + }, + { + "_path": "lib/python3.12/curses/ascii.py", + "path_type": "hardlink", + "sha256": "780dd8bbaf0ee7e832f164c1772953e694a9cd1031d1ab1471af65344d3645e6", + "sha256_in_prefix": "780dd8bbaf0ee7e832f164c1772953e694a9cd1031d1ab1471af65344d3645e6", + "size_in_bytes": 2543 + }, + { + "_path": "lib/python3.12/curses/has_key.py", + "path_type": "hardlink", + "sha256": "15a052812d9ae80124bb25b3f5b9ffae38e2b03073774e163abf3d773140cfb3", + "sha256_in_prefix": "15a052812d9ae80124bb25b3f5b9ffae38e2b03073774e163abf3d773140cfb3", + "size_in_bytes": 5634 + }, + { + "_path": "lib/python3.12/curses/panel.py", + "path_type": "hardlink", + "sha256": "13ef404a30da1825a612ca3e453db88c305d45deef4441c4c9e2ef7ee0ef50c7", + "sha256_in_prefix": "13ef404a30da1825a612ca3e453db88c305d45deef4441c4c9e2ef7ee0ef50c7", + "size_in_bytes": 87 + }, + { + "_path": "lib/python3.12/curses/textpad.py", + "path_type": "hardlink", + "sha256": "6fd91c3fd9f4a6f213979a2c1df6b737c49c95d9c3acf22cf40cfdb1f88fb737", + "sha256_in_prefix": "6fd91c3fd9f4a6f213979a2c1df6b737c49c95d9c3acf22cf40cfdb1f88fb737", + "size_in_bytes": 7754 + }, + { + "_path": "lib/python3.12/dataclasses.py", + "path_type": "hardlink", + "sha256": "35f052e9b71a18e9189e61d3453587d2d0b210bcf7f6be36bc3b134650a92f40", + "sha256_in_prefix": "35f052e9b71a18e9189e61d3453587d2d0b210bcf7f6be36bc3b134650a92f40", + "size_in_bytes": 61580 + }, + { + "_path": "lib/python3.12/datetime.py", + "path_type": "hardlink", + "sha256": "ef20dc6b3554cd585dddffdc573f1f9a7a54c522f2a3fb4576c44edbb1e14238", + "sha256_in_prefix": "ef20dc6b3554cd585dddffdc573f1f9a7a54c522f2a3fb4576c44edbb1e14238", + "size_in_bytes": 268 + }, + { + "_path": "lib/python3.12/dbm/__init__.py", + "path_type": "hardlink", + "sha256": "389407b292f30c38a334599d2546ca1fea316b038a5252f985bbccfce6c8453b", + "sha256_in_prefix": "389407b292f30c38a334599d2546ca1fea316b038a5252f985bbccfce6c8453b", + "size_in_bytes": 5882 + }, + { + "_path": "lib/python3.12/dbm/__pycache__/__init__.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "e30a6fc3e30694b11d152cc059ee8284562fd19859ba2ca6df7642c2f77faecb", + "sha256_in_prefix": "e30a6fc3e30694b11d152cc059ee8284562fd19859ba2ca6df7642c2f77faecb", + "size_in_bytes": 6510 + }, + { + "_path": "lib/python3.12/dbm/__pycache__/dumb.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "ee61266c3f7011a7cd9047ebadf3b0223d3b5bf2d1e8c67ea3bc9b65d7489b06", + "sha256_in_prefix": "ee61266c3f7011a7cd9047ebadf3b0223d3b5bf2d1e8c67ea3bc9b65d7489b06", + "size_in_bytes": 13270 + }, + { + "_path": "lib/python3.12/dbm/__pycache__/gnu.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "58708cac2d04d25d6a98a0ee0af94715a0c5d34c2a0c43dbd6925a633e1949b3", + "sha256_in_prefix": "58708cac2d04d25d6a98a0ee0af94715a0c5d34c2a0c43dbd6925a633e1949b3", + "size_in_bytes": 470 + }, + { + "_path": "lib/python3.12/dbm/__pycache__/ndbm.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "1727533a4e48a830d00564761a112805ba0bdad54b37688e22708a2691b3628d", + "sha256_in_prefix": "1727533a4e48a830d00564761a112805ba0bdad54b37688e22708a2691b3628d", + "size_in_bytes": 469 + }, + { + "_path": "lib/python3.12/dbm/dumb.py", + "path_type": "hardlink", + "sha256": "c99202d9eb4e25a023715a1b804c886fdb7d9f957730959bb071a57d607443b5", + "sha256_in_prefix": "c99202d9eb4e25a023715a1b804c886fdb7d9f957730959bb071a57d607443b5", + "size_in_bytes": 11594 + }, + { + "_path": "lib/python3.12/dbm/gnu.py", + "path_type": "hardlink", + "sha256": "36cd4904f50e00c4df4ad9d450b3970e150957425f47c00cf979ba73eff49778", + "sha256_in_prefix": "36cd4904f50e00c4df4ad9d450b3970e150957425f47c00cf979ba73eff49778", + "size_in_bytes": 72 + }, + { + "_path": "lib/python3.12/dbm/ndbm.py", + "path_type": "hardlink", + "sha256": "1bcc2d9b2fad1901f3421a174eeecb5b8ccc6763283b87bbe0705b404c71904b", + "sha256_in_prefix": "1bcc2d9b2fad1901f3421a174eeecb5b8ccc6763283b87bbe0705b404c71904b", + "size_in_bytes": 70 + }, + { + "_path": "lib/python3.12/decimal.py", + "path_type": "hardlink", + "sha256": "000c00bad31d126b054c6ec7f3e02b27c0f9a4d579f987d3c4f879cee1bacb81", + "sha256_in_prefix": "000c00bad31d126b054c6ec7f3e02b27c0f9a4d579f987d3c4f879cee1bacb81", + "size_in_bytes": 320 + }, + { + "_path": "lib/python3.12/difflib.py", + "path_type": "hardlink", + "sha256": "0c6afc23568d55b3e9ac914f9c5361e3033e778aa5b58d3cc82835fc5c638679", + "sha256_in_prefix": "0c6afc23568d55b3e9ac914f9c5361e3033e778aa5b58d3cc82835fc5c638679", + "size_in_bytes": 83308 + }, + { + "_path": "lib/python3.12/dis.py", + "path_type": "hardlink", + "sha256": "f6f02f5966fed0b1ce95768dc59d7905c64f60f454d79eed67fbeaa724069031", + "sha256_in_prefix": "f6f02f5966fed0b1ce95768dc59d7905c64f60f454d79eed67fbeaa724069031", + "size_in_bytes": 30209 + }, + { + "_path": "lib/python3.12/doctest.py", + "path_type": "hardlink", + "sha256": "9777b5a215ecef673c081310bb5a31853498d7b4d1a5c1bcc8e587395299139c", + "sha256_in_prefix": "9777b5a215ecef673c081310bb5a31853498d7b4d1a5c1bcc8e587395299139c", + "size_in_bytes": 106463 + }, + { + "_path": "lib/python3.12/email/__init__.py", + "path_type": "hardlink", + "sha256": "e4f46e3414c4602c9abb8b404a45e84412fc49dbe38a3d163f9575132dc7c93e", + "sha256_in_prefix": "e4f46e3414c4602c9abb8b404a45e84412fc49dbe38a3d163f9575132dc7c93e", + "size_in_bytes": 1764 + }, + { + "_path": "lib/python3.12/email/__pycache__/__init__.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "8ff78121d7ba7ccba0134bb31956b0a3aa195d4f0f17815e64f44f26f40d9c56", + "sha256_in_prefix": "8ff78121d7ba7ccba0134bb31956b0a3aa195d4f0f17815e64f44f26f40d9c56", + "size_in_bytes": 2173 + }, + { + "_path": "lib/python3.12/email/__pycache__/_encoded_words.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "86458bfd71ae56934b44654be026e95d94d1b66f73c0c7bb47c5554ba7179972", + "sha256_in_prefix": "86458bfd71ae56934b44654be026e95d94d1b66f73c0c7bb47c5554ba7179972", + "size_in_bytes": 8560 + }, + { + "_path": "lib/python3.12/email/__pycache__/_header_value_parser.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "4a6852a9452843de27165de82618b83a11168e20002b502b3036cab15a50ac22", + "sha256_in_prefix": "4a6852a9452843de27165de82618b83a11168e20002b502b3036cab15a50ac22", + "size_in_bytes": 131439 + }, + { + "_path": "lib/python3.12/email/__pycache__/_parseaddr.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "03bebd15dc78c73e6fcd9c0ff0871c389def0db670beb01c0af38ece999d5e71", + "sha256_in_prefix": "03bebd15dc78c73e6fcd9c0ff0871c389def0db670beb01c0af38ece999d5e71", + "size_in_bytes": 23519 + }, + { + "_path": "lib/python3.12/email/__pycache__/_policybase.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "9ae8defc5442e0e098a889f47df2c668805b18881dae26673f7b3f3444c780a3", + "sha256_in_prefix": "9ae8defc5442e0e098a889f47df2c668805b18881dae26673f7b3f3444c780a3", + "size_in_bytes": 18446 + }, + { + "_path": "lib/python3.12/email/__pycache__/base64mime.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "51ec796a0f79153df52560a1027a35f1330b244242c1c5da3cdcfcb8a7c9bb9e", + "sha256_in_prefix": "51ec796a0f79153df52560a1027a35f1330b244242c1c5da3cdcfcb8a7c9bb9e", + "size_in_bytes": 4204 + }, + { + "_path": "lib/python3.12/email/__pycache__/charset.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "82a89d38bdc58b2991e3e57d7f4ceb241567beffa75f652425dd62564afa6cb0", + "sha256_in_prefix": "82a89d38bdc58b2991e3e57d7f4ceb241567beffa75f652425dd62564afa6cb0", + "size_in_bytes": 15499 + }, + { + "_path": "lib/python3.12/email/__pycache__/contentmanager.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "4e832f796db300448313370dc6ef83afc168ae89db8dd004b83eba0c55bb02e7", + "sha256_in_prefix": "4e832f796db300448313370dc6ef83afc168ae89db8dd004b83eba0c55bb02e7", + "size_in_bytes": 12653 + }, + { + "_path": "lib/python3.12/email/__pycache__/encoders.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "f81dcd3579139b4c4702e2f009262370069908f2ce3959c083a057c2d5ff022f", + "sha256_in_prefix": "f81dcd3579139b4c4702e2f009262370069908f2ce3959c083a057c2d5ff022f", + "size_in_bytes": 2343 + }, + { + "_path": "lib/python3.12/email/__pycache__/errors.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "a78e5641d63b7dbf8d09a0118bc732dedf0d6974891a19e9f5ede2df1a2d9b24", + "sha256_in_prefix": "a78e5641d63b7dbf8d09a0118bc732dedf0d6974891a19e9f5ede2df1a2d9b24", + "size_in_bytes": 7094 + }, + { + "_path": "lib/python3.12/email/__pycache__/feedparser.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "92f55cff97f6beb5c11ab64300a145f1ff2e5368dbe8c7cdbccd45c2fd007abb", + "sha256_in_prefix": "92f55cff97f6beb5c11ab64300a145f1ff2e5368dbe8c7cdbccd45c2fd007abb", + "size_in_bytes": 20091 + }, + { + "_path": "lib/python3.12/email/__pycache__/generator.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "a0cd39901c8d446003c1a925f73b653d2581da3bbb619c492f05b572e2961c31", + "sha256_in_prefix": "a0cd39901c8d446003c1a925f73b653d2581da3bbb619c492f05b572e2961c31", + "size_in_bytes": 20162 + }, + { + "_path": "lib/python3.12/email/__pycache__/header.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "4c387db89495669a1a2fb2fbb06dab5c6c68f3574937b5deb4e7a77d219db911", + "sha256_in_prefix": "4c387db89495669a1a2fb2fbb06dab5c6c68f3574937b5deb4e7a77d219db911", + "size_in_bytes": 24828 + }, + { + "_path": "lib/python3.12/email/__pycache__/headerregistry.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "519a59a80241db8ccb6d937701451935712aff347133eb5c31caca62c4cb1300", + "sha256_in_prefix": "519a59a80241db8ccb6d937701451935712aff347133eb5c31caca62c4cb1300", + "size_in_bytes": 31211 + }, + { + "_path": "lib/python3.12/email/__pycache__/iterators.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "bb7272f002715a43c15bb80d5477d62171294b82bad9519d4c471d1c6e43fa5e", + "sha256_in_prefix": "bb7272f002715a43c15bb80d5477d62171294b82bad9519d4c471d1c6e43fa5e", + "size_in_bytes": 3073 + }, + { + "_path": "lib/python3.12/email/__pycache__/message.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "6b739e3ef4ca11748a4ed02306cdd66944e01362f7bd07923c5429db3ede14d3", + "sha256_in_prefix": "6b739e3ef4ca11748a4ed02306cdd66944e01362f7bd07923c5429db3ede14d3", + "size_in_bytes": 53283 + }, + { + "_path": "lib/python3.12/email/__pycache__/parser.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "8fddb4239c6107ad10bdc3629a7bf51c3c48488080bf95ae07e09a67f39d20b9", + "sha256_in_prefix": "8fddb4239c6107ad10bdc3629a7bf51c3c48488080bf95ae07e09a67f39d20b9", + "size_in_bytes": 7000 + }, + { + "_path": "lib/python3.12/email/__pycache__/policy.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "021acc2331f0b7a50f6b25475b416c5e3cb5ef271fbeaace65685e4ec3f946c3", + "sha256_in_prefix": "021acc2331f0b7a50f6b25475b416c5e3cb5ef271fbeaace65685e4ec3f946c3", + "size_in_bytes": 12032 + }, + { + "_path": "lib/python3.12/email/__pycache__/quoprimime.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "2ea8867c883b588879f403be15b0be342ac25851ff693f5ec1d1d334321389e3", + "sha256_in_prefix": "2ea8867c883b588879f403be15b0be342ac25851ff693f5ec1d1d334321389e3", + "size_in_bytes": 10222 + }, + { + "_path": "lib/python3.12/email/__pycache__/utils.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "49907fb7131b48dc3dc5e25a1628afd5323dec64068b2bdb93484be759a87cd4", + "sha256_in_prefix": "49907fb7131b48dc3dc5e25a1628afd5323dec64068b2bdb93484be759a87cd4", + "size_in_bytes": 13009 + }, + { + "_path": "lib/python3.12/email/_encoded_words.py", + "path_type": "hardlink", + "sha256": "4178321600c0a19ca04cfe8542ce44487f339d15d89a473b58cea63c0b230217", + "sha256_in_prefix": "4178321600c0a19ca04cfe8542ce44487f339d15d89a473b58cea63c0b230217", + "size_in_bytes": 8541 + }, + { + "_path": "lib/python3.12/email/_header_value_parser.py", + "path_type": "hardlink", + "sha256": "740b00a7d6d1dbbca260000907412e888f3f31c6d4ab0fccd24c21608c0ad7cf", + "sha256_in_prefix": "740b00a7d6d1dbbca260000907412e888f3f31c6d4ab0fccd24c21608c0ad7cf", + "size_in_bytes": 107244 + }, + { + "_path": "lib/python3.12/email/_parseaddr.py", + "path_type": "hardlink", + "sha256": "4308932872acbf4a674312a45a49b870e48026e3dfedc878ee2f512ddf2f30ba", + "sha256_in_prefix": "4308932872acbf4a674312a45a49b870e48026e3dfedc878ee2f512ddf2f30ba", + "size_in_bytes": 17821 + }, + { + "_path": "lib/python3.12/email/_policybase.py", + "path_type": "hardlink", + "sha256": "967a41672b54f3443eac096968ad189d75c77be7eb42611b4d81d12a41605be9", + "sha256_in_prefix": "967a41672b54f3443eac096968ad189d75c77be7eb42611b4d81d12a41605be9", + "size_in_bytes": 15073 + }, + { + "_path": "lib/python3.12/email/architecture.rst", + "path_type": "hardlink", + "sha256": "f2b2ba7497fd02d13abcfc2a98099283a94b09e8b4f2c1c822ecacde3bec3eae", + "sha256_in_prefix": "f2b2ba7497fd02d13abcfc2a98099283a94b09e8b4f2c1c822ecacde3bec3eae", + "size_in_bytes": 9561 + }, + { + "_path": "lib/python3.12/email/base64mime.py", + "path_type": "hardlink", + "sha256": "e2b4b87a5f42a8c5780e343f675513bbcc6abdd23fa14f8f1a7d4f7d72304770", + "sha256_in_prefix": "e2b4b87a5f42a8c5780e343f675513bbcc6abdd23fa14f8f1a7d4f7d72304770", + "size_in_bytes": 3551 + }, + { + "_path": "lib/python3.12/email/charset.py", + "path_type": "hardlink", + "sha256": "a90653f13a4dc5eb3205079dda1d62561a8bf9a7b45585f5dbf90aa31a966680", + "sha256_in_prefix": "a90653f13a4dc5eb3205079dda1d62561a8bf9a7b45585f5dbf90aa31a966680", + "size_in_bytes": 17063 + }, + { + "_path": "lib/python3.12/email/contentmanager.py", + "path_type": "hardlink", + "sha256": "2d81026aef17e4786b15d9ec0629304987e3f275a0fd0a421a81b4ed87234b2c", + "sha256_in_prefix": "2d81026aef17e4786b15d9ec0629304987e3f275a0fd0a421a81b4ed87234b2c", + "size_in_bytes": 10588 + }, + { + "_path": "lib/python3.12/email/encoders.py", + "path_type": "hardlink", + "sha256": "690b275529788cc48e8f541a2aef321dc31e92f75764ac7924896db72d8a9555", + "sha256_in_prefix": "690b275529788cc48e8f541a2aef321dc31e92f75764ac7924896db72d8a9555", + "size_in_bytes": 1778 + }, + { + "_path": "lib/python3.12/email/errors.py", + "path_type": "hardlink", + "sha256": "33fc889cbff57bb78c913bb6c24c5d52bd02f3cba0f4b1cb2913340294a6ec1a", + "sha256_in_prefix": "33fc889cbff57bb78c913bb6c24c5d52bd02f3cba0f4b1cb2913340294a6ec1a", + "size_in_bytes": 3735 + }, + { + "_path": "lib/python3.12/email/feedparser.py", + "path_type": "hardlink", + "sha256": "6046239fcdd6977d1c25841581cabedaeec8046cc5fedcb8ff2d6450a36442bd", + "sha256_in_prefix": "6046239fcdd6977d1c25841581cabedaeec8046cc5fedcb8ff2d6450a36442bd", + "size_in_bytes": 22796 + }, + { + "_path": "lib/python3.12/email/generator.py", + "path_type": "hardlink", + "sha256": "7bd82690e4112edf019458c79a497d54e741106d5d9e2c7b88ef3506a1bcfe23", + "sha256_in_prefix": "7bd82690e4112edf019458c79a497d54e741106d5d9e2c7b88ef3506a1bcfe23", + "size_in_bytes": 20190 + }, + { + "_path": "lib/python3.12/email/header.py", + "path_type": "hardlink", + "sha256": "4d9baa908ad5288dd8fad8cf20b3802ffac77ba1642727804a633b201c56e5ca", + "sha256_in_prefix": "4d9baa908ad5288dd8fad8cf20b3802ffac77ba1642727804a633b201c56e5ca", + "size_in_bytes": 24092 + }, + { + "_path": "lib/python3.12/email/headerregistry.py", + "path_type": "hardlink", + "sha256": "fada56c25b6a457c6a62af43f9f929bbc29424103ce65f40f114adb4fdf3d39f", + "sha256_in_prefix": "fada56c25b6a457c6a62af43f9f929bbc29424103ce65f40f114adb4fdf3d39f", + "size_in_bytes": 20819 + }, + { + "_path": "lib/python3.12/email/iterators.py", + "path_type": "hardlink", + "sha256": "1080a2d03779176d6d45f6ecd976dbe69f5579f7e4e83b75224c3f92fd258102", + "sha256_in_prefix": "1080a2d03779176d6d45f6ecd976dbe69f5579f7e4e83b75224c3f92fd258102", + "size_in_bytes": 2129 + }, + { + "_path": "lib/python3.12/email/message.py", + "path_type": "hardlink", + "sha256": "6b51945ff4891fdf72470eb9011b64adaa0c44d77eaa5b98787e0fef359af828", + "sha256_in_prefix": "6b51945ff4891fdf72470eb9011b64adaa0c44d77eaa5b98787e0fef359af828", + "size_in_bytes": 48091 + }, + { + "_path": "lib/python3.12/email/mime/__init__.py", + "path_type": "hardlink", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size_in_bytes": 0 + }, + { + "_path": "lib/python3.12/email/mime/__pycache__/__init__.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "b2be4ab35a359f547f5f2303d0090f9c8613cdbe7455c2481812bd665ff715d0", + "sha256_in_prefix": "b2be4ab35a359f547f5f2303d0090f9c8613cdbe7455c2481812bd665ff715d0", + "size_in_bytes": 393 + }, + { + "_path": "lib/python3.12/email/mime/__pycache__/application.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "3b904776ff924ac3e72788142c79cf244a1f4821646e19ab869c32e69929e162", + "sha256_in_prefix": "3b904776ff924ac3e72788142c79cf244a1f4821646e19ab869c32e69929e162", + "size_in_bytes": 1919 + }, + { + "_path": "lib/python3.12/email/mime/__pycache__/audio.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "d88e6182ab0d8705cb7a44ca5bf8ee3e72b00825bbac3fa9a18528a216d57257", + "sha256_in_prefix": "d88e6182ab0d8705cb7a44ca5bf8ee3e72b00825bbac3fa9a18528a216d57257", + "size_in_bytes": 3704 + }, + { + "_path": "lib/python3.12/email/mime/__pycache__/base.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "6913f6eca7d1b38933888a60193f089433728fc13dea86277554e6a5813467a7", + "sha256_in_prefix": "6913f6eca7d1b38933888a60193f089433728fc13dea86277554e6a5813467a7", + "size_in_bytes": 1552 + }, + { + "_path": "lib/python3.12/email/mime/__pycache__/image.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "05171a23a15dccfc1629e6ec6b8992f547a57b3bd391764cf8c02b6c4d45f5c2", + "sha256_in_prefix": "05171a23a15dccfc1629e6ec6b8992f547a57b3bd391764cf8c02b6c4d45f5c2", + "size_in_bytes": 5968 + }, + { + "_path": "lib/python3.12/email/mime/__pycache__/message.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "a53f84b2892a2ba22ffb1c39a68da50f6f1b82e343967dc81214a57a0ea13216", + "sha256_in_prefix": "a53f84b2892a2ba22ffb1c39a68da50f6f1b82e343967dc81214a57a0ea13216", + "size_in_bytes": 1816 + }, + { + "_path": "lib/python3.12/email/mime/__pycache__/multipart.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "4ce7ca956d09deb7a139a26aade86f723bc388a3b34f5a07978924b54ce4e6ad", + "sha256_in_prefix": "4ce7ca956d09deb7a139a26aade86f723bc388a3b34f5a07978924b54ce4e6ad", + "size_in_bytes": 1964 + }, + { + "_path": "lib/python3.12/email/mime/__pycache__/nonmultipart.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "c8efc6aec30c337956a1a780e3db11cba537e7d9010938a7768aa54fc1e61e43", + "sha256_in_prefix": "c8efc6aec30c337956a1a780e3db11cba537e7d9010938a7768aa54fc1e61e43", + "size_in_bytes": 1113 + }, + { + "_path": "lib/python3.12/email/mime/__pycache__/text.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "672b2190cf3a7e4d26783d3f9b833cdc44a658d79b915ddddbde510ffb0248ff", + "sha256_in_prefix": "672b2190cf3a7e4d26783d3f9b833cdc44a658d79b915ddddbde510ffb0248ff", + "size_in_bytes": 1751 + }, + { + "_path": "lib/python3.12/email/mime/application.py", + "path_type": "hardlink", + "sha256": "b82a944ccba03e7e7eec46232e50ffe4ce2c32f4b0e26662e6bde30d533584ae", + "sha256_in_prefix": "b82a944ccba03e7e7eec46232e50ffe4ce2c32f4b0e26662e6bde30d533584ae", + "size_in_bytes": 1321 + }, + { + "_path": "lib/python3.12/email/mime/audio.py", + "path_type": "hardlink", + "sha256": "856263b25a3384a7450a1a0b9869fb897b84f893b2e7147c7e045ae50d132cd3", + "sha256_in_prefix": "856263b25a3384a7450a1a0b9869fb897b84f893b2e7147c7e045ae50d132cd3", + "size_in_bytes": 3094 + }, + { + "_path": "lib/python3.12/email/mime/base.py", + "path_type": "hardlink", + "sha256": "9a7b36653b5657525a0aeeaa72d4a0b09f598e6edc29c139c2dc2612b7d29fb8", + "sha256_in_prefix": "9a7b36653b5657525a0aeeaa72d4a0b09f598e6edc29c139c2dc2612b7d29fb8", + "size_in_bytes": 914 + }, + { + "_path": "lib/python3.12/email/mime/image.py", + "path_type": "hardlink", + "sha256": "460be5b50cfcaab8e72a73f24f14ab062cedf1a40a775b8b0d80c13aed44bb5e", + "sha256_in_prefix": "460be5b50cfcaab8e72a73f24f14ab062cedf1a40a775b8b0d80c13aed44bb5e", + "size_in_bytes": 3726 + }, + { + "_path": "lib/python3.12/email/mime/message.py", + "path_type": "hardlink", + "sha256": "30fccea73b874b5ddaccbd3c64936833749ff039f08d40524c1b0b25b8e8e2b8", + "sha256_in_prefix": "30fccea73b874b5ddaccbd3c64936833749ff039f08d40524c1b0b25b8e8e2b8", + "size_in_bytes": 1315 + }, + { + "_path": "lib/python3.12/email/mime/multipart.py", + "path_type": "hardlink", + "sha256": "8bf2beca6de95d66f12968380a428d3bb0a28a8a6ea2078da521511e1ed80a38", + "sha256_in_prefix": "8bf2beca6de95d66f12968380a428d3bb0a28a8a6ea2078da521511e1ed80a38", + "size_in_bytes": 1619 + }, + { + "_path": "lib/python3.12/email/mime/nonmultipart.py", + "path_type": "hardlink", + "sha256": "4eb9ad32603d66fc9d55aebcc4d3cf759edd9e95a591d38690659afb2e57b050", + "sha256_in_prefix": "4eb9ad32603d66fc9d55aebcc4d3cf759edd9e95a591d38690659afb2e57b050", + "size_in_bytes": 689 + }, + { + "_path": "lib/python3.12/email/mime/text.py", + "path_type": "hardlink", + "sha256": "71c56a41675a36801259c9946f7b7bf838e6c29c453ba8c34d89401f2b972d6c", + "sha256_in_prefix": "71c56a41675a36801259c9946f7b7bf838e6c29c453ba8c34d89401f2b972d6c", + "size_in_bytes": 1394 + }, + { + "_path": "lib/python3.12/email/parser.py", + "path_type": "hardlink", + "sha256": "88890ea9994c55ff7d6c1fd570fece2785f51ed407ee95df4aff946e250bcd66", + "sha256_in_prefix": "88890ea9994c55ff7d6c1fd570fece2785f51ed407ee95df4aff946e250bcd66", + "size_in_bytes": 4975 + }, + { + "_path": "lib/python3.12/email/policy.py", + "path_type": "hardlink", + "sha256": "56a2a90d973c06668f6f113d67f26cf348af10b33eece2a6b812e34da45258d8", + "sha256_in_prefix": "56a2a90d973c06668f6f113d67f26cf348af10b33eece2a6b812e34da45258d8", + "size_in_bytes": 10519 + }, + { + "_path": "lib/python3.12/email/quoprimime.py", + "path_type": "hardlink", + "sha256": "77b454bd3ba3b5e3776be28ae3a0fd8de5d1e50d5b8ee10dd539c37c2bd68082", + "sha256_in_prefix": "77b454bd3ba3b5e3776be28ae3a0fd8de5d1e50d5b8ee10dd539c37c2bd68082", + "size_in_bytes": 9864 + }, + { + "_path": "lib/python3.12/email/utils.py", + "path_type": "hardlink", + "sha256": "b337be3534f81d662c0368e99cca165252f5b865bb1fb00cdef525bb2833e460", + "sha256_in_prefix": "b337be3534f81d662c0368e99cca165252f5b865bb1fb00cdef525bb2833e460", + "size_in_bytes": 12292 + }, + { + "_path": "lib/python3.12/encodings/__init__.py", + "path_type": "hardlink", + "sha256": "78c4744d407690f321565488710b5aaf6486b5afa8d185637aa1e7633ab59cd8", + "sha256_in_prefix": "78c4744d407690f321565488710b5aaf6486b5afa8d185637aa1e7633ab59cd8", + "size_in_bytes": 5884 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/__init__.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "aac1ba24998020a65a9286767da05af5a8c67a311a0e5d77284f5dfa4391317b", + "sha256_in_prefix": "aac1ba24998020a65a9286767da05af5a8c67a311a0e5d77284f5dfa4391317b", + "size_in_bytes": 6044 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/aliases.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "3bd62b9c06e7c8bdf5e287da27717dc5f181956175001bf7c8a073732de3b4c1", + "sha256_in_prefix": "3bd62b9c06e7c8bdf5e287da27717dc5f181956175001bf7c8a073732de3b4c1", + "size_in_bytes": 12662 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/ascii.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "3ec5ee5d8a2c0faa1caa7c1d5b062a8386986a8f4372b98731c167304dfd95bf", + "sha256_in_prefix": "3ec5ee5d8a2c0faa1caa7c1d5b062a8386986a8f4372b98731c167304dfd95bf", + "size_in_bytes": 2769 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/base64_codec.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "41a84bcf7606d6de52016c1b7a0acdf058d5afc3b636fe6eec9e281846f0dc5f", + "sha256_in_prefix": "41a84bcf7606d6de52016c1b7a0acdf058d5afc3b636fe6eec9e281846f0dc5f", + "size_in_bytes": 3231 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/big5.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "f1bd8fb019b5d203275aca614a23fec28a093d40b3a0a6f5f4511df18e54daa4", + "sha256_in_prefix": "f1bd8fb019b5d203275aca614a23fec28a093d40b3a0a6f5f4511df18e54daa4", + "size_in_bytes": 2244 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/big5hkscs.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "c6316f419b894b0c78152da9180d91772713642f309c7b5e79187d737b4e8f3b", + "sha256_in_prefix": "c6316f419b894b0c78152da9180d91772713642f309c7b5e79187d737b4e8f3b", + "size_in_bytes": 2254 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/bz2_codec.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "68310027d0edd00409e0bcd811a2680ee2d2415349814e648ae1be47981828c2", + "sha256_in_prefix": "68310027d0edd00409e0bcd811a2680ee2d2415349814e648ae1be47981828c2", + "size_in_bytes": 4579 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/charmap.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "aba1d1edbc3312fffec0cff67d4b21d6efcb7e7a0d068ec805ded1c9032ee068", + "sha256_in_prefix": "aba1d1edbc3312fffec0cff67d4b21d6efcb7e7a0d068ec805ded1c9032ee068", + "size_in_bytes": 4113 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/cp037.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "a2ebdeceddcb62c4c9f3d70fded1871736d88432c612420183314bb461fc780b", + "sha256_in_prefix": "a2ebdeceddcb62c4c9f3d70fded1871736d88432c612420183314bb461fc780b", + "size_in_bytes": 3361 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/cp1006.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "2a9fd04c6549684acf69db0de4cb30b32a4aa9ce59199d7fe0811bed6bd2b571", + "sha256_in_prefix": "2a9fd04c6549684acf69db0de4cb30b32a4aa9ce59199d7fe0811bed6bd2b571", + "size_in_bytes": 3437 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/cp1026.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "db263bc84d6319146d55b125855b050f3b11af16aa5a5947db758d076d059aa2", + "sha256_in_prefix": "db263bc84d6319146d55b125855b050f3b11af16aa5a5947db758d076d059aa2", + "size_in_bytes": 3365 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/cp1125.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "53b57331d5e77af89ff8168d3e6e06cf483abe2d31d32c68f08de703bb4b4c3f", + "sha256_in_prefix": "53b57331d5e77af89ff8168d3e6e06cf483abe2d31d32c68f08de703bb4b4c3f", + "size_in_bytes": 13905 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/cp1140.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "65a7bfe1ddafbb4be5aa485d482145354a55f053b61a45b24924be231bddd738", + "sha256_in_prefix": "65a7bfe1ddafbb4be5aa485d482145354a55f053b61a45b24924be231bddd738", + "size_in_bytes": 3351 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/cp1250.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "d3ebfd1ee9279139df89a9fd9ea625f7e6828330913ac5886d52376430199e8f", + "sha256_in_prefix": "d3ebfd1ee9279139df89a9fd9ea625f7e6828330913ac5886d52376430199e8f", + "size_in_bytes": 3388 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/cp1251.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "18348eca935f12070f2021d45bfbd8ff06788b6422666c5c1ff09b3aebfbcd8b", + "sha256_in_prefix": "18348eca935f12070f2021d45bfbd8ff06788b6422666c5c1ff09b3aebfbcd8b", + "size_in_bytes": 3385 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/cp1252.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "273a0d2721fb91cc4c351f73791d272a39b3db7c9dc5a47541ca5af6aeb527bc", + "sha256_in_prefix": "273a0d2721fb91cc4c351f73791d272a39b3db7c9dc5a47541ca5af6aeb527bc", + "size_in_bytes": 3388 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/cp1253.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "6c481c4ebf53bc3a9515469f81bd5bf48f536287b60da87d6a1dc5d54ea8745a", + "sha256_in_prefix": "6c481c4ebf53bc3a9515469f81bd5bf48f536287b60da87d6a1dc5d54ea8745a", + "size_in_bytes": 3401 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/cp1254.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "3b2dcb4ead3d66e6f741e5ddb55e24617a16c21cfc7037addd4b63b7a5f8a93d", + "sha256_in_prefix": "3b2dcb4ead3d66e6f741e5ddb55e24617a16c21cfc7037addd4b63b7a5f8a93d", + "size_in_bytes": 3390 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/cp1255.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "e10f3cff74776a1a14542c7bd2d50937f075dd22d7f0328bb97af64726480051", + "sha256_in_prefix": "e10f3cff74776a1a14542c7bd2d50937f075dd22d7f0328bb97af64726480051", + "size_in_bytes": 3409 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/cp1256.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "bc0208fc0e40881f8a7c8f2b648d8a43baafca55f1cc72fef18d3ce40649c1d4", + "sha256_in_prefix": "bc0208fc0e40881f8a7c8f2b648d8a43baafca55f1cc72fef18d3ce40649c1d4", + "size_in_bytes": 3387 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/cp1257.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "ce58c8048d6dda65817da86d77714d31362e6d0ce85c4c3232c848d2c7f29a06", + "sha256_in_prefix": "ce58c8048d6dda65817da86d77714d31362e6d0ce85c4c3232c848d2c7f29a06", + "size_in_bytes": 3395 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/cp1258.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "cef43f860627cc624f666d02a4118a24fc58fc10568976c3dfa1aa4034407e00", + "sha256_in_prefix": "cef43f860627cc624f666d02a4118a24fc58fc10568976c3dfa1aa4034407e00", + "size_in_bytes": 3393 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/cp273.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "edda93fe6cf4b5063a535fbbc553691c5151f5ab0cd1717d71d96dbec2e7db21", + "sha256_in_prefix": "edda93fe6cf4b5063a535fbbc553691c5151f5ab0cd1717d71d96dbec2e7db21", + "size_in_bytes": 3347 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/cp424.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "99fb2089fa562173542fe53dac37fb828efcf86e729b779c124ee6f7237cdfd7", + "sha256_in_prefix": "99fb2089fa562173542fe53dac37fb828efcf86e729b779c124ee6f7237cdfd7", + "size_in_bytes": 3391 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/cp437.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "bf406c23f558ba134ef0a81b4d049f0328a9a0e27005687ae576b3c1a7f2832d", + "sha256_in_prefix": "bf406c23f558ba134ef0a81b4d049f0328a9a0e27005687ae576b3c1a7f2832d", + "size_in_bytes": 13538 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/cp500.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "c8ed6385489d80f4bcfb1e276ac54ec1b130cecd1e11c8c3be64a60a3d00cb1f", + "sha256_in_prefix": "c8ed6385489d80f4bcfb1e276ac54ec1b130cecd1e11c8c3be64a60a3d00cb1f", + "size_in_bytes": 3361 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/cp720.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "d41f26eb176d92fa2cbf1f20660600a6d986c45819fb177bb5c009c102e045e1", + "sha256_in_prefix": "d41f26eb176d92fa2cbf1f20660600a6d986c45819fb177bb5c009c102e045e1", + "size_in_bytes": 3458 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/cp737.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "f9b11e394d3410f54bf83401a8f4cbedc4cd89fd2a513889a40a9b7226b68bb7", + "sha256_in_prefix": "f9b11e394d3410f54bf83401a8f4cbedc4cd89fd2a513889a40a9b7226b68bb7", + "size_in_bytes": 13940 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/cp775.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "bd81a47e78525965d91b39db2033af59837ddb7eb2e95b264b813fe5c68320f1", + "sha256_in_prefix": "bd81a47e78525965d91b39db2033af59837ddb7eb2e95b264b813fe5c68320f1", + "size_in_bytes": 13578 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/cp850.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "7eb20ef95c873df50778436a87d96d685189179dffece183c7311f2545d02874", + "sha256_in_prefix": "7eb20ef95c873df50778436a87d96d685189179dffece183c7311f2545d02874", + "size_in_bytes": 13119 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/cp852.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "2a71050497f7577e7fe44233184d4de36476281f608d0b7c1895d7ec7b6cbd79", + "sha256_in_prefix": "2a71050497f7577e7fe44233184d4de36476281f608d0b7c1895d7ec7b6cbd79", + "size_in_bytes": 13594 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/cp855.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "8c8914bc43d8b5e23ee05287a4c6c63da4fe0c30d5abcfab7c670048d226501d", + "sha256_in_prefix": "8c8914bc43d8b5e23ee05287a4c6c63da4fe0c30d5abcfab7c670048d226501d", + "size_in_bytes": 13907 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/cp856.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "1df52ecd407557bc4f3e22a62a01240ca82331231c81bf8bfd383b7111429e53", + "sha256_in_prefix": "1df52ecd407557bc4f3e22a62a01240ca82331231c81bf8bfd383b7111429e53", + "size_in_bytes": 3423 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/cp857.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "7ffa9a784acb487f93b84b316a4482616b110a25ce7448b0d16008363a0324d0", + "sha256_in_prefix": "7ffa9a784acb487f93b84b316a4482616b110a25ce7448b0d16008363a0324d0", + "size_in_bytes": 12920 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/cp858.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "eff6b40c600524b4201daa8cf43691096f45f1a598e886cbced20b3dbaf59f9e", + "sha256_in_prefix": "eff6b40c600524b4201daa8cf43691096f45f1a598e886cbced20b3dbaf59f9e", + "size_in_bytes": 13089 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/cp860.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "ad622e613497f42657144b9bf958ffcdea7a68d2ca26db6a4496b1816dd96922", + "sha256_in_prefix": "ad622e613497f42657144b9bf958ffcdea7a68d2ca26db6a4496b1816dd96922", + "size_in_bytes": 13509 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/cp861.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "8cae45a0bbb56f6945a440b317474cca2dca7087d34469e6ddb91409c8a994ff", + "sha256_in_prefix": "8cae45a0bbb56f6945a440b317474cca2dca7087d34469e6ddb91409c8a994ff", + "size_in_bytes": 13534 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/cp862.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "7d775679ca6a80c97f7744d20e846fc2f1d5c55fde898c1f056548a07bed442d", + "sha256_in_prefix": "7d775679ca6a80c97f7744d20e846fc2f1d5c55fde898c1f056548a07bed442d", + "size_in_bytes": 13767 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/cp863.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "e6ee7d5d404ad6557da932c7feaca31f44f5abf1766d26f3f37cfba74665498e", + "sha256_in_prefix": "e6ee7d5d404ad6557da932c7feaca31f44f5abf1766d26f3f37cfba74665498e", + "size_in_bytes": 13530 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/cp864.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "638424cc557238d8853dded4c2538f580d1e7ebb42ca3248aed0b8901d2b99c0", + "sha256_in_prefix": "638424cc557238d8853dded4c2538f580d1e7ebb42ca3248aed0b8901d2b99c0", + "size_in_bytes": 13575 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/cp865.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "0331594a4151c1ee13733524dceb90f245900f1487dcb566d56139ad930504f6", + "sha256_in_prefix": "0331594a4151c1ee13733524dceb90f245900f1487dcb566d56139ad930504f6", + "size_in_bytes": 13534 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/cp866.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "c661e650870cf4e5825ff9879196bed7e0ebac8cc213e8df01866ae4fcf02136", + "sha256_in_prefix": "c661e650870cf4e5825ff9879196bed7e0ebac8cc213e8df01866ae4fcf02136", + "size_in_bytes": 13947 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/cp869.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "c36e2be1e1cac4d93c1c676741bdd9110f345e7a2b9ef4322135a24cc5a3a92f", + "sha256_in_prefix": "c36e2be1e1cac4d93c1c676741bdd9110f345e7a2b9ef4322135a24cc5a3a92f", + "size_in_bytes": 13477 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/cp874.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "a923d648b4ea39e58f66141323379afb12ebd24730b8b00affede3187ff1aa3c", + "sha256_in_prefix": "a923d648b4ea39e58f66141323379afb12ebd24730b8b00affede3187ff1aa3c", + "size_in_bytes": 3489 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/cp875.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "90813678a273bc09a18c82f23a1e2248728342d7ffcf0a53453c3d9efe080846", + "sha256_in_prefix": "90813678a273bc09a18c82f23a1e2248728342d7ffcf0a53453c3d9efe080846", + "size_in_bytes": 3358 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/cp932.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "6a0f16be3f182b1785e698f47e9f50ebe4c148aee8cdce75611f26bd6d0f243b", + "sha256_in_prefix": "6a0f16be3f182b1785e698f47e9f50ebe4c148aee8cdce75611f26bd6d0f243b", + "size_in_bytes": 2246 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/cp949.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "ec59bac7f00c8ea4ce9cf50f3047076b70f7005c030b91d76de45cb192dd3f69", + "sha256_in_prefix": "ec59bac7f00c8ea4ce9cf50f3047076b70f7005c030b91d76de45cb192dd3f69", + "size_in_bytes": 2246 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/cp950.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "0c0fdfa0cbe1437c60babb030885580333dcab4359723fe6cda0d7797a0ae6ea", + "sha256_in_prefix": "0c0fdfa0cbe1437c60babb030885580333dcab4359723fe6cda0d7797a0ae6ea", + "size_in_bytes": 2246 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/euc_jis_2004.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "b471f726c52ec242f7c82f906ef00c56f36ab158528dbcfb935c54b60465ad1d", + "sha256_in_prefix": "b471f726c52ec242f7c82f906ef00c56f36ab158528dbcfb935c54b60465ad1d", + "size_in_bytes": 2260 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/euc_jisx0213.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "84b7bc06dc2ed55cf69006c6937ca9e336631e2e4b1e96a5a9518f1ed8bb4a70", + "sha256_in_prefix": "84b7bc06dc2ed55cf69006c6937ca9e336631e2e4b1e96a5a9518f1ed8bb4a70", + "size_in_bytes": 2260 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/euc_jp.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "9c18e6279d0c3605d0045a09484f4dfdd56fe37d1e11ae2e3c5e5384c464baca", + "sha256_in_prefix": "9c18e6279d0c3605d0045a09484f4dfdd56fe37d1e11ae2e3c5e5384c464baca", + "size_in_bytes": 2248 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/euc_kr.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "a5aee5371961e51d7c178c51bafcf54d43b390dd1535445e4cb677744f742925", + "sha256_in_prefix": "a5aee5371961e51d7c178c51bafcf54d43b390dd1535445e4cb677744f742925", + "size_in_bytes": 2248 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/gb18030.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "a98f721920818b7deeaf52dad89ffd09b1aab2d8412914df22e2b18eda2c2f9e", + "sha256_in_prefix": "a98f721920818b7deeaf52dad89ffd09b1aab2d8412914df22e2b18eda2c2f9e", + "size_in_bytes": 2250 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/gb2312.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "54d6603d46983c1c15ac0cceaad832948de8f57b229c7448e0f99056abc00e9d", + "sha256_in_prefix": "54d6603d46983c1c15ac0cceaad832948de8f57b229c7448e0f99056abc00e9d", + "size_in_bytes": 2248 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/gbk.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "360aa557a33f5c156e31a942f1764b3ca821edd6e5465b0b2be6074eba015ebf", + "sha256_in_prefix": "360aa557a33f5c156e31a942f1764b3ca821edd6e5465b0b2be6074eba015ebf", + "size_in_bytes": 2242 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/hex_codec.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "e61d34325c9a896264ade92beb573470fc0d50f09841d38d83916f87927d3fe7", + "sha256_in_prefix": "e61d34325c9a896264ade92beb573470fc0d50f09841d38d83916f87927d3fe7", + "size_in_bytes": 3218 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/hp_roman8.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "55f138d758b162a0bb7f6dbc0e320f8ad6717361461f94c8a18c230064a29ca3", + "sha256_in_prefix": "55f138d758b162a0bb7f6dbc0e320f8ad6717361461f94c8a18c230064a29ca3", + "size_in_bytes": 3562 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/hz.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "9d5fc2d727082ea860ea444c686818b749dd169506b2d186b234650c999d3571", + "sha256_in_prefix": "9d5fc2d727082ea860ea444c686818b749dd169506b2d186b234650c999d3571", + "size_in_bytes": 2240 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/idna.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "df19b219d75d4588c64f0ea6d92209b74b846f4a65f6ab64fc909880e3bc6a55", + "sha256_in_prefix": "df19b219d75d4588c64f0ea6d92209b74b846f4a65f6ab64fc909880e3bc6a55", + "size_in_bytes": 10170 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/iso2022_jp.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "56ef070f938c7ebe3bb1218fbe3100bab4c9aeccfbde92003d19d69a16b8221e", + "sha256_in_prefix": "56ef070f938c7ebe3bb1218fbe3100bab4c9aeccfbde92003d19d69a16b8221e", + "size_in_bytes": 2261 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/iso2022_jp_1.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "eea75cf050e0615201e9247435bf1603677ab445be68ec9f9e364bc6d82d3191", + "sha256_in_prefix": "eea75cf050e0615201e9247435bf1603677ab445be68ec9f9e364bc6d82d3191", + "size_in_bytes": 2265 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/iso2022_jp_2.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "a993e0806a359b2f113a3c91d0349ac2b9472c1b7e61f7827732e529a7c7b12b", + "sha256_in_prefix": "a993e0806a359b2f113a3c91d0349ac2b9472c1b7e61f7827732e529a7c7b12b", + "size_in_bytes": 2265 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/iso2022_jp_2004.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "a4860204823e1eb53febdc174c6f743aafd5c98ad7d9bfc74324733ea1f93d9e", + "sha256_in_prefix": "a4860204823e1eb53febdc174c6f743aafd5c98ad7d9bfc74324733ea1f93d9e", + "size_in_bytes": 2272 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/iso2022_jp_3.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "8c387be07a6949d43d8a499ffbfddb6f54ce5411d11f8d4f2918a8242aca6055", + "sha256_in_prefix": "8c387be07a6949d43d8a499ffbfddb6f54ce5411d11f8d4f2918a8242aca6055", + "size_in_bytes": 2265 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/iso2022_jp_ext.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "e5befae390e9bd49726e851b1afdd247644303da90e3cd432eaeeb484131a980", + "sha256_in_prefix": "e5befae390e9bd49726e851b1afdd247644303da90e3cd432eaeeb484131a980", + "size_in_bytes": 2270 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/iso2022_kr.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "96582053520f873dee2e186806c6d8d422255c8523a0a08ce8027a73abf0fbbd", + "sha256_in_prefix": "96582053520f873dee2e186806c6d8d422255c8523a0a08ce8027a73abf0fbbd", + "size_in_bytes": 2261 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/iso8859_1.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "d74b6f5e573de0399a5151dfc73b478a5368a854041c6e348507664a68dd4b16", + "sha256_in_prefix": "d74b6f5e573de0399a5151dfc73b478a5368a854041c6e348507664a68dd4b16", + "size_in_bytes": 3360 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/iso8859_10.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "26d7c6498097f6be8e7af8621d7fe2c17b0c2714a591d1941a516b4690986f1e", + "sha256_in_prefix": "26d7c6498097f6be8e7af8621d7fe2c17b0c2714a591d1941a516b4690986f1e", + "size_in_bytes": 3365 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/iso8859_11.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "80351b013332f9c5c5a6e8dfdc814a181ebaedfc2e891deeb4f3fff160e532b7", + "sha256_in_prefix": "80351b013332f9c5c5a6e8dfdc814a181ebaedfc2e891deeb4f3fff160e532b7", + "size_in_bytes": 3459 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/iso8859_13.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "532da04d2f60d73f6106f4e8b3a534d5beffdbf55e5fa570d42f99a90596c3b1", + "sha256_in_prefix": "532da04d2f60d73f6106f4e8b3a534d5beffdbf55e5fa570d42f99a90596c3b1", + "size_in_bytes": 3368 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/iso8859_14.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "04b926cfab5c67cac85a39d278926fc1a7a27fe7ec36c5c43ec5852db8998c9f", + "sha256_in_prefix": "04b926cfab5c67cac85a39d278926fc1a7a27fe7ec36c5c43ec5852db8998c9f", + "size_in_bytes": 3386 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/iso8859_15.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "1e3908885861f522d189809e853ef8c1cc497c5aa1bf02a5f12a3e8e3f5d68b3", + "sha256_in_prefix": "1e3908885861f522d189809e853ef8c1cc497c5aa1bf02a5f12a3e8e3f5d68b3", + "size_in_bytes": 3365 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/iso8859_16.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "d4222c4be42f60fd415dc6381c17bd4c6691dfe045dba41f8edd0b2f9fa5e89f", + "sha256_in_prefix": "d4222c4be42f60fd415dc6381c17bd4c6691dfe045dba41f8edd0b2f9fa5e89f", + "size_in_bytes": 3367 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/iso8859_2.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "2b268301c9df90bf5565d4d8a2200139343535270291d1198462064a7cb4e3c1", + "sha256_in_prefix": "2b268301c9df90bf5565d4d8a2200139343535270291d1198462064a7cb4e3c1", + "size_in_bytes": 3360 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/iso8859_3.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "cfef0ff3a18ac7b1b42382608aefdc2729145fe3910f7784cc2ca4b1af719a32", + "sha256_in_prefix": "cfef0ff3a18ac7b1b42382608aefdc2729145fe3910f7784cc2ca4b1af719a32", + "size_in_bytes": 3367 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/iso8859_4.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "b950105c64037005d5eeab4022cce0eee94780fd5e56fd7e1114521b76699bab", + "sha256_in_prefix": "b950105c64037005d5eeab4022cce0eee94780fd5e56fd7e1114521b76699bab", + "size_in_bytes": 3360 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/iso8859_5.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "ded46235a2a77cf80f973f38ae37cd8dc638873b83de8bf53e339f8d0e65e80d", + "sha256_in_prefix": "ded46235a2a77cf80f973f38ae37cd8dc638873b83de8bf53e339f8d0e65e80d", + "size_in_bytes": 3361 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/iso8859_6.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "8e1f322a1760237daa65406301c510e78617cbc6ec7a13c58576eee754144c12", + "sha256_in_prefix": "8e1f322a1760237daa65406301c510e78617cbc6ec7a13c58576eee754144c12", + "size_in_bytes": 3405 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/iso8859_7.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "32a4d7e7395e822acb2aed50fce59485869d2419c708056f73886ec4688a63c5", + "sha256_in_prefix": "32a4d7e7395e822acb2aed50fce59485869d2419c708056f73886ec4688a63c5", + "size_in_bytes": 3368 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/iso8859_8.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "ecf506f6a42825567c213344a0b1c692ff2a8efbd582cf68a0cf571aa79f092a", + "sha256_in_prefix": "ecf506f6a42825567c213344a0b1c692ff2a8efbd582cf68a0cf571aa79f092a", + "size_in_bytes": 3399 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/iso8859_9.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "e0b3c570a33405485f6caabdf67d69ef45d6bd2cbfff20d32ac9d212cbb00616", + "sha256_in_prefix": "e0b3c570a33405485f6caabdf67d69ef45d6bd2cbfff20d32ac9d212cbb00616", + "size_in_bytes": 3360 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/johab.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "6e7452e532ad765dfcca1bd204c9937deb17912e543353ecaefba63f64b7e46d", + "sha256_in_prefix": "6e7452e532ad765dfcca1bd204c9937deb17912e543353ecaefba63f64b7e46d", + "size_in_bytes": 2246 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/koi8_r.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "c36559de7d4f5289293404395fcf56afdc8472c8560da8342dde3452693a3e7a", + "sha256_in_prefix": "c36559de7d4f5289293404395fcf56afdc8472c8560da8342dde3452693a3e7a", + "size_in_bytes": 3412 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/koi8_t.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "39882cefeeefb5bdae4f4027d0f15b6ebe42235caba7caf5400a32dc65709c71", + "sha256_in_prefix": "39882cefeeefb5bdae4f4027d0f15b6ebe42235caba7caf5400a32dc65709c71", + "size_in_bytes": 3323 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/koi8_u.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "aefc1edb6571729b59e761eb9afde0b1da4146c7c4bec48621b51453bd3a380a", + "sha256_in_prefix": "aefc1edb6571729b59e761eb9afde0b1da4146c7c4bec48621b51453bd3a380a", + "size_in_bytes": 3398 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/kz1048.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "f57ab95f3eae9e161818a87e1068d3e46d52a9f8dda9ccc91d11b62995b13449", + "sha256_in_prefix": "f57ab95f3eae9e161818a87e1068d3e46d52a9f8dda9ccc91d11b62995b13449", + "size_in_bytes": 3375 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/latin_1.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "b7b4844f09fa6606fee7e03b2ee70169b2bc08f8f92ef1f33bd9046bbbbc95de", + "sha256_in_prefix": "b7b4844f09fa6606fee7e03b2ee70169b2bc08f8f92ef1f33bd9046bbbbc95de", + "size_in_bytes": 2781 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/mac_arabic.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "04439593121b61e608181928b6d42098eb84f02a61acc0b5de46c65ffb7cff8b", + "sha256_in_prefix": "04439593121b61e608181928b6d42098eb84f02a61acc0b5de46c65ffb7cff8b", + "size_in_bytes": 13424 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/mac_croatian.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "81c4738b43c142452cf092907557143e1e2ccbcdeba9880c067f1d17fb570210", + "sha256_in_prefix": "81c4738b43c142452cf092907557143e1e2ccbcdeba9880c067f1d17fb570210", + "size_in_bytes": 3407 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/mac_cyrillic.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "814f55c40301f7cbf5af6ed1df0b7497cb06991359ccc20bad748b5f32c9ed56", + "sha256_in_prefix": "814f55c40301f7cbf5af6ed1df0b7497cb06991359ccc20bad748b5f32c9ed56", + "size_in_bytes": 3397 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/mac_farsi.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "5ced0a8b3acb47a4253c03b36e7da93303820f435f5cc28d7669467db199c6f7", + "sha256_in_prefix": "5ced0a8b3acb47a4253c03b36e7da93303820f435f5cc28d7669467db199c6f7", + "size_in_bytes": 3341 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/mac_greek.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "0f6708e1ff9760762e99220e4da309e7d4ffd93790e6c871afd5654a1a1c95f5", + "sha256_in_prefix": "0f6708e1ff9760762e99220e4da309e7d4ffd93790e6c871afd5654a1a1c95f5", + "size_in_bytes": 3381 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/mac_iceland.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "a5931415e09f33c3f76260b525401f6a48654dfddc941769084386528e300f79", + "sha256_in_prefix": "a5931415e09f33c3f76260b525401f6a48654dfddc941769084386528e300f79", + "size_in_bytes": 3400 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/mac_latin2.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "61dc3c79526834623606109ef4c952e2c0e8d81a534a7b18654878d95264d24f", + "sha256_in_prefix": "61dc3c79526834623606109ef4c952e2c0e8d81a534a7b18654878d95264d24f", + "size_in_bytes": 3541 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/mac_roman.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "b4a54d65125caae6865736359fd0061ce39a8daabb3dc857f1cd5d8925c1960f", + "sha256_in_prefix": "b4a54d65125caae6865736359fd0061ce39a8daabb3dc857f1cd5d8925c1960f", + "size_in_bytes": 3398 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/mac_romanian.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "1fce4dbb16723b98495dbd674eb120110bd3c52d2d1ece3a63f307a765a4474e", + "sha256_in_prefix": "1fce4dbb16723b98495dbd674eb120110bd3c52d2d1ece3a63f307a765a4474e", + "size_in_bytes": 3408 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/mac_turkish.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "09df9773cff3a3f7a8e9e9060e2e2922e959fec495cb34dc77640b6e7f400749", + "sha256_in_prefix": "09df9773cff3a3f7a8e9e9060e2e2922e959fec495cb34dc77640b6e7f400749", + "size_in_bytes": 3401 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/mbcs.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "f56d3145850f816469cabbaa5ae43ae51142baf1e02d775fc192e8d830712382", + "sha256_in_prefix": "f56d3145850f816469cabbaa5ae43ae51142baf1e02d775fc192e8d830712382", + "size_in_bytes": 2345 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/oem.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "93ad8353abc6d17f60492fcdae71769d31deb0ea8e8fa3e22bae856bfcaa6399", + "sha256_in_prefix": "93ad8353abc6d17f60492fcdae71769d31deb0ea8e8fa3e22bae856bfcaa6399", + "size_in_bytes": 2158 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/palmos.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "69569e650bab8f85a5dc40bce3beb067568b2ee458ae100dde06f84cdc6792db", + "sha256_in_prefix": "69569e650bab8f85a5dc40bce3beb067568b2ee458ae100dde06f84cdc6792db", + "size_in_bytes": 3388 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/ptcp154.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "85259090adc1f7bddb4643f4caaca2eb495ac6c9cd8044d9afa2452b37310025", + "sha256_in_prefix": "85259090adc1f7bddb4643f4caaca2eb495ac6c9cd8044d9afa2452b37310025", + "size_in_bytes": 3482 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/punycode.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "59ed54cf4c3467706c2509490377056033ba2ad3c568bb93041f179a39bf3865", + "sha256_in_prefix": "59ed54cf4c3467706c2509490377056033ba2ad3c568bb93041f179a39bf3865", + "size_in_bytes": 9679 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/quopri_codec.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "dce4199cc06208d0b511e9381abfc9bc24da29755d5b53b251048336c6a6718e", + "sha256_in_prefix": "dce4199cc06208d0b511e9381abfc9bc24da29755d5b53b251048336c6a6718e", + "size_in_bytes": 3403 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/raw_unicode_escape.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "31481824837d24646b79cc40f0caeb1df9bf9d991e35e8a3c72e6d63975f58c6", + "sha256_in_prefix": "31481824837d24646b79cc40f0caeb1df9bf9d991e35e8a3c72e6d63975f58c6", + "size_in_bytes": 2836 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/rot_13.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "bbfcb3c8c612ed383bd0b36a76dae0741abc382113d15c85eb6c3c2bf6562e9f", + "sha256_in_prefix": "bbfcb3c8c612ed383bd0b36a76dae0741abc382113d15c85eb6c3c2bf6562e9f", + "size_in_bytes": 4656 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/shift_jis.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "85b887b9c040e3fb6d462edf81537e8684833b719cc2be861c5878910983d4bb", + "sha256_in_prefix": "85b887b9c040e3fb6d462edf81537e8684833b719cc2be861c5878910983d4bb", + "size_in_bytes": 2254 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/shift_jis_2004.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "1cd794810a14635829aae1709ac9220140b9b7233a7e4680a300a911ad5bb421", + "sha256_in_prefix": "1cd794810a14635829aae1709ac9220140b9b7233a7e4680a300a911ad5bb421", + "size_in_bytes": 2265 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/shift_jisx0213.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "a58f1be088ad8908da9bd4c24bb827504c41017c9e9bb3b6be120be2c4e2797a", + "sha256_in_prefix": "a58f1be088ad8908da9bd4c24bb827504c41017c9e9bb3b6be120be2c4e2797a", + "size_in_bytes": 2265 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/tis_620.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "0d7d4b997419934ae7551111b2d4297bfc670f0f380d1a8f4ce6e679b716139b", + "sha256_in_prefix": "0d7d4b997419934ae7551111b2d4297bfc670f0f380d1a8f4ce6e679b716139b", + "size_in_bytes": 3450 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/undefined.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "e12e2a6b52d5b7db1b594a144a295eed30a9caf933c82580dbbf0104eded303b", + "sha256_in_prefix": "e12e2a6b52d5b7db1b594a144a295eed30a9caf933c82580dbbf0104eded303b", + "size_in_bytes": 2776 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/unicode_escape.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "eaf535abb91bff4b0a616d58dd7bb873e7f7aab0dc00b269ed92fa875f458f17", + "sha256_in_prefix": "eaf535abb91bff4b0a616d58dd7bb873e7f7aab0dc00b269ed92fa875f458f17", + "size_in_bytes": 2816 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/utf_16.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "ca9f026b894f7e6ba0c0c2d6ca96030ae4822bdf1c857d9facfb30087f9076f2", + "sha256_in_prefix": "ca9f026b894f7e6ba0c0c2d6ca96030ae4822bdf1c857d9facfb30087f9076f2", + "size_in_bytes": 8036 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/utf_16_be.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "4b279086c43c5c6ce18f92637494033209d6b73599c9689e18b2df99e358fa06", + "sha256_in_prefix": "4b279086c43c5c6ce18f92637494033209d6b73599c9689e18b2df99e358fa06", + "size_in_bytes": 2421 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/utf_16_le.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "a12531cf37994c0e7fda35a8cd8da6e8b6a6860e9792cdca7695e6d490cc9b4c", + "sha256_in_prefix": "a12531cf37994c0e7fda35a8cd8da6e8b6a6860e9792cdca7695e6d490cc9b4c", + "size_in_bytes": 2421 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/utf_32.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "8af84e8e182cceeb3c345234fcbce6a99097b5d63889889ad57f3e31958de4e4", + "sha256_in_prefix": "8af84e8e182cceeb3c345234fcbce6a99097b5d63889889ad57f3e31958de4e4", + "size_in_bytes": 7929 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/utf_32_be.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "ae5e28f0a14df14d2d0d3966167893bb8fcfa0261fb0f7070afd13de655c2ad3", + "sha256_in_prefix": "ae5e28f0a14df14d2d0d3966167893bb8fcfa0261fb0f7070afd13de655c2ad3", + "size_in_bytes": 2314 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/utf_32_le.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "7f5dbca1a8149e4a326cfbf473960d06cd36a2fb1a4cf1e2a01c4419d938afb6", + "sha256_in_prefix": "7f5dbca1a8149e4a326cfbf473960d06cd36a2fb1a4cf1e2a01c4419d938afb6", + "size_in_bytes": 2314 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/utf_7.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "cb2e5d814189d43e9b3182522f9e0c13486c5825faff8b6ffedcb7d303934d01", + "sha256_in_prefix": "cb2e5d814189d43e9b3182522f9e0c13486c5825faff8b6ffedcb7d303934d01", + "size_in_bytes": 2342 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/utf_8.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "52ec86541db542b1e9fda7300e948970a5e207d64fe467910e3a3f1f3d8cca6e", + "sha256_in_prefix": "52ec86541db542b1e9fda7300e948970a5e207d64fe467910e3a3f1f3d8cca6e", + "size_in_bytes": 2401 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/utf_8_sig.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "4d566ad67ef9e2685f4828515b81e66f40a4939176869eb9397777e096d85824", + "sha256_in_prefix": "4d566ad67ef9e2685f4828515b81e66f40a4939176869eb9397777e096d85824", + "size_in_bytes": 6999 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/uu_codec.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "65b3f48f0c14aa4ee38a8959c0cf0ec612aa579dfa0f6aee0bbac9c64a046420", + "sha256_in_prefix": "65b3f48f0c14aa4ee38a8959c0cf0ec612aa579dfa0f6aee0bbac9c64a046420", + "size_in_bytes": 4869 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/zlib_codec.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "3d25b03998e70420a072332284aa57912c4384122a9b63e9a901df1e3e8a65e6", + "sha256_in_prefix": "3d25b03998e70420a072332284aa57912c4384122a9b63e9a901df1e3e8a65e6", + "size_in_bytes": 4495 + }, + { + "_path": "lib/python3.12/encodings/aliases.py", + "path_type": "hardlink", + "sha256": "6fdcc49ba23a0203ae6cf28e608f8e6297d7c4d77d52e651db3cb49b9564c6d2", + "sha256_in_prefix": "6fdcc49ba23a0203ae6cf28e608f8e6297d7c4d77d52e651db3cb49b9564c6d2", + "size_in_bytes": 15677 + }, + { + "_path": "lib/python3.12/encodings/ascii.py", + "path_type": "hardlink", + "sha256": "578aa1173f7cc60dad2895071287fe6182bd14787b3fbf47a6c7983dfe3675e3", + "sha256_in_prefix": "578aa1173f7cc60dad2895071287fe6182bd14787b3fbf47a6c7983dfe3675e3", + "size_in_bytes": 1248 + }, + { + "_path": "lib/python3.12/encodings/base64_codec.py", + "path_type": "hardlink", + "sha256": "cf9ac7a464f541492486241d1b4bf33e37b45c6499275cc4d69c5a8e564e5976", + "sha256_in_prefix": "cf9ac7a464f541492486241d1b4bf33e37b45c6499275cc4d69c5a8e564e5976", + "size_in_bytes": 1533 + }, + { + "_path": "lib/python3.12/encodings/big5.py", + "path_type": "hardlink", + "sha256": "98fac6f86a20dd05da197e2058176ebfd47edee7074c3248f5f48fe0fb672d7c", + "sha256_in_prefix": "98fac6f86a20dd05da197e2058176ebfd47edee7074c3248f5f48fe0fb672d7c", + "size_in_bytes": 1019 + }, + { + "_path": "lib/python3.12/encodings/big5hkscs.py", + "path_type": "hardlink", + "sha256": "21d051a00fb5c6a86ba187e0c50e811d659ce00991fd5f5b408f71ebb2ef0f16", + "sha256_in_prefix": "21d051a00fb5c6a86ba187e0c50e811d659ce00991fd5f5b408f71ebb2ef0f16", + "size_in_bytes": 1039 + }, + { + "_path": "lib/python3.12/encodings/bz2_codec.py", + "path_type": "hardlink", + "sha256": "1181a2a89102a2b1d2b2f1f4473236d5d1ececdd0be8fdaa498a3dbe21a185ab", + "sha256_in_prefix": "1181a2a89102a2b1d2b2f1f4473236d5d1ececdd0be8fdaa498a3dbe21a185ab", + "size_in_bytes": 2249 + }, + { + "_path": "lib/python3.12/encodings/charmap.py", + "path_type": "hardlink", + "sha256": "1b8b5fdb36ce3becc62a6115ed904a17083949ec8aaef5a80f7078cec232f43b", + "sha256_in_prefix": "1b8b5fdb36ce3becc62a6115ed904a17083949ec8aaef5a80f7078cec232f43b", + "size_in_bytes": 2084 + }, + { + "_path": "lib/python3.12/encodings/cp037.py", + "path_type": "hardlink", + "sha256": "fda6ca994d710e4e0c760e0204c29a4273fc0f14ebe3169306d2eb54c9953f58", + "sha256_in_prefix": "fda6ca994d710e4e0c760e0204c29a4273fc0f14ebe3169306d2eb54c9953f58", + "size_in_bytes": 13121 + }, + { + "_path": "lib/python3.12/encodings/cp1006.py", + "path_type": "hardlink", + "sha256": "eaded38b427841bdf280e878f1e26da506e743eaa9429075332af60cce429473", + "sha256_in_prefix": "eaded38b427841bdf280e878f1e26da506e743eaa9429075332af60cce429473", + "size_in_bytes": 13568 + }, + { + "_path": "lib/python3.12/encodings/cp1026.py", + "path_type": "hardlink", + "sha256": "f5227237dd7ce5005b16a8e4d8342f0d193193c878e3cf35b9305d22b3b1aaf9", + "sha256_in_prefix": "f5227237dd7ce5005b16a8e4d8342f0d193193c878e3cf35b9305d22b3b1aaf9", + "size_in_bytes": 13113 + }, + { + "_path": "lib/python3.12/encodings/cp1125.py", + "path_type": "hardlink", + "sha256": "f84c7d30ce222e6a50cff1a4c9737173411da108cbd2c9bb57c854480103c470", + "sha256_in_prefix": "f84c7d30ce222e6a50cff1a4c9737173411da108cbd2c9bb57c854480103c470", + "size_in_bytes": 34597 + }, + { + "_path": "lib/python3.12/encodings/cp1140.py", + "path_type": "hardlink", + "sha256": "3379d78b244aa905ffe1171a968caaf41b9a0154d1ddc76c05a2abaca2b289fd", + "sha256_in_prefix": "3379d78b244aa905ffe1171a968caaf41b9a0154d1ddc76c05a2abaca2b289fd", + "size_in_bytes": 13105 + }, + { + "_path": "lib/python3.12/encodings/cp1250.py", + "path_type": "hardlink", + "sha256": "ebcec1adf9167863fb0bab29708c546300c80a77ef07838c9e0437a59e265970", + "sha256_in_prefix": "ebcec1adf9167863fb0bab29708c546300c80a77ef07838c9e0437a59e265970", + "size_in_bytes": 13686 + }, + { + "_path": "lib/python3.12/encodings/cp1251.py", + "path_type": "hardlink", + "sha256": "d57f8cfa34494c5acb6692ddb31f616ae2dd89a075d2af6d36b0b7ec2ffe7af1", + "sha256_in_prefix": "d57f8cfa34494c5acb6692ddb31f616ae2dd89a075d2af6d36b0b7ec2ffe7af1", + "size_in_bytes": 13361 + }, + { + "_path": "lib/python3.12/encodings/cp1252.py", + "path_type": "hardlink", + "sha256": "19aa5bee667f5fb387924a813aec9fa1dda47769d09e8483a748bdb202be6a84", + "sha256_in_prefix": "19aa5bee667f5fb387924a813aec9fa1dda47769d09e8483a748bdb202be6a84", + "size_in_bytes": 13511 + }, + { + "_path": "lib/python3.12/encodings/cp1253.py", + "path_type": "hardlink", + "sha256": "8c27696dcfb6894b378869bc89f113703fbd1e9b13a83934463d5999b055d1e8", + "sha256_in_prefix": "8c27696dcfb6894b378869bc89f113703fbd1e9b13a83934463d5999b055d1e8", + "size_in_bytes": 13094 + }, + { + "_path": "lib/python3.12/encodings/cp1254.py", + "path_type": "hardlink", + "sha256": "06517ec2f74f1c6562d0a1a500c48ba43f2e6e9d0c3d28356d747f274f1a4c8d", + "sha256_in_prefix": "06517ec2f74f1c6562d0a1a500c48ba43f2e6e9d0c3d28356d747f274f1a4c8d", + "size_in_bytes": 13502 + }, + { + "_path": "lib/python3.12/encodings/cp1255.py", + "path_type": "hardlink", + "sha256": "54a1b5087578fa78e5bdd0afa6a9e80e8c5467c1e4226cf6e586cfe7a674a653", + "sha256_in_prefix": "54a1b5087578fa78e5bdd0afa6a9e80e8c5467c1e4226cf6e586cfe7a674a653", + "size_in_bytes": 12466 + }, + { + "_path": "lib/python3.12/encodings/cp1256.py", + "path_type": "hardlink", + "sha256": "ad3768ac2fef2a646b3301c20af705f4d4a1544f22fa8a84241bada27ab84133", + "sha256_in_prefix": "ad3768ac2fef2a646b3301c20af705f4d4a1544f22fa8a84241bada27ab84133", + "size_in_bytes": 12814 + }, + { + "_path": "lib/python3.12/encodings/cp1257.py", + "path_type": "hardlink", + "sha256": "d9149d2925b3f719809ef2297e541461079f15c658af207a3e498be314ab2c6b", + "sha256_in_prefix": "d9149d2925b3f719809ef2297e541461079f15c658af207a3e498be314ab2c6b", + "size_in_bytes": 13374 + }, + { + "_path": "lib/python3.12/encodings/cp1258.py", + "path_type": "hardlink", + "sha256": "672e05b51952a82c8dbd5603769195fcedf565e457bb86c0d5bae04955d04630", + "sha256_in_prefix": "672e05b51952a82c8dbd5603769195fcedf565e457bb86c0d5bae04955d04630", + "size_in_bytes": 13364 + }, + { + "_path": "lib/python3.12/encodings/cp273.py", + "path_type": "hardlink", + "sha256": "6c6aec3b213ea3aebc2c526dd4d121c95d4a25a2fc928a87cd80f8448988185f", + "sha256_in_prefix": "6c6aec3b213ea3aebc2c526dd4d121c95d4a25a2fc928a87cd80f8448988185f", + "size_in_bytes": 14132 + }, + { + "_path": "lib/python3.12/encodings/cp424.py", + "path_type": "hardlink", + "sha256": "30414c2186ea0802bbf3db034122ddec1f8a10061b97c50871e14b74ee36d0ca", + "sha256_in_prefix": "30414c2186ea0802bbf3db034122ddec1f8a10061b97c50871e14b74ee36d0ca", + "size_in_bytes": 12055 + }, + { + "_path": "lib/python3.12/encodings/cp437.py", + "path_type": "hardlink", + "sha256": "5c2a5015cd36cf7f561269f33dec4c323093d3d88b0673969accdabdcb9ce2cb", + "sha256_in_prefix": "5c2a5015cd36cf7f561269f33dec4c323093d3d88b0673969accdabdcb9ce2cb", + "size_in_bytes": 34564 + }, + { + "_path": "lib/python3.12/encodings/cp500.py", + "path_type": "hardlink", + "sha256": "630f503f9110d98ea3e1529f2f965ebc275a2f78d3de47f8e9b69d35589d764b", + "sha256_in_prefix": "630f503f9110d98ea3e1529f2f965ebc275a2f78d3de47f8e9b69d35589d764b", + "size_in_bytes": 13121 + }, + { + "_path": "lib/python3.12/encodings/cp720.py", + "path_type": "hardlink", + "sha256": "395496001271b92efe5df07fc0ae7c3410d1dd2bdfebbd3e4d8e806c8166beb0", + "sha256_in_prefix": "395496001271b92efe5df07fc0ae7c3410d1dd2bdfebbd3e4d8e806c8166beb0", + "size_in_bytes": 13686 + }, + { + "_path": "lib/python3.12/encodings/cp737.py", + "path_type": "hardlink", + "sha256": "be3ca1785a3970ec62310710eaf7de82932181b04d06fe4528f8adaba9fb8c4b", + "sha256_in_prefix": "be3ca1785a3970ec62310710eaf7de82932181b04d06fe4528f8adaba9fb8c4b", + "size_in_bytes": 34681 + }, + { + "_path": "lib/python3.12/encodings/cp775.py", + "path_type": "hardlink", + "sha256": "e0dba85b99329d7f16907e620adada06be5216abcb964406c827b569b2cf1aeb", + "sha256_in_prefix": "e0dba85b99329d7f16907e620adada06be5216abcb964406c827b569b2cf1aeb", + "size_in_bytes": 34476 + }, + { + "_path": "lib/python3.12/encodings/cp850.py", + "path_type": "hardlink", + "sha256": "257e29f235e2a8790dd68cee45668776648bab809ce8584f893cdd8fd007993c", + "sha256_in_prefix": "257e29f235e2a8790dd68cee45668776648bab809ce8584f893cdd8fd007993c", + "size_in_bytes": 34105 + }, + { + "_path": "lib/python3.12/encodings/cp852.py", + "path_type": "hardlink", + "sha256": "cc6faaa9dc4a933127da0aaacd1dc7a44c09266051af56bfe3215ff228636b6b", + "sha256_in_prefix": "cc6faaa9dc4a933127da0aaacd1dc7a44c09266051af56bfe3215ff228636b6b", + "size_in_bytes": 35002 + }, + { + "_path": "lib/python3.12/encodings/cp855.py", + "path_type": "hardlink", + "sha256": "7b25c61c9e8c47b218d3fbb801541a2861926ac712843d2113fff90e2074f5ba", + "sha256_in_prefix": "7b25c61c9e8c47b218d3fbb801541a2861926ac712843d2113fff90e2074f5ba", + "size_in_bytes": 33850 + }, + { + "_path": "lib/python3.12/encodings/cp856.py", + "path_type": "hardlink", + "sha256": "2e52ec5cb1eafa6739b5569b0b98ee89df5f7358b84ccdc8da64e86f017d359f", + "sha256_in_prefix": "2e52ec5cb1eafa6739b5569b0b98ee89df5f7358b84ccdc8da64e86f017d359f", + "size_in_bytes": 12423 + }, + { + "_path": "lib/python3.12/encodings/cp857.py", + "path_type": "hardlink", + "sha256": "8d1b769058bfccdb3c6c70c49a104f5081a2fcc9fad68f7b5eb3e4f67f0b33da", + "sha256_in_prefix": "8d1b769058bfccdb3c6c70c49a104f5081a2fcc9fad68f7b5eb3e4f67f0b33da", + "size_in_bytes": 33908 + }, + { + "_path": "lib/python3.12/encodings/cp858.py", + "path_type": "hardlink", + "sha256": "a24930c4a6ad0ff66dde9a69f2027e4b92c2c9c61dcda2992e940654c606577b", + "sha256_in_prefix": "a24930c4a6ad0ff66dde9a69f2027e4b92c2c9c61dcda2992e940654c606577b", + "size_in_bytes": 34015 + }, + { + "_path": "lib/python3.12/encodings/cp860.py", + "path_type": "hardlink", + "sha256": "2dfae7e31d3d9aa3013cff44a4d7ad842f257ac63765a9998436701b629cd86a", + "sha256_in_prefix": "2dfae7e31d3d9aa3013cff44a4d7ad842f257ac63765a9998436701b629cd86a", + "size_in_bytes": 34681 + }, + { + "_path": "lib/python3.12/encodings/cp861.py", + "path_type": "hardlink", + "sha256": "701930d77a2177497586e99bc3fe60f2d4beffb645608f167c76874a72ff405e", + "sha256_in_prefix": "701930d77a2177497586e99bc3fe60f2d4beffb645608f167c76874a72ff405e", + "size_in_bytes": 34633 + }, + { + "_path": "lib/python3.12/encodings/cp862.py", + "path_type": "hardlink", + "sha256": "15a2844b6ed9544c6400cf7299b42d0c2bef93c9bee70a9e89f66b8610ad6d6d", + "sha256_in_prefix": "15a2844b6ed9544c6400cf7299b42d0c2bef93c9bee70a9e89f66b8610ad6d6d", + "size_in_bytes": 33370 + }, + { + "_path": "lib/python3.12/encodings/cp863.py", + "path_type": "hardlink", + "sha256": "a3d57f61fce1b98fc81ea8e4ebebaf402fae40bbcdd35d4b8297b9bb49a79aa2", + "sha256_in_prefix": "a3d57f61fce1b98fc81ea8e4ebebaf402fae40bbcdd35d4b8297b9bb49a79aa2", + "size_in_bytes": 34252 + }, + { + "_path": "lib/python3.12/encodings/cp864.py", + "path_type": "hardlink", + "sha256": "15ad8f1fdfdd842c7522241372e7eddda7df687e815692a89157c5f256f21a08", + "sha256_in_prefix": "15ad8f1fdfdd842c7522241372e7eddda7df687e815692a89157c5f256f21a08", + "size_in_bytes": 33663 + }, + { + "_path": "lib/python3.12/encodings/cp865.py", + "path_type": "hardlink", + "sha256": "bdbaded987242ed2a8de7133ec2f61ddcc1c2e9de27816ab7cd0a4c678a3a907", + "sha256_in_prefix": "bdbaded987242ed2a8de7133ec2f61ddcc1c2e9de27816ab7cd0a4c678a3a907", + "size_in_bytes": 34618 + }, + { + "_path": "lib/python3.12/encodings/cp866.py", + "path_type": "hardlink", + "sha256": "9efcc8e85bbd1687272a0991f6d0429a4c06679db2d114b2ac95db27a70f9d13", + "sha256_in_prefix": "9efcc8e85bbd1687272a0991f6d0429a4c06679db2d114b2ac95db27a70f9d13", + "size_in_bytes": 34396 + }, + { + "_path": "lib/python3.12/encodings/cp869.py", + "path_type": "hardlink", + "sha256": "52582d9fb769b24eac7154f18d7dae856588297d6da98f37fb5efd8da883826d", + "sha256_in_prefix": "52582d9fb769b24eac7154f18d7dae856588297d6da98f37fb5efd8da883826d", + "size_in_bytes": 32965 + }, + { + "_path": "lib/python3.12/encodings/cp874.py", + "path_type": "hardlink", + "sha256": "fe4752fa2e65741e08a563a31ff914fe71068942ce9c6f4070b1dfd7b25e5e7f", + "sha256_in_prefix": "fe4752fa2e65741e08a563a31ff914fe71068942ce9c6f4070b1dfd7b25e5e7f", + "size_in_bytes": 12595 + }, + { + "_path": "lib/python3.12/encodings/cp875.py", + "path_type": "hardlink", + "sha256": "2fe72632015db2cba2bb4367055551da6fe22051b96d170c7b96fa271c46b257", + "sha256_in_prefix": "2fe72632015db2cba2bb4367055551da6fe22051b96d170c7b96fa271c46b257", + "size_in_bytes": 12854 + }, + { + "_path": "lib/python3.12/encodings/cp932.py", + "path_type": "hardlink", + "sha256": "99748e28113d2d49f5d666b49b78accd2c6e10a7852f7dd6dece9b5b71aa83c4", + "sha256_in_prefix": "99748e28113d2d49f5d666b49b78accd2c6e10a7852f7dd6dece9b5b71aa83c4", + "size_in_bytes": 1023 + }, + { + "_path": "lib/python3.12/encodings/cp949.py", + "path_type": "hardlink", + "sha256": "950a7d29467ce0590b4a1137830d43d88d8f20e4035dcaaa8b2a5c3c3f1de962", + "sha256_in_prefix": "950a7d29467ce0590b4a1137830d43d88d8f20e4035dcaaa8b2a5c3c3f1de962", + "size_in_bytes": 1023 + }, + { + "_path": "lib/python3.12/encodings/cp950.py", + "path_type": "hardlink", + "sha256": "27811178b450731fc955b1247656a605d04e5ee98e0d585e4596b94b703a27f6", + "sha256_in_prefix": "27811178b450731fc955b1247656a605d04e5ee98e0d585e4596b94b703a27f6", + "size_in_bytes": 1023 + }, + { + "_path": "lib/python3.12/encodings/euc_jis_2004.py", + "path_type": "hardlink", + "sha256": "9fa426cd9f17629f6320700ed18baa94839304cf1bcabbee7edb501747dc055d", + "sha256_in_prefix": "9fa426cd9f17629f6320700ed18baa94839304cf1bcabbee7edb501747dc055d", + "size_in_bytes": 1051 + }, + { + "_path": "lib/python3.12/encodings/euc_jisx0213.py", + "path_type": "hardlink", + "sha256": "e28315910da20218dae8b7d5becd81de1e283dfd8b0415a4980d67065de73a0b", + "sha256_in_prefix": "e28315910da20218dae8b7d5becd81de1e283dfd8b0415a4980d67065de73a0b", + "size_in_bytes": 1051 + }, + { + "_path": "lib/python3.12/encodings/euc_jp.py", + "path_type": "hardlink", + "sha256": "b453a439787b0efa031e43416a7d852a6be705c985e1200693eb96d87ea79cdc", + "sha256_in_prefix": "b453a439787b0efa031e43416a7d852a6be705c985e1200693eb96d87ea79cdc", + "size_in_bytes": 1027 + }, + { + "_path": "lib/python3.12/encodings/euc_kr.py", + "path_type": "hardlink", + "sha256": "633a1a5504bfad04b1ec9c96d44d4ebb3bb99066a218318e7d67d866e20887a6", + "sha256_in_prefix": "633a1a5504bfad04b1ec9c96d44d4ebb3bb99066a218318e7d67d866e20887a6", + "size_in_bytes": 1027 + }, + { + "_path": "lib/python3.12/encodings/gb18030.py", + "path_type": "hardlink", + "sha256": "6c10b4dc49bc63724e539137ede6936304fcca1c97c28d16d89f381e10849521", + "sha256_in_prefix": "6c10b4dc49bc63724e539137ede6936304fcca1c97c28d16d89f381e10849521", + "size_in_bytes": 1031 + }, + { + "_path": "lib/python3.12/encodings/gb2312.py", + "path_type": "hardlink", + "sha256": "3d2d567d8d079b78f3f3b566ed52ad2f38af61bf832b7dc28858b0039a032d6b", + "sha256_in_prefix": "3d2d567d8d079b78f3f3b566ed52ad2f38af61bf832b7dc28858b0039a032d6b", + "size_in_bytes": 1027 + }, + { + "_path": "lib/python3.12/encodings/gbk.py", + "path_type": "hardlink", + "sha256": "eff9b8cbc9ad2ef2e10e96afa83d3db1f775ea044aed275b7a35574ae0d8645b", + "sha256_in_prefix": "eff9b8cbc9ad2ef2e10e96afa83d3db1f775ea044aed275b7a35574ae0d8645b", + "size_in_bytes": 1015 + }, + { + "_path": "lib/python3.12/encodings/hex_codec.py", + "path_type": "hardlink", + "sha256": "fc5f0a31b59efe990b86efb98936769f33dd91d912ce55b49a5a4cfc516cd047", + "sha256_in_prefix": "fc5f0a31b59efe990b86efb98936769f33dd91d912ce55b49a5a4cfc516cd047", + "size_in_bytes": 1508 + }, + { + "_path": "lib/python3.12/encodings/hp_roman8.py", + "path_type": "hardlink", + "sha256": "c43cce763d12e8f71a63dbc16641bd87147eaf5f9d9054ea856864b216b2735b", + "sha256_in_prefix": "c43cce763d12e8f71a63dbc16641bd87147eaf5f9d9054ea856864b216b2735b", + "size_in_bytes": 13475 + }, + { + "_path": "lib/python3.12/encodings/hz.py", + "path_type": "hardlink", + "sha256": "025a9531e3046e52d3e039c0be04f9a5a74651d7683a13c7c7ebd4c7dfb5996a", + "sha256_in_prefix": "025a9531e3046e52d3e039c0be04f9a5a74651d7683a13c7c7ebd4c7dfb5996a", + "size_in_bytes": 1011 + }, + { + "_path": "lib/python3.12/encodings/idna.py", + "path_type": "hardlink", + "sha256": "9ca58e82d12b171f25d57239ad237dae5c44214a70f2f4f39358c2759b8b9013", + "sha256_in_prefix": "9ca58e82d12b171f25d57239ad237dae5c44214a70f2f4f39358c2759b8b9013", + "size_in_bytes": 9710 + }, + { + "_path": "lib/python3.12/encodings/iso2022_jp.py", + "path_type": "hardlink", + "sha256": "461a0e7f72eccb8b29f351c4e7926cfbda58e0edd6d0770bd82e0b36c5febe77", + "sha256_in_prefix": "461a0e7f72eccb8b29f351c4e7926cfbda58e0edd6d0770bd82e0b36c5febe77", + "size_in_bytes": 1053 + }, + { + "_path": "lib/python3.12/encodings/iso2022_jp_1.py", + "path_type": "hardlink", + "sha256": "63bacad13a979a5519fcaa4f1e1e07b2c7415005167fac3a689408c7d886fabd", + "sha256_in_prefix": "63bacad13a979a5519fcaa4f1e1e07b2c7415005167fac3a689408c7d886fabd", + "size_in_bytes": 1061 + }, + { + "_path": "lib/python3.12/encodings/iso2022_jp_2.py", + "path_type": "hardlink", + "sha256": "5d4248181548b0fc89a9f5ee9cf52ebecb235708ba87d47896ad14130884ef9f", + "sha256_in_prefix": "5d4248181548b0fc89a9f5ee9cf52ebecb235708ba87d47896ad14130884ef9f", + "size_in_bytes": 1061 + }, + { + "_path": "lib/python3.12/encodings/iso2022_jp_2004.py", + "path_type": "hardlink", + "sha256": "b4d1468bcd608b46f38cb0c6ef115510dcf9aa0f71e590792f407efc6e165164", + "sha256_in_prefix": "b4d1468bcd608b46f38cb0c6ef115510dcf9aa0f71e590792f407efc6e165164", + "size_in_bytes": 1073 + }, + { + "_path": "lib/python3.12/encodings/iso2022_jp_3.py", + "path_type": "hardlink", + "sha256": "3aceaa5661909de14e2861d864443b8472460ce39b99cce5c6965346d47aa5ac", + "sha256_in_prefix": "3aceaa5661909de14e2861d864443b8472460ce39b99cce5c6965346d47aa5ac", + "size_in_bytes": 1061 + }, + { + "_path": "lib/python3.12/encodings/iso2022_jp_ext.py", + "path_type": "hardlink", + "sha256": "f4c9ed8f3031995faa224bcb10153d2b6144944477d1f27d1a6cc4a879fac34c", + "sha256_in_prefix": "f4c9ed8f3031995faa224bcb10153d2b6144944477d1f27d1a6cc4a879fac34c", + "size_in_bytes": 1069 + }, + { + "_path": "lib/python3.12/encodings/iso2022_kr.py", + "path_type": "hardlink", + "sha256": "1c86362e17944f0bcf68db02f4995bdeea605867795fff7ab4079073f96705e4", + "sha256_in_prefix": "1c86362e17944f0bcf68db02f4995bdeea605867795fff7ab4079073f96705e4", + "size_in_bytes": 1053 + }, + { + "_path": "lib/python3.12/encodings/iso8859_1.py", + "path_type": "hardlink", + "sha256": "b5cebd515e057d670bf54e10b8a6f162ef3daa7f21b146aee3249160caf3c32d", + "sha256_in_prefix": "b5cebd515e057d670bf54e10b8a6f162ef3daa7f21b146aee3249160caf3c32d", + "size_in_bytes": 13176 + }, + { + "_path": "lib/python3.12/encodings/iso8859_10.py", + "path_type": "hardlink", + "sha256": "54c886b41819ebb7f4fb34b8dbae1c45f4fc0864f019ecd772676ccfac5fae7b", + "sha256_in_prefix": "54c886b41819ebb7f4fb34b8dbae1c45f4fc0864f019ecd772676ccfac5fae7b", + "size_in_bytes": 13589 + }, + { + "_path": "lib/python3.12/encodings/iso8859_11.py", + "path_type": "hardlink", + "sha256": "ed5a964470a241b4da7a6cfb718e4149d09644933af38f0497602baab6e563ef", + "sha256_in_prefix": "ed5a964470a241b4da7a6cfb718e4149d09644933af38f0497602baab6e563ef", + "size_in_bytes": 12335 + }, + { + "_path": "lib/python3.12/encodings/iso8859_13.py", + "path_type": "hardlink", + "sha256": "7312237e8e5d201d920b4130f057cfdf1b0be9baafaa246826e6d93204fcc206", + "sha256_in_prefix": "7312237e8e5d201d920b4130f057cfdf1b0be9baafaa246826e6d93204fcc206", + "size_in_bytes": 13271 + }, + { + "_path": "lib/python3.12/encodings/iso8859_14.py", + "path_type": "hardlink", + "sha256": "82778b995a0ee87c5f1180fcc52900359eee15bd9a6e3a0e25f0d963e0b2a343", + "sha256_in_prefix": "82778b995a0ee87c5f1180fcc52900359eee15bd9a6e3a0e25f0d963e0b2a343", + "size_in_bytes": 13652 + }, + { + "_path": "lib/python3.12/encodings/iso8859_15.py", + "path_type": "hardlink", + "sha256": "01976a81811873dc9a0c79db9fc00d1c30103487f3c6bc3a6d81b4043cd48e02", + "sha256_in_prefix": "01976a81811873dc9a0c79db9fc00d1c30103487f3c6bc3a6d81b4043cd48e02", + "size_in_bytes": 13212 + }, + { + "_path": "lib/python3.12/encodings/iso8859_16.py", + "path_type": "hardlink", + "sha256": "b5ac8f5a5d8f84c0f903b2b7c342184758d590d8bcf810d561f942fe5b372d66", + "sha256_in_prefix": "b5ac8f5a5d8f84c0f903b2b7c342184758d590d8bcf810d561f942fe5b372d66", + "size_in_bytes": 13557 + }, + { + "_path": "lib/python3.12/encodings/iso8859_2.py", + "path_type": "hardlink", + "sha256": "2b57cab6111cae9021505e3ae1b2adbbfc344ec48165fda322f6b069fbb18adc", + "sha256_in_prefix": "2b57cab6111cae9021505e3ae1b2adbbfc344ec48165fda322f6b069fbb18adc", + "size_in_bytes": 13404 + }, + { + "_path": "lib/python3.12/encodings/iso8859_3.py", + "path_type": "hardlink", + "sha256": "4ffdf89004bf0c5230caa7079f7ca3142fc112f8b923ddb2c7358369d2d3c242", + "sha256_in_prefix": "4ffdf89004bf0c5230caa7079f7ca3142fc112f8b923ddb2c7358369d2d3c242", + "size_in_bytes": 13089 + }, + { + "_path": "lib/python3.12/encodings/iso8859_4.py", + "path_type": "hardlink", + "sha256": "87bd130daa0eaef3e4cb465e10cffb2bcd194ff74097e0c186b4b8eb7be41ac5", + "sha256_in_prefix": "87bd130daa0eaef3e4cb465e10cffb2bcd194ff74097e0c186b4b8eb7be41ac5", + "size_in_bytes": 13376 + }, + { + "_path": "lib/python3.12/encodings/iso8859_5.py", + "path_type": "hardlink", + "sha256": "9961d96cc7b9fdf011ebcaaeaeca7b50b8670fadbd7b75fde66192f8c1f68f30", + "sha256_in_prefix": "9961d96cc7b9fdf011ebcaaeaeca7b50b8670fadbd7b75fde66192f8c1f68f30", + "size_in_bytes": 13015 + }, + { + "_path": "lib/python3.12/encodings/iso8859_6.py", + "path_type": "hardlink", + "sha256": "4840e68014346517680f593ca22f67133c39ba7e46f34b9be62c980a728448c6", + "sha256_in_prefix": "4840e68014346517680f593ca22f67133c39ba7e46f34b9be62c980a728448c6", + "size_in_bytes": 10833 + }, + { + "_path": "lib/python3.12/encodings/iso8859_7.py", + "path_type": "hardlink", + "sha256": "b352eca3b819488f64fb3338fd93f39c1e30f32bb13f2f9c577925e58f2960e4", + "sha256_in_prefix": "b352eca3b819488f64fb3338fd93f39c1e30f32bb13f2f9c577925e58f2960e4", + "size_in_bytes": 12844 + }, + { + "_path": "lib/python3.12/encodings/iso8859_8.py", + "path_type": "hardlink", + "sha256": "4cf9e8a8bbe04accb1c1a80853efb19ae0772d18f81e270adefc1b2386cb368e", + "sha256_in_prefix": "4cf9e8a8bbe04accb1c1a80853efb19ae0772d18f81e270adefc1b2386cb368e", + "size_in_bytes": 11036 + }, + { + "_path": "lib/python3.12/encodings/iso8859_9.py", + "path_type": "hardlink", + "sha256": "84d9b15263e81685f7513c5ab45caf80b2f73c301c68e659f7162c1b1882d359", + "sha256_in_prefix": "84d9b15263e81685f7513c5ab45caf80b2f73c301c68e659f7162c1b1882d359", + "size_in_bytes": 13156 + }, + { + "_path": "lib/python3.12/encodings/johab.py", + "path_type": "hardlink", + "sha256": "9586615917afd3d848c1c4328656603b2834af6115f2aec932fccc935e1a60fb", + "sha256_in_prefix": "9586615917afd3d848c1c4328656603b2834af6115f2aec932fccc935e1a60fb", + "size_in_bytes": 1023 + }, + { + "_path": "lib/python3.12/encodings/koi8_r.py", + "path_type": "hardlink", + "sha256": "4d4e353aee8039bb71e2145a6e68fe1e6833a1b4250b70ee0ac5ec70bbb8c51d", + "sha256_in_prefix": "4d4e353aee8039bb71e2145a6e68fe1e6833a1b4250b70ee0ac5ec70bbb8c51d", + "size_in_bytes": 13779 + }, + { + "_path": "lib/python3.12/encodings/koi8_t.py", + "path_type": "hardlink", + "sha256": "9c9043814abdbe7dc39ff98f3857d5d110a84c978ad2304158d810a4e9eacef1", + "sha256_in_prefix": "9c9043814abdbe7dc39ff98f3857d5d110a84c978ad2304158d810a4e9eacef1", + "size_in_bytes": 13193 + }, + { + "_path": "lib/python3.12/encodings/koi8_u.py", + "path_type": "hardlink", + "sha256": "d449f9858e357fa8c2edbd4b9fe739337e9f201cac3ded20f99bfcecd4970ff7", + "sha256_in_prefix": "d449f9858e357fa8c2edbd4b9fe739337e9f201cac3ded20f99bfcecd4970ff7", + "size_in_bytes": 13762 + }, + { + "_path": "lib/python3.12/encodings/kz1048.py", + "path_type": "hardlink", + "sha256": "76beb30e98a911f72f97609a2373782573c17c88a5fb3537db338aa382979ffc", + "sha256_in_prefix": "76beb30e98a911f72f97609a2373782573c17c88a5fb3537db338aa382979ffc", + "size_in_bytes": 13723 + }, + { + "_path": "lib/python3.12/encodings/latin_1.py", + "path_type": "hardlink", + "sha256": "b75503e532a27c636477396c855209ff5f3036536d2a4bede0a576c89382b60c", + "sha256_in_prefix": "b75503e532a27c636477396c855209ff5f3036536d2a4bede0a576c89382b60c", + "size_in_bytes": 1264 + }, + { + "_path": "lib/python3.12/encodings/mac_arabic.py", + "path_type": "hardlink", + "sha256": "5eafd9a3136abfbd8ed52df9c90203c7a283e7429ed60502a87a02511e0fb777", + "sha256_in_prefix": "5eafd9a3136abfbd8ed52df9c90203c7a283e7429ed60502a87a02511e0fb777", + "size_in_bytes": 36467 + }, + { + "_path": "lib/python3.12/encodings/mac_croatian.py", + "path_type": "hardlink", + "sha256": "a880cd05c82a8d11a29c65ee86a396def3344465dd71441b0bb4a73826024953", + "sha256_in_prefix": "a880cd05c82a8d11a29c65ee86a396def3344465dd71441b0bb4a73826024953", + "size_in_bytes": 13633 + }, + { + "_path": "lib/python3.12/encodings/mac_cyrillic.py", + "path_type": "hardlink", + "sha256": "83616786a1c6308b03a0dc82536908d24d0974b2248d67393d613fe558cea4bd", + "sha256_in_prefix": "83616786a1c6308b03a0dc82536908d24d0974b2248d67393d613fe558cea4bd", + "size_in_bytes": 13454 + }, + { + "_path": "lib/python3.12/encodings/mac_farsi.py", + "path_type": "hardlink", + "sha256": "f5763c38fb4ab0423fafe2fdca34d6f9932ac7f1a74c0cd8109d60234c7dc624", + "sha256_in_prefix": "f5763c38fb4ab0423fafe2fdca34d6f9932ac7f1a74c0cd8109d60234c7dc624", + "size_in_bytes": 15170 + }, + { + "_path": "lib/python3.12/encodings/mac_greek.py", + "path_type": "hardlink", + "sha256": "63016a323ddf98cb3aa9cfa78f3bab4768bedbfe9a5262a36a5aecb13d291f6e", + "sha256_in_prefix": "63016a323ddf98cb3aa9cfa78f3bab4768bedbfe9a5262a36a5aecb13d291f6e", + "size_in_bytes": 13721 + }, + { + "_path": "lib/python3.12/encodings/mac_iceland.py", + "path_type": "hardlink", + "sha256": "753cc1ac635caa7e1b4630fbcebef8db8db332c098154a5b11f652912bf64f37", + "sha256_in_prefix": "753cc1ac635caa7e1b4630fbcebef8db8db332c098154a5b11f652912bf64f37", + "size_in_bytes": 13498 + }, + { + "_path": "lib/python3.12/encodings/mac_latin2.py", + "path_type": "hardlink", + "sha256": "31670da18ce8b5394cd53fe6bf216268e7e8eae4c0247532e420e2e103727d50", + "sha256_in_prefix": "31670da18ce8b5394cd53fe6bf216268e7e8eae4c0247532e420e2e103727d50", + "size_in_bytes": 14118 + }, + { + "_path": "lib/python3.12/encodings/mac_roman.py", + "path_type": "hardlink", + "sha256": "230367d96aef8e8d7f185b4acfb84923714f39ddbcbf9cf38a06bf6f5d621c22", + "sha256_in_prefix": "230367d96aef8e8d7f185b4acfb84923714f39ddbcbf9cf38a06bf6f5d621c22", + "size_in_bytes": 13480 + }, + { + "_path": "lib/python3.12/encodings/mac_romanian.py", + "path_type": "hardlink", + "sha256": "49630cf035c19e896a123ed6e5fee18b5e485123daf2f15da38bf727ff387bee", + "sha256_in_prefix": "49630cf035c19e896a123ed6e5fee18b5e485123daf2f15da38bf727ff387bee", + "size_in_bytes": 13661 + }, + { + "_path": "lib/python3.12/encodings/mac_turkish.py", + "path_type": "hardlink", + "sha256": "99758a5cad2825cb3be3fa5d031e0821e4eba910a46f417fd890207b9b6be77b", + "sha256_in_prefix": "99758a5cad2825cb3be3fa5d031e0821e4eba910a46f417fd890207b9b6be77b", + "size_in_bytes": 13513 + }, + { + "_path": "lib/python3.12/encodings/mbcs.py", + "path_type": "hardlink", + "sha256": "f6ed445ed537c9f856d8defe8b56505727737d0dc9348d0a877abedab4bdd864", + "sha256_in_prefix": "f6ed445ed537c9f856d8defe8b56505727737d0dc9348d0a877abedab4bdd864", + "size_in_bytes": 1211 + }, + { + "_path": "lib/python3.12/encodings/oem.py", + "path_type": "hardlink", + "sha256": "481656d3a35f792d0e5109e3f821e6dbfcf097163a19b0cdfcbff3b3db99292f", + "sha256_in_prefix": "481656d3a35f792d0e5109e3f821e6dbfcf097163a19b0cdfcbff3b3db99292f", + "size_in_bytes": 1019 + }, + { + "_path": "lib/python3.12/encodings/palmos.py", + "path_type": "hardlink", + "sha256": "eccf7418adefcc2a59e9a07fc4e34363bd62f7e878d48c8a02730a8ed1c584c8", + "sha256_in_prefix": "eccf7418adefcc2a59e9a07fc4e34363bd62f7e878d48c8a02730a8ed1c584c8", + "size_in_bytes": 13519 + }, + { + "_path": "lib/python3.12/encodings/ptcp154.py", + "path_type": "hardlink", + "sha256": "0eabcb2c287d335e86b71b0abe5718bd6ddc9aaee234f0f0f2363845d2926d8d", + "sha256_in_prefix": "0eabcb2c287d335e86b71b0abe5718bd6ddc9aaee234f0f0f2363845d2926d8d", + "size_in_bytes": 14015 + }, + { + "_path": "lib/python3.12/encodings/punycode.py", + "path_type": "hardlink", + "sha256": "34edc8fb1c50e4d1cbaa1e008bb491cd7c12116c316e51974f333fe7b628eb7c", + "sha256_in_prefix": "34edc8fb1c50e4d1cbaa1e008bb491cd7c12116c316e51974f333fe7b628eb7c", + "size_in_bytes": 6883 + }, + { + "_path": "lib/python3.12/encodings/quopri_codec.py", + "path_type": "hardlink", + "sha256": "502a213c34c05a94ed063ee03f47680bd6efbb35036e06fb4dc809bf398cfa64", + "sha256_in_prefix": "502a213c34c05a94ed063ee03f47680bd6efbb35036e06fb4dc809bf398cfa64", + "size_in_bytes": 1525 + }, + { + "_path": "lib/python3.12/encodings/raw_unicode_escape.py", + "path_type": "hardlink", + "sha256": "fa6328486b8f5a5cbd10e377e80adb8cf94acbbe19c38b4e1bf708d831a80a3a", + "sha256_in_prefix": "fa6328486b8f5a5cbd10e377e80adb8cf94acbbe19c38b4e1bf708d831a80a3a", + "size_in_bytes": 1332 + }, + { + "_path": "lib/python3.12/encodings/rot_13.py", + "path_type": "hardlink", + "sha256": "14767f475acdc0bf48e6272280dd15b80efaecafb93c06be21136f83dd1ee7e4", + "sha256_in_prefix": "14767f475acdc0bf48e6272280dd15b80efaecafb93c06be21136f83dd1ee7e4", + "size_in_bytes": 2448 + }, + { + "_path": "lib/python3.12/encodings/shift_jis.py", + "path_type": "hardlink", + "sha256": "ad4ac50ebf58294304e412cc0f1b12980988dd6edc414e4110029c0a1abbe966", + "sha256_in_prefix": "ad4ac50ebf58294304e412cc0f1b12980988dd6edc414e4110029c0a1abbe966", + "size_in_bytes": 1039 + }, + { + "_path": "lib/python3.12/encodings/shift_jis_2004.py", + "path_type": "hardlink", + "sha256": "d21c5930f21063ea78fea3b0f76dfb8fd92858d2a4a200064a52126a43dd1a99", + "sha256_in_prefix": "d21c5930f21063ea78fea3b0f76dfb8fd92858d2a4a200064a52126a43dd1a99", + "size_in_bytes": 1059 + }, + { + "_path": "lib/python3.12/encodings/shift_jisx0213.py", + "path_type": "hardlink", + "sha256": "2c8d0b93bb36edf31c1236b1b4d1c0008553868bd2fc9137570115b96b834f2e", + "sha256_in_prefix": "2c8d0b93bb36edf31c1236b1b4d1c0008553868bd2fc9137570115b96b834f2e", + "size_in_bytes": 1059 + }, + { + "_path": "lib/python3.12/encodings/tis_620.py", + "path_type": "hardlink", + "sha256": "647c4719e2c1a7375105e15a89b377c66f6b699977dcabbb71d923a4607b7902", + "sha256_in_prefix": "647c4719e2c1a7375105e15a89b377c66f6b699977dcabbb71d923a4607b7902", + "size_in_bytes": 12300 + }, + { + "_path": "lib/python3.12/encodings/undefined.py", + "path_type": "hardlink", + "sha256": "85bba5c5e1007cd8c1ade5c0214bcc825396d2bbd02054e62a9f162104748b64", + "sha256_in_prefix": "85bba5c5e1007cd8c1ade5c0214bcc825396d2bbd02054e62a9f162104748b64", + "size_in_bytes": 1299 + }, + { + "_path": "lib/python3.12/encodings/unicode_escape.py", + "path_type": "hardlink", + "sha256": "507e7ca8f18df639fd823d7cc23ce4028a3550ceefdfa40b3c76f81d1a94531d", + "sha256_in_prefix": "507e7ca8f18df639fd823d7cc23ce4028a3550ceefdfa40b3c76f81d1a94531d", + "size_in_bytes": 1304 + }, + { + "_path": "lib/python3.12/encodings/utf_16.py", + "path_type": "hardlink", + "sha256": "6c36257f7b8d214473560d195e71bccef0c69a53e1e52d2800b7a7890aad7e58", + "sha256_in_prefix": "6c36257f7b8d214473560d195e71bccef0c69a53e1e52d2800b7a7890aad7e58", + "size_in_bytes": 5236 + }, + { + "_path": "lib/python3.12/encodings/utf_16_be.py", + "path_type": "hardlink", + "sha256": "3357196f3fa52433326a6626880e34964e00c5570aee50e9a0a0a7c6d86f6e4f", + "sha256_in_prefix": "3357196f3fa52433326a6626880e34964e00c5570aee50e9a0a0a7c6d86f6e4f", + "size_in_bytes": 1037 + }, + { + "_path": "lib/python3.12/encodings/utf_16_le.py", + "path_type": "hardlink", + "sha256": "3aedaf3eb49769282daef1eaedfd4fa1c31fe5eebeff67fe2307c89dc2e2fd80", + "sha256_in_prefix": "3aedaf3eb49769282daef1eaedfd4fa1c31fe5eebeff67fe2307c89dc2e2fd80", + "size_in_bytes": 1037 + }, + { + "_path": "lib/python3.12/encodings/utf_32.py", + "path_type": "hardlink", + "sha256": "2072eece5f6026ad2d3549ab193a9e38894ea15ca9d5b3cd408fd6b116acc0c2", + "sha256_in_prefix": "2072eece5f6026ad2d3549ab193a9e38894ea15ca9d5b3cd408fd6b116acc0c2", + "size_in_bytes": 5129 + }, + { + "_path": "lib/python3.12/encodings/utf_32_be.py", + "path_type": "hardlink", + "sha256": "cbba20e1f6d0879c7c4293446c371a9f79e7c90bf3c78a77a9b8fc72b18915dd", + "sha256_in_prefix": "cbba20e1f6d0879c7c4293446c371a9f79e7c90bf3c78a77a9b8fc72b18915dd", + "size_in_bytes": 930 + }, + { + "_path": "lib/python3.12/encodings/utf_32_le.py", + "path_type": "hardlink", + "sha256": "9134b91047d85b442898d59effe23e7e0cf4167ca341ae31119a731dbf880a7b", + "sha256_in_prefix": "9134b91047d85b442898d59effe23e7e0cf4167ca341ae31119a731dbf880a7b", + "size_in_bytes": 930 + }, + { + "_path": "lib/python3.12/encodings/utf_7.py", + "path_type": "hardlink", + "sha256": "9ff32314f4f1fa074f206bbf7fdb851504e5313128636d73b4bf75b886e4a87d", + "sha256_in_prefix": "9ff32314f4f1fa074f206bbf7fdb851504e5313128636d73b4bf75b886e4a87d", + "size_in_bytes": 946 + }, + { + "_path": "lib/python3.12/encodings/utf_8.py", + "path_type": "hardlink", + "sha256": "ba0cac060269583523ca9506473a755203037c57d466a11aa89a30a5f6756f3d", + "sha256_in_prefix": "ba0cac060269583523ca9506473a755203037c57d466a11aa89a30a5f6756f3d", + "size_in_bytes": 1005 + }, + { + "_path": "lib/python3.12/encodings/utf_8_sig.py", + "path_type": "hardlink", + "sha256": "1ef3da8d8aa08149e7f274dc64dbfce2155da812e5258ca8e8f832428d3b5c2d", + "sha256_in_prefix": "1ef3da8d8aa08149e7f274dc64dbfce2155da812e5258ca8e8f832428d3b5c2d", + "size_in_bytes": 4133 + }, + { + "_path": "lib/python3.12/encodings/uu_codec.py", + "path_type": "hardlink", + "sha256": "45ba92000718abf85f158563c755205e100356ce1b4ab9444b4d0a3d21f061a3", + "sha256_in_prefix": "45ba92000718abf85f158563c755205e100356ce1b4ab9444b4d0a3d21f061a3", + "size_in_bytes": 2851 + }, + { + "_path": "lib/python3.12/encodings/zlib_codec.py", + "path_type": "hardlink", + "sha256": "6ef01e8d3a5fe1cc52f7b5ae008df12f1dbce7304111bf8d4758f1bfc0115759", + "sha256_in_prefix": "6ef01e8d3a5fe1cc52f7b5ae008df12f1dbce7304111bf8d4758f1bfc0115759", + "size_in_bytes": 2204 + }, + { + "_path": "lib/python3.12/ensurepip/__init__.py", + "path_type": "hardlink", + "sha256": "02ee7ac7c72ea6f2f9124842f9fc242f4f836a547719ce12f8ac3018e0409f56", + "sha256_in_prefix": "02ee7ac7c72ea6f2f9124842f9fc242f4f836a547719ce12f8ac3018e0409f56", + "size_in_bytes": 9443 + }, + { + "_path": "lib/python3.12/ensurepip/__main__.py", + "path_type": "hardlink", + "sha256": "ee735f518d0fc4dfec81f7aa3da1e052372ed4202c0da4eddd2587840beaecd7", + "sha256_in_prefix": "ee735f518d0fc4dfec81f7aa3da1e052372ed4202c0da4eddd2587840beaecd7", + "size_in_bytes": 88 + }, + { + "_path": "lib/python3.12/ensurepip/__pycache__/__init__.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "725d964acad1b2836f097097f0cd6289f5c2fcc14a2f91541f46c31160f8e7a3", + "sha256_in_prefix": "725d964acad1b2836f097097f0cd6289f5c2fcc14a2f91541f46c31160f8e7a3", + "size_in_bytes": 9774 + }, + { + "_path": "lib/python3.12/ensurepip/__pycache__/__main__.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "26c404920d0ead55a22cec1f485ac9d978a44d912ef36fab4a7fb911d4d91165", + "sha256_in_prefix": "26c404920d0ead55a22cec1f485ac9d978a44d912ef36fab4a7fb911d4d91165", + "size_in_bytes": 579 + }, + { + "_path": "lib/python3.12/ensurepip/__pycache__/_uninstall.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "2c395a59e417498da4ec75a59c78f4da79d88528e3c7d49ef39496cc337bf84c", + "sha256_in_prefix": "2c395a59e417498da4ec75a59c78f4da79d88528e3c7d49ef39496cc337bf84c", + "size_in_bytes": 1592 + }, + { + "_path": "lib/python3.12/ensurepip/_bundled/pip-24.0-py3-none-any.whl", + "path_type": "hardlink", + "sha256": "ba0d021a166865d2265246961bec0152ff124de910c5cc39f1156ce3fa7c69dc", + "sha256_in_prefix": "ba0d021a166865d2265246961bec0152ff124de910c5cc39f1156ce3fa7c69dc", + "size_in_bytes": 2110226 + }, + { + "_path": "lib/python3.12/ensurepip/_uninstall.py", + "path_type": "hardlink", + "sha256": "3a6e95d01c45e2e47c05df3c81073b895c97c1eb0e5b90ab175d6d9263fc81f2", + "sha256_in_prefix": "3a6e95d01c45e2e47c05df3c81073b895c97c1eb0e5b90ab175d6d9263fc81f2", + "size_in_bytes": 808 + }, + { + "_path": "lib/python3.12/enum.py", + "path_type": "hardlink", + "sha256": "278c5c37df86dc49adfd078b109f483205b4da475a2d9d32077a392cc0bd427f", + "sha256_in_prefix": "278c5c37df86dc49adfd078b109f483205b4da475a2d9d32077a392cc0bd427f", + "size_in_bytes": 80591 + }, + { + "_path": "lib/python3.12/filecmp.py", + "path_type": "hardlink", + "sha256": "7ecc32ce8f6f3c19a2dd21bbefe48e9054d01ca9d6ae6e30832a65f530b1223a", + "sha256_in_prefix": "7ecc32ce8f6f3c19a2dd21bbefe48e9054d01ca9d6ae6e30832a65f530b1223a", + "size_in_bytes": 10187 + }, + { + "_path": "lib/python3.12/fileinput.py", + "path_type": "hardlink", + "sha256": "b0cd2a3f01c96f594b6038e52bd83d489bfa081cc757103c70aab4e5b2c4fe1f", + "sha256_in_prefix": "b0cd2a3f01c96f594b6038e52bd83d489bfa081cc757103c70aab4e5b2c4fe1f", + "size_in_bytes": 15714 + }, + { + "_path": "lib/python3.12/fnmatch.py", + "path_type": "hardlink", + "sha256": "6683da36e47af523f3f41e18ad244d837783e19e98911cc0b7415dea81494ebc", + "sha256_in_prefix": "6683da36e47af523f3f41e18ad244d837783e19e98911cc0b7415dea81494ebc", + "size_in_bytes": 5999 + }, + { + "_path": "lib/python3.12/fractions.py", + "path_type": "hardlink", + "sha256": "cf33568f7b767f66896995a7a81cc662e8be226f2e58efb61d2028f64eb5d231", + "sha256_in_prefix": "cf33568f7b767f66896995a7a81cc662e8be226f2e58efb61d2028f64eb5d231", + "size_in_bytes": 38067 + }, + { + "_path": "lib/python3.12/ftplib.py", + "path_type": "hardlink", + "sha256": "d46af0c591299d304747c661da2fd4fe417cb7e057eee56a1789c54e2ce083bd", + "sha256_in_prefix": "d46af0c591299d304747c661da2fd4fe417cb7e057eee56a1789c54e2ce083bd", + "size_in_bytes": 34735 + }, + { + "_path": "lib/python3.12/functools.py", + "path_type": "hardlink", + "sha256": "cca971c456e1bec8b751aecdf41466f34dbf72321ee0840627280ba2ccf9d033", + "sha256_in_prefix": "cca971c456e1bec8b751aecdf41466f34dbf72321ee0840627280ba2ccf9d033", + "size_in_bytes": 38126 + }, + { + "_path": "lib/python3.12/genericpath.py", + "path_type": "hardlink", + "sha256": "6a271770c5e0c0a594075cc0063c807421fac3474df05d91a01c91d12c36eb5f", + "sha256_in_prefix": "6a271770c5e0c0a594075cc0063c807421fac3474df05d91a01c91d12c36eb5f", + "size_in_bytes": 5301 + }, + { + "_path": "lib/python3.12/getopt.py", + "path_type": "hardlink", + "sha256": "0ce875700c8798193b8e2748f7a27fc542cc4d525a1e6fc403767450ec92be99", + "sha256_in_prefix": "0ce875700c8798193b8e2748f7a27fc542cc4d525a1e6fc403767450ec92be99", + "size_in_bytes": 7488 + }, + { + "_path": "lib/python3.12/getpass.py", + "path_type": "hardlink", + "sha256": "e74fd445337ff503223dd8aa4bdd7d04917067d00c796a10bedb7a1381a4960a", + "sha256_in_prefix": "e74fd445337ff503223dd8aa4bdd7d04917067d00c796a10bedb7a1381a4960a", + "size_in_bytes": 5990 + }, + { + "_path": "lib/python3.12/gettext.py", + "path_type": "hardlink", + "sha256": "a5c249a522b6b8e3aa6f1b12a8bcc09508b99ad612b58d2fc973db27ea3b7cc3", + "sha256_in_prefix": "a5c249a522b6b8e3aa6f1b12a8bcc09508b99ad612b58d2fc973db27ea3b7cc3", + "size_in_bytes": 21320 + }, + { + "_path": "lib/python3.12/glob.py", + "path_type": "hardlink", + "sha256": "fa579f8a50a66313d34d339f10be0821c9b4fed6207e8ba8e29ed1c5e119f740", + "sha256_in_prefix": "fa579f8a50a66313d34d339f10be0821c9b4fed6207e8ba8e29ed1c5e119f740", + "size_in_bytes": 8681 + }, + { + "_path": "lib/python3.12/graphlib.py", + "path_type": "hardlink", + "sha256": "7bd338c5a475d1101064603d3baa5507446d3c5e73f741f6d6e77c6204c1eb65", + "sha256_in_prefix": "7bd338c5a475d1101064603d3baa5507446d3c5e73f741f6d6e77c6204c1eb65", + "size_in_bytes": 9656 + }, + { + "_path": "lib/python3.12/gzip.py", + "path_type": "hardlink", + "sha256": "31e7275c5c20d1b414063c28088b68e7a3e657af60c9c23435bf92e77a1fd1e5", + "sha256_in_prefix": "31e7275c5c20d1b414063c28088b68e7a3e657af60c9c23435bf92e77a1fd1e5", + "size_in_bytes": 24859 + }, + { + "_path": "lib/python3.12/hashlib.py", + "path_type": "hardlink", + "sha256": "6dbdebf270868b391080e21dc9687eddfaf321c965ad979f68d3f5c423c613ab", + "sha256_in_prefix": "6dbdebf270868b391080e21dc9687eddfaf321c965ad979f68d3f5c423c613ab", + "size_in_bytes": 9349 + }, + { + "_path": "lib/python3.12/heapq.py", + "path_type": "hardlink", + "sha256": "6d43277e5c76fc0f073cd388fcff852d14d068f6bb6d4886c340f8b75a1229a9", + "sha256_in_prefix": "6d43277e5c76fc0f073cd388fcff852d14d068f6bb6d4886c340f8b75a1229a9", + "size_in_bytes": 23024 + }, + { + "_path": "lib/python3.12/hmac.py", + "path_type": "hardlink", + "sha256": "7facd1330e5487ed995eda5c8619df0d3e32f69cb619f97662372fb76325746e", + "sha256_in_prefix": "7facd1330e5487ed995eda5c8619df0d3e32f69cb619f97662372fb76325746e", + "size_in_bytes": 7716 + }, + { + "_path": "lib/python3.12/html/__init__.py", + "path_type": "hardlink", + "sha256": "923d82d821e75e8d235392c10c145ab8587927b3faf9c952bbd48081eebd8522", + "sha256_in_prefix": "923d82d821e75e8d235392c10c145ab8587927b3faf9c952bbd48081eebd8522", + "size_in_bytes": 4775 + }, + { + "_path": "lib/python3.12/html/__pycache__/__init__.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "27a9f4abcab000805753e31b11e0d9819d447ab979730426a9e281658dfd9973", + "sha256_in_prefix": "27a9f4abcab000805753e31b11e0d9819d447ab979730426a9e281658dfd9973", + "size_in_bytes": 4640 + }, + { + "_path": "lib/python3.12/html/__pycache__/entities.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "fb040d9f9f6d0cf40d49e15d5c0b560b18910f60e3d29329babd6dc0238da1fd", + "sha256_in_prefix": "fb040d9f9f6d0cf40d49e15d5c0b560b18910f60e3d29329babd6dc0238da1fd", + "size_in_bytes": 97924 + }, + { + "_path": "lib/python3.12/html/__pycache__/parser.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "de91b6f3128fe780b0f78c3d2bea6fbdc807876d1077fd0c96542620b5154187", + "sha256_in_prefix": "de91b6f3128fe780b0f78c3d2bea6fbdc807876d1077fd0c96542620b5154187", + "size_in_bytes": 17412 + }, + { + "_path": "lib/python3.12/html/entities.py", + "path_type": "hardlink", + "sha256": "d9c65fb2828dbc1f3e399058a341d51e9375ec5bca95a8e92599c41bd5b78bde", + "sha256_in_prefix": "d9c65fb2828dbc1f3e399058a341d51e9375ec5bca95a8e92599c41bd5b78bde", + "size_in_bytes": 75512 + }, + { + "_path": "lib/python3.12/html/parser.py", + "path_type": "hardlink", + "sha256": "ab5a0a2fce2bec75d969dbe057b490ef574f9ac57cce9e0eaaf7a220b301e838", + "sha256_in_prefix": "ab5a0a2fce2bec75d969dbe057b490ef574f9ac57cce9e0eaaf7a220b301e838", + "size_in_bytes": 17054 + }, + { + "_path": "lib/python3.12/http/__init__.py", + "path_type": "hardlink", + "sha256": "17f4f6832cfc84b5b9600414bab80b77e67ccb611bdfed10a3f2beca9d0d568b", + "sha256_in_prefix": "17f4f6832cfc84b5b9600414bab80b77e67ccb611bdfed10a3f2beca9d0d568b", + "size_in_bytes": 8308 + }, + { + "_path": "lib/python3.12/http/__pycache__/__init__.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "c1074e91a8d6e177cbfa17d94b2b6854158d23b4c90a9121f46b8f275c36744e", + "sha256_in_prefix": "c1074e91a8d6e177cbfa17d94b2b6854158d23b4c90a9121f46b8f275c36744e", + "size_in_bytes": 9741 + }, + { + "_path": "lib/python3.12/http/__pycache__/client.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "3a48694c8c52526a3bc95975a5c4b1e04921ff183fdf6453e6da9f1ee5106c80", + "sha256_in_prefix": "3a48694c8c52526a3bc95975a5c4b1e04921ff183fdf6453e6da9f1ee5106c80", + "size_in_bytes": 57109 + }, + { + "_path": "lib/python3.12/http/__pycache__/cookiejar.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "b6d72faef8ac4058330fa4407d120732b7064d3b19bb566035ba5a0c2ade3e31", + "sha256_in_prefix": "b6d72faef8ac4058330fa4407d120732b7064d3b19bb566035ba5a0c2ade3e31", + "size_in_bytes": 81869 + }, + { + "_path": "lib/python3.12/http/__pycache__/cookies.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "1eacfed315b7d1100d26734dff9a0755200b3034efa79ea8e612d3b450ca9d6f", + "sha256_in_prefix": "1eacfed315b7d1100d26734dff9a0755200b3034efa79ea8e612d3b450ca9d6f", + "size_in_bytes": 21786 + }, + { + "_path": "lib/python3.12/http/__pycache__/server.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "7c8314e75d18641892a523b73be9a37bff788a751ea9f871e3bc8919970cadcf", + "sha256_in_prefix": "7c8314e75d18641892a523b73be9a37bff788a751ea9f871e3bc8919970cadcf", + "size_in_bytes": 55855 + }, + { + "_path": "lib/python3.12/http/client.py", + "path_type": "hardlink", + "sha256": "66eabd4953a4a63589bb1067264405ecdbf7392836d0e65d17ed4619d3a21689", + "sha256_in_prefix": "66eabd4953a4a63589bb1067264405ecdbf7392836d0e65d17ed4619d3a21689", + "size_in_bytes": 57080 + }, + { + "_path": "lib/python3.12/http/cookiejar.py", + "path_type": "hardlink", + "sha256": "2a64dbc46edd0173600f32d195531741de562522da28bc76c2f97dccceb37ddb", + "sha256_in_prefix": "2a64dbc46edd0173600f32d195531741de562522da28bc76c2f97dccceb37ddb", + "size_in_bytes": 77438 + }, + { + "_path": "lib/python3.12/http/cookies.py", + "path_type": "hardlink", + "sha256": "a4712e985f8d892e290e8317d0d4d692313a39d5b0bd22fc640b885a79043ff7", + "sha256_in_prefix": "a4712e985f8d892e290e8317d0d4d692313a39d5b0bd22fc640b885a79043ff7", + "size_in_bytes": 20482 + }, + { + "_path": "lib/python3.12/http/server.py", + "path_type": "hardlink", + "sha256": "6ef28116c245a8e5e7f2d57f17607b7df706fd86110cf1c5a2b8416151b41248", + "sha256_in_prefix": "6ef28116c245a8e5e7f2d57f17607b7df706fd86110cf1c5a2b8416151b41248", + "size_in_bytes": 48516 + }, + { + "_path": "lib/python3.12/idlelib/CREDITS.txt", + "path_type": "hardlink", + "sha256": "33e6a36056667d40e26f195c14371567470f53324c3fec43aec29e09d7d2a60b", + "sha256_in_prefix": "33e6a36056667d40e26f195c14371567470f53324c3fec43aec29e09d7d2a60b", + "size_in_bytes": 2152 + }, + { + "_path": "lib/python3.12/idlelib/ChangeLog", + "path_type": "hardlink", + "sha256": "b7f42699e5e5a7c82ebdf2a2962946b7228c933ece0ea7c0d7789f21a7dd7e64", + "sha256_in_prefix": "b7f42699e5e5a7c82ebdf2a2962946b7228c933ece0ea7c0d7789f21a7dd7e64", + "size_in_bytes": 56360 + }, + { + "_path": "lib/python3.12/idlelib/HISTORY.txt", + "path_type": "hardlink", + "sha256": "531067a78ad392f25631aba1d885f40786cf5f47854577162c9f90ff1f33164c", + "sha256_in_prefix": "531067a78ad392f25631aba1d885f40786cf5f47854577162c9f90ff1f33164c", + "size_in_bytes": 10312 + }, + { + "_path": "lib/python3.12/idlelib/Icons/README.txt", + "path_type": "hardlink", + "sha256": "60399d6129e3e486ce6b437bbf614ff4838bd4e7f42d461c3e5467cf3b4fa272", + "sha256_in_prefix": "60399d6129e3e486ce6b437bbf614ff4838bd4e7f42d461c3e5467cf3b4fa272", + "size_in_bytes": 443 + }, + { + "_path": "lib/python3.12/idlelib/Icons/folder.gif", + "path_type": "hardlink", + "sha256": "7c98d566a13fd599d1c11a375f387fef69b6c595c4f18c5d88c188a860be0e55", + "sha256_in_prefix": "7c98d566a13fd599d1c11a375f387fef69b6c595c4f18c5d88c188a860be0e55", + "size_in_bytes": 120 + }, + { + "_path": "lib/python3.12/idlelib/Icons/idle.ico", + "path_type": "hardlink", + "sha256": "7f13eeb5dca39d05e24b9eb069c6dcb2748633822d67288a8bf8b7e21cdddf55", + "sha256_in_prefix": "7f13eeb5dca39d05e24b9eb069c6dcb2748633822d67288a8bf8b7e21cdddf55", + "size_in_bytes": 57746 + }, + { + "_path": "lib/python3.12/idlelib/Icons/idle_16.gif", + "path_type": "hardlink", + "sha256": "fe3af292b38660a8a58b1a8b4fa4240aa190602e7e9a700ea0536b3181fc968e", + "sha256_in_prefix": "fe3af292b38660a8a58b1a8b4fa4240aa190602e7e9a700ea0536b3181fc968e", + "size_in_bytes": 634 + }, + { + "_path": "lib/python3.12/idlelib/Icons/idle_16.png", + "path_type": "hardlink", + "sha256": "78fb3fb0ec11f61bc6cf0947f3c3923aa18e1c6513684058ed0fa01ac858143e", + "sha256_in_prefix": "78fb3fb0ec11f61bc6cf0947f3c3923aa18e1c6513684058ed0fa01ac858143e", + "size_in_bytes": 1031 + }, + { + "_path": "lib/python3.12/idlelib/Icons/idle_256.png", + "path_type": "hardlink", + "sha256": "3f517467d12e0e3ecf20f9bd68ce4bd18a2b8088f32308fd978fd80e87d3628b", + "sha256_in_prefix": "3f517467d12e0e3ecf20f9bd68ce4bd18a2b8088f32308fd978fd80e87d3628b", + "size_in_bytes": 39205 + }, + { + "_path": "lib/python3.12/idlelib/Icons/idle_32.gif", + "path_type": "hardlink", + "sha256": "fe70991cfccd1267922e94d91e02e9a58d2d29fd3382a2f4975280b9023cb7b9", + "sha256_in_prefix": "fe70991cfccd1267922e94d91e02e9a58d2d29fd3382a2f4975280b9023cb7b9", + "size_in_bytes": 1019 + }, + { + "_path": "lib/python3.12/idlelib/Icons/idle_32.png", + "path_type": "hardlink", + "sha256": "797cd05f1964d57c4c6c248ac7f7ea6a38019ada32a9ab7e6c28d060f87b03de", + "sha256_in_prefix": "797cd05f1964d57c4c6c248ac7f7ea6a38019ada32a9ab7e6c28d060f87b03de", + "size_in_bytes": 2036 + }, + { + "_path": "lib/python3.12/idlelib/Icons/idle_48.gif", + "path_type": "hardlink", + "sha256": "37484901eb40eefa846308e1da3ff6f240ea98f769a2afc3cf4fdba00327ecbe", + "sha256_in_prefix": "37484901eb40eefa846308e1da3ff6f240ea98f769a2afc3cf4fdba00327ecbe", + "size_in_bytes": 1388 + }, + { + "_path": "lib/python3.12/idlelib/Icons/idle_48.png", + "path_type": "hardlink", + "sha256": "a09f433197c8870b12bb7859cc4c3fe2068908cb1ddbd4880ab0f6fee91b6c23", + "sha256_in_prefix": "a09f433197c8870b12bb7859cc4c3fe2068908cb1ddbd4880ab0f6fee91b6c23", + "size_in_bytes": 3977 + }, + { + "_path": "lib/python3.12/idlelib/Icons/minusnode.gif", + "path_type": "hardlink", + "sha256": "efa5aa1d1e3439ab85425bd2aa3a25b9e6c21309e672690cfb32219e1eb7a7f3", + "sha256_in_prefix": "efa5aa1d1e3439ab85425bd2aa3a25b9e6c21309e672690cfb32219e1eb7a7f3", + "size_in_bytes": 75 + }, + { + "_path": "lib/python3.12/idlelib/Icons/openfolder.gif", + "path_type": "hardlink", + "sha256": "9a59e2abf1840156e9db8f85a38822fd56ab79a139eb95ec86f1fba1bb87326b", + "sha256_in_prefix": "9a59e2abf1840156e9db8f85a38822fd56ab79a139eb95ec86f1fba1bb87326b", + "size_in_bytes": 125 + }, + { + "_path": "lib/python3.12/idlelib/Icons/plusnode.gif", + "path_type": "hardlink", + "sha256": "6ace9e90a2bcb16d06c4d78837137f2c14bc26b3bd9f24b7b6afeadb689bdafb", + "sha256_in_prefix": "6ace9e90a2bcb16d06c4d78837137f2c14bc26b3bd9f24b7b6afeadb689bdafb", + "size_in_bytes": 78 + }, + { + "_path": "lib/python3.12/idlelib/Icons/python.gif", + "path_type": "hardlink", + "sha256": "158c31382f8e5b41fded0c2aa9cc66a382928b003cdd8b5b0518836ad9c89377", + "sha256_in_prefix": "158c31382f8e5b41fded0c2aa9cc66a382928b003cdd8b5b0518836ad9c89377", + "size_in_bytes": 380 + }, + { + "_path": "lib/python3.12/idlelib/Icons/tk.gif", + "path_type": "hardlink", + "sha256": "7f16cb2e322891dbd9101302c09ffda0c2a3a72d053bb8c0927d507414c59cad", + "sha256_in_prefix": "7f16cb2e322891dbd9101302c09ffda0c2a3a72d053bb8c0927d507414c59cad", + "size_in_bytes": 72 + }, + { + "_path": "lib/python3.12/idlelib/NEWS2x.txt", + "path_type": "hardlink", + "sha256": "c89a3b513501ebace8e428aea68dce39d0af9f29196e08fc9ea49c99605e79e7", + "sha256_in_prefix": "c89a3b513501ebace8e428aea68dce39d0af9f29196e08fc9ea49c99605e79e7", + "size_in_bytes": 27172 + }, + { + "_path": "lib/python3.12/idlelib/News3.txt", + "path_type": "hardlink", + "sha256": "5b20beec21d162146baefd500b56821250472923c3fa75ee15e794b88c505ba3", + "sha256_in_prefix": "5b20beec21d162146baefd500b56821250472923c3fa75ee15e794b88c505ba3", + "size_in_bytes": 55514 + }, + { + "_path": "lib/python3.12/idlelib/README.txt", + "path_type": "hardlink", + "sha256": "4f2dc8ffdbfc7837b60edc32ac2f593a220f4abf0ea00cc477382ad8ecf8eb3d", + "sha256_in_prefix": "4f2dc8ffdbfc7837b60edc32ac2f593a220f4abf0ea00cc477382ad8ecf8eb3d", + "size_in_bytes": 11653 + }, + { + "_path": "lib/python3.12/idlelib/TODO.txt", + "path_type": "hardlink", + "sha256": "f88e0fb30fa0ab5d0dc3030442ed92713f34170336c4dd2623723dc34829df89", + "sha256_in_prefix": "f88e0fb30fa0ab5d0dc3030442ed92713f34170336c4dd2623723dc34829df89", + "size_in_bytes": 8478 + }, + { + "_path": "lib/python3.12/idlelib/__init__.py", + "path_type": "hardlink", + "sha256": "3f8058df4fec56eb20ff67ff84c86fd3d9697e2384c5a290ed696f6d3187aa45", + "sha256_in_prefix": "3f8058df4fec56eb20ff67ff84c86fd3d9697e2384c5a290ed696f6d3187aa45", + "size_in_bytes": 396 + }, + { + "_path": "lib/python3.12/idlelib/__main__.py", + "path_type": "hardlink", + "sha256": "f8f55514d26791588de02fe685af0ab129174b32ab93efa39faf6140b6795d9d", + "sha256_in_prefix": "f8f55514d26791588de02fe685af0ab129174b32ab93efa39faf6140b6795d9d", + "size_in_bytes": 159 + }, + { + "_path": "lib/python3.12/idlelib/__pycache__/__init__.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "6b0c2c70b7f2d7ab94e67c2054ea7aed7422e33f675a368d9ad1d02cee414432", + "sha256_in_prefix": "6b0c2c70b7f2d7ab94e67c2054ea7aed7422e33f675a368d9ad1d02cee414432", + "size_in_bytes": 773 + }, + { + "_path": "lib/python3.12/idlelib/__pycache__/__main__.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "46698841c8537180804c54ab96aa2ba64fc71e2e264a345427b4eb3758ade196", + "sha256_in_prefix": "46698841c8537180804c54ab96aa2ba64fc71e2e264a345427b4eb3758ade196", + "size_in_bytes": 588 + }, + { + "_path": "lib/python3.12/idlelib/__pycache__/autocomplete.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "a35caf158a9a66c2a69b4279cf11097abce89f639b6586a756c36935679c3f45", + "sha256_in_prefix": "a35caf158a9a66c2a69b4279cf11097abce89f639b6586a756c36935679c3f45", + "size_in_bytes": 11172 + }, + { + "_path": "lib/python3.12/idlelib/__pycache__/autocomplete_w.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "3504db39560ea3a31217c4f2f1e23626d42d3a192bddda7a8aba0eb28ba89dad", + "sha256_in_prefix": "3504db39560ea3a31217c4f2f1e23626d42d3a192bddda7a8aba0eb28ba89dad", + "size_in_bytes": 23970 + }, + { + "_path": "lib/python3.12/idlelib/__pycache__/autoexpand.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "0535a58590113a8e214fdc28d19f041bd7195ed5c239b6ae8e8debd318704784", + "sha256_in_prefix": "0535a58590113a8e214fdc28d19f041bd7195ed5c239b6ae8e8debd318704784", + "size_in_bytes": 4808 + }, + { + "_path": "lib/python3.12/idlelib/__pycache__/browser.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "ef8b0e0a2004d78af666ca17c7ef5c41afe80c1943d1522457ad5d77f4188800", + "sha256_in_prefix": "ef8b0e0a2004d78af666ca17c7ef5c41afe80c1943d1522457ad5d77f4188800", + "size_in_bytes": 13586 + }, + { + "_path": "lib/python3.12/idlelib/__pycache__/calltip.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "6c404867cba69e6dd66de130ac7b98649e541332b5301811fd4524b5b856bf9f", + "sha256_in_prefix": "6c404867cba69e6dd66de130ac7b98649e541332b5301811fd4524b5b856bf9f", + "size_in_bytes": 8618 + }, + { + "_path": "lib/python3.12/idlelib/__pycache__/calltip_w.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "fb8fb29e33445a5aa41fd4b0e6368ac17dcb0ad1138c93f486033d9fd0f76075", + "sha256_in_prefix": "fb8fb29e33445a5aa41fd4b0e6368ac17dcb0ad1138c93f486033d9fd0f76075", + "size_in_bytes": 10536 + }, + { + "_path": "lib/python3.12/idlelib/__pycache__/codecontext.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "0158e91c94c074f8e94cbbc200b456ca817017050b7987bffc9f3e9b0e39c204", + "sha256_in_prefix": "0158e91c94c074f8e94cbbc200b456ca817017050b7987bffc9f3e9b0e39c204", + "size_in_bytes": 13819 + }, + { + "_path": "lib/python3.12/idlelib/__pycache__/colorizer.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "d12dadc17f5943aa9b565cbf3143e44a8a5ed3974316c8f546e85bdcfbbbb293", + "sha256_in_prefix": "d12dadc17f5943aa9b565cbf3143e44a8a5ed3974316c8f546e85bdcfbbbb293", + "size_in_bytes": 17957 + }, + { + "_path": "lib/python3.12/idlelib/__pycache__/config.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "bb5bc739027a050ab2851918c06d22d522725ef7a4c0f4943cb97b94c04bd7aa", + "sha256_in_prefix": "bb5bc739027a050ab2851918c06d22d522725ef7a4c0f4943cb97b94c04bd7aa", + "size_in_bytes": 41737 + }, + { + "_path": "lib/python3.12/idlelib/__pycache__/config_key.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "c06207e48a4228c5c82566c4484c6f51f9f623b27331b85b6539cf1515d9fd86", + "sha256_in_prefix": "c06207e48a4228c5c82566c4484c6f51f9f623b27331b85b6539cf1515d9fd86", + "size_in_bytes": 20143 + }, + { + "_path": "lib/python3.12/idlelib/__pycache__/configdialog.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "8b256de4f6a746611a98604a3c6f093fd191c8d437a47afbce0e39b06808beda", + "sha256_in_prefix": "8b256de4f6a746611a98604a3c6f093fd191c8d437a47afbce0e39b06808beda", + "size_in_bytes": 125619 + }, + { + "_path": "lib/python3.12/idlelib/__pycache__/debugger.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "eb65fbce904a01cbac5fd88bbd6d72eeb2245d4066907f6bb4332f5617669b6c", + "sha256_in_prefix": "eb65fbce904a01cbac5fd88bbd6d72eeb2245d4066907f6bb4332f5617669b6c", + "size_in_bytes": 28441 + }, + { + "_path": "lib/python3.12/idlelib/__pycache__/debugger_r.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "63eb0f79966cbae14e97cc4f3badd1c82bc6f1485e5cd7978330e5a8cc46db9e", + "sha256_in_prefix": "63eb0f79966cbae14e97cc4f3badd1c82bc6f1485e5cd7978330e5a8cc46db9e", + "size_in_bytes": 19029 + }, + { + "_path": "lib/python3.12/idlelib/__pycache__/debugobj.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "68c6738f290b14937d6cd95f33d66f036593e961c1a7fd9a4f0259be0f81b26f", + "sha256_in_prefix": "68c6738f290b14937d6cd95f33d66f036593e961c1a7fd9a4f0259be0f81b26f", + "size_in_bytes": 7845 + }, + { + "_path": "lib/python3.12/idlelib/__pycache__/debugobj_r.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "12289ea765f3a49e28bdd345c28eb61cc65b73645a91b40561afd4eac4a1a6c4", + "sha256_in_prefix": "12289ea765f3a49e28bdd345c28eb61cc65b73645a91b40561afd4eac4a1a6c4", + "size_in_bytes": 2777 + }, + { + "_path": "lib/python3.12/idlelib/__pycache__/delegator.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "7ebea8ddd943d4e8c1525c2a94fb82e2631905fdfc0a373e46e30ea07fa67e6b", + "sha256_in_prefix": "7ebea8ddd943d4e8c1525c2a94fb82e2631905fdfc0a373e46e30ea07fa67e6b", + "size_in_bytes": 1983 + }, + { + "_path": "lib/python3.12/idlelib/__pycache__/dynoption.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "cca26d654c8393300da14bd9f2db72275d816b53912485bd93e8d8b027c4bc83", + "sha256_in_prefix": "cca26d654c8393300da14bd9f2db72275d816b53912485bd93e8d8b027c4bc83", + "size_in_bytes": 3512 + }, + { + "_path": "lib/python3.12/idlelib/__pycache__/editor.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "6c6989b6c9cd42e563fdc31079465996cf51ba6121fb9d3052f548cc4c00cffd", + "sha256_in_prefix": "6c6989b6c9cd42e563fdc31079465996cf51ba6121fb9d3052f548cc4c00cffd", + "size_in_bytes": 86598 + }, + { + "_path": "lib/python3.12/idlelib/__pycache__/filelist.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "bfe3e4bcd644c759ed84f663ce1ad00b12022d7d5830b5e560d6980593696f07", + "sha256_in_prefix": "bfe3e4bcd644c759ed84f663ce1ad00b12022d7d5830b5e560d6980593696f07", + "size_in_bytes": 5900 + }, + { + "_path": "lib/python3.12/idlelib/__pycache__/format.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "249356cdf01a23f557645199175398901e2506ecd1d5de2949f68f78dddf00cb", + "sha256_in_prefix": "249356cdf01a23f557645199175398901e2506ecd1d5de2949f68f78dddf00cb", + "size_in_bytes": 20985 + }, + { + "_path": "lib/python3.12/idlelib/__pycache__/grep.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "4f3dab06dd194ec3eae41f0ae692c98d697ec12cea5537e467cab0c2b81bd0b1", + "sha256_in_prefix": "4f3dab06dd194ec3eae41f0ae692c98d697ec12cea5537e467cab0c2b81bd0b1", + "size_in_bytes": 11441 + }, + { + "_path": "lib/python3.12/idlelib/__pycache__/help.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "73d4e8719b18b3f9afda4aec1eaa0aa80824410d2bea7500cdd0b466ae7ace46", + "sha256_in_prefix": "73d4e8719b18b3f9afda4aec1eaa0aa80824410d2bea7500cdd0b466ae7ace46", + "size_in_bytes": 16492 + }, + { + "_path": "lib/python3.12/idlelib/__pycache__/help_about.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "e41226f873790f2dd1115117d4d8d15217f29216e51caccda71505f8def95e83", + "sha256_in_prefix": "e41226f873790f2dd1115117d4d8d15217f29216e51caccda71505f8def95e83", + "size_in_bytes": 12922 + }, + { + "_path": "lib/python3.12/idlelib/__pycache__/history.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "eb25d0ba512daa159d07741ef5df34d5d8cab0012d058f23f5d1df808c00775b", + "sha256_in_prefix": "eb25d0ba512daa159d07741ef5df34d5d8cab0012d058f23f5d1df808c00775b", + "size_in_bytes": 5436 + }, + { + "_path": "lib/python3.12/idlelib/__pycache__/hyperparser.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "dff36fd84f5c24a6ec1a2a5e04e758e6c6a428b6631148556969683fc690d652", + "sha256_in_prefix": "dff36fd84f5c24a6ec1a2a5e04e758e6c6a428b6631148556969683fc690d652", + "size_in_bytes": 12491 + }, + { + "_path": "lib/python3.12/idlelib/__pycache__/idle.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "aa2fb9c4b153a7234021f93ed48117605e6ad9333cce4c59d0c21ac8310e7fa7", + "sha256_in_prefix": "aa2fb9c4b153a7234021f93ed48117605e6ad9333cce4c59d0c21ac8310e7fa7", + "size_in_bytes": 861 + }, + { + "_path": "lib/python3.12/idlelib/__pycache__/iomenu.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "46c685dc1ca1deb646245c64537a5dc92e28a464a40da2d6b4e68111ed9d8a0b", + "sha256_in_prefix": "46c685dc1ca1deb646245c64537a5dc92e28a464a40da2d6b4e68111ed9d8a0b", + "size_in_bytes": 21597 + }, + { + "_path": "lib/python3.12/idlelib/__pycache__/macosx.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "0fdb3c624f5bf8d729b6678a997ce9201e99efd294db1879c131810d983f1a67", + "sha256_in_prefix": "0fdb3c624f5bf8d729b6678a997ce9201e99efd294db1879c131810d983f1a67", + "size_in_bytes": 10019 + }, + { + "_path": "lib/python3.12/idlelib/__pycache__/mainmenu.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "e8b41a87cb2d9cd87938fecfb41d9b2a0ec8feef0e52dd05feae190cdb748b05", + "sha256_in_prefix": "e8b41a87cb2d9cd87938fecfb41d9b2a0ec8feef0e52dd05feae190cdb748b05", + "size_in_bytes": 3788 + }, + { + "_path": "lib/python3.12/idlelib/__pycache__/multicall.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "3a7f5127aed49232e5c587ceef688afbb48345c0aa611c2210ff93653826a21b", + "sha256_in_prefix": "3a7f5127aed49232e5c587ceef688afbb48345c0aa611c2210ff93653826a21b", + "size_in_bytes": 22033 + }, + { + "_path": "lib/python3.12/idlelib/__pycache__/outwin.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "78cb9c9af59f40491b60b830849a2ddd60bf7dc9faa8e08fd3aee1a0cf684607", + "sha256_in_prefix": "78cb9c9af59f40491b60b830849a2ddd60bf7dc9faa8e08fd3aee1a0cf684607", + "size_in_bytes": 7950 + }, + { + "_path": "lib/python3.12/idlelib/__pycache__/parenmatch.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "c6c496c42cb8d2d250411b4dd6418d288c7a2b21c774d6c882658168acd2787d", + "sha256_in_prefix": "c6c496c42cb8d2d250411b4dd6418d288c7a2b21c774d6c882658168acd2787d", + "size_in_bytes": 9792 + }, + { + "_path": "lib/python3.12/idlelib/__pycache__/pathbrowser.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "e9816e1a01011fce9a7b96bbf13daccbb29453827d33891c9e355e675e641d8b", + "sha256_in_prefix": "e9816e1a01011fce9a7b96bbf13daccbb29453827d33891c9e355e675e641d8b", + "size_in_bytes": 5909 + }, + { + "_path": "lib/python3.12/idlelib/__pycache__/percolator.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "71e89853c0168788c4f82612972355def0d8eace5f78c92c4215c42d76a4a867", + "sha256_in_prefix": "71e89853c0168788c4f82612972355def0d8eace5f78c92c4215c42d76a4a867", + "size_in_bytes": 7120 + }, + { + "_path": "lib/python3.12/idlelib/__pycache__/pyparse.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "e07814f987df5d4873d27ce364cc7a03abadaa35cb3f8b96ecfc49b302723ca6", + "sha256_in_prefix": "e07814f987df5d4873d27ce364cc7a03abadaa35cb3f8b96ecfc49b302723ca6", + "size_in_bytes": 18327 + }, + { + "_path": "lib/python3.12/idlelib/__pycache__/pyshell.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "d01355674fdc6ce49ba0020082e8c2f48159723f71ee583c3ae3e0b0cd22c6b8", + "sha256_in_prefix": "d01355674fdc6ce49ba0020082e8c2f48159723f71ee583c3ae3e0b0cd22c6b8", + "size_in_bytes": 81534 + }, + { + "_path": "lib/python3.12/idlelib/__pycache__/query.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "7bdb2c1b38863fd205ebc55d6cc702656a3f5a551d9b2c7cc84c90a3590972e5", + "sha256_in_prefix": "7bdb2c1b38863fd205ebc55d6cc702656a3f5a551d9b2c7cc84c90a3590972e5", + "size_in_bytes": 19774 + }, + { + "_path": "lib/python3.12/idlelib/__pycache__/redirector.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "05cc71ac182e1a791a4b02879513c45c0b55b781dff93f139f200251700957c6", + "sha256_in_prefix": "05cc71ac182e1a791a4b02879513c45c0b55b781dff93f139f200251700957c6", + "size_in_bytes": 9165 + }, + { + "_path": "lib/python3.12/idlelib/__pycache__/replace.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "2d95133ac8c0f3805c83f8ff995d31e846029572d25a889aa1a22b05bb0a7a66", + "sha256_in_prefix": "2d95133ac8c0f3805c83f8ff995d31e846029572d25a889aa1a22b05bb0a7a66", + "size_in_bytes": 14501 + }, + { + "_path": "lib/python3.12/idlelib/__pycache__/rpc.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "b98373b05e738f886c605d4c918987dd162177c87d8596b940961d817dcc3b8e", + "sha256_in_prefix": "b98373b05e738f886c605d4c918987dd162177c87d8596b940961d817dcc3b8e", + "size_in_bytes": 30270 + }, + { + "_path": "lib/python3.12/idlelib/__pycache__/run.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "a2493f68a6a128da2292ed778a2b6da6083892753f31f2ba2d905e768edf560f", + "sha256_in_prefix": "a2493f68a6a128da2292ed778a2b6da6083892753f31f2ba2d905e768edf560f", + "size_in_bytes": 29751 + }, + { + "_path": "lib/python3.12/idlelib/__pycache__/runscript.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "e75348273e7735ab43d5316cbe0bc4871698855c081de03adccde3a4ec826706", + "sha256_in_prefix": "e75348273e7735ab43d5316cbe0bc4871698855c081de03adccde3a4ec826706", + "size_in_bytes": 11170 + }, + { + "_path": "lib/python3.12/idlelib/__pycache__/scrolledlist.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "8d9983e2116eb9fc01981371f0e7723b0f4c019eacfd4f2fd3d3aa0974ccfe3c", + "sha256_in_prefix": "8d9983e2116eb9fc01981371f0e7723b0f4c019eacfd4f2fd3d3aa0974ccfe3c", + "size_in_bytes": 9271 + }, + { + "_path": "lib/python3.12/idlelib/__pycache__/search.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "497b4ad7b3bb1e0b02eb286f8d14db4e1632250b4d4f7c5ff89b6438f62fd082", + "sha256_in_prefix": "497b4ad7b3bb1e0b02eb286f8d14db4e1632250b4d4f7c5ff89b6438f62fd082", + "size_in_bytes": 8293 + }, + { + "_path": "lib/python3.12/idlelib/__pycache__/searchbase.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "88c1e4084b6dd3552eae1e8863f25a016efee714b2350364cf1f3cd700affe17", + "sha256_in_prefix": "88c1e4084b6dd3552eae1e8863f25a016efee714b2350364cf1f3cd700affe17", + "size_in_bytes": 12451 + }, + { + "_path": "lib/python3.12/idlelib/__pycache__/searchengine.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "4a7f3b6c4c8121812ea49df810d95b3dd811ca50b3420e9534c9d77a9e12d27f", + "sha256_in_prefix": "4a7f3b6c4c8121812ea49df810d95b3dd811ca50b3420e9534c9d77a9e12d27f", + "size_in_bytes": 10216 + }, + { + "_path": "lib/python3.12/idlelib/__pycache__/sidebar.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "a8ea9d170266b187f50096b72dd0504ed89e33fb977fe77e658d2b7dc0cddba6", + "sha256_in_prefix": "a8ea9d170266b187f50096b72dd0504ed89e33fb977fe77e658d2b7dc0cddba6", + "size_in_bytes": 29047 + }, + { + "_path": "lib/python3.12/idlelib/__pycache__/squeezer.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "25472aae8ec35b47381762d3eda9356f1f65965e6564fc12401a802608267f1f", + "sha256_in_prefix": "25472aae8ec35b47381762d3eda9356f1f65965e6564fc12401a802608267f1f", + "size_in_bytes": 14747 + }, + { + "_path": "lib/python3.12/idlelib/__pycache__/stackviewer.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "2d9e249579d125a1686ce49ee5fb309c78779826fe74a1e4bc495ad9a99370bb", + "sha256_in_prefix": "2d9e249579d125a1686ce49ee5fb309c78779826fe74a1e4bc495ad9a99370bb", + "size_in_bytes": 7498 + }, + { + "_path": "lib/python3.12/idlelib/__pycache__/statusbar.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "93721fdaac9e3c9dfa17e26a0f062e8ad1b3aebe450b1b869a31e2ba694b1a44", + "sha256_in_prefix": "93721fdaac9e3c9dfa17e26a0f062e8ad1b3aebe450b1b869a31e2ba694b1a44", + "size_in_bytes": 3201 + }, + { + "_path": "lib/python3.12/idlelib/__pycache__/textview.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "b74a514ce6260a989c8e1a33c0ab0a4e45dfc97347bdf3fa31a57c2c2b52a606", + "sha256_in_prefix": "b74a514ce6260a989c8e1a33c0ab0a4e45dfc97347bdf3fa31a57c2c2b52a606", + "size_in_bytes": 10137 + }, + { + "_path": "lib/python3.12/idlelib/__pycache__/tooltip.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "707f7136079b8861e0028fe87ef033f9d6846e04aa0403f5d365334d7caeadc3", + "sha256_in_prefix": "707f7136079b8861e0028fe87ef033f9d6846e04aa0403f5d365334d7caeadc3", + "size_in_bytes": 9671 + }, + { + "_path": "lib/python3.12/idlelib/__pycache__/tree.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "66f196e4bac7aaa7f36e7d35637f26a9a0ce042c9a28b9aab415376827a845f1", + "sha256_in_prefix": "66f196e4bac7aaa7f36e7d35637f26a9a0ce042c9a28b9aab415376827a845f1", + "size_in_bytes": 28354 + }, + { + "_path": "lib/python3.12/idlelib/__pycache__/undo.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "56a06f986b0c04e3283d1ab7b70b2c08d7d33ae1fca8965975f38fcf3288ad42", + "sha256_in_prefix": "56a06f986b0c04e3283d1ab7b70b2c08d7d33ae1fca8965975f38fcf3288ad42", + "size_in_bytes": 18725 + }, + { + "_path": "lib/python3.12/idlelib/__pycache__/util.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "d1ebdfc8feb5fa841025a3b3b89c7a12592b5aeb49cd9fac64345a9946afea1f", + "sha256_in_prefix": "d1ebdfc8feb5fa841025a3b3b89c7a12592b5aeb49cd9fac64345a9946afea1f", + "size_in_bytes": 1073 + }, + { + "_path": "lib/python3.12/idlelib/__pycache__/window.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "fa4d2785f7789adca17623e349159594d742a1d8dd79fad58e84a5cbcf009f98", + "sha256_in_prefix": "fa4d2785f7789adca17623e349159594d742a1d8dd79fad58e84a5cbcf009f98", + "size_in_bytes": 5118 + }, + { + "_path": "lib/python3.12/idlelib/__pycache__/zoomheight.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "776f4008cf98cb05a5940122b4a31e8d2f815f0f09b2e96dc8e702f93b15b7b7", + "sha256_in_prefix": "776f4008cf98cb05a5940122b4a31e8d2f815f0f09b2e96dc8e702f93b15b7b7", + "size_in_bytes": 4720 + }, + { + "_path": "lib/python3.12/idlelib/__pycache__/zzdummy.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "be162af4097c9768ceb6f743636b0dd89be63f99fdbe61c1e527014f0436fd9c", + "sha256_in_prefix": "be162af4097c9768ceb6f743636b0dd89be63f99fdbe61c1e527014f0436fd9c", + "size_in_bytes": 3524 + }, + { + "_path": "lib/python3.12/idlelib/autocomplete.py", + "path_type": "hardlink", + "sha256": "0d36f7694a50cbaa22d9bf03b91fa0658a147bd90dd867714a9b411febb36427", + "sha256_in_prefix": "0d36f7694a50cbaa22d9bf03b91fa0658a147bd90dd867714a9b411febb36427", + "size_in_bytes": 9354 + }, + { + "_path": "lib/python3.12/idlelib/autocomplete_w.py", + "path_type": "hardlink", + "sha256": "91170b060749d0b3c8f2ab31499104028bedf971e5575155d43392d5c8dae5d6", + "sha256_in_prefix": "91170b060749d0b3c8f2ab31499104028bedf971e5575155d43392d5c8dae5d6", + "size_in_bytes": 20863 + }, + { + "_path": "lib/python3.12/idlelib/autoexpand.py", + "path_type": "hardlink", + "sha256": "c8eb28ef7addf5a664a7e3addfbfebe29040a8695e1db515828305aacba2ee4e", + "sha256_in_prefix": "c8eb28ef7addf5a664a7e3addfbfebe29040a8695e1db515828305aacba2ee4e", + "size_in_bytes": 3216 + }, + { + "_path": "lib/python3.12/idlelib/browser.py", + "path_type": "hardlink", + "sha256": "b607102a6e2ff7de241744008144a5480e2925098694be2a46003d8f60da0f52", + "sha256_in_prefix": "b607102a6e2ff7de241744008144a5480e2925098694be2a46003d8f60da0f52", + "size_in_bytes": 8588 + }, + { + "_path": "lib/python3.12/idlelib/calltip.py", + "path_type": "hardlink", + "sha256": "3a723fdf88c0018dfadd19757142a643b01b785c6df17a50bbe21463663ab590", + "sha256_in_prefix": "3a723fdf88c0018dfadd19757142a643b01b785c6df17a50bbe21463663ab590", + "size_in_bytes": 7267 + }, + { + "_path": "lib/python3.12/idlelib/calltip_w.py", + "path_type": "hardlink", + "sha256": "077e9d0d95946296077d5c95f343e242a7d250a6efece4afc58759b5e984e6c3", + "sha256_in_prefix": "077e9d0d95946296077d5c95f343e242a7d250a6efece4afc58759b5e984e6c3", + "size_in_bytes": 7083 + }, + { + "_path": "lib/python3.12/idlelib/codecontext.py", + "path_type": "hardlink", + "sha256": "628a13325b3bf2f76dea9254b20178b3232261f83c660f0e33785e6215dd6492", + "sha256_in_prefix": "628a13325b3bf2f76dea9254b20178b3232261f83c660f0e33785e6215dd6492", + "size_in_bytes": 11420 + }, + { + "_path": "lib/python3.12/idlelib/colorizer.py", + "path_type": "hardlink", + "sha256": "4de77a632286cf7cb616a2cf50dcd16a99d452fe7b16bf94c34950be97f293c2", + "sha256_in_prefix": "4de77a632286cf7cb616a2cf50dcd16a99d452fe7b16bf94c34950be97f293c2", + "size_in_bytes": 14783 + }, + { + "_path": "lib/python3.12/idlelib/config-extensions.def", + "path_type": "hardlink", + "sha256": "e75df0b77ff61253be457af636d5eb7c55a3ff2b6a733beea844d2b294972ebf", + "sha256_in_prefix": "e75df0b77ff61253be457af636d5eb7c55a3ff2b6a733beea844d2b294972ebf", + "size_in_bytes": 2266 + }, + { + "_path": "lib/python3.12/idlelib/config-highlight.def", + "path_type": "hardlink", + "sha256": "609eada44ff4aa9d5cd10ad8b4c29bb76db8ebc74912a0ae86f5ea3cd19b7547", + "sha256_in_prefix": "609eada44ff4aa9d5cd10ad8b4c29bb76db8ebc74912a0ae86f5ea3cd19b7547", + "size_in_bytes": 2864 + }, + { + "_path": "lib/python3.12/idlelib/config-keys.def", + "path_type": "hardlink", + "sha256": "bee81ba5c5abec1e35e313268f8d8fe72d305d0ad73abfba3d2ea1e2b2308710", + "sha256_in_prefix": "bee81ba5c5abec1e35e313268f8d8fe72d305d0ad73abfba3d2ea1e2b2308710", + "size_in_bytes": 10910 + }, + { + "_path": "lib/python3.12/idlelib/config-main.def", + "path_type": "hardlink", + "sha256": "e783704ad5cd9b3f44c026f55c98be2c52190bf9b7832251283f3e953ba80f87", + "sha256_in_prefix": "e783704ad5cd9b3f44c026f55c98be2c52190bf9b7832251283f3e953ba80f87", + "size_in_bytes": 3168 + }, + { + "_path": "lib/python3.12/idlelib/config.py", + "path_type": "hardlink", + "sha256": "226d4259cf50e32bb1c2b76b90e6914a9d1790171363d82d1c4c47ed9673aa9b", + "sha256_in_prefix": "226d4259cf50e32bb1c2b76b90e6914a9d1790171363d82d1c4c47ed9673aa9b", + "size_in_bytes": 38387 + }, + { + "_path": "lib/python3.12/idlelib/config_key.py", + "path_type": "hardlink", + "sha256": "856bd4b2c1fd7275856d3869cad8975f7770edbf021a93c64816a41c2322c2fa", + "sha256_in_prefix": "856bd4b2c1fd7275856d3869cad8975f7770edbf021a93c64816a41c2322c2fa", + "size_in_bytes": 15230 + }, + { + "_path": "lib/python3.12/idlelib/configdialog.py", + "path_type": "hardlink", + "sha256": "68a6a9470476408acdce5e3a8816196e025f8cccd0845bf1da579db19a5bba8c", + "sha256_in_prefix": "68a6a9470476408acdce5e3a8816196e025f8cccd0845bf1da579db19a5bba8c", + "size_in_bytes": 105314 + }, + { + "_path": "lib/python3.12/idlelib/debugger.py", + "path_type": "hardlink", + "sha256": "6e595d5a388e46b6b6e24490e970a3d355ec116a16a064bfca6ed86d4b17dcb4", + "sha256_in_prefix": "6e595d5a388e46b6b6e24490e970a3d355ec116a16a064bfca6ed86d4b17dcb4", + "size_in_bytes": 20991 + }, + { + "_path": "lib/python3.12/idlelib/debugger_r.py", + "path_type": "hardlink", + "sha256": "ddc797740231f068ca7c7c8610e799d72ad11af670d9bc0b6f9e04fe2ba222d1", + "sha256_in_prefix": "ddc797740231f068ca7c7c8610e799d72ad11af670d9bc0b6f9e04fe2ba222d1", + "size_in_bytes": 12115 + }, + { + "_path": "lib/python3.12/idlelib/debugobj.py", + "path_type": "hardlink", + "sha256": "aae9e2468a3d05366480864dc56689c65896757faf3b0364b8eef9feb4876a43", + "sha256_in_prefix": "aae9e2468a3d05366480864dc56689c65896757faf3b0364b8eef9feb4876a43", + "size_in_bytes": 4177 + }, + { + "_path": "lib/python3.12/idlelib/debugobj_r.py", + "path_type": "hardlink", + "sha256": "4e583b43fdf9bd4a731d70e074ee597aba03f3c8c36302bdc7e74650fb1fcc11", + "sha256_in_prefix": "4e583b43fdf9bd4a731d70e074ee597aba03f3c8c36302bdc7e74650fb1fcc11", + "size_in_bytes": 1082 + }, + { + "_path": "lib/python3.12/idlelib/delegator.py", + "path_type": "hardlink", + "sha256": "c2b31919d27056fc3aaa8f4ef798fbdf162665175fa9216d665f58ba2e4a464d", + "sha256_in_prefix": "c2b31919d27056fc3aaa8f4ef798fbdf162665175fa9216d665f58ba2e4a464d", + "size_in_bytes": 1044 + }, + { + "_path": "lib/python3.12/idlelib/dynoption.py", + "path_type": "hardlink", + "sha256": "29933f56722b2efb5cf451825a7fe50f357983e68f6a261afdf89b52f778e488", + "sha256_in_prefix": "29933f56722b2efb5cf451825a7fe50f357983e68f6a261afdf89b52f778e488", + "size_in_bytes": 1993 + }, + { + "_path": "lib/python3.12/idlelib/editor.py", + "path_type": "hardlink", + "sha256": "694c8e8c109e4bba220ef2cb62d038c67060b224f9deb5db3237d73bed8c81ba", + "sha256_in_prefix": "694c8e8c109e4bba220ef2cb62d038c67060b224f9deb5db3237d73bed8c81ba", + "size_in_bytes": 69155 + }, + { + "_path": "lib/python3.12/idlelib/extend.txt", + "path_type": "hardlink", + "sha256": "5bceaf660c46faf8f9fbf2be5e23389d6e6477d1e458fee680e606bcc95d2853", + "sha256_in_prefix": "5bceaf660c46faf8f9fbf2be5e23389d6e6477d1e458fee680e606bcc95d2853", + "size_in_bytes": 3631 + }, + { + "_path": "lib/python3.12/idlelib/filelist.py", + "path_type": "hardlink", + "sha256": "64e194e4514141414ecb231ac165ed861749bb0d31d0758c7c3a823ce154abe1", + "sha256_in_prefix": "64e194e4514141414ecb231ac165ed861749bb0d31d0758c7c3a823ce154abe1", + "size_in_bytes": 3871 + }, + { + "_path": "lib/python3.12/idlelib/format.py", + "path_type": "hardlink", + "sha256": "dc2b00fb239f38543bf973d94daef2c52457b905d4d89c640993823127b7923c", + "sha256_in_prefix": "dc2b00fb239f38543bf973d94daef2c52457b905d4d89c640993823127b7923c", + "size_in_bytes": 15777 + }, + { + "_path": "lib/python3.12/idlelib/grep.py", + "path_type": "hardlink", + "sha256": "f5a9327c83e7aecec64efb81bf9f4542a4f3e0a13d0b6443e8eca5dfbb509835", + "sha256_in_prefix": "f5a9327c83e7aecec64efb81bf9f4542a4f3e0a13d0b6443e8eca5dfbb509835", + "size_in_bytes": 7526 + }, + { + "_path": "lib/python3.12/idlelib/help.html", + "path_type": "hardlink", + "sha256": "ac81ab586d33514ce0f303cf02d04bc9a2184569c82f4c85fed7c16b209e6dbb", + "sha256_in_prefix": "ac81ab586d33514ce0f303cf02d04bc9a2184569c82f4c85fed7c16b209e6dbb", + "size_in_bytes": 78525 + }, + { + "_path": "lib/python3.12/idlelib/help.py", + "path_type": "hardlink", + "sha256": "35f26243be00070246751349d864ffc576242b38aa559ed536e7b635819ea847", + "sha256_in_prefix": "35f26243be00070246751349d864ffc576242b38aa559ed536e7b635819ea847", + "size_in_bytes": 11902 + }, + { + "_path": "lib/python3.12/idlelib/help_about.py", + "path_type": "hardlink", + "sha256": "93aec712aa0f1899597c52697d859cf26c63163ee355e456f0e20b984dcfdfdf", + "sha256_in_prefix": "93aec712aa0f1899597c52697d859cf26c63163ee355e456f0e20b984dcfdfdf", + "size_in_bytes": 8910 + }, + { + "_path": "lib/python3.12/idlelib/history.py", + "path_type": "hardlink", + "sha256": "f91f1568d083bdbc856d38ef48493bcb138c6a492d523385b300a5bac30133e6", + "sha256_in_prefix": "f91f1568d083bdbc856d38ef48493bcb138c6a492d523385b300a5bac30133e6", + "size_in_bytes": 4065 + }, + { + "_path": "lib/python3.12/idlelib/hyperparser.py", + "path_type": "hardlink", + "sha256": "18563d2b4c248aed70b7f29fd903fd51d1b5aceb3dc93c23f9a54141eed7a9b0", + "sha256_in_prefix": "18563d2b4c248aed70b7f29fd903fd51d1b5aceb3dc93c23f9a54141eed7a9b0", + "size_in_bytes": 12889 + }, + { + "_path": "lib/python3.12/idlelib/idle.bat", + "path_type": "hardlink", + "sha256": "15a3977f0d2c6a8e87db2ef7050ea10afb3a88b064bf5ef95439924e42464114", + "sha256_in_prefix": "15a3977f0d2c6a8e87db2ef7050ea10afb3a88b064bf5ef95439924e42464114", + "size_in_bytes": 177 + }, + { + "_path": "lib/python3.12/idlelib/idle.py", + "path_type": "hardlink", + "sha256": "33ffa2f718e123fd1c4e536bb4a471978515787ee9fbf7806a92073a787a733a", + "sha256_in_prefix": "33ffa2f718e123fd1c4e536bb4a471978515787ee9fbf7806a92073a787a733a", + "size_in_bytes": 454 + }, + { + "_path": "lib/python3.12/idlelib/idle.pyw", + "path_type": "hardlink", + "sha256": "26101d297127132c5e9634499f41ad00e125ea308343a20b278bee9e9225eb5c", + "sha256_in_prefix": "26101d297127132c5e9634499f41ad00e125ea308343a20b278bee9e9225eb5c", + "size_in_bytes": 570 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/README.txt", + "path_type": "hardlink", + "sha256": "94cca8aab706b6ceb5d9ed44cad93127988c9370cdde250a53bec9b132261f05", + "sha256_in_prefix": "94cca8aab706b6ceb5d9ed44cad93127988c9370cdde250a53bec9b132261f05", + "size_in_bytes": 8880 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__init__.py", + "path_type": "hardlink", + "sha256": "0a7370f8ab516e0944f381fcecee02ac660926551b3eb543f88ace3ef024ca70", + "sha256_in_prefix": "0a7370f8ab516e0944f381fcecee02ac660926551b3eb543f88ace3ef024ca70", + "size_in_bytes": 1250 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/__init__.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "7789af9e2606f3672299ac0ddb29bc670e74a1099319bcbcc70331e252dd81da", + "sha256_in_prefix": "7789af9e2606f3672299ac0ddb29bc670e74a1099319bcbcc70331e252dd81da", + "size_in_bytes": 1209 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/htest.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "c51fc731cc4e6664333db308495d70c6980f5f133aa7bc93751f8b4437cdbadb", + "sha256_in_prefix": "c51fc731cc4e6664333db308495d70c6980f5f133aa7bc93751f8b4437cdbadb", + "size_in_bytes": 16627 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/mock_idle.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "ef28aa780e2cbe398c0762e6a389de440672b83762bbadfd50637f1de1763f1f", + "sha256_in_prefix": "ef28aa780e2cbe398c0762e6a389de440672b83762bbadfd50637f1de1763f1f", + "size_in_bytes": 3431 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/mock_tk.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "12ec87b589ee513321a14efa0d95dcfe43070b1a82edbb553a5c1225b3e71443", + "sha256_in_prefix": "12ec87b589ee513321a14efa0d95dcfe43070b1a82edbb553a5c1225b3e71443", + "size_in_bytes": 14332 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/template.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "b98111435c90b783ebd2ef73d2c0b260822606d82fbe110b1206f20d3168830f", + "sha256_in_prefix": "b98111435c90b783ebd2ef73d2c0b260822606d82fbe110b1206f20d3168830f", + "size_in_bytes": 1715 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/test_autocomplete.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "b19c08e516de509fc1d6ebd953cea6767ba6e0c60f13129c8f839969e52782bc", + "sha256_in_prefix": "b19c08e516de509fc1d6ebd953cea6767ba6e0c60f13129c8f839969e52782bc", + "size_in_bytes": 18932 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/test_autocomplete_w.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "bae39b77fcecb413b63c0db1a302a7df962301e34a555977cf3f7465ec662614", + "sha256_in_prefix": "bae39b77fcecb413b63c0db1a302a7df962301e34a555977cf3f7465ec662614", + "size_in_bytes": 2183 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/test_autoexpand.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "c5889d236016c97f47470e75a9e48570d7714989ead48ec088a6d22569ee537a", + "sha256_in_prefix": "c5889d236016c97f47470e75a9e48570d7714989ead48ec088a6d22569ee537a", + "size_in_bytes": 7244 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/test_browser.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "134bc0690027724e1e4fa0e63248e4b9fbc53286876532f62879d95989449949", + "sha256_in_prefix": "134bc0690027724e1e4fa0e63248e4b9fbc53286876532f62879d95989449949", + "size_in_bytes": 17306 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/test_calltip.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "b8648008b1dba12d488df4dfefcff2f1a4250701b018138161daf84eb5da2238", + "sha256_in_prefix": "b8648008b1dba12d488df4dfefcff2f1a4250701b018138161daf84eb5da2238", + "size_in_bytes": 26852 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/test_calltip_w.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "301493a59487a97c20d9aebc77e05b8522c5855ddf2fb4d53f898b5f4c6c9211", + "sha256_in_prefix": "301493a59487a97c20d9aebc77e05b8522c5855ddf2fb4d53f898b5f4c6c9211", + "size_in_bytes": 2123 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/test_codecontext.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "9a589156d0f3c1c3d162307f1f6683a143bca5fb5d58c8817efebdf711c5c0a2", + "sha256_in_prefix": "9a589156d0f3c1c3d162307f1f6683a143bca5fb5d58c8817efebdf711c5c0a2", + "size_in_bytes": 21889 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/test_colorizer.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "4b71f7a27529b75a419f14b49a13875f21809c3babe710e61417c47a0cb27ec7", + "sha256_in_prefix": "4b71f7a27529b75a419f14b49a13875f21809c3babe710e61417c47a0cb27ec7", + "size_in_bytes": 32109 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/test_config.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "ea917864b2fb5b8cfa8c5bb9179fd24a685e949fbb4413ae1ece64e97b0f372f", + "sha256_in_prefix": "ea917864b2fb5b8cfa8c5bb9179fd24a685e949fbb4413ae1ece64e97b0f372f", + "size_in_bytes": 48479 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/test_config_key.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "98d60e47c3ae39d792f78e9944c3d3d566bbda6e632a47bac8ff2fb9fe67a32d", + "sha256_in_prefix": "98d60e47c3ae39d792f78e9944c3d3d566bbda6e632a47bac8ff2fb9fe67a32d", + "size_in_bytes": 22327 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/test_configdialog.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "0fcf50b74e2b70630603f1142f33b66ec65c921dd308e29e237d6061a06f1429", + "sha256_in_prefix": "0fcf50b74e2b70630603f1142f33b66ec65c921dd308e29e237d6061a06f1429", + "size_in_bytes": 91381 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/test_debugger.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "d263e228ec6d6e787e5a190897e47ebcd0856db5863f2318e91c3b72f5724d31", + "sha256_in_prefix": "d263e228ec6d6e787e5a190897e47ebcd0856db5863f2318e91c3b72f5724d31", + "size_in_bytes": 18399 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/test_debugger_r.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "ad4f7d0ae2a7ab64145371a4e14be9e64418360c9423b3a4585a809b38323559", + "sha256_in_prefix": "ad4f7d0ae2a7ab64145371a4e14be9e64418360c9423b3a4585a809b38323559", + "size_in_bytes": 1771 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/test_debugobj.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "ad132d8f40db855c03f4dde155846770a4f510dff1e0e8faa3c511792830cf5d", + "sha256_in_prefix": "ad132d8f40db855c03f4dde155846770a4f510dff1e0e8faa3c511792830cf5d", + "size_in_bytes": 4376 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/test_debugobj_r.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "4cfca7ceb007c3af9a3c83cf0b4b6ada498ff85d777a90b081614a09e8912499", + "sha256_in_prefix": "4cfca7ceb007c3af9a3c83cf0b4b6ada498ff85d777a90b081614a09e8912499", + "size_in_bytes": 1832 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/test_delegator.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "639cf1e724405c51863eb40a5ab73908ae9c4320b262f3cefd35f3b12af64a79", + "sha256_in_prefix": "639cf1e724405c51863eb40a5ab73908ae9c4320b262f3cefd35f3b12af64a79", + "size_in_bytes": 2347 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/test_editmenu.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "4fa51db7d044f0eca116499596b96414ec23163390dfb2255aa57d9c287687ba", + "sha256_in_prefix": "4fa51db7d044f0eca116499596b96414ec23163390dfb2255aa57d9c287687ba", + "size_in_bytes": 4894 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/test_editor.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "9693c6a2f3beb94cd03bb2f794d13358f01c11e54db9ae91ab7930f3e98da5fc", + "sha256_in_prefix": "9693c6a2f3beb94cd03bb2f794d13358f01c11e54db9ae91ab7930f3e98da5fc", + "size_in_bytes": 11434 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/test_filelist.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "4101cc991397f6e41b60530921619c08ef371df50e3295508dd9842b9aa3fd45", + "sha256_in_prefix": "4101cc991397f6e41b60530921619c08ef371df50e3295508dd9842b9aa3fd45", + "size_in_bytes": 2394 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/test_format.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "20e40058df6747b690738fd1f90a5d4b493ec5a7cb367f412660dff6da0d4416", + "sha256_in_prefix": "20e40058df6747b690738fd1f90a5d4b493ec5a7cb367f412660dff6da0d4416", + "size_in_bytes": 33239 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/test_grep.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "32e312f537124e30478be2f7f6d5e8d2be125a4bb7514651a85d7e3d51b05247", + "sha256_in_prefix": "32e312f537124e30478be2f7f6d5e8d2be125a4bb7514651a85d7e3d51b05247", + "size_in_bytes": 8731 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/test_help.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "faae073d73767df6bce7a3ff50689193f40adf9c171752bd6d472209bacd5c96", + "sha256_in_prefix": "faae073d73767df6bce7a3ff50689193f40adf9c171752bd6d472209bacd5c96", + "size_in_bytes": 2429 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/test_help_about.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "0374bfc6b6839767ffac012dfb754a0d04e33b0f193986b46cc279903e1f5f8c", + "sha256_in_prefix": "0374bfc6b6839767ffac012dfb754a0d04e33b0f193986b46cc279903e1f5f8c", + "size_in_bytes": 11586 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/test_history.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "2bb989d1cf4d65d7445c8092dd31980d946364a1388871a21168a17dbbfa57ea", + "sha256_in_prefix": "2bb989d1cf4d65d7445c8092dd31980d946364a1388871a21168a17dbbfa57ea", + "size_in_bytes": 11087 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/test_hyperparser.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "2c55529e5bec557f4bd57864c2e8f9a266ec38787e688fdbf77769340f081d0d", + "sha256_in_prefix": "2c55529e5bec557f4bd57864c2e8f9a266ec38787e688fdbf77769340f081d0d", + "size_in_bytes": 14900 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/test_iomenu.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "b3faadc8991fb9bc0ca0273ad1d82e5a357e755d1ddcb08429c7d9a1c9b19412", + "sha256_in_prefix": "b3faadc8991fb9bc0ca0273ad1d82e5a357e755d1ddcb08429c7d9a1c9b19412", + "size_in_bytes": 5243 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/test_macosx.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "3158fb5ce741ddb7a3ca1e42d27786f9e40d822fcfa8358e0cf84f9364722861", + "sha256_in_prefix": "3158fb5ce741ddb7a3ca1e42d27786f9e40d822fcfa8358e0cf84f9364722861", + "size_in_bytes": 6953 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/test_mainmenu.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "099bdf1330b5e688de83b0cb5515069dc0d3ab4fc11a90b60aada8845170d70d", + "sha256_in_prefix": "099bdf1330b5e688de83b0cb5515069dc0d3ab4fc11a90b60aada8845170d70d", + "size_in_bytes": 2698 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/test_multicall.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "893e56873a0d7eaa3545d2f823af0e473f88b8dd512233965c97cb27c8c890ef", + "sha256_in_prefix": "893e56873a0d7eaa3545d2f823af0e473f88b8dd512233965c97cb27c8c890ef", + "size_in_bytes": 3140 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/test_outwin.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "b0bb046e373fe4d0575d6c20a86417ea1087f0fe5e26c2f5913ad2e9dd4a5f4e", + "sha256_in_prefix": "b0bb046e373fe4d0575d6c20a86417ea1087f0fe5e26c2f5913ad2e9dd4a5f4e", + "size_in_bytes": 9474 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/test_parenmatch.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "a517577b5f6aaf6a1285fd2df701e09ed9094f7523c4f5f4b293bc418cea1f4d", + "sha256_in_prefix": "a517577b5f6aaf6a1285fd2df701e09ed9094f7523c4f5f4b293bc418cea1f4d", + "size_in_bytes": 6387 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/test_pathbrowser.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "511c0ecc700fe29277f1c9cff547ad55df1bc6fe0e041044dd17256f506cc6a6", + "sha256_in_prefix": "511c0ecc700fe29277f1c9cff547ad55df1bc6fe0e041044dd17256f506cc6a6", + "size_in_bytes": 6045 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/test_percolator.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "d7d1ee05e930e4492abf1874d17b3acb8f6f4d679a19bf22bfbf21217745e73c", + "sha256_in_prefix": "d7d1ee05e930e4492abf1874d17b3acb8f6f4d679a19bf22bfbf21217745e73c", + "size_in_bytes": 9380 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/test_pyparse.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "a6e994a89184edf7a03f68211420eb6866197002ddaa75d17f35b17cc7b87784", + "sha256_in_prefix": "a6e994a89184edf7a03f68211420eb6866197002ddaa75d17f35b17cc7b87784", + "size_in_bytes": 23331 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/test_pyshell.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "723d27a392de7c9ad034754869fadc1b5a2ce81af362c882ab3fb82332da190a", + "sha256_in_prefix": "723d27a392de7c9ad034754869fadc1b5a2ce81af362c882ab3fb82332da190a", + "size_in_bytes": 9386 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/test_query.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "12d804c7430b1faab607ccd15d9588bede88ee3ead19ef0ff553e390a6c18cbf", + "sha256_in_prefix": "12d804c7430b1faab607ccd15d9588bede88ee3ead19ef0ff553e390a6c18cbf", + "size_in_bytes": 32097 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/test_redirector.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "c5ac40ec3be9cda632ea8c04a5bb4fe86289839f3d54cdae1b36d79cc546df8d", + "sha256_in_prefix": "c5ac40ec3be9cda632ea8c04a5bb4fe86289839f3d54cdae1b36d79cc546df8d", + "size_in_bytes": 9761 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/test_replace.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "709699d533acd6c74415a1f2f92efd681fae903956e1593183412d847b56f78e", + "sha256_in_prefix": "709699d533acd6c74415a1f2f92efd681fae903956e1593183412d847b56f78e", + "size_in_bytes": 15553 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/test_rpc.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "f45f4104e574d5b6e9b31db8ac40bd9cf7d4b11932f866f003ffd366638310e7", + "sha256_in_prefix": "f45f4104e574d5b6e9b31db8ac40bd9cf7d4b11932f866f003ffd366638310e7", + "size_in_bytes": 2554 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/test_run.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "320ad957dfeef571587afa183d597aa6534392c6cfe96b9c945cbfbc6b70b46a", + "sha256_in_prefix": "320ad957dfeef571587afa183d597aa6534392c6cfe96b9c945cbfbc6b70b46a", + "size_in_bytes": 31172 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/test_runscript.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "10b2581d857a8bbe62a90d28bacaf3190bee4bea7a4a9af7a111387566b3fb3e", + "sha256_in_prefix": "10b2581d857a8bbe62a90d28bacaf3190bee4bea7a4a9af7a111387566b3fb3e", + "size_in_bytes": 2227 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/test_scrolledlist.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "c2c2ca6de48797fb22d1394afd7a6646de4d557bda7853f6d162a72e57877bb3", + "sha256_in_prefix": "c2c2ca6de48797fb22d1394afd7a6646de4d557bda7853f6d162a72e57877bb3", + "size_in_bytes": 1636 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/test_search.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "02a8821d1cf394d3274f1133362872ebc2b5d72c715505de80d83373d4ab2918", + "sha256_in_prefix": "02a8821d1cf394d3274f1133362872ebc2b5d72c715505de80d83373d4ab2918", + "size_in_bytes": 4939 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/test_searchbase.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "2c31ddacfda94aa2f5a3831e754188bbeac5bd67481509ba9c86e549a5fa34cf", + "sha256_in_prefix": "2c31ddacfda94aa2f5a3831e754188bbeac5bd67481509ba9c86e549a5fa34cf", + "size_in_bytes": 10495 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/test_searchengine.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "1c28857142c796fb94eda5bb05b0a1dd2729233a5b9a0a51ab3de58aa196b644", + "sha256_in_prefix": "1c28857142c796fb94eda5bb05b0a1dd2729233a5b9a0a51ab3de58aa196b644", + "size_in_bytes": 18039 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/test_sidebar.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "8de58812693a764ac0c01e913ad3fa127e7e13bca6948973c1e02ccf6c648983", + "sha256_in_prefix": "8de58812693a764ac0c01e913ad3fa127e7e13bca6948973c1e02ccf6c648983", + "size_in_bytes": 45873 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/test_squeezer.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "0d8db58702420185f44a77c742fdcb0d0c44b87cdf08e9436c7685926d3d6da9", + "sha256_in_prefix": "0d8db58702420185f44a77c742fdcb0d0c44b87cdf08e9436c7685926d3d6da9", + "size_in_bytes": 27423 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/test_stackviewer.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "1e8241e3f3a2aa5a06e58aa3d3d50272857fac9ec07c06ab9bfb115a9995f1ba", + "sha256_in_prefix": "1e8241e3f3a2aa5a06e58aa3d3d50272857fac9ec07c06ab9bfb115a9995f1ba", + "size_in_bytes": 2386 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/test_statusbar.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "61f326aa0e8052a5da03cf1bd60d35f5e792a1faecbd9ca8e48160d8c8973c7a", + "sha256_in_prefix": "61f326aa0e8052a5da03cf1bd60d35f5e792a1faecbd9ca8e48160d8c8973c7a", + "size_in_bytes": 2808 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/test_text.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "081fdc8296f611c7e9d984efb9b90817e499172564827a2f5d56f6856c16b29f", + "sha256_in_prefix": "081fdc8296f611c7e9d984efb9b90817e499172564827a2f5d56f6856c16b29f", + "size_in_bytes": 11692 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/test_textview.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "70a2bf5033578b1872bde7a8fee04c0fe842ca797af7ac1a461b5df0b30b8cfc", + "sha256_in_prefix": "70a2bf5033578b1872bde7a8fee04c0fe842ca797af7ac1a461b5df0b30b8cfc", + "size_in_bytes": 15855 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/test_tooltip.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "a0b2473240e85bcf3965aec9e33bdb876d2e3a14bb54837b26e7f0a2f0cd3cbd", + "sha256_in_prefix": "a0b2473240e85bcf3965aec9e33bdb876d2e3a14bb54837b26e7f0a2f0cd3cbd", + "size_in_bytes": 10073 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/test_tree.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "e00e0a19c85092717e35de176e5327739373330f49a8d3923926b2b08cec8fff", + "sha256_in_prefix": "e00e0a19c85092717e35de176e5327739373330f49a8d3923926b2b08cec8fff", + "size_in_bytes": 4100 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/test_undo.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "fa94c52fb91317068db89dad89d2e5c0964a9ae14d92ce710dabd77570bc2f50", + "sha256_in_prefix": "fa94c52fb91317068db89dad89d2e5c0964a9ae14d92ce710dabd77570bc2f50", + "size_in_bytes": 8301 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/test_util.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "1f969d64e017aee4ee52fce8289f66ae4a2c4507691e8976a90ae6f94f666d73", + "sha256_in_prefix": "1f969d64e017aee4ee52fce8289f66ae4a2c4507691e8976a90ae6f94f666d73", + "size_in_bytes": 1137 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/test_warning.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "245fc4633ca593860304e512d74e4265336905353cfcae99ef5850ebae6acc5a", + "sha256_in_prefix": "245fc4633ca593860304e512d74e4265336905353cfcae99ef5850ebae6acc5a", + "size_in_bytes": 4599 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/test_window.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "3d17317cda405a779af392f0883a67dae2396bec3dcc3b58ed007349c05a4e9f", + "sha256_in_prefix": "3d17317cda405a779af392f0883a67dae2396bec3dcc3b58ed007349c05a4e9f", + "size_in_bytes": 2751 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/test_zoomheight.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "0cd27aa7081975411d7d3ef118a9ae73b9cdd6bde1a7b0e22b05919dce5d3f38", + "sha256_in_prefix": "0cd27aa7081975411d7d3ef118a9ae73b9cdd6bde1a7b0e22b05919dce5d3f38", + "size_in_bytes": 2658 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/test_zzdummy.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "b87d05b5b406783643abff78f2e78dac49a5ee30374290244a15a3563703af0b", + "sha256_in_prefix": "b87d05b5b406783643abff78f2e78dac49a5ee30374290244a15a3563703af0b", + "size_in_bytes": 8518 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/tkinter_testing_utils.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "4edbb99dd995ef85b5d6c1750c839c9516354237cf2b0376a8eeb02be38ed86b", + "sha256_in_prefix": "4edbb99dd995ef85b5d6c1750c839c9516354237cf2b0376a8eeb02be38ed86b", + "size_in_bytes": 2915 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/example_noext", + "path_type": "hardlink", + "sha256": "526edff5d21fd1f1421f5ab6a706cb51732edcae235b9895f93a8f46e25505fe", + "sha256_in_prefix": "526edff5d21fd1f1421f5ab6a706cb51732edcae235b9895f93a8f46e25505fe", + "size_in_bytes": 68 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/example_stub.pyi", + "path_type": "hardlink", + "sha256": "e89a8196b490fe728f31af590b3bbca69bddc7aec8cbf09d2a5ae0953240ac56", + "sha256_in_prefix": "e89a8196b490fe728f31af590b3bbca69bddc7aec8cbf09d2a5ae0953240ac56", + "size_in_bytes": 154 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/htest.py", + "path_type": "hardlink", + "sha256": "8c0413ab3067d28fe93f40e2e1da410414095ab278f63fc578a9d8452f98eb5c", + "sha256_in_prefix": "8c0413ab3067d28fe93f40e2e1da410414095ab278f63fc578a9d8452f98eb5c", + "size_in_bytes": 15313 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/mock_idle.py", + "path_type": "hardlink", + "sha256": "637d74d26089c582fb784c2920f5bcb41e5b1fc8b9e0931ddc1cc8d92becbff4", + "sha256_in_prefix": "637d74d26089c582fb784c2920f5bcb41e5b1fc8b9e0931ddc1cc8d92becbff4", + "size_in_bytes": 1943 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/mock_tk.py", + "path_type": "hardlink", + "sha256": "7d60a26e82fd0469a95e02c2adda6607363a51ab67d5851cc323a58a595f74a7", + "sha256_in_prefix": "7d60a26e82fd0469a95e02c2adda6607363a51ab67d5851cc323a58a595f74a7", + "size_in_bytes": 11693 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/template.py", + "path_type": "hardlink", + "sha256": "43421286ad234a4240f8d4bc09f67bb58da0bf9d9b07bf93010989ef2c17f2f8", + "sha256_in_prefix": "43421286ad234a4240f8d4bc09f67bb58da0bf9d9b07bf93010989ef2c17f2f8", + "size_in_bytes": 642 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/test_autocomplete.py", + "path_type": "hardlink", + "sha256": "0ee1af80bb645bd57e6f6383f5e5473f901e9d40524992abf9c48a4163997eef", + "sha256_in_prefix": "0ee1af80bb645bd57e6f6383f5e5473f901e9d40524992abf9c48a4163997eef", + "size_in_bytes": 11093 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/test_autocomplete_w.py", + "path_type": "hardlink", + "sha256": "f8cd80196c2841f65f53ca5ae1c4fb99c7c215b29cf88774e0b189c99e4cee79", + "sha256_in_prefix": "f8cd80196c2841f65f53ca5ae1c4fb99c7c215b29cf88774e0b189c99e4cee79", + "size_in_bytes": 720 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/test_autoexpand.py", + "path_type": "hardlink", + "sha256": "85f913f8cbd5dfd5d52d3b7d00eedec231ec3e4ee7d117db4a2bb714eb1a7243", + "sha256_in_prefix": "85f913f8cbd5dfd5d52d3b7d00eedec231ec3e4ee7d117db4a2bb714eb1a7243", + "size_in_bytes": 4638 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/test_browser.py", + "path_type": "hardlink", + "sha256": "bdfd3bd9ab02ee535e77f3233920f80891eb84d7042f7db381afc7766b3702eb", + "sha256_in_prefix": "bdfd3bd9ab02ee535e77f3233920f80891eb84d7042f7db381afc7766b3702eb", + "size_in_bytes": 8420 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/test_calltip.py", + "path_type": "hardlink", + "sha256": "a67efd1c92e824321254f615d35a72508ee09d75e1058c3d01ad7d8bf3be1ebf", + "sha256_in_prefix": "a67efd1c92e824321254f615d35a72508ee09d75e1058c3d01ad7d8bf3be1ebf", + "size_in_bytes": 13658 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/test_calltip_w.py", + "path_type": "hardlink", + "sha256": "7462c048c689f82c3ae6b5782a18776762f88055b80ae77a92243b6c0606e004", + "sha256_in_prefix": "7462c048c689f82c3ae6b5782a18776762f88055b80ae77a92243b6c0606e004", + "size_in_bytes": 686 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/test_codecontext.py", + "path_type": "hardlink", + "sha256": "84e6b890b22b2abcc0865c691162b93c6ffb9b4e17f05011bdaffa770a52fcf0", + "sha256_in_prefix": "84e6b890b22b2abcc0865c691162b93c6ffb9b4e17f05011bdaffa770a52fcf0", + "size_in_bytes": 16082 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/test_colorizer.py", + "path_type": "hardlink", + "sha256": "6a3fbb630e0ecc7aafc9c8bc56ece3462911c733aa3bb4c52ee55c1d897301d4", + "sha256_in_prefix": "6a3fbb630e0ecc7aafc9c8bc56ece3462911c733aa3bb4c52ee55c1d897301d4", + "size_in_bytes": 22882 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/test_config.py", + "path_type": "hardlink", + "sha256": "02546eb557e57b1654da9016cf56f1826869f3e6c78bcafffb8a89013641c1a1", + "sha256_in_prefix": "02546eb557e57b1654da9016cf56f1826869f3e6c78bcafffb8a89013641c1a1", + "size_in_bytes": 32091 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/test_config_key.py", + "path_type": "hardlink", + "sha256": "54d0c65e1f66d37c415d3fe533c8db891974f08e8fca6374596280d64db86586", + "sha256_in_prefix": "54d0c65e1f66d37c415d3fe533c8db891974f08e8fca6374596280d64db86586", + "size_in_bytes": 11462 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/test_configdialog.py", + "path_type": "hardlink", + "sha256": "56685b99d406c974ffce84260b08b06476b1e98f701d0675c378d86c8f19f579", + "sha256_in_prefix": "56685b99d406c974ffce84260b08b06476b1e98f701d0675c378d86c8f19f579", + "size_in_bytes": 55389 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/test_debugger.py", + "path_type": "hardlink", + "sha256": "8117fa37bf2c4266809f3a41c7c37c603c6a390b235801504123ea533c55d7cc", + "sha256_in_prefix": "8117fa37bf2c4266809f3a41c7c37c603c6a390b235801504123ea533c55d7cc", + "size_in_bytes": 9727 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/test_debugger_r.py", + "path_type": "hardlink", + "sha256": "ccc0ba5e03ee1df449f78a164efdc6739f5a530315ab3971ac05c652bc779cea", + "sha256_in_prefix": "ccc0ba5e03ee1df449f78a164efdc6739f5a530315ab3971ac05c652bc779cea", + "size_in_bytes": 965 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/test_debugobj.py", + "path_type": "hardlink", + "sha256": "5427a574cfcfd36a48e365f6f8864b226ee8d7eb48702ff1496570302b1d9acc", + "sha256_in_prefix": "5427a574cfcfd36a48e365f6f8864b226ee8d7eb48702ff1496570302b1d9acc", + "size_in_bytes": 1611 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/test_debugobj_r.py", + "path_type": "hardlink", + "sha256": "22d74368ba175175b9c14315f9d82fd7ddde60ae93d2e5572e9a647de7e869eb", + "sha256_in_prefix": "22d74368ba175175b9c14315f9d82fd7ddde60ae93d2e5572e9a647de7e869eb", + "size_in_bytes": 545 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/test_delegator.py", + "path_type": "hardlink", + "sha256": "559d39df8c1ff38d177943f245b87f5379ee5ea93399fd6b5f7bfa882e6ed8ca", + "sha256_in_prefix": "559d39df8c1ff38d177943f245b87f5379ee5ea93399fd6b5f7bfa882e6ed8ca", + "size_in_bytes": 1567 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/test_editmenu.py", + "path_type": "hardlink", + "sha256": "ed3800137d48ffcf86ecb71afe5a24cd9ed381571f23036438ba8a97f502326a", + "sha256_in_prefix": "ed3800137d48ffcf86ecb71afe5a24cd9ed381571f23036438ba8a97f502326a", + "size_in_bytes": 2564 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/test_editor.py", + "path_type": "hardlink", + "sha256": "654ae5ca7f747a4a88d2868de48c7bff1f35b26098075f840722e955fe4cb83e", + "sha256_in_prefix": "654ae5ca7f747a4a88d2868de48c7bff1f35b26098075f840722e955fe4cb83e", + "size_in_bytes": 8151 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/test_filelist.py", + "path_type": "hardlink", + "sha256": "d4cea5fdba68fb9e361541820d44eed003c317f4ef14bb9df3406b8d2c53ef7c", + "sha256_in_prefix": "d4cea5fdba68fb9e361541820d44eed003c317f4ef14bb9df3406b8d2c53ef7c", + "size_in_bytes": 795 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/test_format.py", + "path_type": "hardlink", + "sha256": "b356a2a8f5fe14c39c6af73623484df4ed930cc16ef4605f3b04fd9b618867a6", + "sha256_in_prefix": "b356a2a8f5fe14c39c6af73623484df4ed930cc16ef4605f3b04fd9b618867a6", + "size_in_bytes": 23610 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/test_grep.py", + "path_type": "hardlink", + "sha256": "ca64de882b5608e016b7df8f739089c9f262643bce09979b76399cc4be1ea12c", + "sha256_in_prefix": "ca64de882b5608e016b7df8f739089c9f262643bce09979b76399cc4be1ea12c", + "size_in_bytes": 5072 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/test_help.py", + "path_type": "hardlink", + "sha256": "0513a2872307b45ea7869b7e07dc437d7e8c69524073513b96374397f371b32a", + "sha256_in_prefix": "0513a2872307b45ea7869b7e07dc437d7e8c69524073513b96374397f371b32a", + "size_in_bytes": 863 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/test_help_about.py", + "path_type": "hardlink", + "sha256": "47663dfbcddced35ad97631cebb690a30ab3aa724bde0a7174d11290ac79eb02", + "sha256_in_prefix": "47663dfbcddced35ad97631cebb690a30ab3aa724bde0a7174d11290ac79eb02", + "size_in_bytes": 5904 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/test_history.py", + "path_type": "hardlink", + "sha256": "6319fe7810ed91786b503de80701a291a4f9abe54c9e101c19c0917b709e62f3", + "sha256_in_prefix": "6319fe7810ed91786b503de80701a291a4f9abe54c9e101c19c0917b709e62f3", + "size_in_bytes": 5517 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/test_hyperparser.py", + "path_type": "hardlink", + "sha256": "cd2fbc788d4d75b514e53951dc90d00d41a8a87baad31bc1e380b7449bfcf183", + "sha256_in_prefix": "cd2fbc788d4d75b514e53951dc90d00d41a8a87baad31bc1e380b7449bfcf183", + "size_in_bytes": 9082 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/test_iomenu.py", + "path_type": "hardlink", + "sha256": "8250eb60ea1d7760589febf38c171c8c6e202e527a680030233539db59439d8d", + "sha256_in_prefix": "8250eb60ea1d7760589febf38c171c8c6e202e527a680030233539db59439d8d", + "size_in_bytes": 2457 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/test_macosx.py", + "path_type": "hardlink", + "sha256": "975e48ab453711c5072988e2e66a7fe51e716ac64e494f022a5ff82781ccd368", + "sha256_in_prefix": "975e48ab453711c5072988e2e66a7fe51e716ac64e494f022a5ff82781ccd368", + "size_in_bytes": 3444 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/test_mainmenu.py", + "path_type": "hardlink", + "sha256": "faa064ffd9c8e30b1205e46bb4ede816c74b7948cfa34c7795ed19c35eac10d5", + "sha256_in_prefix": "faa064ffd9c8e30b1205e46bb4ede816c74b7948cfa34c7795ed19c35eac10d5", + "size_in_bytes": 1638 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/test_multicall.py", + "path_type": "hardlink", + "sha256": "1bfb51912275d8e346dce0a40ab84316b15e3f142e66529a8c9cfd52210c1a1f", + "sha256_in_prefix": "1bfb51912275d8e346dce0a40ab84316b15e3f142e66529a8c9cfd52210c1a1f", + "size_in_bytes": 1317 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/test_outwin.py", + "path_type": "hardlink", + "sha256": "4f0590e1fe9af387fa627cb8a40cd7618da5d2a46ce4b33446d54f6fbcce2105", + "sha256_in_prefix": "4f0590e1fe9af387fa627cb8a40cd7618da5d2a46ce4b33446d54f6fbcce2105", + "size_in_bytes": 5417 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/test_parenmatch.py", + "path_type": "hardlink", + "sha256": "5e0ba86116e28d46e7db9ed33d85cf7caa837e1779e1b8feb5f6b6b4a837551e", + "sha256_in_prefix": "5e0ba86116e28d46e7db9ed33d85cf7caa837e1779e1b8feb5f6b6b4a837551e", + "size_in_bytes": 3544 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/test_pathbrowser.py", + "path_type": "hardlink", + "sha256": "a7d9c5085ff5c64232897f6ee0a09258a41a35f153f47ff0f3b8fa97ec67be9e", + "sha256_in_prefix": "a7d9c5085ff5c64232897f6ee0a09258a41a35f153f47ff0f3b8fa97ec67be9e", + "size_in_bytes": 2422 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/test_percolator.py", + "path_type": "hardlink", + "sha256": "133b134a46b23cf2c635be3116415fd388e3a1c1581bf1a77d7f7f0aff3a725b", + "sha256_in_prefix": "133b134a46b23cf2c635be3116415fd388e3a1c1581bf1a77d7f7f0aff3a725b", + "size_in_bytes": 4065 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/test_pyparse.py", + "path_type": "hardlink", + "sha256": "8f386a9f535369afb495322e104077c66c5a3abb91917ec69f868b405120cf35", + "sha256_in_prefix": "8f386a9f535369afb495322e104077c66c5a3abb91917ec69f868b405120cf35", + "size_in_bytes": 19365 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/test_pyshell.py", + "path_type": "hardlink", + "sha256": "ff47aecd0657edbd7bc920473fe2e55b0bb0db6f347dc52f5e81b767897d3bc5", + "sha256_in_prefix": "ff47aecd0657edbd7bc920473fe2e55b0bb0db6f347dc52f5e81b767897d3bc5", + "size_in_bytes": 4965 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/test_query.py", + "path_type": "hardlink", + "sha256": "632c2dc13a158a5902e5b758166151ffa377db7f5a0c368bc3b0741a237876c3", + "sha256_in_prefix": "632c2dc13a158a5902e5b758166151ffa377db7f5a0c368bc3b0741a237876c3", + "size_in_bytes": 15454 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/test_redirector.py", + "path_type": "hardlink", + "sha256": "517c1fe16da359e01f3cdfdf3f7aead4283e8b8e1107522b72f59d4c4f3ade4c", + "sha256_in_prefix": "517c1fe16da359e01f3cdfdf3f7aead4283e8b8e1107522b72f59d4c4f3ade4c", + "size_in_bytes": 4176 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/test_replace.py", + "path_type": "hardlink", + "sha256": "321333b3eaad9ecbf633186bc625d4a60c4c736def0fa00665add2ab899eecb1", + "sha256_in_prefix": "321333b3eaad9ecbf633186bc625d4a60c4c736def0fa00665add2ab899eecb1", + "size_in_bytes": 8299 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/test_rpc.py", + "path_type": "hardlink", + "sha256": "1e2d997f442002389b3dadb47ed8134947c664a32ef637f43afdcbd1b5c13823", + "sha256_in_prefix": "1e2d997f442002389b3dadb47ed8134947c664a32ef637f43afdcbd1b5c13823", + "size_in_bytes": 805 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/test_run.py", + "path_type": "hardlink", + "sha256": "3cbd9ab33ef7ad8e575f798cc205988d5f106d8be0df20e12b794394c3342b9e", + "sha256_in_prefix": "3cbd9ab33ef7ad8e575f798cc205988d5f106d8be0df20e12b794394c3342b9e", + "size_in_bytes": 15756 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/test_runscript.py", + "path_type": "hardlink", + "sha256": "4264a834dc230d397725f398d905d0746321d543c56644e5c89af59fe3fedb61", + "sha256_in_prefix": "4264a834dc230d397725f398d905d0746321d543c56644e5c89af59fe3fedb61", + "size_in_bytes": 777 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/test_scrolledlist.py", + "path_type": "hardlink", + "sha256": "a84ec601c8786daf0564e978c97c0e14095c23f9a08bb64950f9cb541b074b3a", + "sha256_in_prefix": "a84ec601c8786daf0564e978c97c0e14095c23f9a08bb64950f9cb541b074b3a", + "size_in_bytes": 496 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/test_search.py", + "path_type": "hardlink", + "sha256": "c0550b241c99a566f61929515ca97aedf99f73568df3dfe93078ed22cb54892b", + "sha256_in_prefix": "c0550b241c99a566f61929515ca97aedf99f73568df3dfe93078ed22cb54892b", + "size_in_bytes": 2459 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/test_searchbase.py", + "path_type": "hardlink", + "sha256": "2b8550dd411b75c6152c4da90843e1221094400080f9a1752e383d0b776f775b", + "sha256_in_prefix": "2b8550dd411b75c6152c4da90843e1221094400080f9a1752e383d0b776f775b", + "size_in_bytes": 5691 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/test_searchengine.py", + "path_type": "hardlink", + "sha256": "519ddd5633eb8732539594f79ed21a6544f65e599a0d5c8c84db3a488ccdad97", + "sha256_in_prefix": "519ddd5633eb8732539594f79ed21a6544f65e599a0d5c8c84db3a488ccdad97", + "size_in_bytes": 11588 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/test_sidebar.py", + "path_type": "hardlink", + "sha256": "262977182301b015c9d5051d8ac9861eb286f03b4126d3b01e4d6fe36d866f09", + "sha256_in_prefix": "262977182301b015c9d5051d8ac9861eb286f03b4126d3b01e4d6fe36d866f09", + "size_in_bytes": 26854 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/test_squeezer.py", + "path_type": "hardlink", + "sha256": "fd5f695e2b1c296719e0a5b494a93184cc7e28cca22e9265def8171b23276b6c", + "sha256_in_prefix": "fd5f695e2b1c296719e0a5b494a93184cc7e28cca22e9265def8171b23276b6c", + "size_in_bytes": 19656 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/test_stackviewer.py", + "path_type": "hardlink", + "sha256": "15eaeabf43bbaf7d7bc795fb3dfd59c92f3691c73a20548513dcadef8d45b8bf", + "sha256_in_prefix": "15eaeabf43bbaf7d7bc795fb3dfd59c92f3691c73a20548513dcadef8d45b8bf", + "size_in_bytes": 991 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/test_statusbar.py", + "path_type": "hardlink", + "sha256": "0e9b262b9ad0046cbb0af1101a651fcb88cd1cba38e474b863abbb074b260a02", + "sha256_in_prefix": "0e9b262b9ad0046cbb0af1101a651fcb88cd1cba38e474b863abbb074b260a02", + "size_in_bytes": 1133 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/test_text.py", + "path_type": "hardlink", + "sha256": "55abe8a9d0bdb45efecb879207f1259702cdcf47dbc636d7cca8dd458f0dc70f", + "sha256_in_prefix": "55abe8a9d0bdb45efecb879207f1259702cdcf47dbc636d7cca8dd458f0dc70f", + "size_in_bytes": 6970 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/test_textview.py", + "path_type": "hardlink", + "sha256": "e45b199106608c7c981c149d3b4ccf092e7a2e7e9430cc76887cd769b9aaf533", + "sha256_in_prefix": "e45b199106608c7c981c149d3b4ccf092e7a2e7e9430cc76887cd769b9aaf533", + "size_in_bytes": 7364 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/test_tooltip.py", + "path_type": "hardlink", + "sha256": "b9a82e57761bbca3d4e07193652e8294895765092ef8a651f4dcf63acec7f153", + "sha256_in_prefix": "b9a82e57761bbca3d4e07193652e8294895765092ef8a651f4dcf63acec7f153", + "size_in_bytes": 5385 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/test_tree.py", + "path_type": "hardlink", + "sha256": "62ae68d64105485107e8173f94ce09739f276004bc8fa65efa5add2c6188e166", + "sha256_in_prefix": "62ae68d64105485107e8173f94ce09739f276004bc8fa65efa5add2c6188e166", + "size_in_bytes": 1752 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/test_undo.py", + "path_type": "hardlink", + "sha256": "c5178b2dd77d794938fa52adce719d4948a92ba1a689068cec1fb6888d033e0e", + "sha256_in_prefix": "c5178b2dd77d794938fa52adce719d4948a92ba1a689068cec1fb6888d033e0e", + "size_in_bytes": 4228 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/test_util.py", + "path_type": "hardlink", + "sha256": "300f627fc2199deb246ec793ef47b032de742d763a4170c8bb15e19ccbf602a5", + "sha256_in_prefix": "300f627fc2199deb246ec793ef47b032de742d763a4170c8bb15e19ccbf602a5", + "size_in_bytes": 308 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/test_warning.py", + "path_type": "hardlink", + "sha256": "d1efc442b3fb93de89fb0988c73f8536fc5099afb761d2b69ec101c239c8c193", + "sha256_in_prefix": "d1efc442b3fb93de89fb0988c73f8536fc5099afb761d2b69ec101c239c8c193", + "size_in_bytes": 2740 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/test_window.py", + "path_type": "hardlink", + "sha256": "336f2b6994f5aacca9689f32249db20a8dac36934314b7d5ba391d94169d63c6", + "sha256_in_prefix": "336f2b6994f5aacca9689f32249db20a8dac36934314b7d5ba391d94169d63c6", + "size_in_bytes": 1075 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/test_zoomheight.py", + "path_type": "hardlink", + "sha256": "6300aa47014a5c2dfc9bc0d6c3fb234dff4e4b60a6527d4cdfbb8c416f99df44", + "sha256_in_prefix": "6300aa47014a5c2dfc9bc0d6c3fb234dff4e4b60a6527d4cdfbb8c416f99df44", + "size_in_bytes": 999 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/test_zzdummy.py", + "path_type": "hardlink", + "sha256": "4502524aaa1923393725c04e6b2f27077399190e42bc8903415e95718c5f3c6f", + "sha256_in_prefix": "4502524aaa1923393725c04e6b2f27077399190e42bc8903415e95718c5f3c6f", + "size_in_bytes": 4455 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/tkinter_testing_utils.py", + "path_type": "hardlink", + "sha256": "ece147cef65152a54b0a3d4319bdf8ed82d9a6310273b0056cc17a2de4d744cd", + "sha256_in_prefix": "ece147cef65152a54b0a3d4319bdf8ed82d9a6310273b0056cc17a2de4d744cd", + "size_in_bytes": 2333 + }, + { + "_path": "lib/python3.12/idlelib/iomenu.py", + "path_type": "hardlink", + "sha256": "7004f1ab2cfa5994e453f426507170ec37c1c4a5b9837ba319e5eaebf1a29c34", + "sha256_in_prefix": "7004f1ab2cfa5994e453f426507170ec37c1c4a5b9837ba319e5eaebf1a29c34", + "size_in_bytes": 16159 + }, + { + "_path": "lib/python3.12/idlelib/macosx.py", + "path_type": "hardlink", + "sha256": "e6c687754bb60cd1015a413073b4d85b5e5bc7993c1acbfbc92d70600a83132e", + "sha256_in_prefix": "e6c687754bb60cd1015a413073b4d85b5e5bc7993c1acbfbc92d70600a83132e", + "size_in_bytes": 9290 + }, + { + "_path": "lib/python3.12/idlelib/mainmenu.py", + "path_type": "hardlink", + "sha256": "092fad4454f593d7bf2e5e1e746acade92bb346d06476ba527f162f843ae3208", + "sha256_in_prefix": "092fad4454f593d7bf2e5e1e746acade92bb346d06476ba527f162f843ae3208", + "size_in_bytes": 3938 + }, + { + "_path": "lib/python3.12/idlelib/multicall.py", + "path_type": "hardlink", + "sha256": "efb7d9bddcae17fab2108cb714c240c82d1368087b6d2b91e02ec224ddebce12", + "sha256_in_prefix": "efb7d9bddcae17fab2108cb714c240c82d1368087b6d2b91e02ec224ddebce12", + "size_in_bytes": 18652 + }, + { + "_path": "lib/python3.12/idlelib/outwin.py", + "path_type": "hardlink", + "sha256": "e1946c1a25a020a48843b2ed528bcdd6df29b2af117472b7e2627997b1339b84", + "sha256_in_prefix": "e1946c1a25a020a48843b2ed528bcdd6df29b2af117472b7e2627997b1339b84", + "size_in_bytes": 5715 + }, + { + "_path": "lib/python3.12/idlelib/parenmatch.py", + "path_type": "hardlink", + "sha256": "f122e13c385a135cbbbe8b1d87efeed43ddd3e0be9ddd8aa24b267b61fac4287", + "sha256_in_prefix": "f122e13c385a135cbbbe8b1d87efeed43ddd3e0be9ddd8aa24b267b61fac4287", + "size_in_bytes": 7204 + }, + { + "_path": "lib/python3.12/idlelib/pathbrowser.py", + "path_type": "hardlink", + "sha256": "42a4e008922c991049f1b42ca18700b65f2f8d0ab6dd12cc22671771e90c2065", + "sha256_in_prefix": "42a4e008922c991049f1b42ca18700b65f2f8d0ab6dd12cc22671771e90c2065", + "size_in_bytes": 3093 + }, + { + "_path": "lib/python3.12/idlelib/percolator.py", + "path_type": "hardlink", + "sha256": "42fe72c167eb3a2795cbe64c498d7cbe1de05132be29a99a58226ae83efb31d4", + "sha256_in_prefix": "42fe72c167eb3a2795cbe64c498d7cbe1de05132be29a99a58226ae83efb31d4", + "size_in_bytes": 3568 + }, + { + "_path": "lib/python3.12/idlelib/pyparse.py", + "path_type": "hardlink", + "sha256": "21c6bf43370998d5a5a6670f7b13409335e9a2c1a350ed586bbe63be5f226648", + "sha256_in_prefix": "21c6bf43370998d5a5a6670f7b13409335e9a2c1a350ed586bbe63be5f226648", + "size_in_bytes": 19864 + }, + { + "_path": "lib/python3.12/idlelib/pyshell.py", + "path_type": "hardlink", + "sha256": "1c1a2257ac73dda641843ff8abb8c26f250a5d6ea121cd42b8bc8c4784fcab77", + "sha256_in_prefix": "1c1a2257ac73dda641843ff8abb8c26f250a5d6ea121cd42b8bc8c4784fcab77", + "size_in_bytes": 62533 + }, + { + "_path": "lib/python3.12/idlelib/query.py", + "path_type": "hardlink", + "sha256": "faea5edd6b8693e6a32107054ad0de3be4d28e6aacb7792f86cbbe146131373b", + "sha256_in_prefix": "faea5edd6b8693e6a32107054ad0de3be4d28e6aacb7792f86cbbe146131373b", + "size_in_bytes": 15067 + }, + { + "_path": "lib/python3.12/idlelib/redirector.py", + "path_type": "hardlink", + "sha256": "7911a7534eb0c73ee3e2464c5f8498109653f73ebed8fa903780c5fd7ca00754", + "sha256_in_prefix": "7911a7534eb0c73ee3e2464c5f8498109653f73ebed8fa903780c5fd7ca00754", + "size_in_bytes": 6777 + }, + { + "_path": "lib/python3.12/idlelib/replace.py", + "path_type": "hardlink", + "sha256": "ea13db39aa89df369b36200c7301874a5636403e8270b1862f946e2fff081b84", + "sha256_in_prefix": "ea13db39aa89df369b36200c7301874a5636403e8270b1862f946e2fff081b84", + "size_in_bytes": 9841 + }, + { + "_path": "lib/python3.12/idlelib/rpc.py", + "path_type": "hardlink", + "sha256": "8d0cb6e11c8dcc5dbda89b9a582bfaa74fe2b661dde442b02eb61b8fc47d9eb3", + "sha256_in_prefix": "8d0cb6e11c8dcc5dbda89b9a582bfaa74fe2b661dde442b02eb61b8fc47d9eb3", + "size_in_bytes": 21078 + }, + { + "_path": "lib/python3.12/idlelib/run.py", + "path_type": "hardlink", + "sha256": "f892ec4391871cfec444e719a198fa020673e6513a397be3465ff95fd8d165d1", + "sha256_in_prefix": "f892ec4391871cfec444e719a198fa020673e6513a397be3465ff95fd8d165d1", + "size_in_bytes": 21462 + }, + { + "_path": "lib/python3.12/idlelib/runscript.py", + "path_type": "hardlink", + "sha256": "b92740fddc7b1d603b1736a135bd15518081f20c0db1e1a779cab715ee9120fe", + "sha256_in_prefix": "b92740fddc7b1d603b1736a135bd15518081f20c0db1e1a779cab715ee9120fe", + "size_in_bytes": 8273 + }, + { + "_path": "lib/python3.12/idlelib/scrolledlist.py", + "path_type": "hardlink", + "sha256": "25b0ad247977f6079226052e2b76dd4c127bf50f2f5e8ffbd1fe10bc631bfca9", + "sha256_in_prefix": "25b0ad247977f6079226052e2b76dd4c127bf50f2f5e8ffbd1fe10bc631bfca9", + "size_in_bytes": 4478 + }, + { + "_path": "lib/python3.12/idlelib/search.py", + "path_type": "hardlink", + "sha256": "c53ff4d4814d97d0d95b7e15030d3ae8c732366ed84c2b300183e933270df724", + "sha256_in_prefix": "c53ff4d4814d97d0d95b7e15030d3ae8c732366ed84c2b300183e933270df724", + "size_in_bytes": 5567 + }, + { + "_path": "lib/python3.12/idlelib/searchbase.py", + "path_type": "hardlink", + "sha256": "5e13c99d9f264166d9204eeff0492d43d03f2afd8f66494b3e110d7665ab29cc", + "sha256_in_prefix": "5e13c99d9f264166d9204eeff0492d43d03f2afd8f66494b3e110d7665ab29cc", + "size_in_bytes": 7856 + }, + { + "_path": "lib/python3.12/idlelib/searchengine.py", + "path_type": "hardlink", + "sha256": "11b0c8df926e4f6bd2e26d0264b2d902c41bcc70d68a4a830df1ea2da2c2a6cc", + "sha256_in_prefix": "11b0c8df926e4f6bd2e26d0264b2d902c41bcc70d68a4a830df1ea2da2c2a6cc", + "size_in_bytes": 7415 + }, + { + "_path": "lib/python3.12/idlelib/sidebar.py", + "path_type": "hardlink", + "sha256": "760f14ebb0312adb289cda0562c9eff70982a0acde5d9d9d0b591390cd4a581e", + "sha256_in_prefix": "760f14ebb0312adb289cda0562c9eff70982a0acde5d9d9d0b591390cd4a581e", + "size_in_bytes": 20338 + }, + { + "_path": "lib/python3.12/idlelib/squeezer.py", + "path_type": "hardlink", + "sha256": "112221334fee94a88cba2ca7ac455e1bd6ab796397cbe036b1e8a98bc0787e30", + "sha256_in_prefix": "112221334fee94a88cba2ca7ac455e1bd6ab796397cbe036b1e8a98bc0787e30", + "size_in_bytes": 12834 + }, + { + "_path": "lib/python3.12/idlelib/stackviewer.py", + "path_type": "hardlink", + "sha256": "ee053a65298e2ec2f4628d8269a33362816271fd81fab4e550a621493c26a76f", + "sha256_in_prefix": "ee053a65298e2ec2f4628d8269a33362816271fd81fab4e550a621493c26a76f", + "size_in_bytes": 4016 + }, + { + "_path": "lib/python3.12/idlelib/statusbar.py", + "path_type": "hardlink", + "sha256": "3f4dc0f27b0c23e488d022abe8461529ce8a1b4eaf9dbfd97123ef2c502f684e", + "sha256_in_prefix": "3f4dc0f27b0c23e488d022abe8461529ce8a1b4eaf9dbfd97123ef2c502f684e", + "size_in_bytes": 1474 + }, + { + "_path": "lib/python3.12/idlelib/textview.py", + "path_type": "hardlink", + "sha256": "eace58159e9636bb1456885c21f5ed474e203090139e5dd3457ac72ad5552006", + "sha256_in_prefix": "eace58159e9636bb1456885c21f5ed474e203090139e5dd3457ac72ad5552006", + "size_in_bytes": 6808 + }, + { + "_path": "lib/python3.12/idlelib/tooltip.py", + "path_type": "hardlink", + "sha256": "73dfad0e6652bcd67f7fccdface2e4cd8d5f3c6ffe2ef1c2e86ca0cb12d5d034", + "sha256_in_prefix": "73dfad0e6652bcd67f7fccdface2e4cd8d5f3c6ffe2ef1c2e86ca0cb12d5d034", + "size_in_bytes": 6471 + }, + { + "_path": "lib/python3.12/idlelib/tree.py", + "path_type": "hardlink", + "sha256": "dd594fd0f47ed3cb956d6bc77f72f200144aca13a3c3b9ecd7f472fcefc9256a", + "sha256_in_prefix": "dd594fd0f47ed3cb956d6bc77f72f200144aca13a3c3b9ecd7f472fcefc9256a", + "size_in_bytes": 16483 + }, + { + "_path": "lib/python3.12/idlelib/undo.py", + "path_type": "hardlink", + "sha256": "291fda98995bb4688fbe05fd3fa689e21aade3627c4c16e8971ed353f6cc3107", + "sha256_in_prefix": "291fda98995bb4688fbe05fd3fa689e21aade3627c4c16e8971ed353f6cc3107", + "size_in_bytes": 11016 + }, + { + "_path": "lib/python3.12/idlelib/util.py", + "path_type": "hardlink", + "sha256": "a80958a9f028ed987daf18cd55d78f6db3aff12e9c5629323d992829c0737413", + "sha256_in_prefix": "a80958a9f028ed987daf18cd55d78f6db3aff12e9c5629323d992829c0737413", + "size_in_bytes": 731 + }, + { + "_path": "lib/python3.12/idlelib/window.py", + "path_type": "hardlink", + "sha256": "ca31d8c01c9b468fcad0a4e529c8e205c1e4ecf30520545db654d466bd7158bd", + "sha256_in_prefix": "ca31d8c01c9b468fcad0a4e529c8e205c1e4ecf30520545db654d466bd7158bd", + "size_in_bytes": 2616 + }, + { + "_path": "lib/python3.12/idlelib/zoomheight.py", + "path_type": "hardlink", + "sha256": "5f6ff83cb0df3ee5e7d997ffe23efb341b994bfbaf00b79a4832d54231a095dd", + "sha256_in_prefix": "5f6ff83cb0df3ee5e7d997ffe23efb341b994bfbaf00b79a4832d54231a095dd", + "size_in_bytes": 4203 + }, + { + "_path": "lib/python3.12/idlelib/zzdummy.py", + "path_type": "hardlink", + "sha256": "5e248f0ea4f35052d23bb2c43564aa567b8cebaf91fd63ba0be8fef2f4167945", + "sha256_in_prefix": "5e248f0ea4f35052d23bb2c43564aa567b8cebaf91fd63ba0be8fef2f4167945", + "size_in_bytes": 2005 + }, + { + "_path": "lib/python3.12/imaplib.py", + "path_type": "hardlink", + "sha256": "81a8a1705087119d7ba1eba17bac27fdb49ed9127a28c6f7678f6013257ce0dd", + "sha256_in_prefix": "81a8a1705087119d7ba1eba17bac27fdb49ed9127a28c6f7678f6013257ce0dd", + "size_in_bytes": 53688 + }, + { + "_path": "lib/python3.12/imghdr.py", + "path_type": "hardlink", + "sha256": "c1bb52ea0816db4c5f3420655ab4a476fb3829709141e91f1a56b9c6fe286d56", + "sha256_in_prefix": "c1bb52ea0816db4c5f3420655ab4a476fb3829709141e91f1a56b9c6fe286d56", + "size_in_bytes": 4398 + }, + { + "_path": "lib/python3.12/importlib/__init__.py", + "path_type": "hardlink", + "sha256": "c9e1b3dbc619ac31e7017ac43668a20200872c1c0e79ae379c0dab6ed399b730", + "sha256_in_prefix": "c9e1b3dbc619ac31e7017ac43668a20200872c1c0e79ae379c0dab6ed399b730", + "size_in_bytes": 4774 + }, + { + "_path": "lib/python3.12/importlib/__pycache__/__init__.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "d9806fa3c93f64715e2f5b096a74f1bb6da97037b2ffde546f2ff7d4555514cb", + "sha256_in_prefix": "d9806fa3c93f64715e2f5b096a74f1bb6da97037b2ffde546f2ff7d4555514cb", + "size_in_bytes": 4819 + }, + { + "_path": "lib/python3.12/importlib/__pycache__/_abc.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "280f9f0f8a10c7571ab828f798b7e03ec1f71adb28ae9338ca7ddf066b0f8c34", + "sha256_in_prefix": "280f9f0f8a10c7571ab828f798b7e03ec1f71adb28ae9338ca7ddf066b0f8c34", + "size_in_bytes": 1897 + }, + { + "_path": "lib/python3.12/importlib/__pycache__/_bootstrap.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "5bf229629dddd3f28bd9c2f0299ce6339b5eefb5d6c7639a25a46e2665692f9c", + "sha256_in_prefix": "5bf229629dddd3f28bd9c2f0299ce6339b5eefb5d6c7639a25a46e2665692f9c", + "size_in_bytes": 56034 + }, + { + "_path": "lib/python3.12/importlib/__pycache__/_bootstrap_external.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "268ee56b568d6337b636f5c519b4552306973f1939fe4569bc2bb591fcd92010", + "sha256_in_prefix": "268ee56b568d6337b636f5c519b4552306973f1939fe4569bc2bb591fcd92010", + "size_in_bytes": 61750 + }, + { + "_path": "lib/python3.12/importlib/__pycache__/abc.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "f2bfd696cb6f8af1cb2ae5c1b9d867847925c99153c21afecb754f55197b2d01", + "sha256_in_prefix": "f2bfd696cb6f8af1cb2ae5c1b9d867847925c99153c21afecb754f55197b2d01", + "size_in_bytes": 10670 + }, + { + "_path": "lib/python3.12/importlib/__pycache__/machinery.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "c9666aed1ce52f437f3f16f1f755a5fe90d46afc198c20222ca593259446910a", + "sha256_in_prefix": "c9666aed1ce52f437f3f16f1f755a5fe90d46afc198c20222ca593259446910a", + "size_in_bytes": 1309 + }, + { + "_path": "lib/python3.12/importlib/__pycache__/readers.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "a9d6481225306223914368cb991a920071390def4f06a1f5d1737ef0fdd3c7c9", + "sha256_in_prefix": "a9d6481225306223914368cb991a920071390def4f06a1f5d1737ef0fdd3c7c9", + "size_in_bytes": 716 + }, + { + "_path": "lib/python3.12/importlib/__pycache__/simple.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "5175c9535fd55acb4c5f75043fea8ee6e57bd040864afbe96aeba88d1c9915d0", + "sha256_in_prefix": "5175c9535fd55acb4c5f75043fea8ee6e57bd040864afbe96aeba88d1c9915d0", + "size_in_bytes": 723 + }, + { + "_path": "lib/python3.12/importlib/__pycache__/util.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "56d459516693c0c112d5159b431bffa3745183425740f1928f2234ba6fa26159", + "sha256_in_prefix": "56d459516693c0c112d5159b431bffa3745183425740f1928f2234ba6fa26159", + "size_in_bytes": 11515 + }, + { + "_path": "lib/python3.12/importlib/_abc.py", + "path_type": "hardlink", + "sha256": "80aab7931dc999dee581c8b8b56fcd973fe156335a96ceeaf6acfc03cebf10e8", + "sha256_in_prefix": "80aab7931dc999dee581c8b8b56fcd973fe156335a96ceeaf6acfc03cebf10e8", + "size_in_bytes": 1354 + }, + { + "_path": "lib/python3.12/importlib/_bootstrap.py", + "path_type": "hardlink", + "sha256": "9653944363a4773cc32bbb34426024597a9d2ee4cd42e7912b4daf8cadfb53ed", + "sha256_in_prefix": "9653944363a4773cc32bbb34426024597a9d2ee4cd42e7912b4daf8cadfb53ed", + "size_in_bytes": 57056 + }, + { + "_path": "lib/python3.12/importlib/_bootstrap_external.py", + "path_type": "hardlink", + "sha256": "625a077defd004aa9b23f8d1b6952ff94018875baef71f2b8a3f1383ae27d8f5", + "sha256_in_prefix": "625a077defd004aa9b23f8d1b6952ff94018875baef71f2b8a3f1383ae27d8f5", + "size_in_bytes": 69069 + }, + { + "_path": "lib/python3.12/importlib/abc.py", + "path_type": "hardlink", + "sha256": "5f9cb36ca1bce9d5df00bc8d4d7f46b7ea2353dfa99292ad7f099affddfb5d03", + "sha256_in_prefix": "5f9cb36ca1bce9d5df00bc8d4d7f46b7ea2353dfa99292ad7f099affddfb5d03", + "size_in_bytes": 7612 + }, + { + "_path": "lib/python3.12/importlib/machinery.py", + "path_type": "hardlink", + "sha256": "d045cd7ecf2a12b6ecbfbef79eb114e87ef2ebd756f5b705f73e6f3266e3dede", + "sha256_in_prefix": "d045cd7ecf2a12b6ecbfbef79eb114e87ef2ebd756f5b705f73e6f3266e3dede", + "size_in_bytes": 880 + }, + { + "_path": "lib/python3.12/importlib/metadata/__init__.py", + "path_type": "hardlink", + "sha256": "b37ac52c704b3b0cd038f335723d4d91903e51bd4c34ed0bb7544dcc6b46d50d", + "sha256_in_prefix": "b37ac52c704b3b0cd038f335723d4d91903e51bd4c34ed0bb7544dcc6b46d50d", + "size_in_bytes": 28726 + }, + { + "_path": "lib/python3.12/importlib/metadata/__pycache__/__init__.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "72f1b00f2ce7f14d85f8a112b1df43d8887b7c04c8da140a2ca899a648378b04", + "sha256_in_prefix": "72f1b00f2ce7f14d85f8a112b1df43d8887b7c04c8da140a2ca899a648378b04", + "size_in_bytes": 48713 + }, + { + "_path": "lib/python3.12/importlib/metadata/__pycache__/_adapters.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "365b0dc09925d60d774ca2eb27d9f526ed753b9b3ba95db42e3f0be26dc65d33", + "sha256_in_prefix": "365b0dc09925d60d774ca2eb27d9f526ed753b9b3ba95db42e3f0be26dc65d33", + "size_in_bytes": 4089 + }, + { + "_path": "lib/python3.12/importlib/metadata/__pycache__/_collections.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "b96d6b415ad0d4c92bbedc6b90c3a89d8eed198550ebf7c931c6773f06dfb8e8", + "sha256_in_prefix": "b96d6b415ad0d4c92bbedc6b90c3a89d8eed198550ebf7c931c6773f06dfb8e8", + "size_in_bytes": 2137 + }, + { + "_path": "lib/python3.12/importlib/metadata/__pycache__/_functools.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "fc7e38a92103fbe3d531ad95f291b50bb0a2d0c21b2a590594fc726aabaca9b2", + "sha256_in_prefix": "fc7e38a92103fbe3d531ad95f291b50bb0a2d0c21b2a590594fc726aabaca9b2", + "size_in_bytes": 3695 + }, + { + "_path": "lib/python3.12/importlib/metadata/__pycache__/_itertools.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "fab2f22878cd516a2a50818f1125c47ae2b6640794e53c75678324d3c6dceaaf", + "sha256_in_prefix": "fab2f22878cd516a2a50818f1125c47ae2b6640794e53c75678324d3c6dceaaf", + "size_in_bytes": 2619 + }, + { + "_path": "lib/python3.12/importlib/metadata/__pycache__/_meta.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "7519ddb992b6e6bcf3b6f79bf9926f327a9f8611afef7eda8e1827ad4f263889", + "sha256_in_prefix": "7519ddb992b6e6bcf3b6f79bf9926f327a9f8611afef7eda8e1827ad4f263889", + "size_in_bytes": 3535 + }, + { + "_path": "lib/python3.12/importlib/metadata/__pycache__/_text.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "cecb58aac9a1483a9619bcc1e1b1664cddf7fec40af5954bc56db3a20a356e2e", + "sha256_in_prefix": "cecb58aac9a1483a9619bcc1e1b1664cddf7fec40af5954bc56db3a20a356e2e", + "size_in_bytes": 4096 + }, + { + "_path": "lib/python3.12/importlib/metadata/_adapters.py", + "path_type": "hardlink", + "sha256": "de9a880abc4513af1b69ce150cd5a5093201c39131717cdc2ba6b19f4364c163", + "sha256_in_prefix": "de9a880abc4513af1b69ce150cd5a5093201c39131717cdc2ba6b19f4364c163", + "size_in_bytes": 2406 + }, + { + "_path": "lib/python3.12/importlib/metadata/_collections.py", + "path_type": "hardlink", + "sha256": "089d0e4c21c88d6034648552e2fa0e440b27d91e11d9c40112d3ec6442690126", + "sha256_in_prefix": "089d0e4c21c88d6034648552e2fa0e440b27d91e11d9c40112d3ec6442690126", + "size_in_bytes": 743 + }, + { + "_path": "lib/python3.12/importlib/metadata/_functools.py", + "path_type": "hardlink", + "sha256": "3ec636fb8aeb297e1155e442d681a9d65075a660bd78a37cf3f7fe6c3f6e3a80", + "sha256_in_prefix": "3ec636fb8aeb297e1155e442d681a9d65075a660bd78a37cf3f7fe6c3f6e3a80", + "size_in_bytes": 2895 + }, + { + "_path": "lib/python3.12/importlib/metadata/_itertools.py", + "path_type": "hardlink", + "sha256": "72faffdaff0145bc5c225e71e6575fa9d1e3848f188bcb3cca4e741bf9e6ea34", + "sha256_in_prefix": "72faffdaff0145bc5c225e71e6575fa9d1e3848f188bcb3cca4e741bf9e6ea34", + "size_in_bytes": 2068 + }, + { + "_path": "lib/python3.12/importlib/metadata/_meta.py", + "path_type": "hardlink", + "sha256": "bd3504040497cd049e6b529bde0b461f63cd2be3070f2d0815d4dd7609b266c8", + "sha256_in_prefix": "bd3504040497cd049e6b529bde0b461f63cd2be3070f2d0815d4dd7609b266c8", + "size_in_bytes": 1590 + }, + { + "_path": "lib/python3.12/importlib/metadata/_text.py", + "path_type": "hardlink", + "sha256": "1c2b0592c66924b7933f734493f9e0ac079755146d4ebb7287d78e001a113f80", + "sha256_in_prefix": "1c2b0592c66924b7933f734493f9e0ac079755146d4ebb7287d78e001a113f80", + "size_in_bytes": 2166 + }, + { + "_path": "lib/python3.12/importlib/readers.py", + "path_type": "hardlink", + "sha256": "d0d57d118d64916f7e6edb04f8bd1a760a1abb879125899ef50a36d09ef54df4", + "sha256_in_prefix": "d0d57d118d64916f7e6edb04f8bd1a760a1abb879125899ef50a36d09ef54df4", + "size_in_bytes": 327 + }, + { + "_path": "lib/python3.12/importlib/resources/__init__.py", + "path_type": "hardlink", + "sha256": "7af3e6d7690b818a939bea5bce6eb46cebae9ae993f08a41356169d2e332af31", + "sha256_in_prefix": "7af3e6d7690b818a939bea5bce6eb46cebae9ae993f08a41356169d2e332af31", + "size_in_bytes": 506 + }, + { + "_path": "lib/python3.12/importlib/resources/__pycache__/__init__.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "b7e75a5d29b9ba57a0fde076260abbdc02d85ca07886827dacb02431698a40b3", + "sha256_in_prefix": "b7e75a5d29b9ba57a0fde076260abbdc02d85ca07886827dacb02431698a40b3", + "size_in_bytes": 869 + }, + { + "_path": "lib/python3.12/importlib/resources/__pycache__/_adapters.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "e8ad5b703433879fbf79623c7c0cce0611c5ecd5387f5f839a9f6a09a61febdb", + "sha256_in_prefix": "e8ad5b703433879fbf79623c7c0cce0611c5ecd5387f5f839a9f6a09a61febdb", + "size_in_bytes": 9880 + }, + { + "_path": "lib/python3.12/importlib/resources/__pycache__/_common.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "2c2b9c86fd91a5be884b4ddad969eb67b4ace0937536785672f15ff5de7d8789", + "sha256_in_prefix": "2c2b9c86fd91a5be884b4ddad969eb67b4ace0937536785672f15ff5de7d8789", + "size_in_bytes": 8963 + }, + { + "_path": "lib/python3.12/importlib/resources/__pycache__/_itertools.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "1a57e6f3f5fa60b03f9aed8d70d2dfa08e8bd2dfb38060be8667909b97115dd6", + "sha256_in_prefix": "1a57e6f3f5fa60b03f9aed8d70d2dfa08e8bd2dfb38060be8667909b97115dd6", + "size_in_bytes": 1793 + }, + { + "_path": "lib/python3.12/importlib/resources/__pycache__/_legacy.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "edf6f8beb0581f621698b0ec4b4b02cb3a121757210a321142b84ad3a96feeec", + "sha256_in_prefix": "edf6f8beb0581f621698b0ec4b4b02cb3a121757210a321142b84ad3a96feeec", + "size_in_bytes": 5997 + }, + { + "_path": "lib/python3.12/importlib/resources/__pycache__/abc.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "855fc4766b811f29c2bebaa21441ce62cf5da5536f95fa326bb94ba6041d6964", + "sha256_in_prefix": "855fc4766b811f29c2bebaa21441ce62cf5da5536f95fa326bb94ba6041d6964", + "size_in_bytes": 9175 + }, + { + "_path": "lib/python3.12/importlib/resources/__pycache__/readers.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "4775cfdb5a850e6004e40028575b939f57e820c30bd03782adc2134d3a45660f", + "sha256_in_prefix": "4775cfdb5a850e6004e40028575b939f57e820c30bd03782adc2134d3a45660f", + "size_in_bytes": 9148 + }, + { + "_path": "lib/python3.12/importlib/resources/__pycache__/simple.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "02d4f4a142edc85672898b1d33caad1e1464cd70dc3dcee49a6f3a0763a5bf95", + "sha256_in_prefix": "02d4f4a142edc85672898b1d33caad1e1464cd70dc3dcee49a6f3a0763a5bf95", + "size_in_bytes": 5705 + }, + { + "_path": "lib/python3.12/importlib/resources/_adapters.py", + "path_type": "hardlink", + "sha256": "be9ac919b51e1db6a35fa5c2b8c3fa27794caea0a2f8ffcc4e5ce225447b8df9", + "sha256_in_prefix": "be9ac919b51e1db6a35fa5c2b8c3fa27794caea0a2f8ffcc4e5ce225447b8df9", + "size_in_bytes": 4482 + }, + { + "_path": "lib/python3.12/importlib/resources/_common.py", + "path_type": "hardlink", + "sha256": "9bfef8de14579936e96c0e921e934a3f4f56b4e32d3cfacc12f3e24436fc37b4", + "sha256_in_prefix": "9bfef8de14579936e96c0e921e934a3f4f56b4e32d3cfacc12f3e24436fc37b4", + "size_in_bytes": 5459 + }, + { + "_path": "lib/python3.12/importlib/resources/_itertools.py", + "path_type": "hardlink", + "sha256": "7838ac57a46a88d64ea202d25dfe8b3861ce61cefd14680faca34bcc52e60ab5", + "sha256_in_prefix": "7838ac57a46a88d64ea202d25dfe8b3861ce61cefd14680faca34bcc52e60ab5", + "size_in_bytes": 1277 + }, + { + "_path": "lib/python3.12/importlib/resources/_legacy.py", + "path_type": "hardlink", + "sha256": "d1329d662c712d603ec70b40670e07729a899a3e17a6bc7566472dcb48134596", + "sha256_in_prefix": "d1329d662c712d603ec70b40670e07729a899a3e17a6bc7566472dcb48134596", + "size_in_bytes": 3481 + }, + { + "_path": "lib/python3.12/importlib/resources/abc.py", + "path_type": "hardlink", + "sha256": "a726c48590b21ba5532f0c654735991571bc0ecafe88145cb8891d82cd364e5e", + "sha256_in_prefix": "a726c48590b21ba5532f0c654735991571bc0ecafe88145cb8891d82cd364e5e", + "size_in_bytes": 5203 + }, + { + "_path": "lib/python3.12/importlib/resources/readers.py", + "path_type": "hardlink", + "sha256": "231e0c485123729f26b706e54b1810d4294d3bd7182a2355b14b8318bd4ecf8e", + "sha256_in_prefix": "231e0c485123729f26b706e54b1810d4294d3bd7182a2355b14b8318bd4ecf8e", + "size_in_bytes": 4303 + }, + { + "_path": "lib/python3.12/importlib/resources/simple.py", + "path_type": "hardlink", + "sha256": "d3fff64d0053428aa46a362634fb751f11117117804fa6e854a240df6f29af4e", + "sha256_in_prefix": "d3fff64d0053428aa46a362634fb751f11117117804fa6e854a240df6f29af4e", + "size_in_bytes": 2576 + }, + { + "_path": "lib/python3.12/importlib/simple.py", + "path_type": "hardlink", + "sha256": "8e687aeeb1db537d2717cb0352c5f126ff7d4095c6de6dc7f00d5103f3009c40", + "sha256_in_prefix": "8e687aeeb1db537d2717cb0352c5f126ff7d4095c6de6dc7f00d5103f3009c40", + "size_in_bytes": 354 + }, + { + "_path": "lib/python3.12/importlib/util.py", + "path_type": "hardlink", + "sha256": "9f3e638fab0ce5825edd78ac09f326ca80bd757bdf61be1658bf2a2b0cae5d69", + "sha256_in_prefix": "9f3e638fab0ce5825edd78ac09f326ca80bd757bdf61be1658bf2a2b0cae5d69", + "size_in_bytes": 9610 + }, + { + "_path": "lib/python3.12/inspect.py", + "path_type": "hardlink", + "sha256": "2cc3b3e41032cd523110607a7d7cad966106e58d0a4dc5869b20185a097213ad", + "sha256_in_prefix": "2cc3b3e41032cd523110607a7d7cad966106e58d0a4dc5869b20185a097213ad", + "size_in_bytes": 126247 + }, + { + "_path": "lib/python3.12/io.py", + "path_type": "hardlink", + "sha256": "7cec3cb8ac004058dd0a5af246e6d950fb59c7ddd0058fda48bcb3fcb98d8822", + "sha256_in_prefix": "7cec3cb8ac004058dd0a5af246e6d950fb59c7ddd0058fda48bcb3fcb98d8822", + "size_in_bytes": 3582 + }, + { + "_path": "lib/python3.12/ipaddress.py", + "path_type": "hardlink", + "sha256": "687e343fa31d6470a3856d825e410509b24f7117be12ccba8a704d88214e206a", + "sha256_in_prefix": "687e343fa31d6470a3856d825e410509b24f7117be12ccba8a704d88214e206a", + "size_in_bytes": 75012 + }, + { + "_path": "lib/python3.12/json/__init__.py", + "path_type": "hardlink", + "sha256": "d5d41e2c29049515d295d81a6d40b4890fbec8d8482cfb401630f8ef2f77e4d5", + "sha256_in_prefix": "d5d41e2c29049515d295d81a6d40b4890fbec8d8482cfb401630f8ef2f77e4d5", + "size_in_bytes": 14020 + }, + { + "_path": "lib/python3.12/json/__pycache__/__init__.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "7c6d6f98db7b4417c4dccc2d3604e2427055990ba036ad997bb9e2828492b5f8", + "sha256_in_prefix": "7c6d6f98db7b4417c4dccc2d3604e2427055990ba036ad997bb9e2828492b5f8", + "size_in_bytes": 13874 + }, + { + "_path": "lib/python3.12/json/__pycache__/decoder.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "a15b91358f94d4b058167656c4e4fb9a44b0661b5dcd289b3251a67900c02183", + "sha256_in_prefix": "a15b91358f94d4b058167656c4e4fb9a44b0661b5dcd289b3251a67900c02183", + "size_in_bytes": 14079 + }, + { + "_path": "lib/python3.12/json/__pycache__/encoder.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "4799e0b1e576011a09cdfe851c8f8bd131605303c642f1f80ce49ec35505c9d9", + "sha256_in_prefix": "4799e0b1e576011a09cdfe851c8f8bd131605303c642f1f80ce49ec35505c9d9", + "size_in_bytes": 15362 + }, + { + "_path": "lib/python3.12/json/__pycache__/scanner.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "31b0b96b6adc5b2ffbf60bc664b993055be6a0682623526454400a97cca68593", + "sha256_in_prefix": "31b0b96b6adc5b2ffbf60bc664b993055be6a0682623526454400a97cca68593", + "size_in_bytes": 3575 + }, + { + "_path": "lib/python3.12/json/__pycache__/tool.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "8f410f195ea4b74b00be4d1fbf4edfe97b0da4b8789d5067c2bbe0e64deeb6ee", + "sha256_in_prefix": "8f410f195ea4b74b00be4d1fbf4edfe97b0da4b8789d5067c2bbe0e64deeb6ee", + "size_in_bytes": 4556 + }, + { + "_path": "lib/python3.12/json/decoder.py", + "path_type": "hardlink", + "sha256": "9f02654649816145bc76f8c210a5fe3ba1de142d4d97a1c93105732e747c285b", + "sha256_in_prefix": "9f02654649816145bc76f8c210a5fe3ba1de142d4d97a1c93105732e747c285b", + "size_in_bytes": 12473 + }, + { + "_path": "lib/python3.12/json/encoder.py", + "path_type": "hardlink", + "sha256": "7c358788fbb2a6a07f66f1f8446c52396f35fc201108f666d5be002d86f31af2", + "sha256_in_prefix": "7c358788fbb2a6a07f66f1f8446c52396f35fc201108f666d5be002d86f31af2", + "size_in_bytes": 16080 + }, + { + "_path": "lib/python3.12/json/scanner.py", + "path_type": "hardlink", + "sha256": "8604d9d03786d0d509abb49e9f069337278ea988c244069ae8ca2c89acc2cb08", + "sha256_in_prefix": "8604d9d03786d0d509abb49e9f069337278ea988c244069ae8ca2c89acc2cb08", + "size_in_bytes": 2425 + }, + { + "_path": "lib/python3.12/json/tool.py", + "path_type": "hardlink", + "sha256": "d5174b728b376a12cff3f17472d6b9b609c1d3926f7ee02d74d60c80afd60c77", + "sha256_in_prefix": "d5174b728b376a12cff3f17472d6b9b609c1d3926f7ee02d74d60c80afd60c77", + "size_in_bytes": 3339 + }, + { + "_path": "lib/python3.12/keyword.py", + "path_type": "hardlink", + "sha256": "18c2be738c04ad20ad375f6a71db34b3823c7f40b0340f5294d0e89f3c9b093b", + "sha256_in_prefix": "18c2be738c04ad20ad375f6a71db34b3823c7f40b0340f5294d0e89f3c9b093b", + "size_in_bytes": 1073 + }, + { + "_path": "lib/python3.12/lib-dynload/_asyncio.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "c89cefdc9f6a011938e9d9bb9bded27dbecbbd6770c7a90082df9c9e4d1ba3cc", + "sha256_in_prefix": "c89cefdc9f6a011938e9d9bb9bded27dbecbbd6770c7a90082df9c9e4d1ba3cc", + "size_in_bytes": 100080 + }, + { + "_path": "lib/python3.12/lib-dynload/_bisect.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "f4656cdef8be5eaac895481b8ab3c798f71d33f534e0ff323c4e4fb0a1d18898", + "sha256_in_prefix": "f4656cdef8be5eaac895481b8ab3c798f71d33f534e0ff323c4e4fb0a1d18898", + "size_in_bytes": 53984 + }, + { + "_path": "lib/python3.12/lib-dynload/_blake2.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "20f0328bb1c1be443a02cfbb66f37e25a97a799bc1db73c27113ef2076ecc4d3", + "sha256_in_prefix": "20f0328bb1c1be443a02cfbb66f37e25a97a799bc1db73c27113ef2076ecc4d3", + "size_in_bytes": 72784 + }, + { + "_path": "lib/python3.12/lib-dynload/_bz2.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "e119679f41d1fd3763f6e3bafdff8466c58a9360755a4d0ceec6eb815e7c9f3a", + "sha256_in_prefix": "e119679f41d1fd3763f6e3bafdff8466c58a9360755a4d0ceec6eb815e7c9f3a", + "size_in_bytes": 56144 + }, + { + "_path": "lib/python3.12/lib-dynload/_codecs_cn.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "ac12e1f043a7cddc5f642eabee253830482cdf604733dd43c92c60bee7361d70", + "sha256_in_prefix": "ac12e1f043a7cddc5f642eabee253830482cdf604733dd43c92c60bee7361d70", + "size_in_bytes": 169088 + }, + { + "_path": "lib/python3.12/lib-dynload/_codecs_hk.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "a44a2a7f07da8cf0b53a4e40d4d6095382274f376a8141a258d16e0710f2bb1e", + "sha256_in_prefix": "a44a2a7f07da8cf0b53a4e40d4d6095382274f376a8141a258d16e0710f2bb1e", + "size_in_bytes": 185680 + }, + { + "_path": "lib/python3.12/lib-dynload/_codecs_iso2022.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "3ade05a9af7f029bcd7b46278bf83b372111567999ac2b667c351d063eb49b0a", + "sha256_in_prefix": "3ade05a9af7f029bcd7b46278bf83b372111567999ac2b667c351d063eb49b0a", + "size_in_bytes": 55152 + }, + { + "_path": "lib/python3.12/lib-dynload/_codecs_jp.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "fe26ba9ac10eaf481ae11da44f2d540b61070f7283e22b41d6ec6f873ea6fb16", + "sha256_in_prefix": "fe26ba9ac10eaf481ae11da44f2d540b61070f7283e22b41d6ec6f873ea6fb16", + "size_in_bytes": 285600 + }, + { + "_path": "lib/python3.12/lib-dynload/_codecs_kr.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "f58cb94e90925ce685e4d3e0ecf1a4cb87395dd938193b1b3fe181af74cb4c5a", + "sha256_in_prefix": "f58cb94e90925ce685e4d3e0ecf1a4cb87395dd938193b1b3fe181af74cb4c5a", + "size_in_bytes": 152656 + }, + { + "_path": "lib/python3.12/lib-dynload/_codecs_tw.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "ae8c5528343cb56bc50d5f2039b67c827b633cbeca798398ffae422594acbc36", + "sha256_in_prefix": "ae8c5528343cb56bc50d5f2039b67c827b633cbeca798398ffae422594acbc36", + "size_in_bytes": 152160 + }, + { + "_path": "lib/python3.12/lib-dynload/_contextvars.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "59bee12d6689491c65ce2bf45fbac9dbd335c77cc62a35badc4604ad2f6fbf10", + "sha256_in_prefix": "59bee12d6689491c65ce2bf45fbac9dbd335c77cc62a35badc4604ad2f6fbf10", + "size_in_bytes": 51696 + }, + { + "_path": "lib/python3.12/lib-dynload/_crypt.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "f0c244c96f4c0554c8bba75cceb49d862e52c1b1e7f77533018486a1202f6ff1", + "sha256_in_prefix": "f0c244c96f4c0554c8bba75cceb49d862e52c1b1e7f77533018486a1202f6ff1", + "size_in_bytes": 51984 + }, + { + "_path": "lib/python3.12/lib-dynload/_csv.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "e10919b3feee4eabfa6830e99362d5810e41f5e7b6d7118c3e5dcfb522ff2bc1", + "sha256_in_prefix": "e10919b3feee4eabfa6830e99362d5810e41f5e7b6d7118c3e5dcfb522ff2bc1", + "size_in_bytes": 74592 + }, + { + "_path": "lib/python3.12/lib-dynload/_ctypes.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "bb593e13795dd4768fa1072d1cdfd0d682e763cdda1b1465239dfb82c0dd9bda", + "sha256_in_prefix": "bb593e13795dd4768fa1072d1cdfd0d682e763cdda1b1465239dfb82c0dd9bda", + "size_in_bytes": 141120 + }, + { + "_path": "lib/python3.12/lib-dynload/_ctypes_test.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "e717c2c5ac5016b94f7028a34437fbd178a0140385b47e1cec719a2937231821", + "sha256_in_prefix": "e717c2c5ac5016b94f7028a34437fbd178a0140385b47e1cec719a2937231821", + "size_in_bytes": 57392 + }, + { + "_path": "lib/python3.12/lib-dynload/_curses.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "1e3bd2c721ba83c6a73a388323d21fc455b35ebc5e46ab2d3597ca15751d771d", + "sha256_in_prefix": "1e3bd2c721ba83c6a73a388323d21fc455b35ebc5e46ab2d3597ca15751d771d", + "size_in_bytes": 158800 + }, + { + "_path": "lib/python3.12/lib-dynload/_curses_panel.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "d2267baec769db7a1d76a779c3965a8b082f2efa76f09b969e02eb90cb7ec066", + "sha256_in_prefix": "d2267baec769db7a1d76a779c3965a8b082f2efa76f09b969e02eb90cb7ec066", + "size_in_bytes": 56352 + }, + { + "_path": "lib/python3.12/lib-dynload/_datetime.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "2c995a7388df907056bfd2100d011e52ae9a4636aa5f6d9f7dc49f240cbafdc8", + "sha256_in_prefix": "2c995a7388df907056bfd2100d011e52ae9a4636aa5f6d9f7dc49f240cbafdc8", + "size_in_bytes": 132672 + }, + { + "_path": "lib/python3.12/lib-dynload/_dbm.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "0244a210c5c7b7e0f938fb6776d0e6cd4b833ec968afa82ef349901dc970a054", + "sha256_in_prefix": "0244a210c5c7b7e0f938fb6776d0e6cd4b833ec968afa82ef349901dc970a054", + "size_in_bytes": 55088 + }, + { + "_path": "lib/python3.12/lib-dynload/_decimal.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "2d63736924403f339350d77c794d809d1e44c24133283257f2526bb02ffd1382", + "sha256_in_prefix": "2d63736924403f339350d77c794d809d1e44c24133283257f2526bb02ffd1382", + "size_in_bytes": 325936 + }, + { + "_path": "lib/python3.12/lib-dynload/_elementtree.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "f0b6f7165bd632cee2358f11fa0aa5e5a932c6dfb87f348e2a54e20301d3c014", + "sha256_in_prefix": "f0b6f7165bd632cee2358f11fa0aa5e5a932c6dfb87f348e2a54e20301d3c014", + "size_in_bytes": 100912 + }, + { + "_path": "lib/python3.12/lib-dynload/_hashlib.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "e473a715d4f827eb5f1db40421120eac4d7ec46458b18e34a2b96dffc6761e19", + "sha256_in_prefix": "e473a715d4f827eb5f1db40421120eac4d7ec46458b18e34a2b96dffc6761e19", + "size_in_bytes": 80928 + }, + { + "_path": "lib/python3.12/lib-dynload/_heapq.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "d0c475d46f61bfcb2949c61cff4f2983f08c28e2acf121487dfea77ced192c8f", + "sha256_in_prefix": "d0c475d46f61bfcb2949c61cff4f2983f08c28e2acf121487dfea77ced192c8f", + "size_in_bytes": 52864 + }, + { + "_path": "lib/python3.12/lib-dynload/_json.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "06f830210bea960630d66f046e4c60a38dcae37209c0fe475b9aec6a5fedb4b5", + "sha256_in_prefix": "06f830210bea960630d66f046e4c60a38dcae37209c0fe475b9aec6a5fedb4b5", + "size_in_bytes": 73648 + }, + { + "_path": "lib/python3.12/lib-dynload/_lsprof.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "d3094f8b25e8125020c420ab1ec7ccc92e913bdc01dcf4fa1fda1962b0a63322", + "sha256_in_prefix": "d3094f8b25e8125020c420ab1ec7ccc92e913bdc01dcf4fa1fda1962b0a63322", + "size_in_bytes": 55904 + }, + { + "_path": "lib/python3.12/lib-dynload/_lzma.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "6780d012bb31edf487c86158fe96a10313a839572c53b654ca899711b789095b", + "sha256_in_prefix": "6780d012bb31edf487c86158fe96a10313a839572c53b654ca899711b789095b", + "size_in_bytes": 75920 + }, + { + "_path": "lib/python3.12/lib-dynload/_md5.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "a0c37e32da7caa098be8a2be56bceb8bf71e8ac33bcf62fd20114ba162dd4422", + "sha256_in_prefix": "a0c37e32da7caa098be8a2be56bceb8bf71e8ac33bcf62fd20114ba162dd4422", + "size_in_bytes": 54544 + }, + { + "_path": "lib/python3.12/lib-dynload/_multibytecodec.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "a940004319594e7efb087aff56d4fa05d365619b86a012db43a22b4032a96ed6", + "sha256_in_prefix": "a940004319594e7efb087aff56d4fa05d365619b86a012db43a22b4032a96ed6", + "size_in_bytes": 79296 + }, + { + "_path": "lib/python3.12/lib-dynload/_multiprocessing.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "3eb6fd2c7961b99e0a93039205bd0bf5ad11ec8a6fc33b448db91679a9865fbe", + "sha256_in_prefix": "3eb6fd2c7961b99e0a93039205bd0bf5ad11ec8a6fc33b448db91679a9865fbe", + "size_in_bytes": 56496 + }, + { + "_path": "lib/python3.12/lib-dynload/_opcode.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "ac407c32bb39406125b45e88c2cc0116e067cea739344c4fcbf382915a09f4da", + "sha256_in_prefix": "ac407c32bb39406125b45e88c2cc0116e067cea739344c4fcbf382915a09f4da", + "size_in_bytes": 52304 + }, + { + "_path": "lib/python3.12/lib-dynload/_pickle.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "63074055ace2be2539b025d75139baf0da00edf18b72d84b98864ba0bd1812f7", + "sha256_in_prefix": "63074055ace2be2539b025d75139baf0da00edf18b72d84b98864ba0bd1812f7", + "size_in_bytes": 151376 + }, + { + "_path": "lib/python3.12/lib-dynload/_posixshmem.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "f7a529633e78d495c8afd4e62296ae348e858df5802f4ea376fd26333e51e0d9", + "sha256_in_prefix": "f7a529633e78d495c8afd4e62296ae348e858df5802f4ea376fd26333e51e0d9", + "size_in_bytes": 52672 + }, + { + "_path": "lib/python3.12/lib-dynload/_posixsubprocess.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "7b504fccb47acdcb31f3525345e13d85a2a1e1bf87b423abb5bee4c9750f7fd9", + "sha256_in_prefix": "7b504fccb47acdcb31f3525345e13d85a2a1e1bf87b423abb5bee4c9750f7fd9", + "size_in_bytes": 55520 + }, + { + "_path": "lib/python3.12/lib-dynload/_queue.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "dadd461d48840a3b626b6b7782db8d0a6025d59cbe47b098bd28883756f340dd", + "sha256_in_prefix": "dadd461d48840a3b626b6b7782db8d0a6025d59cbe47b098bd28883756f340dd", + "size_in_bytes": 55456 + }, + { + "_path": "lib/python3.12/lib-dynload/_random.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "9db9d38102925d913e09e545e8aaac1bdf526e3d80c1e5a74c835687481b9e96", + "sha256_in_prefix": "9db9d38102925d913e09e545e8aaac1bdf526e3d80c1e5a74c835687481b9e96", + "size_in_bytes": 54784 + }, + { + "_path": "lib/python3.12/lib-dynload/_scproxy.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "a93c04d25efc3aa237a71b4e84d55ba1c1632db5a8657251e33a0136f0356413", + "sha256_in_prefix": "a93c04d25efc3aa237a71b4e84d55ba1c1632db5a8657251e33a0136f0356413", + "size_in_bytes": 54432 + }, + { + "_path": "lib/python3.12/lib-dynload/_sha1.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "803f19aa0bebe110a3c48d9c2b94bf7a4dba57003098b681a446ac52312e1cbf", + "sha256_in_prefix": "803f19aa0bebe110a3c48d9c2b94bf7a4dba57003098b681a446ac52312e1cbf", + "size_in_bytes": 54576 + }, + { + "_path": "lib/python3.12/lib-dynload/_sha2.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "f6ade0de09f97cf08e8b6fd49c698c0258a8bbf1f5fda27b1a572249e525c507", + "sha256_in_prefix": "f6ade0de09f97cf08e8b6fd49c698c0258a8bbf1f5fda27b1a572249e525c507", + "size_in_bytes": 72368 + }, + { + "_path": "lib/python3.12/lib-dynload/_sha3.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "d5a61b7f91fea785dda01c995c6b62e2f7015dc94bbd3e241bd47455dde7c9f1", + "sha256_in_prefix": "d5a61b7f91fea785dda01c995c6b62e2f7015dc94bbd3e241bd47455dde7c9f1", + "size_in_bytes": 72480 + }, + { + "_path": "lib/python3.12/lib-dynload/_socket.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "45201cd9a0a2ed4e86faab9a7f52c1ed13d3782808e2ee1766c202ca984c62b5", + "sha256_in_prefix": "45201cd9a0a2ed4e86faab9a7f52c1ed13d3782808e2ee1766c202ca984c62b5", + "size_in_bytes": 115168 + }, + { + "_path": "lib/python3.12/lib-dynload/_sqlite3.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "a04a1e10cdb6a42dea427640d1ef2a647b6504b6ccbab19b1c91aa553cce61ca", + "sha256_in_prefix": "a04a1e10cdb6a42dea427640d1ef2a647b6504b6ccbab19b1c91aa553cce61ca", + "size_in_bytes": 144144 + }, + { + "_path": "lib/python3.12/lib-dynload/_ssl.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "3fe5709fa26962dfa9f498c743520273d0de9009ea84e21dfc621a439a481841", + "sha256_in_prefix": "3fe5709fa26962dfa9f498c743520273d0de9009ea84e21dfc621a439a481841", + "size_in_bytes": 201104 + }, + { + "_path": "lib/python3.12/lib-dynload/_statistics.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "5d8c4d56e4c571a7b4282f21c0b7ba25cc07fd1acdfd36a122d76fa403855249", + "sha256_in_prefix": "5d8c4d56e4c571a7b4282f21c0b7ba25cc07fd1acdfd36a122d76fa403855249", + "size_in_bytes": 51856 + }, + { + "_path": "lib/python3.12/lib-dynload/_struct.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "73f08f7bee74f11215d5f8ea4ae07c0b10dd472c27107ff70f1f37ade1cc1fc3", + "sha256_in_prefix": "73f08f7bee74f11215d5f8ea4ae07c0b10dd472c27107ff70f1f37ade1cc1fc3", + "size_in_bytes": 77952 + }, + { + "_path": "lib/python3.12/lib-dynload/_testbuffer.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "854fa73c220a9dc618c02e68c0452717c0972653a4eb1ed08c77f950b16194ae", + "sha256_in_prefix": "854fa73c220a9dc618c02e68c0452717c0972653a4eb1ed08c77f950b16194ae", + "size_in_bytes": 75168 + }, + { + "_path": "lib/python3.12/lib-dynload/_testcapi.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "2e69a44487f0422fd108642ed0a9209a6467b7352daa96ffde43b41e92177150", + "sha256_in_prefix": "2e69a44487f0422fd108642ed0a9209a6467b7352daa96ffde43b41e92177150", + "size_in_bytes": 358864 + }, + { + "_path": "lib/python3.12/lib-dynload/_testclinic.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "770a1356bfb35261a5602dca4d32d97920813b478c3f4ccc3c3c360fa99b35f1", + "sha256_in_prefix": "770a1356bfb35261a5602dca4d32d97920813b478c3f4ccc3c3c360fa99b35f1", + "size_in_bytes": 96032 + }, + { + "_path": "lib/python3.12/lib-dynload/_testimportmultiple.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "29fd4a8a10956a3f6463af6103d4c879b5828ab901e3ccc3a5ac7428bb0f0b3e", + "sha256_in_prefix": "29fd4a8a10956a3f6463af6103d4c879b5828ab901e3ccc3a5ac7428bb0f0b3e", + "size_in_bytes": 51344 + }, + { + "_path": "lib/python3.12/lib-dynload/_testinternalcapi.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "f1e576eb2f151afe032186fabb5f9891b45697cd90ebcd3ef909a7b4aec69632", + "sha256_in_prefix": "f1e576eb2f151afe032186fabb5f9891b45697cd90ebcd3ef909a7b4aec69632", + "size_in_bytes": 76976 + }, + { + "_path": "lib/python3.12/lib-dynload/_testmultiphase.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "19881be175fb67690af2fb5784e0f5d89be422bdd764b2e73dbe565a4ec8e511", + "sha256_in_prefix": "19881be175fb67690af2fb5784e0f5d89be422bdd764b2e73dbe565a4ec8e511", + "size_in_bytes": 60096 + }, + { + "_path": "lib/python3.12/lib-dynload/_testsinglephase.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "5e7103a052592cacc94e73bc3fb92bb788082c4a792a780b93af4654b30708c1", + "sha256_in_prefix": "5e7103a052592cacc94e73bc3fb92bb788082c4a792a780b93af4654b30708c1", + "size_in_bytes": 53456 + }, + { + "_path": "lib/python3.12/lib-dynload/_tkinter.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "6076c2ba18b7fa775341805e03e4b556d9d6617cd5609b854d335984389098c3", + "sha256_in_prefix": "6076c2ba18b7fa775341805e03e4b556d9d6617cd5609b854d335984389098c3", + "size_in_bytes": 100576 + }, + { + "_path": "lib/python3.12/lib-dynload/_uuid.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "5d2e95f7d6dbeb4dddc9a6f16fd4271d79dcc8f3a588801454bdf8e1e8d8b476", + "sha256_in_prefix": "5d2e95f7d6dbeb4dddc9a6f16fd4271d79dcc8f3a588801454bdf8e1e8d8b476", + "size_in_bytes": 51648 + }, + { + "_path": "lib/python3.12/lib-dynload/_xxinterpchannels.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "73473b1458aa4bd75e433e87afc23346548d3fcf75518d8615a5a8ac598beab9", + "sha256_in_prefix": "73473b1458aa4bd75e433e87afc23346548d3fcf75518d8615a5a8ac598beab9", + "size_in_bytes": 74224 + }, + { + "_path": "lib/python3.12/lib-dynload/_xxsubinterpreters.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "983c832e71357fc0f392a8bff80271c31337d6a0a50376af20d8528d8e29ace8", + "sha256_in_prefix": "983c832e71357fc0f392a8bff80271c31337d6a0a50376af20d8528d8e29ace8", + "size_in_bytes": 56960 + }, + { + "_path": "lib/python3.12/lib-dynload/_xxtestfuzz.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "0be6c1ae120929048217291fa7963dc55b719409f4be03aba5c7a145001e06f5", + "sha256_in_prefix": "0be6c1ae120929048217291fa7963dc55b719409f4be03aba5c7a145001e06f5", + "size_in_bytes": 54384 + }, + { + "_path": "lib/python3.12/lib-dynload/_zoneinfo.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "d9e054f9025d883ad005b814198ec64d034517cfda8873aa42b9c4e96abc21af", + "sha256_in_prefix": "d9e054f9025d883ad005b814198ec64d034517cfda8873aa42b9c4e96abc21af", + "size_in_bytes": 74912 + }, + { + "_path": "lib/python3.12/lib-dynload/array.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "ceeee17c1065018c4ddcbfd4635913ee79fcaa99acf33c20a91bf71a122a2ea2", + "sha256_in_prefix": "ceeee17c1065018c4ddcbfd4635913ee79fcaa99acf33c20a91bf71a122a2ea2", + "size_in_bytes": 96736 + }, + { + "_path": "lib/python3.12/lib-dynload/audioop.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "316e0d291fd0c7f47fe7f6ae752993dca4a1bb32df8e8271e04961813bf678bf", + "sha256_in_prefix": "316e0d291fd0c7f47fe7f6ae752993dca4a1bb32df8e8271e04961813bf678bf", + "size_in_bytes": 72736 + }, + { + "_path": "lib/python3.12/lib-dynload/binascii.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "efaf8bb203739accedaaf51f0bfc21de00e112438477591311a4c5644a716654", + "sha256_in_prefix": "efaf8bb203739accedaaf51f0bfc21de00e112438477591311a4c5644a716654", + "size_in_bytes": 72048 + }, + { + "_path": "lib/python3.12/lib-dynload/cmath.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "68ffe96da886357b59a98993bbf78d7e157fd541883dce54a0be1807186ef6a5", + "sha256_in_prefix": "68ffe96da886357b59a98993bbf78d7e157fd541883dce54a0be1807186ef6a5", + "size_in_bytes": 72064 + }, + { + "_path": "lib/python3.12/lib-dynload/fcntl.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "ec0ab681e2e2fc101b6101715d1f2ae6bf41a757ee690bdfbc095d29e5a5e536", + "sha256_in_prefix": "ec0ab681e2e2fc101b6101715d1f2ae6bf41a757ee690bdfbc095d29e5a5e536", + "size_in_bytes": 53456 + }, + { + "_path": "lib/python3.12/lib-dynload/grp.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "cfb02814ea98450d824c2c6b0c1406a76a8be7825679ff3ec4de3c7b229e300c", + "sha256_in_prefix": "cfb02814ea98450d824c2c6b0c1406a76a8be7825679ff3ec4de3c7b229e300c", + "size_in_bytes": 53856 + }, + { + "_path": "lib/python3.12/lib-dynload/math.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "f9a354f6b25bbb5649aff05605ecdbf2cdc8374ee6732614318d6767dc0a22bb", + "sha256_in_prefix": "f9a354f6b25bbb5649aff05605ecdbf2cdc8374ee6732614318d6767dc0a22bb", + "size_in_bytes": 94848 + }, + { + "_path": "lib/python3.12/lib-dynload/mmap.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "348fdad4b45a697582d9849457376b18a9ab18137dbda0c39dda294f63dc2ae4", + "sha256_in_prefix": "348fdad4b45a697582d9849457376b18a9ab18137dbda0c39dda294f63dc2ae4", + "size_in_bytes": 56640 + }, + { + "_path": "lib/python3.12/lib-dynload/nis.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "dc27a7bb04e13ee9d2046705b712fb0842845dcae004bcae6cf987ce7f91a49e", + "sha256_in_prefix": "dc27a7bb04e13ee9d2046705b712fb0842845dcae004bcae6cf987ce7f91a49e", + "size_in_bytes": 54176 + }, + { + "_path": "lib/python3.12/lib-dynload/pyexpat.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "469d29cad01d83becaaa0ffa62761d0d556d48e90cc7fa4bef96b93955e5cc30", + "sha256_in_prefix": "469d29cad01d83becaaa0ffa62761d0d556d48e90cc7fa4bef96b93955e5cc30", + "size_in_bytes": 98352 + }, + { + "_path": "lib/python3.12/lib-dynload/readline.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "812a02c22c213dc0329024b590fd7ce566567ba2930a97517298a63cffeac070", + "sha256_in_prefix": "812a02c22c213dc0329024b590fd7ce566567ba2930a97517298a63cffeac070", + "size_in_bytes": 78416 + }, + { + "_path": "lib/python3.12/lib-dynload/resource.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "e78994af80fa4dfd0658eee901033b999d0e516f649c555c76289e4918ca294f", + "sha256_in_prefix": "e78994af80fa4dfd0658eee901033b999d0e516f649c555c76289e4918ca294f", + "size_in_bytes": 53552 + }, + { + "_path": "lib/python3.12/lib-dynload/select.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "425ab37263f89f95139d73bf070fdf5d18770547922c6abd34174c2ce5af0798", + "sha256_in_prefix": "425ab37263f89f95139d73bf070fdf5d18770547922c6abd34174c2ce5af0798", + "size_in_bytes": 75520 + }, + { + "_path": "lib/python3.12/lib-dynload/syslog.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "a0a16a649d1f75eda06f975191cab163ad6eaee6f89af5662ff6a3317d42e5e9", + "sha256_in_prefix": "a0a16a649d1f75eda06f975191cab163ad6eaee6f89af5662ff6a3317d42e5e9", + "size_in_bytes": 53632 + }, + { + "_path": "lib/python3.12/lib-dynload/termios.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "c819196a155ccbe9bff824150328b04c3d2ab14d774a59cd6b3f1e6acc053150", + "sha256_in_prefix": "c819196a155ccbe9bff824150328b04c3d2ab14d774a59cd6b3f1e6acc053150", + "size_in_bytes": 54864 + }, + { + "_path": "lib/python3.12/lib-dynload/unicodedata.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "859770590c70d5199aee141820cff416a9cbad1ea4120ad645dd1f0df4811aeb", + "sha256_in_prefix": "859770590c70d5199aee141820cff416a9cbad1ea4120ad645dd1f0df4811aeb", + "size_in_bytes": 1163440 + }, + { + "_path": "lib/python3.12/lib-dynload/xxlimited.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "6348e2d4a2c045ee0a0c6aa3ed20fcccd68f52c81f695b374a0c091abd62c43a", + "sha256_in_prefix": "6348e2d4a2c045ee0a0c6aa3ed20fcccd68f52c81f695b374a0c091abd62c43a", + "size_in_bytes": 53920 + }, + { + "_path": "lib/python3.12/lib-dynload/xxlimited_35.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "34b15b7626627d7f4efb03a92aaff56477a8c7f62b5b46dcf258f3c0a547acce", + "sha256_in_prefix": "34b15b7626627d7f4efb03a92aaff56477a8c7f62b5b46dcf258f3c0a547acce", + "size_in_bytes": 53520 + }, + { + "_path": "lib/python3.12/lib-dynload/xxsubtype.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "dc6c8758aaf74a398cd292ef3e6b899b4b491d4bb2f3e9d193fd127ba9cc9a33", + "sha256_in_prefix": "dc6c8758aaf74a398cd292ef3e6b899b4b491d4bb2f3e9d193fd127ba9cc9a33", + "size_in_bytes": 52656 + }, + { + "_path": "lib/python3.12/lib-dynload/zlib.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "9b382d8cff3876f2f801922a39e3ab834f0f7e781ef965c68a61777fc85844b4", + "sha256_in_prefix": "9b382d8cff3876f2f801922a39e3ab834f0f7e781ef965c68a61777fc85844b4", + "size_in_bytes": 76224 + }, + { + "_path": "lib/python3.12/lib2to3/Grammar.txt", + "path_type": "hardlink", + "sha256": "508e62e787dd756eb0a4eb1b8d128320ca02cd246ab14cc8ce0a476dc88cc5b6", + "sha256_in_prefix": "508e62e787dd756eb0a4eb1b8d128320ca02cd246ab14cc8ce0a476dc88cc5b6", + "size_in_bytes": 8696 + }, + { + "_path": "lib/python3.12/lib2to3/PatternGrammar.txt", + "path_type": "hardlink", + "sha256": "ee5ba5db3b6722a0e2fbe2560ebc1c883e72328ef9c3b4da1c7c5d1cc649bce3", + "sha256_in_prefix": "ee5ba5db3b6722a0e2fbe2560ebc1c883e72328ef9c3b4da1c7c5d1cc649bce3", + "size_in_bytes": 793 + }, + { + "_path": "lib/python3.12/lib2to3/__init__.py", + "path_type": "hardlink", + "sha256": "5373a81ab198cda8e95652dff46ecfee197a0b8901e8432ab448d97b8bc37f87", + "sha256_in_prefix": "5373a81ab198cda8e95652dff46ecfee197a0b8901e8432ab448d97b8bc37f87", + "size_in_bytes": 156 + }, + { + "_path": "lib/python3.12/lib2to3/__main__.py", + "path_type": "hardlink", + "sha256": "c7b09f90e66dea194ad63dc02c6425dff977d16f1f21a157b7475905c219a707", + "sha256_in_prefix": "c7b09f90e66dea194ad63dc02c6425dff977d16f1f21a157b7475905c219a707", + "size_in_bytes": 67 + }, + { + "_path": "lib/python3.12/lib2to3/__pycache__/__init__.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "a2ed04ff125e97f971dee4722ebaabb098c73d771d4f1a6fe60f4c37bb401f3b", + "sha256_in_prefix": "a2ed04ff125e97f971dee4722ebaabb098c73d771d4f1a6fe60f4c37bb401f3b", + "size_in_bytes": 598 + }, + { + "_path": "lib/python3.12/lib2to3/__pycache__/__main__.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "4b62538b2d19361174a7583fbd81c801a35cdff83ead6e78a7b2766a6057c73c", + "sha256_in_prefix": "4b62538b2d19361174a7583fbd81c801a35cdff83ead6e78a7b2766a6057c73c", + "size_in_bytes": 529 + }, + { + "_path": "lib/python3.12/lib2to3/__pycache__/btm_matcher.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "a370bd4136df38d06408a30a1a573a7a61dda219a845d20b8887bf422e4daedb", + "sha256_in_prefix": "a370bd4136df38d06408a30a1a573a7a61dda219a845d20b8887bf422e4daedb", + "size_in_bytes": 7625 + }, + { + "_path": "lib/python3.12/lib2to3/__pycache__/btm_utils.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "25469415263861b9076d5b214ca2d358bbb576c8adcc902b3b4714a17645e344", + "sha256_in_prefix": "25469415263861b9076d5b214ca2d358bbb576c8adcc902b3b4714a17645e344", + "size_in_bytes": 11378 + }, + { + "_path": "lib/python3.12/lib2to3/__pycache__/fixer_base.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "6112cbd8ec1e098a44e381f68fa2a7f0bc86ee02f82aecbfde35a33ab6d998f9", + "sha256_in_prefix": "6112cbd8ec1e098a44e381f68fa2a7f0bc86ee02f82aecbfde35a33ab6d998f9", + "size_in_bytes": 8123 + }, + { + "_path": "lib/python3.12/lib2to3/__pycache__/fixer_util.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "095a005c14c90ae18a61b743b1baa488e62482ebe82f6f4524e6a976d2adced9", + "sha256_in_prefix": "095a005c14c90ae18a61b743b1baa488e62482ebe82f6f4524e6a976d2adced9", + "size_in_bytes": 22082 + }, + { + "_path": "lib/python3.12/lib2to3/__pycache__/main.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "2025259ca429f58f010b3f46f0b0c59d78177d405bcfdabfd663440f5962d86f", + "sha256_in_prefix": "2025259ca429f58f010b3f46f0b0c59d78177d405bcfdabfd663440f5962d86f", + "size_in_bytes": 14339 + }, + { + "_path": "lib/python3.12/lib2to3/__pycache__/patcomp.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "e9deeea1af8d2491be0d0c28fcbe36117ff926d433f04442e674d1d007750164", + "sha256_in_prefix": "e9deeea1af8d2491be0d0c28fcbe36117ff926d433f04442e674d1d007750164", + "size_in_bytes": 10198 + }, + { + "_path": "lib/python3.12/lib2to3/__pycache__/pygram.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "7243e3803d4a6069bc0fd94e1df25d00e210b736b47b96df2dd4abb69024d29c", + "sha256_in_prefix": "7243e3803d4a6069bc0fd94e1df25d00e210b736b47b96df2dd4abb69024d29c", + "size_in_bytes": 2151 + }, + { + "_path": "lib/python3.12/lib2to3/__pycache__/pytree.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "b98e944ba3e8ab5c2c15e62708310125c4823b77a51ebfb7df3dc15b631274dc", + "sha256_in_prefix": "b98e944ba3e8ab5c2c15e62708310125c4823b77a51ebfb7df3dc15b631274dc", + "size_in_bytes": 35046 + }, + { + "_path": "lib/python3.12/lib2to3/__pycache__/refactor.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "61cfa9d4e0c55fcbda923c849cace5d14921ea4cd290896eed2705c4cc3702fa", + "sha256_in_prefix": "61cfa9d4e0c55fcbda923c849cace5d14921ea4cd290896eed2705c4cc3702fa", + "size_in_bytes": 34746 + }, + { + "_path": "lib/python3.12/lib2to3/btm_matcher.py", + "path_type": "hardlink", + "sha256": "a1aa5d35558acf4b6016054963285cb145f97a764926bea07cbd674563f3248d", + "sha256_in_prefix": "a1aa5d35558acf4b6016054963285cb145f97a764926bea07cbd674563f3248d", + "size_in_bytes": 6623 + }, + { + "_path": "lib/python3.12/lib2to3/btm_utils.py", + "path_type": "hardlink", + "sha256": "c0653eb497a1a48195dd9c4ecbbf87e4eab31188be29ab1640e353209741588c", + "sha256_in_prefix": "c0653eb497a1a48195dd9c4ecbbf87e4eab31188be29ab1640e353209741588c", + "size_in_bytes": 9945 + }, + { + "_path": "lib/python3.12/lib2to3/fixer_base.py", + "path_type": "hardlink", + "sha256": "c795a53ca849c42212c8ec33a74284e0377df852eb4ea599aba62d5af1df282a", + "sha256_in_prefix": "c795a53ca849c42212c8ec33a74284e0377df852eb4ea599aba62d5af1df282a", + "size_in_bytes": 6690 + }, + { + "_path": "lib/python3.12/lib2to3/fixer_util.py", + "path_type": "hardlink", + "sha256": "306d0b2ea8169bdca711c6a31c0b1a3ce710d38ae2b6568ef519aa38451af608", + "sha256_in_prefix": "306d0b2ea8169bdca711c6a31c0b1a3ce710d38ae2b6568ef519aa38451af608", + "size_in_bytes": 15206 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/__init__.py", + "path_type": "hardlink", + "sha256": "836cdb388117cf81e78d9fa2a141cca1b14b0179733322e710067749a1b16fe9", + "sha256_in_prefix": "836cdb388117cf81e78d9fa2a141cca1b14b0179733322e710067749a1b16fe9", + "size_in_bytes": 47 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/__pycache__/__init__.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "d970f73e5ff404af04c42b71444677aa895ba7bc1a72544fa591098628ffbb08", + "sha256_in_prefix": "d970f73e5ff404af04c42b71444677aa895ba7bc1a72544fa591098628ffbb08", + "size_in_bytes": 396 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/__pycache__/fix_apply.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "b686f1f94cbd8af9b1811711aad33b960368949b13fa7b382dba86b9340e964e", + "sha256_in_prefix": "b686f1f94cbd8af9b1811711aad33b960368949b13fa7b382dba86b9340e964e", + "size_in_bytes": 3021 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/__pycache__/fix_asserts.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "89494908ab99ca71dd133afd3e027997e5c1db52c3a5764cecdf802ff7777d6e", + "sha256_in_prefix": "89494908ab99ca71dd133afd3e027997e5c1db52c3a5764cecdf802ff7777d6e", + "size_in_bytes": 1778 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/__pycache__/fix_basestring.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "393384160a55f0af98492f4b4692cbb1139c11a14bfc73e7b6daf085fba49e53", + "sha256_in_prefix": "393384160a55f0af98492f4b4692cbb1139c11a14bfc73e7b6daf085fba49e53", + "size_in_bytes": 1024 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/__pycache__/fix_buffer.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "bc19adeaee453cf310532fc89b5befa2aee662f5947c8224617b3a8891b77651", + "sha256_in_prefix": "bc19adeaee453cf310532fc89b5befa2aee662f5947c8224617b3a8891b77651", + "size_in_bytes": 1214 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/__pycache__/fix_dict.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "cf5609d4b5e984feedb321baa7d3f3fbbfb8fd9efd9a699f3f1809546306a5d1", + "sha256_in_prefix": "cf5609d4b5e984feedb321baa7d3f3fbbfb8fd9efd9a699f3f1809546306a5d1", + "size_in_bytes": 4828 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/__pycache__/fix_except.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "47295fc8354c077f95a9a356c3dcaf46b09b2742564f8dd39b43a14ee3f4bfe5", + "sha256_in_prefix": "47295fc8354c077f95a9a356c3dcaf46b09b2742564f8dd39b43a14ee3f4bfe5", + "size_in_bytes": 4282 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/__pycache__/fix_exec.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "8154213e3b147c53840d1181e8189b2994621b6bae0b4b3bea337d4d159fec4b", + "sha256_in_prefix": "8154213e3b147c53840d1181e8189b2994621b6bae0b4b3bea337d4d159fec4b", + "size_in_bytes": 1857 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/__pycache__/fix_execfile.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "ccfff884b5055e4c51a22df9b77dc5d04ad8b4d4f7921461e3cb27217ab68f1c", + "sha256_in_prefix": "ccfff884b5055e4c51a22df9b77dc5d04ad8b4d4f7921461e3cb27217ab68f1c", + "size_in_bytes": 2988 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/__pycache__/fix_exitfunc.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "977a5f5425f423babcf9c170f6deb52a89d1d127d8afaa860c7f5d529e2609b6", + "sha256_in_prefix": "977a5f5425f423babcf9c170f6deb52a89d1d127d8afaa860c7f5d529e2609b6", + "size_in_bytes": 3823 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/__pycache__/fix_filter.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "053fb3b53d3b3fa36e1b1488df64c7ddc35e1f787287f228717be56a0498aaa3", + "sha256_in_prefix": "053fb3b53d3b3fa36e1b1488df64c7ddc35e1f787287f228717be56a0498aaa3", + "size_in_bytes": 3861 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/__pycache__/fix_funcattrs.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "a75e6c1d87534047966946b651549167f23cb4fb7d882297abb197bc1bb97c5d", + "sha256_in_prefix": "a75e6c1d87534047966946b651549167f23cb4fb7d882297abb197bc1bb97c5d", + "size_in_bytes": 1418 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/__pycache__/fix_future.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "23d72574b1a5424ea9cb3c7bc8d6c4b71c2460981f60a3918cb84593df05d551", + "sha256_in_prefix": "23d72574b1a5424ea9cb3c7bc8d6c4b71c2460981f60a3918cb84593df05d551", + "size_in_bytes": 1163 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/__pycache__/fix_getcwdu.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "c1a3aa4bc04c5b8c2179747d4997ed8a0374e0f47e6016f9ba7e8bd45fc267c4", + "sha256_in_prefix": "c1a3aa4bc04c5b8c2179747d4997ed8a0374e0f47e6016f9ba7e8bd45fc267c4", + "size_in_bytes": 1191 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/__pycache__/fix_has_key.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "ca5b39248173866cc8440cbce5ae882d5bd1569a1fe3dc64f0d03191998a9a5e", + "sha256_in_prefix": "ca5b39248173866cc8440cbce5ae882d5bd1569a1fe3dc64f0d03191998a9a5e", + "size_in_bytes": 4466 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/__pycache__/fix_idioms.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "5846044d280f08f78d8a8e933e9ba2d09ac037435c76b102cac2744b93d7cec8", + "sha256_in_prefix": "5846044d280f08f78d8a8e933e9ba2d09ac037435c76b102cac2744b93d7cec8", + "size_in_bytes": 5705 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/__pycache__/fix_import.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "20f664b4c9b93541d0c6d47f925c797360e50ac38862c52dbb1be4f4da69c9dd", + "sha256_in_prefix": "20f664b4c9b93541d0c6d47f925c797360e50ac38862c52dbb1be4f4da69c9dd", + "size_in_bytes": 4510 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/__pycache__/fix_imports.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "448a3375aebdba7bb518d2abb88931be777f8d9dafc31f7cc5d3071bf482213f", + "sha256_in_prefix": "448a3375aebdba7bb518d2abb88931be777f8d9dafc31f7cc5d3071bf482213f", + "size_in_bytes": 6351 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/__pycache__/fix_imports2.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "dd1dec441dda5f9276529d07fb86916249c8e00ee491a9f92962cd6ef19c1eb4", + "sha256_in_prefix": "dd1dec441dda5f9276529d07fb86916249c8e00ee491a9f92962cd6ef19c1eb4", + "size_in_bytes": 864 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/__pycache__/fix_input.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "f9a102b9dd6ae5196812cb4ccd95266dbc85eeb4bbf86fb4b60d523b29594331", + "sha256_in_prefix": "f9a102b9dd6ae5196812cb4ccd95266dbc85eeb4bbf86fb4b60d523b29594331", + "size_in_bytes": 1515 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/__pycache__/fix_intern.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "b28cbe3d2a7d2bc9a44d4eb8ad15442fe96e6de6d875b441c2ecd429c90ed136", + "sha256_in_prefix": "b28cbe3d2a7d2bc9a44d4eb8ad15442fe96e6de6d875b441c2ecd429c90ed136", + "size_in_bytes": 1658 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/__pycache__/fix_isinstance.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "a0db4e2b5c54680eccfa43c79f6aab2d21733542c69a300ef3e8b0fe604829cd", + "sha256_in_prefix": "a0db4e2b5c54680eccfa43c79f6aab2d21733542c69a300ef3e8b0fe604829cd", + "size_in_bytes": 2600 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/__pycache__/fix_itertools.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "d6d60fa611fdd3b29f119a2aa9313bc954e3503d24e130f78ecbae8010a678c0", + "sha256_in_prefix": "d6d60fa611fdd3b29f119a2aa9313bc954e3503d24e130f78ecbae8010a678c0", + "size_in_bytes": 2226 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/__pycache__/fix_itertools_imports.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "487ea00bb9c8374664616c58789e60f3d9cf0bf3a37289f1627bf69c049282c3", + "sha256_in_prefix": "487ea00bb9c8374664616c58789e60f3d9cf0bf3a37289f1627bf69c049282c3", + "size_in_bytes": 2967 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/__pycache__/fix_long.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "ad08d69faeb606df9f56e6925945a156962e42c1efe8aae7bd2ffbfaf4735e1e", + "sha256_in_prefix": "ad08d69faeb606df9f56e6925945a156962e42c1efe8aae7bd2ffbfaf4735e1e", + "size_in_bytes": 1090 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/__pycache__/fix_map.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "46359268bb310851ecb16fc654534e6787b7ecee950e1cb0e8898f4554b5972f", + "sha256_in_prefix": "46359268bb310851ecb16fc654534e6787b7ecee950e1cb0e8898f4554b5972f", + "size_in_bytes": 4761 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/__pycache__/fix_metaclass.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "4b57217ec7c2dbd152c4e8aab1b1c2193caec1a80ab4eb919f3b9472b3fbcf6b", + "sha256_in_prefix": "4b57217ec7c2dbd152c4e8aab1b1c2193caec1a80ab4eb919f3b9472b3fbcf6b", + "size_in_bytes": 10714 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/__pycache__/fix_methodattrs.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "d3b43e43de88f31d479b807d87f409395e07d4c8e6fd5aa3356b3259476d28c1", + "sha256_in_prefix": "d3b43e43de88f31d479b807d87f409395e07d4c8e6fd5aa3356b3259476d28c1", + "size_in_bytes": 1398 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/__pycache__/fix_ne.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "94b5bbea6b0abbf51fb241bc2a2b165a94fcc4752c5c6f7aede80cdff4e63a9b", + "sha256_in_prefix": "94b5bbea6b0abbf51fb241bc2a2b165a94fcc4752c5c6f7aede80cdff4e63a9b", + "size_in_bytes": 1289 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/__pycache__/fix_next.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "ec50b2fdb587bcdd833e58bfbed53365d12aaf1711f62efbc6de05ca9109be1d", + "sha256_in_prefix": "ec50b2fdb587bcdd833e58bfbed53365d12aaf1711f62efbc6de05ca9109be1d", + "size_in_bytes": 4614 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/__pycache__/fix_nonzero.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "6eec087d3c315547eb5b923410f59866e1684ebf67d5192b05c720a3a50ad189", + "sha256_in_prefix": "6eec087d3c315547eb5b923410f59866e1684ebf67d5192b05c720a3a50ad189", + "size_in_bytes": 1328 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/__pycache__/fix_numliterals.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "e5879d840c337f511fb2c08e23fd3468e5aef4044684ebfd8b3698b06e001d27", + "sha256_in_prefix": "e5879d840c337f511fb2c08e23fd3468e5aef4044684ebfd8b3698b06e001d27", + "size_in_bytes": 1683 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/__pycache__/fix_operator.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "e47e06903b2d816007bcf13bcd35e9ba0152f6f28ef9a29b8a5931c80f54076d", + "sha256_in_prefix": "e47e06903b2d816007bcf13bcd35e9ba0152f6f28ef9a29b8a5931c80f54076d", + "size_in_bytes": 5869 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/__pycache__/fix_paren.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "7bccac6d51901f8d5ea81ed01eb187d856ef4752e43846aa8094d1503c85acce", + "sha256_in_prefix": "7bccac6d51901f8d5ea81ed01eb187d856ef4752e43846aa8094d1503c85acce", + "size_in_bytes": 1875 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/__pycache__/fix_print.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "a51ce784ef9afe8c3bd4ba456efa7038da5340f817f34f91f59628d1edcfbc6c", + "sha256_in_prefix": "a51ce784ef9afe8c3bd4ba456efa7038da5340f817f34f91f59628d1edcfbc6c", + "size_in_bytes": 3747 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/__pycache__/fix_raise.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "41fdac8d5e35dfd92f41eca87e8f38e15d9fd52785c137458e8464e4fba8187c", + "sha256_in_prefix": "41fdac8d5e35dfd92f41eca87e8f38e15d9fd52785c137458e8464e4fba8187c", + "size_in_bytes": 3632 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/__pycache__/fix_raw_input.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "cf37882b4294fbf449ca14c4c6125e120f12594c7bca88837bd3d0097850e9ad", + "sha256_in_prefix": "cf37882b4294fbf449ca14c4c6125e120f12594c7bca88837bd3d0097850e9ad", + "size_in_bytes": 1196 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/__pycache__/fix_reduce.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "79e958fdef4f80de00e7155660b4822a9298177341e28318fbf63533c00d4c05", + "sha256_in_prefix": "79e958fdef4f80de00e7155660b4822a9298177341e28318fbf63533c00d4c05", + "size_in_bytes": 1471 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/__pycache__/fix_reload.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "ff8bfaf83765d5d5ee65372185f2e655a2e1ead45f74dfc6987cd31984eb84b2", + "sha256_in_prefix": "ff8bfaf83765d5d5ee65372185f2e655a2e1ead45f74dfc6987cd31984eb84b2", + "size_in_bytes": 1670 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/__pycache__/fix_renames.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "7917242ca61c39c612f56191f269a7fcdc5c746e9d0147c71b05a39aea94537a", + "sha256_in_prefix": "7917242ca61c39c612f56191f269a7fcdc5c746e9d0147c71b05a39aea94537a", + "size_in_bytes": 3118 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/__pycache__/fix_repr.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "30df45b438bf5b7fff997e1f4dc01826847246834c1a69a4f0affe4fef83c79d", + "sha256_in_prefix": "30df45b438bf5b7fff997e1f4dc01826847246834c1a69a4f0affe4fef83c79d", + "size_in_bytes": 1376 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/__pycache__/fix_set_literal.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "9a352752ec6a1f430737b3a9f5ddfa0bbb71893078c7221994fc95bff0fa049c", + "sha256_in_prefix": "9a352752ec6a1f430737b3a9f5ddfa0bbb71893078c7221994fc95bff0fa049c", + "size_in_bytes": 2880 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/__pycache__/fix_standarderror.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "b50d0e862ffc70d8218d448fa5f47400e1ee8d434a50e08f1231bb4b266d5008", + "sha256_in_prefix": "b50d0e862ffc70d8218d448fa5f47400e1ee8d434a50e08f1231bb4b266d5008", + "size_in_bytes": 1085 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/__pycache__/fix_sys_exc.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "8e6d0ed8bdfcf9bcdc404551c157da87d83346e802f6523b282af45670e79708", + "sha256_in_prefix": "8e6d0ed8bdfcf9bcdc404551c157da87d83346e802f6523b282af45670e79708", + "size_in_bytes": 2263 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/__pycache__/fix_throw.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "84ced0515609af9f3725c453f896386c60101d19ca7c59477c6914338dd833d5", + "sha256_in_prefix": "84ced0515609af9f3725c453f896386c60101d19ca7c59477c6914338dd833d5", + "size_in_bytes": 2696 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/__pycache__/fix_tuple_params.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "b637a964edaeb91c7c354f1d6e5bb71bd4815d22d8a90079a742c8d220d37513", + "sha256_in_prefix": "b637a964edaeb91c7c354f1d6e5bb71bd4815d22d8a90079a742c8d220d37513", + "size_in_bytes": 8110 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/__pycache__/fix_types.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "af064ba8e0e084ea6e18c95dcd56e310a2d5db248c3d9bec10b53efe7bfe9967", + "sha256_in_prefix": "af064ba8e0e084ea6e18c95dcd56e310a2d5db248c3d9bec10b53efe7bfe9967", + "size_in_bytes": 2525 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/__pycache__/fix_unicode.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "82afe90ef054a0d6054f9e7022d00603e4441d6309922d1a109d5cc584a234af", + "sha256_in_prefix": "82afe90ef054a0d6054f9e7022d00603e4441d6309922d1a109d5cc584a234af", + "size_in_bytes": 2413 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/__pycache__/fix_urllib.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "b847a08114b1d31ad834337e569b481c68465fffaf1f1bc10a865aad50816a3f", + "sha256_in_prefix": "b847a08114b1d31ad834337e569b481c68465fffaf1f1bc10a865aad50816a3f", + "size_in_bytes": 9455 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/__pycache__/fix_ws_comma.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "8897868956c1725c642e3627468eb1164447aab6b4c6d86dffd26e58ab0170c9", + "sha256_in_prefix": "8897868956c1725c642e3627468eb1164447aab6b4c6d86dffd26e58ab0170c9", + "size_in_bytes": 1810 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/__pycache__/fix_xrange.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "34feca7db52fbebd93a451dd90d70ba07009d8e4a3d7aba77ddc007a1323c5da", + "sha256_in_prefix": "34feca7db52fbebd93a451dd90d70ba07009d8e4a3d7aba77ddc007a1323c5da", + "size_in_bytes": 4069 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/__pycache__/fix_xreadlines.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "ae565169401ed03675802924ed562657aa3f69c2250ae2d9af606203733aa8b7", + "sha256_in_prefix": "ae565169401ed03675802924ed562657aa3f69c2250ae2d9af606203733aa8b7", + "size_in_bytes": 1530 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/__pycache__/fix_zip.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "41d9ff31c7a4257a2acfe87c47a689ac90707f3d4866314d841d0c6f8e210dc2", + "sha256_in_prefix": "41d9ff31c7a4257a2acfe87c47a689ac90707f3d4866314d841d0c6f8e210dc2", + "size_in_bytes": 2231 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/fix_apply.py", + "path_type": "hardlink", + "sha256": "b5171e32758a78450854f40867775d4aca58665bc920ebece04fcfcc153af02a", + "sha256_in_prefix": "b5171e32758a78450854f40867775d4aca58665bc920ebece04fcfcc153af02a", + "size_in_bytes": 2346 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/fix_asserts.py", + "path_type": "hardlink", + "sha256": "4c77972812cb5ec0a72afbce3e1d618c27ef7b239329c5c952c2bcbe77dba5dd", + "sha256_in_prefix": "4c77972812cb5ec0a72afbce3e1d618c27ef7b239329c5c952c2bcbe77dba5dd", + "size_in_bytes": 984 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/fix_basestring.py", + "path_type": "hardlink", + "sha256": "d041443d6499a735bb78fec9da1bf33b3d034b5192c98bc273b16a44692fc88f", + "sha256_in_prefix": "d041443d6499a735bb78fec9da1bf33b3d034b5192c98bc273b16a44692fc88f", + "size_in_bytes": 320 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/fix_buffer.py", + "path_type": "hardlink", + "sha256": "2da37b49c30d6a0b4db43146ebb4ac8e5ffcb9814816b4742e464cb856977883", + "sha256_in_prefix": "2da37b49c30d6a0b4db43146ebb4ac8e5ffcb9814816b4742e464cb856977883", + "size_in_bytes": 590 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/fix_dict.py", + "path_type": "hardlink", + "sha256": "38f460596ebfb64046aab3d9a65935bd4c76a470118fb7d10a088dc0ecdc53ea", + "sha256_in_prefix": "38f460596ebfb64046aab3d9a65935bd4c76a470118fb7d10a088dc0ecdc53ea", + "size_in_bytes": 3760 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/fix_except.py", + "path_type": "hardlink", + "sha256": "7ff6f560c3c3d7a5d9ceef5ba31c556341f7ce1bc1b52d96b063f6c2c4765651", + "sha256_in_prefix": "7ff6f560c3c3d7a5d9ceef5ba31c556341f7ce1bc1b52d96b063f6c2c4765651", + "size_in_bytes": 3344 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/fix_exec.py", + "path_type": "hardlink", + "sha256": "9e0893327205dea12004e88d18c580286e7977e081b5eda7baf5b7bc93bc6c52", + "sha256_in_prefix": "9e0893327205dea12004e88d18c580286e7977e081b5eda7baf5b7bc93bc6c52", + "size_in_bytes": 979 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/fix_execfile.py", + "path_type": "hardlink", + "sha256": "6ff65db1192099457cb3d9f2618a893c6ac430028550284f3a34d5c08042b0eb", + "sha256_in_prefix": "6ff65db1192099457cb3d9f2618a893c6ac430028550284f3a34d5c08042b0eb", + "size_in_bytes": 2048 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/fix_exitfunc.py", + "path_type": "hardlink", + "sha256": "ef4f18f651d32410c43644c27590903d41e38e763b0e108e6c685a3412a7d29c", + "sha256_in_prefix": "ef4f18f651d32410c43644c27590903d41e38e763b0e108e6c685a3412a7d29c", + "size_in_bytes": 2495 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/fix_filter.py", + "path_type": "hardlink", + "sha256": "2c7f0121193395750eab2b2abf5059d9a3b1a61f81763f52511265d7bca5cb21", + "sha256_in_prefix": "2c7f0121193395750eab2b2abf5059d9a3b1a61f81763f52511265d7bca5cb21", + "size_in_bytes": 2765 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/fix_funcattrs.py", + "path_type": "hardlink", + "sha256": "111df53fac6a121d61abe33883a68e731820ddc4864b0a4c1000cf2ac5f019cd", + "sha256_in_prefix": "111df53fac6a121d61abe33883a68e731820ddc4864b0a4c1000cf2ac5f019cd", + "size_in_bytes": 644 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/fix_future.py", + "path_type": "hardlink", + "sha256": "baba8cafb48dd9181a0e1f7b0f20b585ce2925e8f347e00b87407a256bb16663", + "sha256_in_prefix": "baba8cafb48dd9181a0e1f7b0f20b585ce2925e8f347e00b87407a256bb16663", + "size_in_bytes": 547 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/fix_getcwdu.py", + "path_type": "hardlink", + "sha256": "5bc5252f683a401e7d81c5911617c4af1a1bcdf99a51c4bf1cfccb00446ff220", + "sha256_in_prefix": "5bc5252f683a401e7d81c5911617c4af1a1bcdf99a51c4bf1cfccb00446ff220", + "size_in_bytes": 451 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/fix_has_key.py", + "path_type": "hardlink", + "sha256": "32943d3b921c1c3f0d3776d19e5120806990b817bc99a7e22799847abfda1f63", + "sha256_in_prefix": "32943d3b921c1c3f0d3776d19e5120806990b817bc99a7e22799847abfda1f63", + "size_in_bytes": 3196 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/fix_idioms.py", + "path_type": "hardlink", + "sha256": "600e34faf36e14307e59d55088e3979881d497b8fc9d77659e77709f9e8bafd7", + "sha256_in_prefix": "600e34faf36e14307e59d55088e3979881d497b8fc9d77659e77709f9e8bafd7", + "size_in_bytes": 4876 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/fix_import.py", + "path_type": "hardlink", + "sha256": "803baf96f9603c957eb974f252b0ad9829c889a293e0ce6829db1bce3da6dd4e", + "sha256_in_prefix": "803baf96f9603c957eb974f252b0ad9829c889a293e0ce6829db1bce3da6dd4e", + "size_in_bytes": 3256 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/fix_imports.py", + "path_type": "hardlink", + "sha256": "cdf7ee6d85e2b148230984cfc4ea3f193be458958ea42ef290854a9672a64370", + "sha256_in_prefix": "cdf7ee6d85e2b148230984cfc4ea3f193be458958ea42ef290854a9672a64370", + "size_in_bytes": 5684 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/fix_imports2.py", + "path_type": "hardlink", + "sha256": "b6f3c628839ffe7fd72569dd6ca2210e18edae3e180002747ea011b76b7ec0ef", + "sha256_in_prefix": "b6f3c628839ffe7fd72569dd6ca2210e18edae3e180002747ea011b76b7ec0ef", + "size_in_bytes": 289 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/fix_input.py", + "path_type": "hardlink", + "sha256": "10c5ef3b45a4ee7e88af8852181916a788aae2bea52b08f3473815c1c43598d1", + "sha256_in_prefix": "10c5ef3b45a4ee7e88af8852181916a788aae2bea52b08f3473815c1c43598d1", + "size_in_bytes": 708 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/fix_intern.py", + "path_type": "hardlink", + "sha256": "8d29a162536b99c91bd2f9259dda7f39fec751949d6354d2c1f2e5d070c87d66", + "sha256_in_prefix": "8d29a162536b99c91bd2f9259dda7f39fec751949d6354d2c1f2e5d070c87d66", + "size_in_bytes": 1144 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/fix_isinstance.py", + "path_type": "hardlink", + "sha256": "8408c92b99f50d8c4978b47a2b2155588e315f2ebbe58c160dcdcdcb89e19914", + "sha256_in_prefix": "8408c92b99f50d8c4978b47a2b2155588e315f2ebbe58c160dcdcdcb89e19914", + "size_in_bytes": 1608 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/fix_itertools.py", + "path_type": "hardlink", + "sha256": "578a51b9935020b03a510de15ece55fcd02c9474f37a54c158fb97ba5fd15af1", + "sha256_in_prefix": "578a51b9935020b03a510de15ece55fcd02c9474f37a54c158fb97ba5fd15af1", + "size_in_bytes": 1548 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/fix_itertools_imports.py", + "path_type": "hardlink", + "sha256": "2e419cfbd7f2a326ae7fa10873aa377112ebec32545238fdf988acb088c3cdb7", + "sha256_in_prefix": "2e419cfbd7f2a326ae7fa10873aa377112ebec32545238fdf988acb088c3cdb7", + "size_in_bytes": 2086 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/fix_long.py", + "path_type": "hardlink", + "sha256": "306b80e0a72c0d16dd934b7d51ab0c9a4224f83be5d6cbad8a7158a0a5d73551", + "sha256_in_prefix": "306b80e0a72c0d16dd934b7d51ab0c9a4224f83be5d6cbad8a7158a0a5d73551", + "size_in_bytes": 476 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/fix_map.py", + "path_type": "hardlink", + "sha256": "b82c0762c44adf2af7745c030afe291e2badfe360925046c8e58d85340717696", + "sha256_in_prefix": "b82c0762c44adf2af7745c030afe291e2badfe360925046c8e58d85340717696", + "size_in_bytes": 3640 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/fix_metaclass.py", + "path_type": "hardlink", + "sha256": "45a30c866aa2ff69e089da147ed09986aad4516b5e5dd943f8dfcb7d3946a3e1", + "sha256_in_prefix": "45a30c866aa2ff69e089da147ed09986aad4516b5e5dd943f8dfcb7d3946a3e1", + "size_in_bytes": 8197 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/fix_methodattrs.py", + "path_type": "hardlink", + "sha256": "8d60082f98ce52ee4955099bfd447cbadfa0e9b24ccb8d135cecc833168d44e8", + "sha256_in_prefix": "8d60082f98ce52ee4955099bfd447cbadfa0e9b24ccb8d135cecc833168d44e8", + "size_in_bytes": 606 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/fix_ne.py", + "path_type": "hardlink", + "sha256": "4f9cb1388ba86f29422d20979d3423fdf3541ba35a17ed44d6f4a517ff784ecd", + "sha256_in_prefix": "4f9cb1388ba86f29422d20979d3423fdf3541ba35a17ed44d6f4a517ff784ecd", + "size_in_bytes": 571 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/fix_next.py", + "path_type": "hardlink", + "sha256": "5c7d86d9f81b2498486d626c7feced1b92f23171cf9e42881abb78de1a93bccd", + "sha256_in_prefix": "5c7d86d9f81b2498486d626c7feced1b92f23171cf9e42881abb78de1a93bccd", + "size_in_bytes": 3174 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/fix_nonzero.py", + "path_type": "hardlink", + "sha256": "c2cd7e3ba44508643a20eec4ea4c19f2f1adfd36f6b974d7c143e449571ae736", + "sha256_in_prefix": "c2cd7e3ba44508643a20eec4ea4c19f2f1adfd36f6b974d7c143e449571ae736", + "size_in_bytes": 591 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/fix_numliterals.py", + "path_type": "hardlink", + "sha256": "1c4dd0f7881999abde6cf4d232836fa3e55fc41a7d5aa2b9866092f65707db7f", + "sha256_in_prefix": "1c4dd0f7881999abde6cf4d232836fa3e55fc41a7d5aa2b9866092f65707db7f", + "size_in_bytes": 768 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/fix_operator.py", + "path_type": "hardlink", + "sha256": "023872fe9f03a25387cf2c17fc950cf0f990353df66e603c3a1cd3199dbccd86", + "sha256_in_prefix": "023872fe9f03a25387cf2c17fc950cf0f990353df66e603c3a1cd3199dbccd86", + "size_in_bytes": 3426 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/fix_paren.py", + "path_type": "hardlink", + "sha256": "53734f1d7778ad28a4ec3ab4415923e2da8f230de4cd527589829f570e9f254d", + "sha256_in_prefix": "53734f1d7778ad28a4ec3ab4415923e2da8f230de4cd527589829f570e9f254d", + "size_in_bytes": 1226 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/fix_print.py", + "path_type": "hardlink", + "sha256": "cf2690f1b502249289f52cd544190db0b94d59df5eca139829cd2bf0742e9dba", + "sha256_in_prefix": "cf2690f1b502249289f52cd544190db0b94d59df5eca139829cd2bf0742e9dba", + "size_in_bytes": 2844 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/fix_raise.py", + "path_type": "hardlink", + "sha256": "c38ffec5862597ee8f9dac50385af943ee312bfc394366be08b2fc12563ca1a5", + "sha256_in_prefix": "c38ffec5862597ee8f9dac50385af943ee312bfc394366be08b2fc12563ca1a5", + "size_in_bytes": 2926 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/fix_raw_input.py", + "path_type": "hardlink", + "sha256": "ce04cbaa76d414949afc230360dd9a29ff579bd868cc7f8805230d126ac9ce9b", + "sha256_in_prefix": "ce04cbaa76d414949afc230360dd9a29ff579bd868cc7f8805230d126ac9ce9b", + "size_in_bytes": 454 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/fix_reduce.py", + "path_type": "hardlink", + "sha256": "9a03910a6c183586e1db01863fcde6417d06745fb3e63032333d71c5e82e7919", + "sha256_in_prefix": "9a03910a6c183586e1db01863fcde6417d06745fb3e63032333d71c5e82e7919", + "size_in_bytes": 837 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/fix_reload.py", + "path_type": "hardlink", + "sha256": "17570148167e43b2155b6e1c814a3cca9e3ef53750c504932a9c7d62a8b68a3f", + "sha256_in_prefix": "17570148167e43b2155b6e1c814a3cca9e3ef53750c504932a9c7d62a8b68a3f", + "size_in_bytes": 1081 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/fix_renames.py", + "path_type": "hardlink", + "sha256": "8b71472317bf3adabf819e665c725d03e3064baa45f6ffbfd78cca83eaa46e8d", + "sha256_in_prefix": "8b71472317bf3adabf819e665c725d03e3064baa45f6ffbfd78cca83eaa46e8d", + "size_in_bytes": 2221 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/fix_repr.py", + "path_type": "hardlink", + "sha256": "d16930b7ef8577747cfef602aba854c64ce85d4ae1e54a18a456eaa202643e3d", + "sha256_in_prefix": "d16930b7ef8577747cfef602aba854c64ce85d4ae1e54a18a456eaa202643e3d", + "size_in_bytes": 613 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/fix_set_literal.py", + "path_type": "hardlink", + "sha256": "33f2c0b6e16357e083c3a98877e7317abe1578a44c288e5979c9d96fb5aa6727", + "sha256_in_prefix": "33f2c0b6e16357e083c3a98877e7317abe1578a44c288e5979c9d96fb5aa6727", + "size_in_bytes": 1697 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/fix_standarderror.py", + "path_type": "hardlink", + "sha256": "ce7eb37bc7fb29aa138b1cec6656ae8b4886cbfa700e119a1bb8484284cb717a", + "sha256_in_prefix": "ce7eb37bc7fb29aa138b1cec6656ae8b4886cbfa700e119a1bb8484284cb717a", + "size_in_bytes": 449 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/fix_sys_exc.py", + "path_type": "hardlink", + "sha256": "0143830586d09d702ca3eeaa8f86698e5fd18af69fd28147e71a1a77600d356a", + "sha256_in_prefix": "0143830586d09d702ca3eeaa8f86698e5fd18af69fd28147e71a1a77600d356a", + "size_in_bytes": 1034 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/fix_throw.py", + "path_type": "hardlink", + "sha256": "fec731ed523d5cdfa21893833b52b2844eabfd1549792c1c9f8ceac2d0e8e901", + "sha256_in_prefix": "fec731ed523d5cdfa21893833b52b2844eabfd1549792c1c9f8ceac2d0e8e901", + "size_in_bytes": 1582 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/fix_tuple_params.py", + "path_type": "hardlink", + "sha256": "f3307d4750d0657d9c42b857d5f37bdb5824f9358939da7d16d13f61eb8abc72", + "sha256_in_prefix": "f3307d4750d0657d9c42b857d5f37bdb5824f9358939da7d16d13f61eb8abc72", + "size_in_bytes": 5565 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/fix_types.py", + "path_type": "hardlink", + "sha256": "a0a133cfc78e82e1f71ce628408e7d10a38552ba3e3228ebd113838c1ce44484", + "sha256_in_prefix": "a0a133cfc78e82e1f71ce628408e7d10a38552ba3e3228ebd113838c1ce44484", + "size_in_bytes": 1774 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/fix_unicode.py", + "path_type": "hardlink", + "sha256": "01b2a9b1084b6a0424f27eec488c761f75f053a409608ec36a9ee0ede0d38097", + "sha256_in_prefix": "01b2a9b1084b6a0424f27eec488c761f75f053a409608ec36a9ee0ede0d38097", + "size_in_bytes": 1256 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/fix_urllib.py", + "path_type": "hardlink", + "sha256": "3d1c04d976ff4d2841025a785aaab0cc4ee06c9c9b4e09d1e2456949fa273856", + "sha256_in_prefix": "3d1c04d976ff4d2841025a785aaab0cc4ee06c9c9b4e09d1e2456949fa273856", + "size_in_bytes": 8367 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/fix_ws_comma.py", + "path_type": "hardlink", + "sha256": "5e7a16daec0b2619110516804bf90cac459a4d0315198fd4eff69c36c54378dd", + "sha256_in_prefix": "5e7a16daec0b2619110516804bf90cac459a4d0315198fd4eff69c36c54378dd", + "size_in_bytes": 1090 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/fix_xrange.py", + "path_type": "hardlink", + "sha256": "60d8ce92db6f399606d2e40a3c631ba566127e8cd637ebbf35b822672139cab2", + "sha256_in_prefix": "60d8ce92db6f399606d2e40a3c631ba566127e8cd637ebbf35b822672139cab2", + "size_in_bytes": 2694 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/fix_xreadlines.py", + "path_type": "hardlink", + "sha256": "e8c2f19f7047bfc7539fd78839929004d8fe0efba1fbcbd9d712d285e43834ba", + "sha256_in_prefix": "e8c2f19f7047bfc7539fd78839929004d8fe0efba1fbcbd9d712d285e43834ba", + "size_in_bytes": 689 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/fix_zip.py", + "path_type": "hardlink", + "sha256": "55ce115556c7513dd967364dc6a40c39210c874e8168cf090ddd6dc606df34cb", + "sha256_in_prefix": "55ce115556c7513dd967364dc6a40c39210c874e8168cf090ddd6dc606df34cb", + "size_in_bytes": 1289 + }, + { + "_path": "lib/python3.12/lib2to3/main.py", + "path_type": "hardlink", + "sha256": "8f5dfa77b8c8b375daba8bb88aaa195395674311e2513b29575a70821e3aa0b8", + "sha256_in_prefix": "8f5dfa77b8c8b375daba8bb88aaa195395674311e2513b29575a70821e3aa0b8", + "size_in_bytes": 11854 + }, + { + "_path": "lib/python3.12/lib2to3/patcomp.py", + "path_type": "hardlink", + "sha256": "a033a3eb91a39f96747d4300aa3394965e529c71896cd6503dd27e6b685eede5", + "sha256_in_prefix": "a033a3eb91a39f96747d4300aa3394965e529c71896cd6503dd27e6b685eede5", + "size_in_bytes": 7054 + }, + { + "_path": "lib/python3.12/lib2to3/pgen2/__init__.py", + "path_type": "hardlink", + "sha256": "858eb0f50533bd3bd16fe32815f77fabfed92ede885070b6cb15827ec66ea500", + "sha256_in_prefix": "858eb0f50533bd3bd16fe32815f77fabfed92ede885070b6cb15827ec66ea500", + "size_in_bytes": 143 + }, + { + "_path": "lib/python3.12/lib2to3/pgen2/__pycache__/__init__.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "2a04f04c0b7967699c9cf9d59dc416c39b7b70ffd449e54799632c55766ae12d", + "sha256_in_prefix": "2a04f04c0b7967699c9cf9d59dc416c39b7b70ffd449e54799632c55766ae12d", + "size_in_bytes": 431 + }, + { + "_path": "lib/python3.12/lib2to3/pgen2/__pycache__/conv.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "bbe43a55a18e09f2f4aee97e9581538ba0a000cdce42c16343f3e9d0a3d97550", + "sha256_in_prefix": "bbe43a55a18e09f2f4aee97e9581538ba0a000cdce42c16343f3e9d0a3d97550", + "size_in_bytes": 11973 + }, + { + "_path": "lib/python3.12/lib2to3/pgen2/__pycache__/driver.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "d53f3a3fdf661fe6002fa64a1e5088efe1e49fb5af3c06758dbff6ae7debd569", + "sha256_in_prefix": "d53f3a3fdf661fe6002fa64a1e5088efe1e49fb5af3c06758dbff6ae7debd569", + "size_in_bytes": 8368 + }, + { + "_path": "lib/python3.12/lib2to3/pgen2/__pycache__/grammar.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "7478de3140d799fc775d961eea3d66c638626398ee040ab41d58a175c3b07910", + "sha256_in_prefix": "7478de3140d799fc775d961eea3d66c638626398ee040ab41d58a175c3b07910", + "size_in_bytes": 7288 + }, + { + "_path": "lib/python3.12/lib2to3/pgen2/__pycache__/literals.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "aed8f68debf0165fb8691806977b95660b469d918b23fdba2afaa5c6e437b334", + "sha256_in_prefix": "aed8f68debf0165fb8691806977b95660b469d918b23fdba2afaa5c6e437b334", + "size_in_bytes": 2839 + }, + { + "_path": "lib/python3.12/lib2to3/pgen2/__pycache__/parse.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "4bf5dc17a1c50ba54a859ae6c356941395d606500d7e0b65d62dd23ff90acde5", + "sha256_in_prefix": "4bf5dc17a1c50ba54a859ae6c356941395d606500d7e0b65d62dd23ff90acde5", + "size_in_bytes": 8983 + }, + { + "_path": "lib/python3.12/lib2to3/pgen2/__pycache__/pgen.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "57a741efc037d25f96b46b36fb4daa9b268424bf98245f6b726d5b2189f14a10", + "sha256_in_prefix": "57a741efc037d25f96b46b36fb4daa9b268424bf98245f6b726d5b2189f14a10", + "size_in_bytes": 19043 + }, + { + "_path": "lib/python3.12/lib2to3/pgen2/__pycache__/token.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "b6e94f04953edc6327f90b4175dd5c2290f2a43d20d905dfc105da187ccb6e68", + "sha256_in_prefix": "b6e94f04953edc6327f90b4175dd5c2290f2a43d20d905dfc105da187ccb6e68", + "size_in_bytes": 2501 + }, + { + "_path": "lib/python3.12/lib2to3/pgen2/__pycache__/tokenize.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "7ee5ca8e53280f15ec5716c3f269729576ae7ba4bac92a94f05ae406c685a68e", + "sha256_in_prefix": "7ee5ca8e53280f15ec5716c3f269729576ae7ba4bac92a94f05ae406c685a68e", + "size_in_bytes": 21182 + }, + { + "_path": "lib/python3.12/lib2to3/pgen2/conv.py", + "path_type": "hardlink", + "sha256": "e2946a686c12e02248fafb1a57e7514e0c22bdb2b4a66e644215c86fedc37bff", + "sha256_in_prefix": "e2946a686c12e02248fafb1a57e7514e0c22bdb2b4a66e644215c86fedc37bff", + "size_in_bytes": 9642 + }, + { + "_path": "lib/python3.12/lib2to3/pgen2/driver.py", + "path_type": "hardlink", + "sha256": "57af5e220cd6c6b75e8dead2cea395ead2297dd98e398ad705ca2bce0e9e6594", + "sha256_in_prefix": "57af5e220cd6c6b75e8dead2cea395ead2297dd98e398ad705ca2bce0e9e6594", + "size_in_bytes": 5969 + }, + { + "_path": "lib/python3.12/lib2to3/pgen2/grammar.py", + "path_type": "hardlink", + "sha256": "4898d446d6ae73f7259a3f91839eca1a3380670a9f378b80780707f714fad17c", + "sha256_in_prefix": "4898d446d6ae73f7259a3f91839eca1a3380670a9f378b80780707f714fad17c", + "size_in_bytes": 5552 + }, + { + "_path": "lib/python3.12/lib2to3/pgen2/literals.py", + "path_type": "hardlink", + "sha256": "84bc9d5387a2e20fab844e530358571afa39fa3fc0e8024270b5f7d8ac5a595a", + "sha256_in_prefix": "84bc9d5387a2e20fab844e530358571afa39fa3fc0e8024270b5f7d8ac5a595a", + "size_in_bytes": 1635 + }, + { + "_path": "lib/python3.12/lib2to3/pgen2/parse.py", + "path_type": "hardlink", + "sha256": "e245e005e524ab445a570df31f70c6fd7b901ee3b0b68bd3bcf4b41b37fa7bb6", + "sha256_in_prefix": "e245e005e524ab445a570df31f70c6fd7b901ee3b0b68bd3bcf4b41b37fa7bb6", + "size_in_bytes": 8155 + }, + { + "_path": "lib/python3.12/lib2to3/pgen2/pgen.py", + "path_type": "hardlink", + "sha256": "8fe2ac7e0303f0110d75832d746e6661fcd5373fa498d929163f557fd1027434", + "sha256_in_prefix": "8fe2ac7e0303f0110d75832d746e6661fcd5373fa498d929163f557fd1027434", + "size_in_bytes": 13830 + }, + { + "_path": "lib/python3.12/lib2to3/pgen2/token.py", + "path_type": "hardlink", + "sha256": "7ee05616410d46d8caed0cb0755bf780c62cccf17e3c93c8ccb8dcaaa1e7094c", + "sha256_in_prefix": "7ee05616410d46d8caed0cb0755bf780c62cccf17e3c93c8ccb8dcaaa1e7094c", + "size_in_bytes": 1302 + }, + { + "_path": "lib/python3.12/lib2to3/pgen2/tokenize.py", + "path_type": "hardlink", + "sha256": "aaa0b98f6a65e08e9f8e34358198e329d29554a0d4b5f5059924a252eeb0f5c4", + "sha256_in_prefix": "aaa0b98f6a65e08e9f8e34358198e329d29554a0d4b5f5059924a252eeb0f5c4", + "size_in_bytes": 21119 + }, + { + "_path": "lib/python3.12/lib2to3/pygram.py", + "path_type": "hardlink", + "sha256": "b49d77876a9d1822ff6be04daf464341a8e4c0c3414240abf519254de2a97a48", + "sha256_in_prefix": "b49d77876a9d1822ff6be04daf464341a8e4c0c3414240abf519254de2a97a48", + "size_in_bytes": 1305 + }, + { + "_path": "lib/python3.12/lib2to3/pytree.py", + "path_type": "hardlink", + "sha256": "e53689352fb4fc83d85a09369650389ee01db802ad872a8abfc0bf6603ec38b9", + "sha256_in_prefix": "e53689352fb4fc83d85a09369650389ee01db802ad872a8abfc0bf6603ec38b9", + "size_in_bytes": 27974 + }, + { + "_path": "lib/python3.12/lib2to3/refactor.py", + "path_type": "hardlink", + "sha256": "6e9a4262fb65cd4d277f009df73ffa5748f5fe3b963d3c5395c160d5f88b089b", + "sha256_in_prefix": "6e9a4262fb65cd4d277f009df73ffa5748f5fe3b963d3c5395c160d5f88b089b", + "size_in_bytes": 27507 + }, + { + "_path": "lib/python3.12/linecache.py", + "path_type": "hardlink", + "sha256": "e814839fc75010db274ae034f45b0fff7e529ccb702319048545fef84c2045b7", + "sha256_in_prefix": "e814839fc75010db274ae034f45b0fff7e529ccb702319048545fef84c2045b7", + "size_in_bytes": 5690 + }, + { + "_path": "lib/python3.12/locale.py", + "path_type": "hardlink", + "sha256": "5caa43b5ca0d60fd8a6c0bf7e9b8c8a23e86c58e49f1f8b4398f0d2fdf237b6e", + "sha256_in_prefix": "5caa43b5ca0d60fd8a6c0bf7e9b8c8a23e86c58e49f1f8b4398f0d2fdf237b6e", + "size_in_bytes": 78558 + }, + { + "_path": "lib/python3.12/logging/__init__.py", + "path_type": "hardlink", + "sha256": "c246c90b76621840a71d59360039b713544d351fde5c9ac4994dbf42d304fe55", + "sha256_in_prefix": "c246c90b76621840a71d59360039b713544d351fde5c9ac4994dbf42d304fe55", + "size_in_bytes": 83583 + }, + { + "_path": "lib/python3.12/logging/__pycache__/__init__.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "f52741f3ebe816b0c09d841a1a14db765dab7e702d831317bfffa5e53b75e7e3", + "sha256_in_prefix": "f52741f3ebe816b0c09d841a1a14db765dab7e702d831317bfffa5e53b75e7e3", + "size_in_bytes": 95773 + }, + { + "_path": "lib/python3.12/logging/__pycache__/config.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "0e33ac77cc9c6380384e148a0ce3ca9a3d30221e00ef95caecf41696df40d087", + "sha256_in_prefix": "0e33ac77cc9c6380384e148a0ce3ca9a3d30221e00ef95caecf41696df40d087", + "size_in_bytes": 43311 + }, + { + "_path": "lib/python3.12/logging/__pycache__/handlers.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "ed6d8edaa44f3f8e48fbf6a99b702df3812c1c087386ee442b93f607a44e7a0b", + "sha256_in_prefix": "ed6d8edaa44f3f8e48fbf6a99b702df3812c1c087386ee442b93f607a44e7a0b", + "size_in_bytes": 67248 + }, + { + "_path": "lib/python3.12/logging/config.py", + "path_type": "hardlink", + "sha256": "4f39b6fab0d83992524c1e8fa5e96251cc7a22f490e4e60b15c732740bf741ae", + "sha256_in_prefix": "4f39b6fab0d83992524c1e8fa5e96251cc7a22f490e4e60b15c732740bf741ae", + "size_in_bytes": 41526 + }, + { + "_path": "lib/python3.12/logging/handlers.py", + "path_type": "hardlink", + "sha256": "d6790ea3ee1fb3fe87459c57fe241383d0f324932f66bdeaeef23a099e87eba8", + "sha256_in_prefix": "d6790ea3ee1fb3fe87459c57fe241383d0f324932f66bdeaeef23a099e87eba8", + "size_in_bytes": 62297 + }, + { + "_path": "lib/python3.12/lzma.py", + "path_type": "hardlink", + "sha256": "58fb9d2fdc8a8af7b25e218f17ea3b51bdfa53bdf40f440ab33c605974ca5c2e", + "sha256_in_prefix": "58fb9d2fdc8a8af7b25e218f17ea3b51bdfa53bdf40f440ab33c605974ca5c2e", + "size_in_bytes": 13277 + }, + { + "_path": "lib/python3.12/mailbox.py", + "path_type": "hardlink", + "sha256": "9a56f129b4f06cf24e77c5a085414b72b51f43206ba8b850da8647e9de2c0274", + "sha256_in_prefix": "9a56f129b4f06cf24e77c5a085414b72b51f43206ba8b850da8647e9de2c0274", + "size_in_bytes": 78766 + }, + { + "_path": "lib/python3.12/mailcap.py", + "path_type": "hardlink", + "sha256": "d3242c92bfedb13c7cf5e7aa116e9a38c07e9c6de58f53d03f72a469e9448ca6", + "sha256_in_prefix": "d3242c92bfedb13c7cf5e7aa116e9a38c07e9c6de58f53d03f72a469e9448ca6", + "size_in_bytes": 9333 + }, + { + "_path": "lib/python3.12/mimetypes.py", + "path_type": "hardlink", + "sha256": "f70302916d265621c71f3b2a7a37a8d26f7cd486662551bf860e19613aa0d99d", + "sha256_in_prefix": "f70302916d265621c71f3b2a7a37a8d26f7cd486662551bf860e19613aa0d99d", + "size_in_bytes": 22717 + }, + { + "_path": "lib/python3.12/modulefinder.py", + "path_type": "hardlink", + "sha256": "e07ab000c3698a7530af2c52955ac8bb7647140d22dca1c30f83443faa191e0f", + "sha256_in_prefix": "e07ab000c3698a7530af2c52955ac8bb7647140d22dca1c30f83443faa191e0f", + "size_in_bytes": 23699 + }, + { + "_path": "lib/python3.12/multiprocessing/__init__.py", + "path_type": "hardlink", + "sha256": "a5a42976033c7d63ee2740acceef949a3582dcb0e0442845f9717e1be771c68b", + "sha256_in_prefix": "a5a42976033c7d63ee2740acceef949a3582dcb0e0442845f9717e1be771c68b", + "size_in_bytes": 916 + }, + { + "_path": "lib/python3.12/multiprocessing/__pycache__/__init__.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "875dfc4df060d83805dd7b49029b443f401761527bd7c4df43c31f34d220f10f", + "sha256_in_prefix": "875dfc4df060d83805dd7b49029b443f401761527bd7c4df43c31f34d220f10f", + "size_in_bytes": 1208 + }, + { + "_path": "lib/python3.12/multiprocessing/__pycache__/connection.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "9e2296747272ac54a7e2aad40c6b4b80627845c2594906a6bea8c8eb04f41b04", + "sha256_in_prefix": "9e2296747272ac54a7e2aad40c6b4b80627845c2594906a6bea8c8eb04f41b04", + "size_in_bytes": 48396 + }, + { + "_path": "lib/python3.12/multiprocessing/__pycache__/context.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "d763b70ba8892637cc4eb8b95a83da152f57c89c0d9ec3413e58c2d512fdbac4", + "sha256_in_prefix": "d763b70ba8892637cc4eb8b95a83da152f57c89c0d9ec3413e58c2d512fdbac4", + "size_in_bytes": 17281 + }, + { + "_path": "lib/python3.12/multiprocessing/__pycache__/forkserver.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "0d007731f58479fcec81884edb7dbc12636818370850180fadc5b92c5ad647d1", + "sha256_in_prefix": "0d007731f58479fcec81884edb7dbc12636818370850180fadc5b92c5ad647d1", + "size_in_bytes": 15411 + }, + { + "_path": "lib/python3.12/multiprocessing/__pycache__/heap.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "eea70bf259f7a5f88ab45a81ec0d424d652a8d51c1375be93160bd93dfc0d1d5", + "sha256_in_prefix": "eea70bf259f7a5f88ab45a81ec0d424d652a8d51c1375be93160bd93dfc0d1d5", + "size_in_bytes": 14119 + }, + { + "_path": "lib/python3.12/multiprocessing/__pycache__/managers.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "2ee9a3bc40348e344894614b8d679b277d41499995df8d788ba14f617913a143", + "sha256_in_prefix": "2ee9a3bc40348e344894614b8d679b277d41499995df8d788ba14f617913a143", + "size_in_bytes": 68269 + }, + { + "_path": "lib/python3.12/multiprocessing/__pycache__/pool.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "439a501091b6ab7c3e955c7dba8ba73eeec4739e3f3270e9b3c40046808b3c42", + "sha256_in_prefix": "439a501091b6ab7c3e955c7dba8ba73eeec4739e3f3270e9b3c40046808b3c42", + "size_in_bytes": 44291 + }, + { + "_path": "lib/python3.12/multiprocessing/__pycache__/popen_fork.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "5a9e03b1425ef0e2a7d2dfb27cba4013b8b1456da1ba9bd304986a178831a208", + "sha256_in_prefix": "5a9e03b1425ef0e2a7d2dfb27cba4013b8b1456da1ba9bd304986a178831a208", + "size_in_bytes": 4358 + }, + { + "_path": "lib/python3.12/multiprocessing/__pycache__/popen_forkserver.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "303a0fcc46dfdd8a979b708481b5d1d7030629c037478286526c8a4f97eeed15", + "sha256_in_prefix": "303a0fcc46dfdd8a979b708481b5d1d7030629c037478286526c8a4f97eeed15", + "size_in_bytes": 4218 + }, + { + "_path": "lib/python3.12/multiprocessing/__pycache__/popen_spawn_posix.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "3519718db1e49a910dc38f348e088f9291a904e921b99112522ad3ca26c96ab3", + "sha256_in_prefix": "3519718db1e49a910dc38f348e088f9291a904e921b99112522ad3ca26c96ab3", + "size_in_bytes": 4199 + }, + { + "_path": "lib/python3.12/multiprocessing/__pycache__/popen_spawn_win32.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "870ef925629dc29c9a408f04e458f73e732769eee68840e2db15aa130c9e9e57", + "sha256_in_prefix": "870ef925629dc29c9a408f04e458f73e732769eee68840e2db15aa130c9e9e57", + "size_in_bytes": 6420 + }, + { + "_path": "lib/python3.12/multiprocessing/__pycache__/process.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "48ba6dd23eb95056a942ff89d07e0cd39e9a8fd0bf467914def7c2af1d8effaa", + "sha256_in_prefix": "48ba6dd23eb95056a942ff89d07e0cd39e9a8fd0bf467914def7c2af1d8effaa", + "size_in_bytes": 17996 + }, + { + "_path": "lib/python3.12/multiprocessing/__pycache__/queues.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "00a49e0b81bc52eb4e3dc72629372a1c49751344857665c75bc051606ab9c149", + "sha256_in_prefix": "00a49e0b81bc52eb4e3dc72629372a1c49751344857665c75bc051606ab9c149", + "size_in_bytes": 18772 + }, + { + "_path": "lib/python3.12/multiprocessing/__pycache__/reduction.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "f1431b57d43f99083b44dc97f2a599862749d610e7082ff019266a86eac8f788", + "sha256_in_prefix": "f1431b57d43f99083b44dc97f2a599862749d610e7082ff019266a86eac8f788", + "size_in_bytes": 14153 + }, + { + "_path": "lib/python3.12/multiprocessing/__pycache__/resource_sharer.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "55eac2e0ea81ee66f6cbf0d52abc74f0111ab383f08815a7625887ee410da917", + "sha256_in_prefix": "55eac2e0ea81ee66f6cbf0d52abc74f0111ab383f08815a7625887ee410da917", + "size_in_bytes": 9159 + }, + { + "_path": "lib/python3.12/multiprocessing/__pycache__/resource_tracker.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "45930f9fa48627aa2a61eb15ddab0fb4aea3d786d490f603978d3afdf4b3f600", + "sha256_in_prefix": "45930f9fa48627aa2a61eb15ddab0fb4aea3d786d490f603978d3afdf4b3f600", + "size_in_bytes": 11408 + }, + { + "_path": "lib/python3.12/multiprocessing/__pycache__/shared_memory.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "ee6fa4605035941d35eaf5a3d0085cb86327640a240f311be1e2657323e1e20d", + "sha256_in_prefix": "ee6fa4605035941d35eaf5a3d0085cb86327640a240f311be1e2657323e1e20d", + "size_in_bytes": 23814 + }, + { + "_path": "lib/python3.12/multiprocessing/__pycache__/sharedctypes.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "e6fdcc72e1591ca021cb23cc8eee8aedf1ed1c974cc577dac8558d47822f5027", + "sha256_in_prefix": "e6fdcc72e1591ca021cb23cc8eee8aedf1ed1c974cc577dac8558d47822f5027", + "size_in_bytes": 10953 + }, + { + "_path": "lib/python3.12/multiprocessing/__pycache__/spawn.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "4b0994726dc2d0ed421fab73a521c7c1b92acc158f64dace052d466f068d2e8f", + "sha256_in_prefix": "4b0994726dc2d0ed421fab73a521c7c1b92acc158f64dace052d466f068d2e8f", + "size_in_bytes": 11926 + }, + { + "_path": "lib/python3.12/multiprocessing/__pycache__/synchronize.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "751c49969cebd7da3645c92e6d15c5b4d7d64fc2745ba6a155bd16b5d6fdf4a9", + "sha256_in_prefix": "751c49969cebd7da3645c92e6d15c5b4d7d64fc2745ba6a155bd16b5d6fdf4a9", + "size_in_bytes": 21091 + }, + { + "_path": "lib/python3.12/multiprocessing/__pycache__/util.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "9834c79fcf00103ac456001eb6c0b30aea5110f6625437f142c256f5e1978b55", + "sha256_in_prefix": "9834c79fcf00103ac456001eb6c0b30aea5110f6625437f142c256f5e1978b55", + "size_in_bytes": 18934 + }, + { + "_path": "lib/python3.12/multiprocessing/connection.py", + "path_type": "hardlink", + "sha256": "0aefc3bfec2f73f93a7cdffbbbee0bfcba31c8e37be45afbfe19a5f963654d55", + "sha256_in_prefix": "0aefc3bfec2f73f93a7cdffbbbee0bfcba31c8e37be45afbfe19a5f963654d55", + "size_in_bytes": 41369 + }, + { + "_path": "lib/python3.12/multiprocessing/context.py", + "path_type": "hardlink", + "sha256": "63f15d3169f4453eb80af4ce673a193a0670941206673ab5192ea16a17e8419f", + "sha256_in_prefix": "63f15d3169f4453eb80af4ce673a193a0670941206673ab5192ea16a17e8419f", + "size_in_bytes": 11673 + }, + { + "_path": "lib/python3.12/multiprocessing/dummy/__init__.py", + "path_type": "hardlink", + "sha256": "9127a40ea0ff342cb414383b5e7c594a05be2dd835fe246bd3bb0dc036a32a90", + "sha256_in_prefix": "9127a40ea0ff342cb414383b5e7c594a05be2dd835fe246bd3bb0dc036a32a90", + "size_in_bytes": 3061 + }, + { + "_path": "lib/python3.12/multiprocessing/dummy/__pycache__/__init__.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "d950fafab5a447427c9daaaa5330572dc37d94305bcbc97e7cee50157a4d4cda", + "sha256_in_prefix": "d950fafab5a447427c9daaaa5330572dc37d94305bcbc97e7cee50157a4d4cda", + "size_in_bytes": 5858 + }, + { + "_path": "lib/python3.12/multiprocessing/dummy/__pycache__/connection.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "5376f73863b8c3961c3174322c6fe92f15a90c65d4dadf07ef356838d8be201a", + "sha256_in_prefix": "5376f73863b8c3961c3174322c6fe92f15a90c65d4dadf07ef356838d8be201a", + "size_in_bytes": 3749 + }, + { + "_path": "lib/python3.12/multiprocessing/dummy/connection.py", + "path_type": "hardlink", + "sha256": "d63dd1979fde9c133efe430ee870e6ba6de43c0a0513866ce3ce475791fe57ab", + "sha256_in_prefix": "d63dd1979fde9c133efe430ee870e6ba6de43c0a0513866ce3ce475791fe57ab", + "size_in_bytes": 1598 + }, + { + "_path": "lib/python3.12/multiprocessing/forkserver.py", + "path_type": "hardlink", + "sha256": "e99f0aa2e4dc41af9d259f220c5eb2632e2ace89b6851e712223bf2682016f29", + "sha256_in_prefix": "e99f0aa2e4dc41af9d259f220c5eb2632e2ace89b6851e712223bf2682016f29", + "size_in_bytes": 12134 + }, + { + "_path": "lib/python3.12/multiprocessing/heap.py", + "path_type": "hardlink", + "sha256": "f6bb79bb99b9ae484935f0d68822e9603a1622dd0b6c4966c79db232a93ba614", + "sha256_in_prefix": "f6bb79bb99b9ae484935f0d68822e9603a1622dd0b6c4966c79db232a93ba614", + "size_in_bytes": 11626 + }, + { + "_path": "lib/python3.12/multiprocessing/managers.py", + "path_type": "hardlink", + "sha256": "7c5431f44b7f966ada442a8524e2df857e6319447001094e78fc4fb041a58f4e", + "sha256_in_prefix": "7c5431f44b7f966ada442a8524e2df857e6319447001094e78fc4fb041a58f4e", + "size_in_bytes": 47616 + }, + { + "_path": "lib/python3.12/multiprocessing/pool.py", + "path_type": "hardlink", + "sha256": "418cd41ea5c341e66c6979a38070f6f552cbbdf0539073022b6d15c67e53f480", + "sha256_in_prefix": "418cd41ea5c341e66c6979a38070f6f552cbbdf0539073022b6d15c67e53f480", + "size_in_bytes": 32760 + }, + { + "_path": "lib/python3.12/multiprocessing/popen_fork.py", + "path_type": "hardlink", + "sha256": "0a09db57e7fab7061c01a61778feea6e2b6bb02ccbc150332f2960b05258ef95", + "sha256_in_prefix": "0a09db57e7fab7061c01a61778feea6e2b6bb02ccbc150332f2960b05258ef95", + "size_in_bytes": 2377 + }, + { + "_path": "lib/python3.12/multiprocessing/popen_forkserver.py", + "path_type": "hardlink", + "sha256": "0588ad0e5a36718b4377dc2a2a97864a10986c25a33dc3bfed12595711b0cdab", + "sha256_in_prefix": "0588ad0e5a36718b4377dc2a2a97864a10986c25a33dc3bfed12595711b0cdab", + "size_in_bytes": 2230 + }, + { + "_path": "lib/python3.12/multiprocessing/popen_spawn_posix.py", + "path_type": "hardlink", + "sha256": "97b5d25aa479516894489877e6a7921252ee35f51e118c2f1f91f32919e7caa8", + "sha256_in_prefix": "97b5d25aa479516894489877e6a7921252ee35f51e118c2f1f91f32919e7caa8", + "size_in_bytes": 2029 + }, + { + "_path": "lib/python3.12/multiprocessing/popen_spawn_win32.py", + "path_type": "hardlink", + "sha256": "6ef8efd9cd4e99c64a6778f7ad0957e924de9eb4aa167337ed121a2621b1ffaa", + "sha256_in_prefix": "6ef8efd9cd4e99c64a6778f7ad0957e924de9eb4aa167337ed121a2621b1ffaa", + "size_in_bytes": 4515 + }, + { + "_path": "lib/python3.12/multiprocessing/process.py", + "path_type": "hardlink", + "sha256": "67f0c2a7a3a83c92dd024705bac18619a2e123c9df77c414beb81035ea4a0e18", + "sha256_in_prefix": "67f0c2a7a3a83c92dd024705bac18619a2e123c9df77c414beb81035ea4a0e18", + "size_in_bytes": 12139 + }, + { + "_path": "lib/python3.12/multiprocessing/queues.py", + "path_type": "hardlink", + "sha256": "f4721a323ab2981a172dd2b853d2cfeded696e9716fba340cf6e168f5ed95f83", + "sha256_in_prefix": "f4721a323ab2981a172dd2b853d2cfeded696e9716fba340cf6e168f5ed95f83", + "size_in_bytes": 12693 + }, + { + "_path": "lib/python3.12/multiprocessing/reduction.py", + "path_type": "hardlink", + "sha256": "4999f8b9ae7b3e8a7f5de302612b4131498dc2e238a2c47f894905c1c63294fe", + "sha256_in_prefix": "4999f8b9ae7b3e8a7f5de302612b4131498dc2e238a2c47f894905c1c63294fe", + "size_in_bytes": 9512 + }, + { + "_path": "lib/python3.12/multiprocessing/resource_sharer.py", + "path_type": "hardlink", + "sha256": "bba3c7f2b76a9cf4e8ceb642801c405411da95adf91947d81b0043586038290e", + "sha256_in_prefix": "bba3c7f2b76a9cf4e8ceb642801c405411da95adf91947d81b0043586038290e", + "size_in_bytes": 5145 + }, + { + "_path": "lib/python3.12/multiprocessing/resource_tracker.py", + "path_type": "hardlink", + "sha256": "b0099f5e2285fe2462b77c47bbf29220b57c778741a34f386c10c1e9940884c8", + "sha256_in_prefix": "b0099f5e2285fe2462b77c47bbf29220b57c778741a34f386c10c1e9940884c8", + "size_in_bytes": 10332 + }, + { + "_path": "lib/python3.12/multiprocessing/shared_memory.py", + "path_type": "hardlink", + "sha256": "51301e70710220e1c494ff5383ac94442a38a4a6622f2eb94e40128c45de1aeb", + "sha256_in_prefix": "51301e70710220e1c494ff5383ac94442a38a4a6622f2eb94e40128c45de1aeb", + "size_in_bytes": 18458 + }, + { + "_path": "lib/python3.12/multiprocessing/sharedctypes.py", + "path_type": "hardlink", + "sha256": "77ef522912474652490b7df523112858e51721e63dcf109b8567a35ce9b31b0d", + "sha256_in_prefix": "77ef522912474652490b7df523112858e51721e63dcf109b8567a35ce9b31b0d", + "size_in_bytes": 6306 + }, + { + "_path": "lib/python3.12/multiprocessing/spawn.py", + "path_type": "hardlink", + "sha256": "ebf9fa40eb622384c37690d8c78e7208744df031155ab4ceedab0fc791a1669b", + "sha256_in_prefix": "ebf9fa40eb622384c37690d8c78e7208744df031155ab4ceedab0fc791a1669b", + "size_in_bytes": 9644 + }, + { + "_path": "lib/python3.12/multiprocessing/synchronize.py", + "path_type": "hardlink", + "sha256": "9afc08f6d99deb0cefcbe2f0302dadf3942114aa5564afa0b41bc69f54d1ecaf", + "sha256_in_prefix": "9afc08f6d99deb0cefcbe2f0302dadf3942114aa5564afa0b41bc69f54d1ecaf", + "size_in_bytes": 12285 + }, + { + "_path": "lib/python3.12/multiprocessing/util.py", + "path_type": "hardlink", + "sha256": "6752c4515ec69f82e9df64e017da490c3754e51d818c270ea1ad2d64e09268be", + "sha256_in_prefix": "6752c4515ec69f82e9df64e017da490c3754e51d818c270ea1ad2d64e09268be", + "size_in_bytes": 14261 + }, + { + "_path": "lib/python3.12/netrc.py", + "path_type": "hardlink", + "sha256": "229da6d0cbe6a10295be6c64ac3806420ea018124c09e4887410548fc2fc8b5d", + "sha256_in_prefix": "229da6d0cbe6a10295be6c64ac3806420ea018124c09e4887410548fc2fc8b5d", + "size_in_bytes": 6922 + }, + { + "_path": "lib/python3.12/nntplib.py", + "path_type": "hardlink", + "sha256": "6a76a94b951b273aa87335d7c9c4d7273e4c59485c784b057f681443b32d9004", + "sha256_in_prefix": "6a76a94b951b273aa87335d7c9c4d7273e4c59485c784b057f681443b32d9004", + "size_in_bytes": 41087 + }, + { + "_path": "lib/python3.12/ntpath.py", + "path_type": "hardlink", + "sha256": "0ba5b71169c209deaf39bb3c6f043f65586c931424236ed10cfe9b932b1e6197", + "sha256_in_prefix": "0ba5b71169c209deaf39bb3c6f043f65586c931424236ed10cfe9b932b1e6197", + "size_in_bytes": 31483 + }, + { + "_path": "lib/python3.12/nturl2path.py", + "path_type": "hardlink", + "sha256": "980982ba66cc403d17874369d2770e09845b3d49f1d4514e1c52e01518114332", + "sha256_in_prefix": "980982ba66cc403d17874369d2770e09845b3d49f1d4514e1c52e01518114332", + "size_in_bytes": 2887 + }, + { + "_path": "lib/python3.12/numbers.py", + "path_type": "hardlink", + "sha256": "ac381960a3dc1db0498b0bd43d8ef278d6599713121a186b153ff09d9552e0db", + "sha256_in_prefix": "ac381960a3dc1db0498b0bd43d8ef278d6599713121a186b153ff09d9552e0db", + "size_in_bytes": 11467 + }, + { + "_path": "lib/python3.12/opcode.py", + "path_type": "hardlink", + "sha256": "192f6008508f28d3273bff42eaea9b01c8394dab1607cd36aea778bdd166c3a6", + "sha256_in_prefix": "192f6008508f28d3273bff42eaea9b01c8394dab1607cd36aea778bdd166c3a6", + "size_in_bytes": 13174 + }, + { + "_path": "lib/python3.12/operator.py", + "path_type": "hardlink", + "sha256": "b2af20f67667203c1730e686cc5d0427becc94db4c97f1d3efe3ed2158473f6a", + "sha256_in_prefix": "b2af20f67667203c1730e686cc5d0427becc94db4c97f1d3efe3ed2158473f6a", + "size_in_bytes": 10965 + }, + { + "_path": "lib/python3.12/optparse.py", + "path_type": "hardlink", + "sha256": "07d224301cba312fa0697bff9cd5a4bb4f778a90629632091b3f4ae874d89af5", + "sha256_in_prefix": "07d224301cba312fa0697bff9cd5a4bb4f778a90629632091b3f4ae874d89af5", + "size_in_bytes": 60369 + }, + { + "_path": "lib/python3.12/os.py", + "path_type": "hardlink", + "sha256": "e36b0a6d4feefa0ec1f15b84abd87f61da6f5db434586467869ff0e5f5e1dc24", + "sha256_in_prefix": "e36b0a6d4feefa0ec1f15b84abd87f61da6f5db434586467869ff0e5f5e1dc24", + "size_in_bytes": 39760 + }, + { + "_path": "lib/python3.12/pathlib.py", + "path_type": "hardlink", + "sha256": "dc14d8207519fb8bcdd9c7bae1d54da3ad1b339aa83d4979c16057cd552a3487", + "sha256_in_prefix": "dc14d8207519fb8bcdd9c7bae1d54da3ad1b339aa83d4979c16057cd552a3487", + "size_in_bytes": 51105 + }, + { + "_path": "lib/python3.12/pdb.py", + "path_type": "hardlink", + "sha256": "2e235aa352654b9341dfd3ae088ad27dddf960fb1c9e9158d693d86a3ab4928a", + "sha256_in_prefix": "2e235aa352654b9341dfd3ae088ad27dddf960fb1c9e9158d693d86a3ab4928a", + "size_in_bytes": 70062 + }, + { + "_path": "lib/python3.12/pickle.py", + "path_type": "hardlink", + "sha256": "865b5788a1e35433f89d047187a514057e15ddc2a301b06b5f85da62b4259c04", + "sha256_in_prefix": "865b5788a1e35433f89d047187a514057e15ddc2a301b06b5f85da62b4259c04", + "size_in_bytes": 64901 + }, + { + "_path": "lib/python3.12/pickletools.py", + "path_type": "hardlink", + "sha256": "85a06ddd0cbb8c08557b65ba22ed49f7458314bc78d74c298877da7afd06c4bb", + "sha256_in_prefix": "85a06ddd0cbb8c08557b65ba22ed49f7458314bc78d74c298877da7afd06c4bb", + "size_in_bytes": 93862 + }, + { + "_path": "lib/python3.12/pipes.py", + "path_type": "hardlink", + "sha256": "153f2d249d954b5536c6a049202617ff43ba2f9b109c426e06676c577ddedc61", + "sha256_in_prefix": "153f2d249d954b5536c6a049202617ff43ba2f9b109c426e06676c577ddedc61", + "size_in_bytes": 8978 + }, + { + "_path": "lib/python3.12/pkgutil.py", + "path_type": "hardlink", + "sha256": "44300bc77f6f52ef2ad74d26e5053309c04f49eaa91c099356eb61426cde504f", + "sha256_in_prefix": "44300bc77f6f52ef2ad74d26e5053309c04f49eaa91c099356eb61426cde504f", + "size_in_bytes": 18281 + }, + { + "_path": "lib/python3.12/platform.py", + "path_type": "hardlink", + "sha256": "dbfb80dd05e351a45456b40d272c869bb9e8f6c4d7ef22fda738755318f147ca", + "sha256_in_prefix": "dbfb80dd05e351a45456b40d272c869bb9e8f6c4d7ef22fda738755318f147ca", + "size_in_bytes": 43516 + }, + { + "_path": "lib/python3.12/plistlib.py", + "path_type": "hardlink", + "sha256": "502ea7953e190f0bb03c6acec41c6ab54eb51bbdbd9d8e1c41e53a2d2191aebf", + "sha256_in_prefix": "502ea7953e190f0bb03c6acec41c6ab54eb51bbdbd9d8e1c41e53a2d2191aebf", + "size_in_bytes": 28342 + }, + { + "_path": "lib/python3.12/poplib.py", + "path_type": "hardlink", + "sha256": "08609dc8298e62bf9232de174f5ae4307f27ebef490bf7996625f88d837f08ad", + "sha256_in_prefix": "08609dc8298e62bf9232de174f5ae4307f27ebef490bf7996625f88d837f08ad", + "size_in_bytes": 14163 + }, + { + "_path": "lib/python3.12/posixpath.py", + "path_type": "hardlink", + "sha256": "8396232224e1b9df7896a32980046825b64c00bb010ddd2a4ccc23fe4fbfe262", + "sha256_in_prefix": "8396232224e1b9df7896a32980046825b64c00bb010ddd2a4ccc23fe4fbfe262", + "size_in_bytes": 17564 + }, + { + "_path": "lib/python3.12/pprint.py", + "path_type": "hardlink", + "sha256": "1585c8d74d7f485590db2af46680ae0a73737ca9fb66022b2bcbbc4c4925e203", + "sha256_in_prefix": "1585c8d74d7f485590db2af46680ae0a73737ca9fb66022b2bcbbc4c4925e203", + "size_in_bytes": 24158 + }, + { + "_path": "lib/python3.12/profile.py", + "path_type": "hardlink", + "sha256": "dee2125b2a0913fcfd0330b75d7fb752f2dbbe1bf43e479fb0cba117b9ae6e17", + "sha256_in_prefix": "dee2125b2a0913fcfd0330b75d7fb752f2dbbe1bf43e479fb0cba117b9ae6e17", + "size_in_bytes": 23093 + }, + { + "_path": "lib/python3.12/pstats.py", + "path_type": "hardlink", + "sha256": "3e89c57f1e9d2501abf2e49701cf7d7f1e9525b1b88aeacdfb1c4cc530f4168e", + "sha256_in_prefix": "3e89c57f1e9d2501abf2e49701cf7d7f1e9525b1b88aeacdfb1c4cc530f4168e", + "size_in_bytes": 29289 + }, + { + "_path": "lib/python3.12/pty.py", + "path_type": "hardlink", + "sha256": "ddbb1749387539c2929957c7ec1235fd201d7ec15d285fe5246e88b35c722a4a", + "sha256_in_prefix": "ddbb1749387539c2929957c7ec1235fd201d7ec15d285fe5246e88b35c722a4a", + "size_in_bytes": 6137 + }, + { + "_path": "lib/python3.12/py_compile.py", + "path_type": "hardlink", + "sha256": "3464f04938b57a7aafbc5c394ccd4c46823ee607f7fe36b48b91ecbc30ff4e48", + "sha256_in_prefix": "3464f04938b57a7aafbc5c394ccd4c46823ee607f7fe36b48b91ecbc30ff4e48", + "size_in_bytes": 7837 + }, + { + "_path": "lib/python3.12/pyclbr.py", + "path_type": "hardlink", + "sha256": "e8ca09333701ba41244e20b8c2c37b7ed0499b88c4b2ca82cac51ef89ca9e647", + "sha256_in_prefix": "e8ca09333701ba41244e20b8c2c37b7ed0499b88c4b2ca82cac51ef89ca9e647", + "size_in_bytes": 11396 + }, + { + "_path": "lib/python3.12/pydoc.py", + "path_type": "hardlink", + "sha256": "ed4be37cfad5bd55fc11374f1343df4ec2ee9862cce4f825976a6cb851b5cd55", + "sha256_in_prefix": "ed4be37cfad5bd55fc11374f1343df4ec2ee9862cce4f825976a6cb851b5cd55", + "size_in_bytes": 109280 + }, + { + "_path": "lib/python3.12/pydoc_data/__init__.py", + "path_type": "hardlink", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size_in_bytes": 0 + }, + { + "_path": "lib/python3.12/pydoc_data/__pycache__/__init__.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "3c02bc6d766b9475db585874b52a3a2211b8033a4797d78bde7d9949f43d18ba", + "sha256_in_prefix": "3c02bc6d766b9475db585874b52a3a2211b8033a4797d78bde7d9949f43d18ba", + "size_in_bytes": 393 + }, + { + "_path": "lib/python3.12/pydoc_data/__pycache__/topics.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "9b2c02d1763d361b1915ca3d41a560c65dc4e4dd326662a729df020c9c3315f6", + "sha256_in_prefix": "9b2c02d1763d361b1915ca3d41a560c65dc4e4dd326662a729df020c9c3315f6", + "size_in_bytes": 501342 + }, + { + "_path": "lib/python3.12/pydoc_data/_pydoc.css", + "path_type": "hardlink", + "sha256": "038d4bf51b4d373284640f3658d70eaa856def24d8d02b8e29b289beaabf1cc9", + "sha256_in_prefix": "038d4bf51b4d373284640f3658d70eaa856def24d8d02b8e29b289beaabf1cc9", + "size_in_bytes": 1325 + }, + { + "_path": "lib/python3.12/pydoc_data/topics.py", + "path_type": "hardlink", + "sha256": "e77a8728b1bf2c1e46582c676307ef5a59ec0c400a60b44be717a2083a1b4c3e", + "sha256_in_prefix": "e77a8728b1bf2c1e46582c676307ef5a59ec0c400a60b44be717a2083a1b4c3e", + "size_in_bytes": 803712 + }, + { + "_path": "lib/python3.12/queue.py", + "path_type": "hardlink", + "sha256": "f6c37fc37cd7440979f7d22d40ee818fa3b714c573610c08fa52911d541193f0", + "sha256_in_prefix": "f6c37fc37cd7440979f7d22d40ee818fa3b714c573610c08fa52911d541193f0", + "size_in_bytes": 11496 + }, + { + "_path": "lib/python3.12/quopri.py", + "path_type": "hardlink", + "sha256": "a1cd7f3b22033d32151209886cc855d4b71cc4c83530769f920097582339013a", + "sha256_in_prefix": "a1cd7f3b22033d32151209886cc855d4b71cc4c83530769f920097582339013a", + "size_in_bytes": 7184 + }, + { + "_path": "lib/python3.12/random.py", + "path_type": "hardlink", + "sha256": "0693d4ded36916f5b07d6c395cc331dbf1011bb70e90daaa29eaa32490a09425", + "sha256_in_prefix": "0693d4ded36916f5b07d6c395cc331dbf1011bb70e90daaa29eaa32490a09425", + "size_in_bytes": 34683 + }, + { + "_path": "lib/python3.12/re/__init__.py", + "path_type": "hardlink", + "sha256": "8ff3c37c63b917fcf8dc8d50993a502292a3dc159e41de4f4018c72a53d1c07b", + "sha256_in_prefix": "8ff3c37c63b917fcf8dc8d50993a502292a3dc159e41de4f4018c72a53d1c07b", + "size_in_bytes": 16315 + }, + { + "_path": "lib/python3.12/re/__pycache__/__init__.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "7aba98f6df028ed142da9cf25003eadc0b74f349789c5d94737910327930047c", + "sha256_in_prefix": "7aba98f6df028ed142da9cf25003eadc0b74f349789c5d94737910327930047c", + "size_in_bytes": 18189 + }, + { + "_path": "lib/python3.12/re/__pycache__/_casefix.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "167865fd5cc5095b43cab10ee8da45e90f329263efae083a3577b9aac831004e", + "sha256_in_prefix": "167865fd5cc5095b43cab10ee8da45e90f329263efae083a3577b9aac831004e", + "size_in_bytes": 2070 + }, + { + "_path": "lib/python3.12/re/__pycache__/_compiler.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "c4a1f26400e20101a374efc0cafdce74ad28d008f020aa862555073d3df3c963", + "sha256_in_prefix": "c4a1f26400e20101a374efc0cafdce74ad28d008f020aa862555073d3df3c963", + "size_in_bytes": 26753 + }, + { + "_path": "lib/python3.12/re/__pycache__/_constants.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "6cb221cdb3c595ac5038616e79fb3b70f1c44a9f7e3801f3b7e8644f72be895d", + "sha256_in_prefix": "6cb221cdb3c595ac5038616e79fb3b70f1c44a9f7e3801f3b7e8644f72be895d", + "size_in_bytes": 5550 + }, + { + "_path": "lib/python3.12/re/__pycache__/_parser.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "1b8f42858b03fd6ada7416f7d17464702071c787971503cb885f068d21fcdb4a", + "sha256_in_prefix": "1b8f42858b03fd6ada7416f7d17464702071c787971503cb885f068d21fcdb4a", + "size_in_bytes": 42254 + }, + { + "_path": "lib/python3.12/re/_casefix.py", + "path_type": "hardlink", + "sha256": "41572ac50cf96b04496e676d8a6708898bb8e752e06dad34ed4c50c5d8f1fe40", + "sha256_in_prefix": "41572ac50cf96b04496e676d8a6708898bb8e752e06dad34ed4c50c5d8f1fe40", + "size_in_bytes": 5446 + }, + { + "_path": "lib/python3.12/re/_compiler.py", + "path_type": "hardlink", + "sha256": "c05067f8bfa4c13cbbf1eedc4d5cafc9b621bcb6ebc5771ba0518a18095af15a", + "sha256_in_prefix": "c05067f8bfa4c13cbbf1eedc4d5cafc9b621bcb6ebc5771ba0518a18095af15a", + "size_in_bytes": 26089 + }, + { + "_path": "lib/python3.12/re/_constants.py", + "path_type": "hardlink", + "sha256": "fa4fdb200f238f9e7817b63892b0d69833d8165134801e775e10cc113348a375", + "sha256_in_prefix": "fa4fdb200f238f9e7817b63892b0d69833d8165134801e775e10cc113348a375", + "size_in_bytes": 5930 + }, + { + "_path": "lib/python3.12/re/_parser.py", + "path_type": "hardlink", + "sha256": "a51a85b37cf3f44ba7ff25754da5f31306e4ccfa6eb3c017f9d37bdf4e770840", + "sha256_in_prefix": "a51a85b37cf3f44ba7ff25754da5f31306e4ccfa6eb3c017f9d37bdf4e770840", + "size_in_bytes": 41201 + }, + { + "_path": "lib/python3.12/reprlib.py", + "path_type": "hardlink", + "sha256": "8da31054076803065758311f54b18b8a616824941977d907dc3ee729228e9015", + "sha256_in_prefix": "8da31054076803065758311f54b18b8a616824941977d907dc3ee729228e9015", + "size_in_bytes": 6569 + }, + { + "_path": "lib/python3.12/rlcompleter.py", + "path_type": "hardlink", + "sha256": "fee9ad9c55529be48329b78e982fbba0201bd218326eaf80a87996c9f8c805bb", + "sha256_in_prefix": "fee9ad9c55529be48329b78e982fbba0201bd218326eaf80a87996c9f8c805bb", + "size_in_bytes": 7827 + }, + { + "_path": "lib/python3.12/runpy.py", + "path_type": "hardlink", + "sha256": "b1f47f717848022b83b511c74e0f862f58d1e11afa768910e87a49fccf0be2ff", + "sha256_in_prefix": "b1f47f717848022b83b511c74e0f862f58d1e11afa768910e87a49fccf0be2ff", + "size_in_bytes": 12898 + }, + { + "_path": "lib/python3.12/sched.py", + "path_type": "hardlink", + "sha256": "edfb309483d7cb05e06ad86d1fdeb819629f71402dc6710a1bec36c7afcaac50", + "sha256_in_prefix": "edfb309483d7cb05e06ad86d1fdeb819629f71402dc6710a1bec36c7afcaac50", + "size_in_bytes": 6351 + }, + { + "_path": "lib/python3.12/secrets.py", + "path_type": "hardlink", + "sha256": "277000574358a6ecda4bb40e73332ae81a3bc1c8e1fa36f50e5c6a7d4d3f0f17", + "sha256_in_prefix": "277000574358a6ecda4bb40e73332ae81a3bc1c8e1fa36f50e5c6a7d4d3f0f17", + "size_in_bytes": 1984 + }, + { + "_path": "lib/python3.12/selectors.py", + "path_type": "hardlink", + "sha256": "1eeb102373e18c96311203f30c516e785bd8642275aa0bd66e43a284c9692385", + "sha256_in_prefix": "1eeb102373e18c96311203f30c516e785bd8642275aa0bd66e43a284c9692385", + "size_in_bytes": 19671 + }, + { + "_path": "lib/python3.12/shelve.py", + "path_type": "hardlink", + "sha256": "b978c6f0ffa901b041d6518afed03f2938a62168066013ee7d23baac31c356c0", + "sha256_in_prefix": "b978c6f0ffa901b041d6518afed03f2938a62168066013ee7d23baac31c356c0", + "size_in_bytes": 8560 + }, + { + "_path": "lib/python3.12/shlex.py", + "path_type": "hardlink", + "sha256": "f927227de5ba5b1b2bdd75e3d9c8cb72b602b3bba3cc8edbf8fb554de0dc1fd7", + "sha256_in_prefix": "f927227de5ba5b1b2bdd75e3d9c8cb72b602b3bba3cc8edbf8fb554de0dc1fd7", + "size_in_bytes": 13353 + }, + { + "_path": "lib/python3.12/shutil.py", + "path_type": "hardlink", + "sha256": "cd1d0c76d0c907b8dafdb1203dc0dd947cf703f516e26ebde9fca55822b5b9ad", + "sha256_in_prefix": "cd1d0c76d0c907b8dafdb1203dc0dd947cf703f516e26ebde9fca55822b5b9ad", + "size_in_bytes": 58088 + }, + { + "_path": "lib/python3.12/signal.py", + "path_type": "hardlink", + "sha256": "0363c964c90ac0b3e515de5749205e6e6454051a1211058375d84d91eab6071a", + "sha256_in_prefix": "0363c964c90ac0b3e515de5749205e6e6454051a1211058375d84d91eab6071a", + "size_in_bytes": 2495 + }, + { + "_path": "lib/python3.12/site-packages/README.txt", + "path_type": "hardlink", + "sha256": "cba8fece8f62c36306ba27a128f124a257710e41fc619301ee97be93586917cb", + "sha256_in_prefix": "cba8fece8f62c36306ba27a128f124a257710e41fc619301ee97be93586917cb", + "size_in_bytes": 119 + }, + { + "_path": "lib/python3.12/site.py", + "path_type": "hardlink", + "sha256": "72296c68b28b4af912b6cf361d529562210679468e0e3ed04bec8e40a273bb62", + "sha256_in_prefix": "72296c68b28b4af912b6cf361d529562210679468e0e3ed04bec8e40a273bb62", + "size_in_bytes": 22823 + }, + { + "_path": "lib/python3.12/smtplib.py", + "path_type": "hardlink", + "sha256": "f19369e751e199f5dfc05882e2f77b6a692719cebd8a18c84552544a0b93e963", + "sha256_in_prefix": "f19369e751e199f5dfc05882e2f77b6a692719cebd8a18c84552544a0b93e963", + "size_in_bytes": 43532 + }, + { + "_path": "lib/python3.12/sndhdr.py", + "path_type": "hardlink", + "sha256": "d1cb49f6545ef831a69322275ef26f6ca6964953e70d81a8a80fcca8d600ffc0", + "sha256_in_prefix": "d1cb49f6545ef831a69322275ef26f6ca6964953e70d81a8a80fcca8d600ffc0", + "size_in_bytes": 7448 + }, + { + "_path": "lib/python3.12/socket.py", + "path_type": "hardlink", + "sha256": "b59366f7c35583a274c8031351c146d9c64c4e680adf45d99a3335536a20a6cc", + "sha256_in_prefix": "b59366f7c35583a274c8031351c146d9c64c4e680adf45d99a3335536a20a6cc", + "size_in_bytes": 37411 + }, + { + "_path": "lib/python3.12/socketserver.py", + "path_type": "hardlink", + "sha256": "177f7e4c71a255eecb94ef404df1682843a416b7c5083ae2b07a38016d7e16d7", + "sha256_in_prefix": "177f7e4c71a255eecb94ef404df1682843a416b7c5083ae2b07a38016d7e16d7", + "size_in_bytes": 27851 + }, + { + "_path": "lib/python3.12/sqlite3/__init__.py", + "path_type": "hardlink", + "sha256": "f7cc982617b68e147540ef352d38310fe4d25c2c9c2542b67d0590c871df09a8", + "sha256_in_prefix": "f7cc982617b68e147540ef352d38310fe4d25c2c9c2542b67d0590c871df09a8", + "size_in_bytes": 2501 + }, + { + "_path": "lib/python3.12/sqlite3/__main__.py", + "path_type": "hardlink", + "sha256": "495a939623e825a487cde07b62a68aeefdbb1704b53a8b5388af070dc3fac690", + "sha256_in_prefix": "495a939623e825a487cde07b62a68aeefdbb1704b53a8b5388af070dc3fac690", + "size_in_bytes": 3855 + }, + { + "_path": "lib/python3.12/sqlite3/__pycache__/__init__.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "29a547f6cec8b38a8f33d5011c2e10f0aaeb318d215c31fe6f2db645f8af15f3", + "sha256_in_prefix": "29a547f6cec8b38a8f33d5011c2e10f0aaeb318d215c31fe6f2db645f8af15f3", + "size_in_bytes": 2081 + }, + { + "_path": "lib/python3.12/sqlite3/__pycache__/__main__.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "c29f80905fce5d5842418d1321e5a7c978e125be280f9714397f62f3e30db2ae", + "sha256_in_prefix": "c29f80905fce5d5842418d1321e5a7c978e125be280f9714397f62f3e30db2ae", + "size_in_bytes": 5839 + }, + { + "_path": "lib/python3.12/sqlite3/__pycache__/dbapi2.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "1b73d7f916576074fffeb9d009b5589d109683bf624404afa9ff8816869b4fda", + "sha256_in_prefix": "1b73d7f916576074fffeb9d009b5589d109683bf624404afa9ff8816869b4fda", + "size_in_bytes": 5299 + }, + { + "_path": "lib/python3.12/sqlite3/__pycache__/dump.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "d44b9cf1b9a4bbacfa80fa18e3fb932d09f40f23e1348800a5aaaf1df419d9d7", + "sha256_in_prefix": "d44b9cf1b9a4bbacfa80fa18e3fb932d09f40f23e1348800a5aaaf1df419d9d7", + "size_in_bytes": 3909 + }, + { + "_path": "lib/python3.12/sqlite3/dbapi2.py", + "path_type": "hardlink", + "sha256": "7c5c8d98df1f2c50c4062a3be2c0f0499190c179fa4fc281507a1ef763a98f28", + "sha256_in_prefix": "7c5c8d98df1f2c50c4062a3be2c0f0499190c179fa4fc281507a1ef763a98f28", + "size_in_bytes": 3631 + }, + { + "_path": "lib/python3.12/sqlite3/dump.py", + "path_type": "hardlink", + "sha256": "7b23e13d844d448f6b34fa8b051cec57c9a2c37a94eae96c57b03233b64457d8", + "sha256_in_prefix": "7b23e13d844d448f6b34fa8b051cec57c9a2c37a94eae96c57b03233b64457d8", + "size_in_bytes": 3471 + }, + { + "_path": "lib/python3.12/sre_compile.py", + "path_type": "hardlink", + "sha256": "f7fd87f8ac9dad7d1387e2401761ec05806c5108201a6d1ede6ab2f481f6df54", + "sha256_in_prefix": "f7fd87f8ac9dad7d1387e2401761ec05806c5108201a6d1ede6ab2f481f6df54", + "size_in_bytes": 231 + }, + { + "_path": "lib/python3.12/sre_constants.py", + "path_type": "hardlink", + "sha256": "87013dc0b349c2c044100f70a8daa9d713e60a527e26f6ab8ee1fc978a6d3234", + "sha256_in_prefix": "87013dc0b349c2c044100f70a8daa9d713e60a527e26f6ab8ee1fc978a6d3234", + "size_in_bytes": 232 + }, + { + "_path": "lib/python3.12/sre_parse.py", + "path_type": "hardlink", + "sha256": "c4929134532306081918f185c99305c6f55213bc16b32f8c259bc60f7f81e810", + "sha256_in_prefix": "c4929134532306081918f185c99305c6f55213bc16b32f8c259bc60f7f81e810", + "size_in_bytes": 229 + }, + { + "_path": "lib/python3.12/ssl.py", + "path_type": "hardlink", + "sha256": "ca7dd38c7d39af5112b9669abffcef3f1bb374fb8fa0a2cd071aea09fce203da", + "sha256_in_prefix": "ca7dd38c7d39af5112b9669abffcef3f1bb374fb8fa0a2cd071aea09fce203da", + "size_in_bytes": 50822 + }, + { + "_path": "lib/python3.12/stat.py", + "path_type": "hardlink", + "sha256": "052af0327eae6941b69b05c088b3e748f79995635f80ac4cc7125eb333eb4c77", + "sha256_in_prefix": "052af0327eae6941b69b05c088b3e748f79995635f80ac4cc7125eb333eb4c77", + "size_in_bytes": 5485 + }, + { + "_path": "lib/python3.12/statistics.py", + "path_type": "hardlink", + "sha256": "b9ef01a757de37e9fbf13d32beeb9530c8271582cabec4998226dcb7e0613cd0", + "sha256_in_prefix": "b9ef01a757de37e9fbf13d32beeb9530c8271582cabec4998226dcb7e0613cd0", + "size_in_bytes": 50227 + }, + { + "_path": "lib/python3.12/string.py", + "path_type": "hardlink", + "sha256": "24aeae1f0526250f442022022bf98df9a823b1cb330543ee79e70e44907462e9", + "sha256_in_prefix": "24aeae1f0526250f442022022bf98df9a823b1cb330543ee79e70e44907462e9", + "size_in_bytes": 11786 + }, + { + "_path": "lib/python3.12/stringprep.py", + "path_type": "hardlink", + "sha256": "60b6c83581093029312efb6670b11c540090b3f78bcf72264467b494f02f21a5", + "sha256_in_prefix": "60b6c83581093029312efb6670b11c540090b3f78bcf72264467b494f02f21a5", + "size_in_bytes": 12917 + }, + { + "_path": "lib/python3.12/struct.py", + "path_type": "hardlink", + "sha256": "9c231f9497caf513a22dee8f790b07f969b0e45854a0bdd6dd84b492e08c2856", + "sha256_in_prefix": "9c231f9497caf513a22dee8f790b07f969b0e45854a0bdd6dd84b492e08c2856", + "size_in_bytes": 257 + }, + { + "_path": "lib/python3.12/subprocess.py", + "path_type": "hardlink", + "sha256": "615c6025002fbf150850f43efe49e72c2754dd4bdf35159b29e99bb82ea31907", + "sha256_in_prefix": "615c6025002fbf150850f43efe49e72c2754dd4bdf35159b29e99bb82ea31907", + "size_in_bytes": 88659 + }, + { + "_path": "lib/python3.12/sunau.py", + "path_type": "hardlink", + "sha256": "7e4f850f6460bcd302439d6d2a9fc1bfc31f88f87ad86c508489f5612b346b7a", + "sha256_in_prefix": "7e4f850f6460bcd302439d6d2a9fc1bfc31f88f87ad86c508489f5612b346b7a", + "size_in_bytes": 18478 + }, + { + "_path": "lib/python3.12/symtable.py", + "path_type": "hardlink", + "sha256": "53801d0f6d9b7702d9537e6a13dfac06b89340f70d9f046aa512f37b3e0ca7a6", + "sha256_in_prefix": "53801d0f6d9b7702d9537e6a13dfac06b89340f70d9f046aa512f37b3e0ca7a6", + "size_in_bytes": 10753 + }, + { + "_path": "lib/python3.12/sysconfig.py", + "path_type": "hardlink", + "sha256": "42d47318d7b26a578adc466a3c5b25266a6ceb154fb67b825b163ed2d02341fb", + "sha256_in_prefix": "42d47318d7b26a578adc466a3c5b25266a6ceb154fb67b825b163ed2d02341fb", + "size_in_bytes": 31075 + }, + { + "_path": "lib/python3.12/tabnanny.py", + "path_type": "hardlink", + "sha256": "edd89dcff09ac08bf48a135cd839bc295d8f74438872973b31c07a75bba7944a", + "sha256_in_prefix": "edd89dcff09ac08bf48a135cd839bc295d8f74438872973b31c07a75bba7944a", + "size_in_bytes": 11531 + }, + { + "_path": "lib/python3.12/tarfile.py", + "path_type": "hardlink", + "sha256": "5dd00cc68e88d9581551b1a457398c5b63d87ae1152fa03ef298743485d12cc8", + "sha256_in_prefix": "5dd00cc68e88d9581551b1a457398c5b63d87ae1152fa03ef298743485d12cc8", + "size_in_bytes": 106883 + }, + { + "_path": "lib/python3.12/telnetlib.py", + "path_type": "hardlink", + "sha256": "1984cebfb50180759ca075b0ea340d3624500dc22fab524a4dbf57c18bb548ca", + "sha256_in_prefix": "1984cebfb50180759ca075b0ea340d3624500dc22fab524a4dbf57c18bb548ca", + "size_in_bytes": 23301 + }, + { + "_path": "lib/python3.12/tempfile.py", + "path_type": "hardlink", + "sha256": "fb44155f430fac1923d3d7b6af1a0210edcfb580291d664e66f338491d68b62b", + "sha256_in_prefix": "fb44155f430fac1923d3d7b6af1a0210edcfb580291d664e66f338491d68b62b", + "size_in_bytes": 32236 + }, + { + "_path": "lib/python3.12/test/__init__.py", + "path_type": "hardlink", + "sha256": "836cdb388117cf81e78d9fa2a141cca1b14b0179733322e710067749a1b16fe9", + "sha256_in_prefix": "836cdb388117cf81e78d9fa2a141cca1b14b0179733322e710067749a1b16fe9", + "size_in_bytes": 47 + }, + { + "_path": "lib/python3.12/test/__pycache__/__init__.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "192c5a56d72d0ae47b1fe2ebef41af2d66ba911eb675fa1f6e1dcbafc060bb80", + "sha256_in_prefix": "192c5a56d72d0ae47b1fe2ebef41af2d66ba911eb675fa1f6e1dcbafc060bb80", + "size_in_bytes": 387 + }, + { + "_path": "lib/python3.12/test/__pycache__/test_script_helper.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "b37c50bd376541297f0f025c58f0d358760a5313c31054b8ec4839ae7244afc9", + "sha256_in_prefix": "b37c50bd376541297f0f025c58f0d358760a5313c31054b8ec4839ae7244afc9", + "size_in_bytes": 10502 + }, + { + "_path": "lib/python3.12/test/__pycache__/test_support.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "e4f6383b6d224777a6793a90b022478c5599d266c27154e4ddbcc08c72072037", + "sha256_in_prefix": "e4f6383b6d224777a6793a90b022478c5599d266c27154e4ddbcc08c72072037", + "size_in_bytes": 45450 + }, + { + "_path": "lib/python3.12/test/support/__init__.py", + "path_type": "hardlink", + "sha256": "39ce6a99ef58e089cd7ba2396b5c928001690b9a353c92f78f96b3d2e76afe16", + "sha256_in_prefix": "39ce6a99ef58e089cd7ba2396b5c928001690b9a353c92f78f96b3d2e76afe16", + "size_in_bytes": 79472 + }, + { + "_path": "lib/python3.12/test/support/__pycache__/__init__.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "c0e721c24397183d6c7d3d2bf4ea54d7cf75a2f8e571ca094fa1cd2101bc65a8", + "sha256_in_prefix": "c0e721c24397183d6c7d3d2bf4ea54d7cf75a2f8e571ca094fa1cd2101bc65a8", + "size_in_bytes": 97326 + }, + { + "_path": "lib/python3.12/test/support/__pycache__/ast_helper.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "1b66816339a5276d63ff3cf911e6603fe5e8885cbb681c6b13689386888f0024", + "sha256_in_prefix": "1b66816339a5276d63ff3cf911e6603fe5e8885cbb681c6b13689386888f0024", + "size_in_bytes": 2466 + }, + { + "_path": "lib/python3.12/test/support/__pycache__/asynchat.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "eb1ceb9e7e9ac142d81aae74e17bd5d200b3f314ba2eca23bf7e36d2e3c4e5f1", + "sha256_in_prefix": "eb1ceb9e7e9ac142d81aae74e17bd5d200b3f314ba2eca23bf7e36d2e3c4e5f1", + "size_in_bytes": 10987 + }, + { + "_path": "lib/python3.12/test/support/__pycache__/asyncore.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "1202c33543f7aa733dceaeaed457d1c22da016cc69058c14fdb969bcb3ff7051", + "sha256_in_prefix": "1202c33543f7aa733dceaeaed457d1c22da016cc69058c14fdb969bcb3ff7051", + "size_in_bytes": 25241 + }, + { + "_path": "lib/python3.12/test/support/__pycache__/bytecode_helper.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "96057896c4d5f610d8dd0120f00e70ed66052c2a085ba7f0f650dcfa51580431", + "sha256_in_prefix": "96057896c4d5f610d8dd0120f00e70ed66052c2a085ba7f0f650dcfa51580431", + "size_in_bytes": 7971 + }, + { + "_path": "lib/python3.12/test/support/__pycache__/hashlib_helper.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "42918d8d9c694c67bf581c363842eb60f6505f09cd3bd016ea8fd4125b77e46d", + "sha256_in_prefix": "42918d8d9c694c67bf581c363842eb60f6505f09cd3bd016ea8fd4125b77e46d", + "size_in_bytes": 2803 + }, + { + "_path": "lib/python3.12/test/support/__pycache__/hypothesis_helper.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "5d1762db25d1369d75b12e478fe3eb41456c094030a00384779000b8a4039124", + "sha256_in_prefix": "5d1762db25d1369d75b12e478fe3eb41456c094030a00384779000b8a4039124", + "size_in_bytes": 1554 + }, + { + "_path": "lib/python3.12/test/support/__pycache__/import_helper.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "3633c2206093d0a5b8bf9eb2df8571db8ff9c9fa53d5444800ddada54032477d", + "sha256_in_prefix": "3633c2206093d0a5b8bf9eb2df8571db8ff9c9fa53d5444800ddada54032477d", + "size_in_bytes": 14640 + }, + { + "_path": "lib/python3.12/test/support/__pycache__/interpreters.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "019a1a837cb6d11f57fd2380e1aedc6be8d6e6b50b535dae5b8329e8a1714827", + "sha256_in_prefix": "019a1a837cb6d11f57fd2380e1aedc6be8d6e6b50b535dae5b8329e8a1714827", + "size_in_bytes": 9853 + }, + { + "_path": "lib/python3.12/test/support/__pycache__/logging_helper.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "d750df069362c4928b8a7b6a1557fc7d1930f2a8fa7c10ef154d55de6f726757", + "sha256_in_prefix": "d750df069362c4928b8a7b6a1557fc7d1930f2a8fa7c10ef154d55de6f726757", + "size_in_bytes": 1836 + }, + { + "_path": "lib/python3.12/test/support/__pycache__/os_helper.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "42073116109e464a62d5d361587c3762123bd05573d2b668db1b1e4e1ed1564a", + "sha256_in_prefix": "42073116109e464a62d5d361587c3762123bd05573d2b668db1b1e4e1ed1564a", + "size_in_bytes": 30036 + }, + { + "_path": "lib/python3.12/test/support/__pycache__/pty_helper.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "0e023a95e3477ccce7cde23372361f49322c22d2fe2e981e870aa338e16f1418", + "sha256_in_prefix": "0e023a95e3477ccce7cde23372361f49322c22d2fe2e981e870aa338e16f1418", + "size_in_bytes": 4050 + }, + { + "_path": "lib/python3.12/test/support/__pycache__/script_helper.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "083ed38cc93a596274821b3b15dea3aa995617c122496e4a71349b298b4b3669", + "sha256_in_prefix": "083ed38cc93a596274821b3b15dea3aa995617c122496e4a71349b298b4b3669", + "size_in_bytes": 13305 + }, + { + "_path": "lib/python3.12/test/support/__pycache__/smtpd.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "5709352461ee4b5c4e1d7ab646e27a36a68efd2f1eb85b68db1037bdbbac4e7f", + "sha256_in_prefix": "5709352461ee4b5c4e1d7ab646e27a36a68efd2f1eb85b68db1037bdbbac4e7f", + "size_in_bytes": 39416 + }, + { + "_path": "lib/python3.12/test/support/__pycache__/socket_helper.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "53281424aea59e717560569bf8d12c282423044b8f625d1d9e63d73d80a1c5a8", + "sha256_in_prefix": "53281424aea59e717560569bf8d12c282423044b8f625d1d9e63d73d80a1c5a8", + "size_in_bytes": 16487 + }, + { + "_path": "lib/python3.12/test/support/__pycache__/testcase.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "63f9f09eaf68d1dcd38c1e79ec13114b3772b762c3b9555a0678214ee3f2ddb3", + "sha256_in_prefix": "63f9f09eaf68d1dcd38c1e79ec13114b3772b762c3b9555a0678214ee3f2ddb3", + "size_in_bytes": 2045 + }, + { + "_path": "lib/python3.12/test/support/__pycache__/threading_helper.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "e041411dda0e8864c252f0e06903b4b7685d86106972546fda1e1f2f08caa6d2", + "sha256_in_prefix": "e041411dda0e8864c252f0e06903b4b7685d86106972546fda1e1f2f08caa6d2", + "size_in_bytes": 12013 + }, + { + "_path": "lib/python3.12/test/support/__pycache__/warnings_helper.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "97deee091383b721b02325c1a0c9708bb3d5955ba550bcfcdc2a1c4731888142", + "sha256_in_prefix": "97deee091383b721b02325c1a0c9708bb3d5955ba550bcfcdc2a1c4731888142", + "size_in_bytes": 10165 + }, + { + "_path": "lib/python3.12/test/support/_hypothesis_stubs/__init__.py", + "path_type": "hardlink", + "sha256": "6addb9fbd5d9007e5d50c40c4af5710d73bd62a5c1192b6d067a35cf580be219", + "sha256_in_prefix": "6addb9fbd5d9007e5d50c40c4af5710d73bd62a5c1192b6d067a35cf580be219", + "size_in_bytes": 2444 + }, + { + "_path": "lib/python3.12/test/support/_hypothesis_stubs/__pycache__/__init__.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "393a7f09e3cf0d4cebc63193bf898a1b63cbe61c070f7b9daac1e5b750626d28", + "sha256_in_prefix": "393a7f09e3cf0d4cebc63193bf898a1b63cbe61c070f7b9daac1e5b750626d28", + "size_in_bytes": 4185 + }, + { + "_path": "lib/python3.12/test/support/_hypothesis_stubs/__pycache__/_helpers.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "203d5008bc46346af3af6413bef6f5e218b2dee24f74d49bb3c62e6d8dd13d12", + "sha256_in_prefix": "203d5008bc46346af3af6413bef6f5e218b2dee24f74d49bb3c62e6d8dd13d12", + "size_in_bytes": 2835 + }, + { + "_path": "lib/python3.12/test/support/_hypothesis_stubs/__pycache__/strategies.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "3d9808a05f7fc2990f3787e3c8d0b98f591b975560c2cdd7f3e9dfd675cc74b6", + "sha256_in_prefix": "3d9808a05f7fc2990f3787e3c8d0b98f591b975560c2cdd7f3e9dfd675cc74b6", + "size_in_bytes": 3353 + }, + { + "_path": "lib/python3.12/test/support/_hypothesis_stubs/_helpers.py", + "path_type": "hardlink", + "sha256": "7d1d2fc87b9cbaf744af1ed8e31a96947b13da28bf2e7a0358996af9c195e380", + "sha256_in_prefix": "7d1d2fc87b9cbaf744af1ed8e31a96947b13da28bf2e7a0358996af9c195e380", + "size_in_bytes": 1298 + }, + { + "_path": "lib/python3.12/test/support/_hypothesis_stubs/strategies.py", + "path_type": "hardlink", + "sha256": "1fd24490e10dec6271a006fc01014adcccf9d486b7c201dde975092927246b68", + "sha256_in_prefix": "1fd24490e10dec6271a006fc01014adcccf9d486b7c201dde975092927246b68", + "size_in_bytes": 1857 + }, + { + "_path": "lib/python3.12/test/support/ast_helper.py", + "path_type": "hardlink", + "sha256": "5c72e61f5972cec7e2f830aa0bcdd6c8f3d56c7736a8e78af679d994aa7af84e", + "sha256_in_prefix": "5c72e61f5972cec7e2f830aa0bcdd6c8f3d56c7736a8e78af679d994aa7af84e", + "size_in_bytes": 1828 + }, + { + "_path": "lib/python3.12/test/support/asynchat.py", + "path_type": "hardlink", + "sha256": "67f2619c60c171d03b091931851b658f7a92446e131ac261a3352eb0ccc1b17e", + "sha256_in_prefix": "67f2619c60c171d03b091931851b658f7a92446e131ac261a3352eb0ccc1b17e", + "size_in_bytes": 11602 + }, + { + "_path": "lib/python3.12/test/support/asyncore.py", + "path_type": "hardlink", + "sha256": "4cc554dcb58d602bd9d557b2aa497fe9a325d9e021d97a95c0358e907291a47a", + "sha256_in_prefix": "4cc554dcb58d602bd9d557b2aa497fe9a325d9e021d97a95c0358e907291a47a", + "size_in_bytes": 20381 + }, + { + "_path": "lib/python3.12/test/support/bytecode_helper.py", + "path_type": "hardlink", + "sha256": "fb67d0e9f8e7869235e94949b06313e412be59c29ad1f089f323019f0f3a0e49", + "sha256_in_prefix": "fb67d0e9f8e7869235e94949b06313e412be59c29ad1f089f323019f0f3a0e49", + "size_in_bytes": 4999 + }, + { + "_path": "lib/python3.12/test/support/hashlib_helper.py", + "path_type": "hardlink", + "sha256": "19924c427e33c86284ef2a41f76ab6937ab36f12e3d1ef4e617cdbf616a8fc12", + "sha256_in_prefix": "19924c427e33c86284ef2a41f76ab6937ab36f12e3d1ef4e617cdbf616a8fc12", + "size_in_bytes": 1907 + }, + { + "_path": "lib/python3.12/test/support/hypothesis_helper.py", + "path_type": "hardlink", + "sha256": "0cbf55d49bdb78c5a93446d44dfe0bf247a408ae159813989285f7e8c87fd469", + "sha256_in_prefix": "0cbf55d49bdb78c5a93446d44dfe0bf247a408ae159813989285f7e8c87fd469", + "size_in_bytes": 1383 + }, + { + "_path": "lib/python3.12/test/support/import_helper.py", + "path_type": "hardlink", + "sha256": "32bcd1fc9d407042df157c843fbe5684ea3d7704f587f55049017e28a65bda4c", + "sha256_in_prefix": "32bcd1fc9d407042df157c843fbe5684ea3d7704f587f55049017e28a65bda4c", + "size_in_bytes": 10521 + }, + { + "_path": "lib/python3.12/test/support/interpreters.py", + "path_type": "hardlink", + "sha256": "b74464655baa283d2de961e223e0853b498ca51f0889cb790267c8554ac79c92", + "sha256_in_prefix": "b74464655baa283d2de961e223e0853b498ca51f0889cb790267c8554ac79c92", + "size_in_bytes": 5808 + }, + { + "_path": "lib/python3.12/test/support/logging_helper.py", + "path_type": "hardlink", + "sha256": "be1927e654180fcf6d84257be161fe6fa59796774e862c89b6b78adb656738f3", + "sha256_in_prefix": "be1927e654180fcf6d84257be161fe6fa59796774e862c89b6b78adb656738f3", + "size_in_bytes": 916 + }, + { + "_path": "lib/python3.12/test/support/os_helper.py", + "path_type": "hardlink", + "sha256": "927aa94e0831b09c237b129749e06bb355deb007be0e1fd63dc0cdf4ef5c265d", + "sha256_in_prefix": "927aa94e0831b09c237b129749e06bb355deb007be0e1fd63dc0cdf4ef5c265d", + "size_in_bytes": 24286 + }, + { + "_path": "lib/python3.12/test/support/pty_helper.py", + "path_type": "hardlink", + "sha256": "d724296e344278ce3ffb39962c5761dd04b19e987f8068a09fff02cab7418cc2", + "sha256_in_prefix": "d724296e344278ce3ffb39962c5761dd04b19e987f8068a09fff02cab7418cc2", + "size_in_bytes": 3052 + }, + { + "_path": "lib/python3.12/test/support/script_helper.py", + "path_type": "hardlink", + "sha256": "65a4dc19ffb84e91400a7e3c6e51a58ced9f998270703fb8f9fc96daaa0c5740", + "sha256_in_prefix": "65a4dc19ffb84e91400a7e3c6e51a58ced9f998270703fb8f9fc96daaa0c5740", + "size_in_bytes": 11719 + }, + { + "_path": "lib/python3.12/test/support/smtpd.py", + "path_type": "hardlink", + "sha256": "00599762dd76cb7f6e0763238079c436f96f6a50331abaf2511cad8f0169ae40", + "sha256_in_prefix": "00599762dd76cb7f6e0763238079c436f96f6a50331abaf2511cad8f0169ae40", + "size_in_bytes": 30733 + }, + { + "_path": "lib/python3.12/test/support/socket_helper.py", + "path_type": "hardlink", + "sha256": "482196211cee77253034cb6b85b50bffb302fde20f083a5e888f34af603ea4ec", + "sha256_in_prefix": "482196211cee77253034cb6b85b50bffb302fde20f083a5e888f34af603ea4ec", + "size_in_bytes": 13794 + }, + { + "_path": "lib/python3.12/test/support/testcase.py", + "path_type": "hardlink", + "sha256": "3181376673273db26aa634b690c176d9b5cc176351f5f0d0d5f5a480d6fa0ece", + "sha256_in_prefix": "3181376673273db26aa634b690c176d9b5cc176351f5f0d0d5f5a480d6fa0ece", + "size_in_bytes": 1047 + }, + { + "_path": "lib/python3.12/test/support/threading_helper.py", + "path_type": "hardlink", + "sha256": "7f191895d8e33cb8b36645d0ef197096c459c6f63450366114753a85eaa8c113", + "sha256_in_prefix": "7f191895d8e33cb8b36645d0ef197096c459c6f63450366114753a85eaa8c113", + "size_in_bytes": 8049 + }, + { + "_path": "lib/python3.12/test/support/warnings_helper.py", + "path_type": "hardlink", + "sha256": "515c10201568a2fcb868d1c34ffe9d7f04e3f617a2cb61d587167359a83b09ec", + "sha256_in_prefix": "515c10201568a2fcb868d1c34ffe9d7f04e3f617a2cb61d587167359a83b09ec", + "size_in_bytes": 6853 + }, + { + "_path": "lib/python3.12/test/test_script_helper.py", + "path_type": "hardlink", + "sha256": "f484f6c67bdf6c47322799d6d9437dd4d00ff194c98f6caf97bb69e7bd65e867", + "sha256_in_prefix": "f484f6c67bdf6c47322799d6d9437dd4d00ff194c98f6caf97bb69e7bd65e867", + "size_in_bytes": 5960 + }, + { + "_path": "lib/python3.12/test/test_support.py", + "path_type": "hardlink", + "sha256": "abb8f0e9bce292ff4ce907541aa4fcae663064e9340b0fe9a41a3e9c07729fdc", + "sha256_in_prefix": "abb8f0e9bce292ff4ce907541aa4fcae663064e9340b0fe9a41a3e9c07729fdc", + "size_in_bytes": 27701 + }, + { + "_path": "lib/python3.12/textwrap.py", + "path_type": "hardlink", + "sha256": "62867e40cdea6669b361f72af4d7daf0359f207c92cbeddfc7c7506397c1f31c", + "sha256_in_prefix": "62867e40cdea6669b361f72af4d7daf0359f207c92cbeddfc7c7506397c1f31c", + "size_in_bytes": 19718 + }, + { + "_path": "lib/python3.12/this.py", + "path_type": "hardlink", + "sha256": "481d0cb3de511eae0b5713dad18542b07eafd9c013bb7690f7497bad49923a71", + "sha256_in_prefix": "481d0cb3de511eae0b5713dad18542b07eafd9c013bb7690f7497bad49923a71", + "size_in_bytes": 1003 + }, + { + "_path": "lib/python3.12/threading.py", + "path_type": "hardlink", + "sha256": "8273b4cf5b6f274b4993f5cae08634dd272c6952af9867ff9aa13ed446f1549b", + "sha256_in_prefix": "8273b4cf5b6f274b4993f5cae08634dd272c6952af9867ff9aa13ed446f1549b", + "size_in_bytes": 60123 + }, + { + "_path": "lib/python3.12/timeit.py", + "path_type": "hardlink", + "sha256": "d47d9deb6be0136d817e04d0e4824aa66c66efa01fe61cf62860fff08ecfe83a", + "sha256_in_prefix": "d47d9deb6be0136d817e04d0e4824aa66c66efa01fe61cf62860fff08ecfe83a", + "size_in_bytes": 13464 + }, + { + "_path": "lib/python3.12/tkinter/__init__.py", + "path_type": "hardlink", + "sha256": "0ee94734ebb7c8a97fcbfd367381c634bd9ac6caced7b64decf706c9f08d9932", + "sha256_in_prefix": "0ee94734ebb7c8a97fcbfd367381c634bd9ac6caced7b64decf706c9f08d9932", + "size_in_bytes": 172514 + }, + { + "_path": "lib/python3.12/tkinter/__main__.py", + "path_type": "hardlink", + "sha256": "9738a6cb9cdd8139721dd82118bd527897db5325d807222883f70fb1c5a1c27e", + "sha256_in_prefix": "9738a6cb9cdd8139721dd82118bd527897db5325d807222883f70fb1c5a1c27e", + "size_in_bytes": 148 + }, + { + "_path": "lib/python3.12/tkinter/__pycache__/__init__.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "8a818505a98005d2edbb4158f4ca6d0b30de0eee52816f4ef820cc825949f8a5", + "sha256_in_prefix": "8a818505a98005d2edbb4158f4ca6d0b30de0eee52816f4ef820cc825949f8a5", + "size_in_bytes": 245463 + }, + { + "_path": "lib/python3.12/tkinter/__pycache__/__main__.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "9ebd66b6de11f5efbff9ad4635843262f231e80a98d20dbd9cae95e15c53c80d", + "sha256_in_prefix": "9ebd66b6de11f5efbff9ad4635843262f231e80a98d20dbd9cae95e15c53c80d", + "size_in_bytes": 676 + }, + { + "_path": "lib/python3.12/tkinter/__pycache__/colorchooser.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "c4270ea531db365cb38aa9c944b1253271656e54397d4806a75a22c30b0e0a71", + "sha256_in_prefix": "c4270ea531db365cb38aa9c944b1253271656e54397d4806a75a22c30b0e0a71", + "size_in_bytes": 3010 + }, + { + "_path": "lib/python3.12/tkinter/__pycache__/commondialog.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "384019f384834ff9f042a630d62c41235217134c65f01bc8119406ee207f98f2", + "sha256_in_prefix": "384019f384834ff9f042a630d62c41235217134c65f01bc8119406ee207f98f2", + "size_in_bytes": 2148 + }, + { + "_path": "lib/python3.12/tkinter/__pycache__/constants.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "6c65e11b0ca60ef78a194cd5445782644d24a96749be3dd3022baa982f9ba04c", + "sha256_in_prefix": "6c65e11b0ca60ef78a194cd5445782644d24a96749be3dd3022baa982f9ba04c", + "size_in_bytes": 2186 + }, + { + "_path": "lib/python3.12/tkinter/__pycache__/dialog.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "0b3c901d438005e7668084494f15bc9c8a9246899d00210f2cb68a872e4b3523", + "sha256_in_prefix": "0b3c901d438005e7668084494f15bc9c8a9246899d00210f2cb68a872e4b3523", + "size_in_bytes": 2364 + }, + { + "_path": "lib/python3.12/tkinter/__pycache__/dnd.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "f612f5a4887df731cbb3decfdf9fdc5173dff300bebfb0ed6fdded73b75289cc", + "sha256_in_prefix": "f612f5a4887df731cbb3decfdf9fdc5173dff300bebfb0ed6fdded73b75289cc", + "size_in_bytes": 16579 + }, + { + "_path": "lib/python3.12/tkinter/__pycache__/filedialog.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "cfef1d398c35f794742bb6d5dc8c918632b12aa2227169ca72d936303d933fec", + "sha256_in_prefix": "cfef1d398c35f794742bb6d5dc8c918632b12aa2227169ca72d936303d933fec", + "size_in_bytes": 22884 + }, + { + "_path": "lib/python3.12/tkinter/__pycache__/font.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "88530b333742eafaf187bc8d33c11b8790919642019997d566a803e83eca4a3e", + "sha256_in_prefix": "88530b333742eafaf187bc8d33c11b8790919642019997d566a803e83eca4a3e", + "size_in_bytes": 11146 + }, + { + "_path": "lib/python3.12/tkinter/__pycache__/messagebox.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "99947b9f728f2cb1b0595b8c09a0e524beb2e47388d173947d59d45f7108c22f", + "sha256_in_prefix": "99947b9f728f2cb1b0595b8c09a0e524beb2e47388d173947d59d45f7108c22f", + "size_in_bytes": 4354 + }, + { + "_path": "lib/python3.12/tkinter/__pycache__/scrolledtext.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "98f15bf0665ac7503a531d65a975a59e71efcd9b7e9a2d891514baaaa87d1401", + "sha256_in_prefix": "98f15bf0665ac7503a531d65a975a59e71efcd9b7e9a2d891514baaaa87d1401", + "size_in_bytes": 3583 + }, + { + "_path": "lib/python3.12/tkinter/__pycache__/simpledialog.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "d088a4f68452c9dadb41aea32d5f5372436cd8ccdf43fa265f8c32cc1a8f5e53", + "sha256_in_prefix": "d088a4f68452c9dadb41aea32d5f5372436cd8ccdf43fa265f8c32cc1a8f5e53", + "size_in_bytes": 17797 + }, + { + "_path": "lib/python3.12/tkinter/__pycache__/tix.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "dd630a5e9467af46caa435e6ea7a3e2d82e569be7163e57ae469bf5865e2d807", + "sha256_in_prefix": "dd630a5e9467af46caa435e6ea7a3e2d82e569be7163e57ae469bf5865e2d807", + "size_in_bytes": 112073 + }, + { + "_path": "lib/python3.12/tkinter/__pycache__/ttk.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "81cfd33ef7ed6f1f9052c04b6924e420e500fd64887dc26f66ba7e8c34065da2", + "sha256_in_prefix": "81cfd33ef7ed6f1f9052c04b6924e420e500fd64887dc26f66ba7e8c34065da2", + "size_in_bytes": 73833 + }, + { + "_path": "lib/python3.12/tkinter/colorchooser.py", + "path_type": "hardlink", + "sha256": "1224241dcfb4ec6aff3cafc66adeb2b2a3759397a28693173915458c50040143", + "sha256_in_prefix": "1224241dcfb4ec6aff3cafc66adeb2b2a3759397a28693173915458c50040143", + "size_in_bytes": 2660 + }, + { + "_path": "lib/python3.12/tkinter/commondialog.py", + "path_type": "hardlink", + "sha256": "e683ab0ee9404baec656a88d637910bcb2badb4b4e5d5def2b80cc4534551e6f", + "sha256_in_prefix": "e683ab0ee9404baec656a88d637910bcb2badb4b4e5d5def2b80cc4534551e6f", + "size_in_bytes": 1289 + }, + { + "_path": "lib/python3.12/tkinter/constants.py", + "path_type": "hardlink", + "sha256": "c01314dc51d1c8effeba2528720a65da133596d4143200c68595c02067bf1da2", + "sha256_in_prefix": "c01314dc51d1c8effeba2528720a65da133596d4143200c68595c02067bf1da2", + "size_in_bytes": 1493 + }, + { + "_path": "lib/python3.12/tkinter/dialog.py", + "path_type": "hardlink", + "sha256": "4f8201d3ada7b6d0f450b417e55747adaee5f894412c4875169b0736a5ff0faa", + "sha256_in_prefix": "4f8201d3ada7b6d0f450b417e55747adaee5f894412c4875169b0736a5ff0faa", + "size_in_bytes": 1535 + }, + { + "_path": "lib/python3.12/tkinter/dnd.py", + "path_type": "hardlink", + "sha256": "542b804b243b502b5525a8b1f04a02a120b1db4e3599f5c7865e60693ed3672a", + "sha256_in_prefix": "542b804b243b502b5525a8b1f04a02a120b1db4e3599f5c7865e60693ed3672a", + "size_in_bytes": 11644 + }, + { + "_path": "lib/python3.12/tkinter/filedialog.py", + "path_type": "hardlink", + "sha256": "d75c1eb4131db658b8622acffd8262ecbd7337425c799ea3be8d605ea6be7b94", + "sha256_in_prefix": "d75c1eb4131db658b8622acffd8262ecbd7337425c799ea3be8d605ea6be7b94", + "size_in_bytes": 14939 + }, + { + "_path": "lib/python3.12/tkinter/font.py", + "path_type": "hardlink", + "sha256": "a73482badacc4a69ff7fae9445793a4d858212fdef103360a478bbfd6ed2f496", + "sha256_in_prefix": "a73482badacc4a69ff7fae9445793a4d858212fdef103360a478bbfd6ed2f496", + "size_in_bytes": 7000 + }, + { + "_path": "lib/python3.12/tkinter/messagebox.py", + "path_type": "hardlink", + "sha256": "cdbf655c66778a19f0e25754a5f198a850c8bd958ce651e8fe4b2b52ad7f9c63", + "sha256_in_prefix": "cdbf655c66778a19f0e25754a5f198a850c8bd958ce651e8fe4b2b52ad7f9c63", + "size_in_bytes": 3861 + }, + { + "_path": "lib/python3.12/tkinter/scrolledtext.py", + "path_type": "hardlink", + "sha256": "c7cc050ec9cc3cc6a47215b5bc79b2d3e5c6ed895a4300ab0e20f6c249385e3f", + "sha256_in_prefix": "c7cc050ec9cc3cc6a47215b5bc79b2d3e5c6ed895a4300ab0e20f6c249385e3f", + "size_in_bytes": 1816 + }, + { + "_path": "lib/python3.12/tkinter/simpledialog.py", + "path_type": "hardlink", + "sha256": "63349ae75f9d74a49376f3375e38e5059c9424b918bfd2c67cf45ec70dcf3eac", + "sha256_in_prefix": "63349ae75f9d74a49376f3375e38e5059c9424b918bfd2c67cf45ec70dcf3eac", + "size_in_bytes": 11753 + }, + { + "_path": "lib/python3.12/tkinter/tix.py", + "path_type": "hardlink", + "sha256": "5d7a11093a1f6510de786b0e9d67902ab33a57f637cd8f5e2603cf6c5c609a18", + "sha256_in_prefix": "5d7a11093a1f6510de786b0e9d67902ab33a57f637cd8f5e2603cf6c5c609a18", + "size_in_bytes": 77032 + }, + { + "_path": "lib/python3.12/tkinter/ttk.py", + "path_type": "hardlink", + "sha256": "9e10f6f4434357958dc813ae4d9128d36d51f7bf9193ebc3f1ea049176a8b5ad", + "sha256_in_prefix": "9e10f6f4434357958dc813ae4d9128d36d51f7bf9193ebc3f1ea049176a8b5ad", + "size_in_bytes": 56242 + }, + { + "_path": "lib/python3.12/token.py", + "path_type": "hardlink", + "sha256": "fc76ed1a1cbdb2c961d27cd67acee766abcfcdab06661701db4d9524efb5bd41", + "sha256_in_prefix": "fc76ed1a1cbdb2c961d27cd67acee766abcfcdab06661701db4d9524efb5bd41", + "size_in_bytes": 2479 + }, + { + "_path": "lib/python3.12/tokenize.py", + "path_type": "hardlink", + "sha256": "601b53c9ae77e96fe2a9e10deb273aac64270635cc02e0d46d0976b91f890848", + "sha256_in_prefix": "601b53c9ae77e96fe2a9e10deb273aac64270635cc02e0d46d0976b91f890848", + "size_in_bytes": 19596 + }, + { + "_path": "lib/python3.12/tomllib/__init__.py", + "path_type": "hardlink", + "sha256": "71f67036895f4c5acab942618af0cbd3d814451ba61e967f358d0f341a5b8f51", + "sha256_in_prefix": "71f67036895f4c5acab942618af0cbd3d814451ba61e967f358d0f341a5b8f51", + "size_in_bytes": 308 + }, + { + "_path": "lib/python3.12/tomllib/__pycache__/__init__.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "9539bc88fd9e18cf3eab191fb4067c55016c18d88fa167587fd34243f975d78d", + "sha256_in_prefix": "9539bc88fd9e18cf3eab191fb4067c55016c18d88fa167587fd34243f975d78d", + "size_in_bytes": 557 + }, + { + "_path": "lib/python3.12/tomllib/__pycache__/_parser.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "ef2887c9795ec14c21b444a333c6a23fd79b1203c7acf8717674a7e1e3ab2452", + "sha256_in_prefix": "ef2887c9795ec14c21b444a333c6a23fd79b1203c7acf8717674a7e1e3ab2452", + "size_in_bytes": 27127 + }, + { + "_path": "lib/python3.12/tomllib/__pycache__/_re.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "51c87a033260fd1f7c8677e29d189a04757b9208c9840ce322b59485291cb03a", + "sha256_in_prefix": "51c87a033260fd1f7c8677e29d189a04757b9208c9840ce322b59485291cb03a", + "size_in_bytes": 4110 + }, + { + "_path": "lib/python3.12/tomllib/__pycache__/_types.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "46c5bb21ebab38534e0f2ab9ece7103c2a2e9d8057daeaba03b60e69c035b670", + "sha256_in_prefix": "46c5bb21ebab38534e0f2ab9ece7103c2a2e9d8057daeaba03b60e69c035b670", + "size_in_bytes": 568 + }, + { + "_path": "lib/python3.12/tomllib/_parser.py", + "path_type": "hardlink", + "sha256": "4579b04a7566452304781ccce37d3ebc1c36e810b058bdb1f33c0e51ddab0397", + "sha256_in_prefix": "4579b04a7566452304781ccce37d3ebc1c36e810b058bdb1f33c0e51ddab0397", + "size_in_bytes": 22631 + }, + { + "_path": "lib/python3.12/tomllib/_re.py", + "path_type": "hardlink", + "sha256": "75b8e0e428594f6dca6bdcfd0c73977ddb52a4fc147dd80c5e78fc34ea25cbec", + "sha256_in_prefix": "75b8e0e428594f6dca6bdcfd0c73977ddb52a4fc147dd80c5e78fc34ea25cbec", + "size_in_bytes": 2943 + }, + { + "_path": "lib/python3.12/tomllib/_types.py", + "path_type": "hardlink", + "sha256": "f864c6d9552a929c7032ace654ee05ef26ca75d21b027b801d77e65907138b74", + "sha256_in_prefix": "f864c6d9552a929c7032ace654ee05ef26ca75d21b027b801d77e65907138b74", + "size_in_bytes": 254 + }, + { + "_path": "lib/python3.12/trace.py", + "path_type": "hardlink", + "sha256": "dd08f8dc9adfd264e52adaf319be22246e59f2b3a9c2b6fd8cfd62bc915be639", + "sha256_in_prefix": "dd08f8dc9adfd264e52adaf319be22246e59f2b3a9c2b6fd8cfd62bc915be639", + "size_in_bytes": 29182 + }, + { + "_path": "lib/python3.12/traceback.py", + "path_type": "hardlink", + "sha256": "a96b7d5bfe46a8be9b90613b1555dbd795d51f46aec6b769af06cec465bee39e", + "sha256_in_prefix": "a96b7d5bfe46a8be9b90613b1555dbd795d51f46aec6b769af06cec465bee39e", + "size_in_bytes": 46325 + }, + { + "_path": "lib/python3.12/tracemalloc.py", + "path_type": "hardlink", + "sha256": "c2cc84a05b824df79840c98729a0e94ef8909b11c528a1b2c5a00aa436b97b25", + "sha256_in_prefix": "c2cc84a05b824df79840c98729a0e94ef8909b11c528a1b2c5a00aa436b97b25", + "size_in_bytes": 18047 + }, + { + "_path": "lib/python3.12/tty.py", + "path_type": "hardlink", + "sha256": "1ab5e5e047130b310355e907a3306178299b9f2044fb526ac63bd116e9a16d2b", + "sha256_in_prefix": "1ab5e5e047130b310355e907a3306178299b9f2044fb526ac63bd116e9a16d2b", + "size_in_bytes": 2035 + }, + { + "_path": "lib/python3.12/turtle.py", + "path_type": "hardlink", + "sha256": "1140915f9d17dc0b9ca8ced708d21d75fb38ae395b063a351d85874c7b9fc154", + "sha256_in_prefix": "1140915f9d17dc0b9ca8ced708d21d75fb38ae395b063a351d85874c7b9fc154", + "size_in_bytes": 146361 + }, + { + "_path": "lib/python3.12/turtledemo/__init__.py", + "path_type": "hardlink", + "sha256": "5f465277c96c107a5af544b0a962561f97cb0bfd75906d9bf9741450ed02b0e1", + "sha256_in_prefix": "5f465277c96c107a5af544b0a962561f97cb0bfd75906d9bf9741450ed02b0e1", + "size_in_bytes": 314 + }, + { + "_path": "lib/python3.12/turtledemo/__main__.py", + "path_type": "hardlink", + "sha256": "6620f0af34be5e144cf5097f120b3c9e457be5389b8b35c7aae2e88495486aee", + "sha256_in_prefix": "6620f0af34be5e144cf5097f120b3c9e457be5389b8b35c7aae2e88495486aee", + "size_in_bytes": 15285 + }, + { + "_path": "lib/python3.12/turtledemo/__pycache__/__init__.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "0a90154ff24755c97f77213e9af143115292c3c0d82339a2dfbbb9990f77e318", + "sha256_in_prefix": "0a90154ff24755c97f77213e9af143115292c3c0d82339a2dfbbb9990f77e318", + "size_in_bytes": 720 + }, + { + "_path": "lib/python3.12/turtledemo/__pycache__/__main__.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "bff7a45be2a332c49952ad9f03abfcca2ec9a93da03dd85336a2effe6be75e8c", + "sha256_in_prefix": "bff7a45be2a332c49952ad9f03abfcca2ec9a93da03dd85336a2effe6be75e8c", + "size_in_bytes": 21626 + }, + { + "_path": "lib/python3.12/turtledemo/__pycache__/bytedesign.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "14b2aaaebd3abdfcfdd0b45416c76ee41e63c9501623d72e290968850b425045", + "sha256_in_prefix": "14b2aaaebd3abdfcfdd0b45416c76ee41e63c9501623d72e290968850b425045", + "size_in_bytes": 8481 + }, + { + "_path": "lib/python3.12/turtledemo/__pycache__/chaos.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "de0c0e48bbc41dcf37bb4c409fa26748033c4e6258384f7fff9ac0d716ff0d77", + "sha256_in_prefix": "de0c0e48bbc41dcf37bb4c409fa26748033c4e6258384f7fff9ac0d716ff0d77", + "size_in_bytes": 2740 + }, + { + "_path": "lib/python3.12/turtledemo/__pycache__/clock.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "b7bc1d2a27190eddb9aa7861425676dfe89d2d4fdaf0d8bfb9611dca9ed82101", + "sha256_in_prefix": "b7bc1d2a27190eddb9aa7861425676dfe89d2d4fdaf0d8bfb9611dca9ed82101", + "size_in_bytes": 6170 + }, + { + "_path": "lib/python3.12/turtledemo/__pycache__/colormixer.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "be98213c3af06166258c94eea4a3d6fb229c9e2558082818ce40ddfc30c16c92", + "sha256_in_prefix": "be98213c3af06166258c94eea4a3d6fb229c9e2558082818ce40ddfc30c16c92", + "size_in_bytes": 3572 + }, + { + "_path": "lib/python3.12/turtledemo/__pycache__/forest.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "9b8b2897fe5e0dc4d5512db1dc77bd971745bda9c151fe278771295f93477f12", + "sha256_in_prefix": "9b8b2897fe5e0dc4d5512db1dc77bd971745bda9c151fe278771295f93477f12", + "size_in_bytes": 5352 + }, + { + "_path": "lib/python3.12/turtledemo/__pycache__/fractalcurves.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "16f7e573158f54433bd4fa95d04cbbf2612f3247c7f6e4f29adec6ee1c2e41b0", + "sha256_in_prefix": "16f7e573158f54433bd4fa95d04cbbf2612f3247c7f6e4f29adec6ee1c2e41b0", + "size_in_bytes": 6048 + }, + { + "_path": "lib/python3.12/turtledemo/__pycache__/lindenmayer.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "fd5c00aadef194132573a6bab0fcb4c820c4b70c272882e9aa9a55ab3cc6244d", + "sha256_in_prefix": "fd5c00aadef194132573a6bab0fcb4c820c4b70c272882e9aa9a55ab3cc6244d", + "size_in_bytes": 4034 + }, + { + "_path": "lib/python3.12/turtledemo/__pycache__/minimal_hanoi.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "14843184c0e182babf5115e83b147f2316fe19f5ab4a23efc2e3ac7fadbc1956", + "sha256_in_prefix": "14843184c0e182babf5115e83b147f2316fe19f5ab4a23efc2e3ac7fadbc1956", + "size_in_bytes": 4234 + }, + { + "_path": "lib/python3.12/turtledemo/__pycache__/nim.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "39ab321bad1f5ea68e0358daa87d3c9f03eab08fea041526c3c242c9382fc002", + "sha256_in_prefix": "39ab321bad1f5ea68e0358daa87d3c9f03eab08fea041526c3c242c9382fc002", + "size_in_bytes": 13788 + }, + { + "_path": "lib/python3.12/turtledemo/__pycache__/paint.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "9e492e6a19ae894cacc0351b6e6d612ae4b38ab727aaea7a59c0f620991d9f9d", + "sha256_in_prefix": "9e492e6a19ae894cacc0351b6e6d612ae4b38ab727aaea7a59c0f620991d9f9d", + "size_in_bytes": 2325 + }, + { + "_path": "lib/python3.12/turtledemo/__pycache__/peace.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "356b0b2091a2b5c0ad2c52105c436273a8d4a22454ab78b5fefa4563a4ce974a", + "sha256_in_prefix": "356b0b2091a2b5c0ad2c52105c436273a8d4a22454ab78b5fefa4563a4ce974a", + "size_in_bytes": 2068 + }, + { + "_path": "lib/python3.12/turtledemo/__pycache__/penrose.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "b76e1da3168ad929d66a10b63754aae94f3d230b062f4434ccea77ae83061037", + "sha256_in_prefix": "b76e1da3168ad929d66a10b63754aae94f3d230b062f4434ccea77ae83061037", + "size_in_bytes": 7457 + }, + { + "_path": "lib/python3.12/turtledemo/__pycache__/planet_and_moon.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "7f98bb8dcf162df7a0dc0a79f601bda8c354bc4be1a30d8591d28ca46d142c50", + "sha256_in_prefix": "7f98bb8dcf162df7a0dc0a79f601bda8c354bc4be1a30d8591d28ca46d142c50", + "size_in_bytes": 6564 + }, + { + "_path": "lib/python3.12/turtledemo/__pycache__/rosette.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "da05d4dfd5f5b649d871ffa489ade3a81aa2433f3dab74a63e29eff5657b8376", + "sha256_in_prefix": "da05d4dfd5f5b649d871ffa489ade3a81aa2433f3dab74a63e29eff5657b8376", + "size_in_bytes": 3090 + }, + { + "_path": "lib/python3.12/turtledemo/__pycache__/round_dance.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "c0ad5179076c4fe109a566e5356f8e5b8974ff827613a824243d5a8d6af3e82b", + "sha256_in_prefix": "c0ad5179076c4fe109a566e5356f8e5b8974ff827613a824243d5a8d6af3e82b", + "size_in_bytes": 3082 + }, + { + "_path": "lib/python3.12/turtledemo/__pycache__/sorting_animate.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "d1b19d606e7b5d31b02b0c715027939b702687b53662184620bce1f1a67a29f8", + "sha256_in_prefix": "d1b19d606e7b5d31b02b0c715027939b702687b53662184620bce1f1a67a29f8", + "size_in_bytes": 10530 + }, + { + "_path": "lib/python3.12/turtledemo/__pycache__/tree.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "c1f8b59f5e44909f3be0156a160234c223b6f21c61c8b70cc7d37d9df4499256", + "sha256_in_prefix": "c1f8b59f5e44909f3be0156a160234c223b6f21c61c8b70cc7d37d9df4499256", + "size_in_bytes": 2801 + }, + { + "_path": "lib/python3.12/turtledemo/__pycache__/two_canvases.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "a5b355a84e0986cf1a41f142ae8af2b84d579062280fbe6e0a2f9ff008f7634a", + "sha256_in_prefix": "a5b355a84e0986cf1a41f142ae8af2b84d579062280fbe6e0a2f9ff008f7634a", + "size_in_bytes": 2560 + }, + { + "_path": "lib/python3.12/turtledemo/__pycache__/yinyang.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "ed335a62a565472ab39cdbf6a6affac919ec91d3f49b4f26e486bae9734afb6d", + "sha256_in_prefix": "ed335a62a565472ab39cdbf6a6affac919ec91d3f49b4f26e486bae9734afb6d", + "size_in_bytes": 1913 + }, + { + "_path": "lib/python3.12/turtledemo/bytedesign.py", + "path_type": "hardlink", + "sha256": "6deeee99e0ddb4ed29a648f95d4d33e9f3292c21dbecec301337c22a605a280f", + "sha256_in_prefix": "6deeee99e0ddb4ed29a648f95d4d33e9f3292c21dbecec301337c22a605a280f", + "size_in_bytes": 4248 + }, + { + "_path": "lib/python3.12/turtledemo/chaos.py", + "path_type": "hardlink", + "sha256": "bc8a3a9b77e90446fb7060ff68ee008ffd6b23b366052207ec225cc163b4dae5", + "sha256_in_prefix": "bc8a3a9b77e90446fb7060ff68ee008ffd6b23b366052207ec225cc163b4dae5", + "size_in_bytes": 951 + }, + { + "_path": "lib/python3.12/turtledemo/clock.py", + "path_type": "hardlink", + "sha256": "8728b6e1f7e81e8c9fbc5797588d1766e6be15d353e0f29c38f3e75d28084fcd", + "sha256_in_prefix": "8728b6e1f7e81e8c9fbc5797588d1766e6be15d353e0f29c38f3e75d28084fcd", + "size_in_bytes": 3180 + }, + { + "_path": "lib/python3.12/turtledemo/colormixer.py", + "path_type": "hardlink", + "sha256": "bbb065830edb37fd53b1c004118853176fd8da32ee532cb0d363960880920374", + "sha256_in_prefix": "bbb065830edb37fd53b1c004118853176fd8da32ee532cb0d363960880920374", + "size_in_bytes": 1339 + }, + { + "_path": "lib/python3.12/turtledemo/forest.py", + "path_type": "hardlink", + "sha256": "68cd81b7da35ca49d9066cc2cba24768cddbf90797dbd619a559cf899cde926b", + "sha256_in_prefix": "68cd81b7da35ca49d9066cc2cba24768cddbf90797dbd619a559cf899cde926b", + "size_in_bytes": 2966 + }, + { + "_path": "lib/python3.12/turtledemo/fractalcurves.py", + "path_type": "hardlink", + "sha256": "29fadf34c5eabda4649848d052fa2ed3ae829e55bc3ac5933f2aedf3fb04b320", + "sha256_in_prefix": "29fadf34c5eabda4649848d052fa2ed3ae829e55bc3ac5933f2aedf3fb04b320", + "size_in_bytes": 3473 + }, + { + "_path": "lib/python3.12/turtledemo/lindenmayer.py", + "path_type": "hardlink", + "sha256": "4b597f52c1cb35ae8ed540d1db2dab52276c7874febd7a659ee50f26be26f61e", + "sha256_in_prefix": "4b597f52c1cb35ae8ed540d1db2dab52276c7874febd7a659ee50f26be26f61e", + "size_in_bytes": 2434 + }, + { + "_path": "lib/python3.12/turtledemo/minimal_hanoi.py", + "path_type": "hardlink", + "sha256": "0e458a6257fb5a4ecd2785962850fa87924b23d4ead8aebb70aab38904ff8ef5", + "sha256_in_prefix": "0e458a6257fb5a4ecd2785962850fa87924b23d4ead8aebb70aab38904ff8ef5", + "size_in_bytes": 2051 + }, + { + "_path": "lib/python3.12/turtledemo/nim.py", + "path_type": "hardlink", + "sha256": "939d1ee904a7b00579bb44719b0286e7524bf560c7ffff6d482064b41b09fdb3", + "sha256_in_prefix": "939d1ee904a7b00579bb44719b0286e7524bf560c7ffff6d482064b41b09fdb3", + "size_in_bytes": 6513 + }, + { + "_path": "lib/python3.12/turtledemo/paint.py", + "path_type": "hardlink", + "sha256": "81aa22d0da1d934cb47edfef1883f9fe8ef864c56d484f79f9ec4b46457d047e", + "sha256_in_prefix": "81aa22d0da1d934cb47edfef1883f9fe8ef864c56d484f79f9ec4b46457d047e", + "size_in_bytes": 1291 + }, + { + "_path": "lib/python3.12/turtledemo/peace.py", + "path_type": "hardlink", + "sha256": "b260b857164684b3065ad760fec0245ab6505c220814fb179a3d080f2bba0814", + "sha256_in_prefix": "b260b857164684b3065ad760fec0245ab6505c220814fb179a3d080f2bba0814", + "size_in_bytes": 1066 + }, + { + "_path": "lib/python3.12/turtledemo/penrose.py", + "path_type": "hardlink", + "sha256": "14aeb10db966bfd4ec923a19eb96892eb2aa2723c0962c0824fe2ca9f30e300a", + "sha256_in_prefix": "14aeb10db966bfd4ec923a19eb96892eb2aa2723c0962c0824fe2ca9f30e300a", + "size_in_bytes": 3380 + }, + { + "_path": "lib/python3.12/turtledemo/planet_and_moon.py", + "path_type": "hardlink", + "sha256": "cd2c5344b67dbe781cf4c7f0f1eb1b97e6d8a5bf50329bdaa4e42e7d390ea609", + "sha256_in_prefix": "cd2c5344b67dbe781cf4c7f0f1eb1b97e6d8a5bf50329bdaa4e42e7d390ea609", + "size_in_bytes": 2825 + }, + { + "_path": "lib/python3.12/turtledemo/rosette.py", + "path_type": "hardlink", + "sha256": "61dfd5bb932cc5a0c3bb9caa8ed74889a19a8d3ee3cb6707ea8f63595ec350b0", + "sha256_in_prefix": "61dfd5bb932cc5a0c3bb9caa8ed74889a19a8d3ee3cb6707ea8f63595ec350b0", + "size_in_bytes": 1361 + }, + { + "_path": "lib/python3.12/turtledemo/round_dance.py", + "path_type": "hardlink", + "sha256": "4ecaac02e68f11ec1a406a6ce8a4b17e4f8af74f76157e0776360d0dd041f276", + "sha256_in_prefix": "4ecaac02e68f11ec1a406a6ce8a4b17e4f8af74f76157e0776360d0dd041f276", + "size_in_bytes": 1804 + }, + { + "_path": "lib/python3.12/turtledemo/sorting_animate.py", + "path_type": "hardlink", + "sha256": "a82a7608d3620cd8a956d3335bddbc2e30320486645de5d2ec26f481b0a74254", + "sha256_in_prefix": "a82a7608d3620cd8a956d3335bddbc2e30320486645de5d2ec26f481b0a74254", + "size_in_bytes": 5052 + }, + { + "_path": "lib/python3.12/turtledemo/tree.py", + "path_type": "hardlink", + "sha256": "3318448046c83c176f95a97c33b5cd82e0076bee038d72810bef3dac1085e590", + "sha256_in_prefix": "3318448046c83c176f95a97c33b5cd82e0076bee038d72810bef3dac1085e590", + "size_in_bytes": 1401 + }, + { + "_path": "lib/python3.12/turtledemo/turtle.cfg", + "path_type": "hardlink", + "sha256": "de66698dc4f083792df6aaed1e5d94e879852d72f1f24ac09c8fb4cd144c6c88", + "sha256_in_prefix": "de66698dc4f083792df6aaed1e5d94e879852d72f1f24ac09c8fb4cd144c6c88", + "size_in_bytes": 160 + }, + { + "_path": "lib/python3.12/turtledemo/two_canvases.py", + "path_type": "hardlink", + "sha256": "3300593114fb9286af9360cc9d871a40e5dcbea4aedc24b832607d1dd71c7b96", + "sha256_in_prefix": "3300593114fb9286af9360cc9d871a40e5dcbea4aedc24b832607d1dd71c7b96", + "size_in_bytes": 1119 + }, + { + "_path": "lib/python3.12/turtledemo/yinyang.py", + "path_type": "hardlink", + "sha256": "0737a80b939aafcf3d8a1bf60b63e781979c749337d02b6c216680893f9fffc5", + "sha256_in_prefix": "0737a80b939aafcf3d8a1bf60b63e781979c749337d02b6c216680893f9fffc5", + "size_in_bytes": 821 + }, + { + "_path": "lib/python3.12/types.py", + "path_type": "hardlink", + "sha256": "345474ef027a1273f353da9bdc1f7c18f65335e72e681bcc0376774cc51f2405", + "sha256_in_prefix": "345474ef027a1273f353da9bdc1f7c18f65335e72e681bcc0376774cc51f2405", + "size_in_bytes": 10993 + }, + { + "_path": "lib/python3.12/typing.py", + "path_type": "hardlink", + "sha256": "a92b15962dc0e9a49cd0563b0b0b5861bd58278cdde6295e63ce02ae7fabd97d", + "sha256_in_prefix": "a92b15962dc0e9a49cd0563b0b0b5861bd58278cdde6295e63ce02ae7fabd97d", + "size_in_bytes": 116414 + }, + { + "_path": "lib/python3.12/unittest/__init__.py", + "path_type": "hardlink", + "sha256": "32ed48385c0377bc2900a76e9a6acc3705aeef402c72de8554b3c637420506f0", + "sha256_in_prefix": "32ed48385c0377bc2900a76e9a6acc3705aeef402c72de8554b3c637420506f0", + "size_in_bytes": 3487 + }, + { + "_path": "lib/python3.12/unittest/__main__.py", + "path_type": "hardlink", + "sha256": "ff6b9a100d32001715b40d61bc4d613623b139edb1fdc3566427b83c331caae3", + "sha256_in_prefix": "ff6b9a100d32001715b40d61bc4d613623b139edb1fdc3566427b83c331caae3", + "size_in_bytes": 472 + }, + { + "_path": "lib/python3.12/unittest/__pycache__/__init__.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "f1eae42f4fa78034d788b0a2f472d68b8c187a2de5bca7aa16bcad2a360081ed", + "sha256_in_prefix": "f1eae42f4fa78034d788b0a2f472d68b8c187a2de5bca7aa16bcad2a360081ed", + "size_in_bytes": 3686 + }, + { + "_path": "lib/python3.12/unittest/__pycache__/__main__.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "c94e7e7d31f689bb4c8eb875ff9fc9cb1c6a73af94f3f510a60398a45999c53e", + "sha256_in_prefix": "c94e7e7d31f689bb4c8eb875ff9fc9cb1c6a73af94f3f510a60398a45999c53e", + "size_in_bytes": 870 + }, + { + "_path": "lib/python3.12/unittest/__pycache__/_log.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "10abd1c4acf8da5f3c99adf7f0fcb1072737a22dae90ee59226246a12edd374b", + "sha256_in_prefix": "10abd1c4acf8da5f3c99adf7f0fcb1072737a22dae90ee59226246a12edd374b", + "size_in_bytes": 4930 + }, + { + "_path": "lib/python3.12/unittest/__pycache__/async_case.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "1c06b1fe7bf1be21505afef5dffc640e54de2281e21da54e8a5342c885e4bbf3", + "sha256_in_prefix": "1c06b1fe7bf1be21505afef5dffc640e54de2281e21da54e8a5342c885e4bbf3", + "size_in_bytes": 6615 + }, + { + "_path": "lib/python3.12/unittest/__pycache__/case.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "d6e3f540c4a4f26259ddb2a7f06823610d077f3ec4663e935db12c19c81c90c3", + "sha256_in_prefix": "d6e3f540c4a4f26259ddb2a7f06823610d077f3ec4663e935db12c19c81c90c3", + "size_in_bytes": 70080 + }, + { + "_path": "lib/python3.12/unittest/__pycache__/loader.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "2248ec21c5d7b0032a284dd7f9e9e76d3ba527f98c1fb59cc3c1ef2750ecc0bd", + "sha256_in_prefix": "2248ec21c5d7b0032a284dd7f9e9e76d3ba527f98c1fb59cc3c1ef2750ecc0bd", + "size_in_bytes": 24193 + }, + { + "_path": "lib/python3.12/unittest/__pycache__/main.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "4a7b723ec76330da892c510a25763800c1b91422fe211b8f34704f06097eebf7", + "sha256_in_prefix": "4a7b723ec76330da892c510a25763800c1b91422fe211b8f34704f06097eebf7", + "size_in_bytes": 13819 + }, + { + "_path": "lib/python3.12/unittest/__pycache__/mock.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "3f1600b17dce2a31ff39cc686f7f0df65f5cec92c0157b522bcf5e03de87919c", + "sha256_in_prefix": "3f1600b17dce2a31ff39cc686f7f0df65f5cec92c0157b522bcf5e03de87919c", + "size_in_bytes": 117537 + }, + { + "_path": "lib/python3.12/unittest/__pycache__/result.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "2e6d00c04a82a84bc669e6f830782f6415f04a29c8edf5131f7893bcfaa0ccec", + "sha256_in_prefix": "2e6d00c04a82a84bc669e6f830782f6415f04a29c8edf5131f7893bcfaa0ccec", + "size_in_bytes": 12997 + }, + { + "_path": "lib/python3.12/unittest/__pycache__/runner.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "76a5a77a1d206b126d969a75ffe3fe13ad6299c0ac561a5e383fe09ce381feb6", + "sha256_in_prefix": "76a5a77a1d206b126d969a75ffe3fe13ad6299c0ac561a5e383fe09ce381feb6", + "size_in_bytes": 16741 + }, + { + "_path": "lib/python3.12/unittest/__pycache__/signals.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "0ab8ccfd23c12061b82333d519118fd46d704a0f04f06c3a96ce0d4817ad88e4", + "sha256_in_prefix": "0ab8ccfd23c12061b82333d519118fd46d704a0f04f06c3a96ce0d4817ad88e4", + "size_in_bytes": 3867 + }, + { + "_path": "lib/python3.12/unittest/__pycache__/suite.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "9e1f8b2b286b398a3e17b58b9b2d55e522fde0cec8a4fd6ab9dad05e660834c1", + "sha256_in_prefix": "9e1f8b2b286b398a3e17b58b9b2d55e522fde0cec8a4fd6ab9dad05e660834c1", + "size_in_bytes": 15716 + }, + { + "_path": "lib/python3.12/unittest/__pycache__/util.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "511a039d513ceafb5e58a4c39617944f9031cc5101c64a2e1bf63b9a1ad784ba", + "sha256_in_prefix": "511a039d513ceafb5e58a4c39617944f9031cc5101c64a2e1bf63b9a1ad784ba", + "size_in_bytes": 7537 + }, + { + "_path": "lib/python3.12/unittest/_log.py", + "path_type": "hardlink", + "sha256": "905672317ab26c656c600defce25d477728068f597f00a7f94e22e8128c323b9", + "sha256_in_prefix": "905672317ab26c656c600defce25d477728068f597f00a7f94e22e8128c323b9", + "size_in_bytes": 2746 + }, + { + "_path": "lib/python3.12/unittest/async_case.py", + "path_type": "hardlink", + "sha256": "b389b976f622c28223105998bf0be011f2b8c48eb33d2f1133e41e562867ee31", + "sha256_in_prefix": "b389b976f622c28223105998bf0be011f2b8c48eb33d2f1133e41e562867ee31", + "size_in_bytes": 5465 + }, + { + "_path": "lib/python3.12/unittest/case.py", + "path_type": "hardlink", + "sha256": "45bac6d80a4fc3a0dea8340a80681e30b263f017b4a5002cb8f489a632e0f987", + "sha256_in_prefix": "45bac6d80a4fc3a0dea8340a80681e30b263f017b4a5002cb8f489a632e0f987", + "size_in_bytes": 57531 + }, + { + "_path": "lib/python3.12/unittest/loader.py", + "path_type": "hardlink", + "sha256": "b7d18839241a4339d4913e73867c639e2a7dd20345f53c9fb30be5c639b20513", + "sha256_in_prefix": "b7d18839241a4339d4913e73867c639e2a7dd20345f53c9fb30be5c639b20513", + "size_in_bytes": 21010 + }, + { + "_path": "lib/python3.12/unittest/main.py", + "path_type": "hardlink", + "sha256": "db58280574389c0d6cba9559cc51e1787f5b418c4e85d354aa55ca43335c487a", + "sha256_in_prefix": "db58280574389c0d6cba9559cc51e1787f5b418c4e85d354aa55ca43335c487a", + "size_in_bytes": 11991 + }, + { + "_path": "lib/python3.12/unittest/mock.py", + "path_type": "hardlink", + "sha256": "c596af2675784e6a81203b89fbbcdad6a6476d643c7bc67d37c76ed9328ebc66", + "sha256_in_prefix": "c596af2675784e6a81203b89fbbcdad6a6476d643c7bc67d37c76ed9328ebc66", + "size_in_bytes": 104588 + }, + { + "_path": "lib/python3.12/unittest/result.py", + "path_type": "hardlink", + "sha256": "5db286bdd3821d64150377e554d7edbdd58db7bb8b950772f977e9ec1d535617", + "sha256_in_prefix": "5db286bdd3821d64150377e554d7edbdd58db7bb8b950772f977e9ec1d535617", + "size_in_bytes": 9130 + }, + { + "_path": "lib/python3.12/unittest/runner.py", + "path_type": "hardlink", + "sha256": "76d9beb9c21d0d367a1b040a921ad43f90b7971fcc8cacfccd6f9760bedf1ce2", + "sha256_in_prefix": "76d9beb9c21d0d367a1b040a921ad43f90b7971fcc8cacfccd6f9760bedf1ce2", + "size_in_bytes": 10368 + }, + { + "_path": "lib/python3.12/unittest/signals.py", + "path_type": "hardlink", + "sha256": "f8286e818ca56e10e03745bc056cdfd31147678f9a1dc8cb6b0fe96ef9a4362a", + "sha256_in_prefix": "f8286e818ca56e10e03745bc056cdfd31147678f9a1dc8cb6b0fe96ef9a4362a", + "size_in_bytes": 2403 + }, + { + "_path": "lib/python3.12/unittest/suite.py", + "path_type": "hardlink", + "sha256": "ed2da92bc9f97c53403ee2d3d12cc53b16a96e85d596ebc887b5a93458f3f6bc", + "sha256_in_prefix": "ed2da92bc9f97c53403ee2d3d12cc53b16a96e85d596ebc887b5a93458f3f6bc", + "size_in_bytes": 13512 + }, + { + "_path": "lib/python3.12/unittest/util.py", + "path_type": "hardlink", + "sha256": "fdcc640c3505d16deab9c32eae7c3f5f67c3b5e81c563dc6698fa7fcf403854d", + "sha256_in_prefix": "fdcc640c3505d16deab9c32eae7c3f5f67c3b5e81c563dc6698fa7fcf403854d", + "size_in_bytes": 5215 + }, + { + "_path": "lib/python3.12/urllib/__init__.py", + "path_type": "hardlink", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size_in_bytes": 0 + }, + { + "_path": "lib/python3.12/urllib/__pycache__/__init__.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "bf5e23d976f618ea5f366df0bddf87662cda9d0080862dffe9f287a2b4b88835", + "sha256_in_prefix": "bf5e23d976f618ea5f366df0bddf87662cda9d0080862dffe9f287a2b4b88835", + "size_in_bytes": 389 + }, + { + "_path": "lib/python3.12/urllib/__pycache__/error.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "ccf38ed885481184538c8b1900631d0646e634e24cd97255fbf8174b4ce7873f", + "sha256_in_prefix": "ccf38ed885481184538c8b1900631d0646e634e24cd97255fbf8174b4ce7873f", + "size_in_bytes": 3902 + }, + { + "_path": "lib/python3.12/urllib/__pycache__/parse.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "430fa4906f5d6e6e6d81d45ada21bd422af35f5b3cb11ccaedafea3d246a1e23", + "sha256_in_prefix": "430fa4906f5d6e6e6d81d45ada21bd422af35f5b3cb11ccaedafea3d246a1e23", + "size_in_bytes": 50108 + }, + { + "_path": "lib/python3.12/urllib/__pycache__/request.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "f98b7d9f463e11ee958774e6473572f4c8c5497c44971af4219d7fd08368e287", + "sha256_in_prefix": "f98b7d9f463e11ee958774e6473572f4c8c5497c44971af4219d7fd08368e287", + "size_in_bytes": 115595 + }, + { + "_path": "lib/python3.12/urllib/__pycache__/response.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "dbd31c4705a75e0598b144d00cdf971f3caa54b0b192651d67a7644bf1b55c69", + "sha256_in_prefix": "dbd31c4705a75e0598b144d00cdf971f3caa54b0b192651d67a7644bf1b55c69", + "size_in_bytes": 4668 + }, + { + "_path": "lib/python3.12/urllib/__pycache__/robotparser.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "84eee4eede237bfca71d98e1324af04955d69d83577efad810e2b21b8a04fb83", + "sha256_in_prefix": "84eee4eede237bfca71d98e1324af04955d69d83577efad810e2b21b8a04fb83", + "size_in_bytes": 12550 + }, + { + "_path": "lib/python3.12/urllib/error.py", + "path_type": "hardlink", + "sha256": "d12b3cc66af3f42a8ebe63e1c91d24f92c6237b6a93a3702938dffabd812d77b", + "sha256_in_prefix": "d12b3cc66af3f42a8ebe63e1c91d24f92c6237b6a93a3702938dffabd812d77b", + "size_in_bytes": 2415 + }, + { + "_path": "lib/python3.12/urllib/parse.py", + "path_type": "hardlink", + "sha256": "2582309acd08b572a7b80b22c2d976cdc42be417503a12afce2d129498456ae8", + "sha256_in_prefix": "2582309acd08b572a7b80b22c2d976cdc42be417503a12afce2d129498456ae8", + "size_in_bytes": 44829 + }, + { + "_path": "lib/python3.12/urllib/request.py", + "path_type": "hardlink", + "sha256": "bd66422e67f305ec9ada71090293ec8bf9a94f9a0a74ace0613e9400c712e726", + "sha256_in_prefix": "bd66422e67f305ec9ada71090293ec8bf9a94f9a0a74ace0613e9400c712e726", + "size_in_bytes": 103157 + }, + { + "_path": "lib/python3.12/urllib/response.py", + "path_type": "hardlink", + "sha256": "7e6c3b6d7a95f0d74f5968f51a87adae8a51bf42390cdfec98c7a99203e7bb76", + "sha256_in_prefix": "7e6c3b6d7a95f0d74f5968f51a87adae8a51bf42390cdfec98c7a99203e7bb76", + "size_in_bytes": 2361 + }, + { + "_path": "lib/python3.12/urllib/robotparser.py", + "path_type": "hardlink", + "sha256": "389b811835f9a3ba72b192c3487b0266fa31f6e571b7a83ceb2a34792dc0d9fc", + "sha256_in_prefix": "389b811835f9a3ba72b192c3487b0266fa31f6e571b7a83ceb2a34792dc0d9fc", + "size_in_bytes": 9424 + }, + { + "_path": "lib/python3.12/uu.py", + "path_type": "hardlink", + "sha256": "dd1f5be33fb25a1b0832891ea07db4a4a2ae41b466e37e24e204604fdc6d18cf", + "sha256_in_prefix": "dd1f5be33fb25a1b0832891ea07db4a4a2ae41b466e37e24e204604fdc6d18cf", + "size_in_bytes": 7365 + }, + { + "_path": "lib/python3.12/uuid.py", + "path_type": "hardlink", + "sha256": "fe357bff7241e9fd6f86ee81567fd20aeec2e17460428ea9b7924bebf57301fc", + "sha256_in_prefix": "fe357bff7241e9fd6f86ee81567fd20aeec2e17460428ea9b7924bebf57301fc", + "size_in_bytes": 29656 + }, + { + "_path": "lib/python3.12/venv/__init__.py", + "path_type": "hardlink", + "sha256": "ce2e0f80e0b3fa49715e4263d95193dc2371a58c75bdc0f82b7d461bd7dc803b", + "sha256_in_prefix": "ce2e0f80e0b3fa49715e4263d95193dc2371a58c75bdc0f82b7d461bd7dc803b", + "size_in_bytes": 24618 + }, + { + "_path": "lib/python3.12/venv/__main__.py", + "path_type": "hardlink", + "sha256": "722537c68c0622f8293d39bb6ab1288f3637d8dc45d6f9aae96e49af8145ca36", + "sha256_in_prefix": "722537c68c0622f8293d39bb6ab1288f3637d8dc45d6f9aae96e49af8145ca36", + "size_in_bytes": 145 + }, + { + "_path": "lib/python3.12/venv/__pycache__/__init__.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "0a599d7bff07f525b8992a4e2200a0b3d793505a204988b57e4ec19aca374d68", + "sha256_in_prefix": "0a599d7bff07f525b8992a4e2200a0b3d793505a204988b57e4ec19aca374d68", + "size_in_bytes": 29167 + }, + { + "_path": "lib/python3.12/venv/__pycache__/__main__.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "7fc007b421193ea0fa0bed97012d240dcaa07529483201149423c187a56fd572", + "sha256_in_prefix": "7fc007b421193ea0fa0bed97012d240dcaa07529483201149423c187a56fd572", + "size_in_bytes": 734 + }, + { + "_path": "lib/python3.12/venv/scripts/common/Activate.ps1", + "path_type": "hardlink", + "sha256": "3795a060dea7d621320d6d841deb37591fadf7f5592c5cb2286f9867af0e91df", + "sha256_in_prefix": "3795a060dea7d621320d6d841deb37591fadf7f5592c5cb2286f9867af0e91df", + "size_in_bytes": 9033 + }, + { + "_path": "lib/python3.12/venv/scripts/common/activate", + "path_type": "hardlink", + "sha256": "76b3d2a782a6b9871ba5b0fe6096a7e315b06c9095be1618ebf5087e9ba1f73b", + "sha256_in_prefix": "76b3d2a782a6b9871ba5b0fe6096a7e315b06c9095be1618ebf5087e9ba1f73b", + "size_in_bytes": 2042 + }, + { + "_path": "lib/python3.12/venv/scripts/posix/activate.csh", + "path_type": "hardlink", + "sha256": "cdd8a01bb9c221836bfa4470d52c9fb5acbce2de6454df71efdae3adc342441e", + "sha256_in_prefix": "cdd8a01bb9c221836bfa4470d52c9fb5acbce2de6454df71efdae3adc342441e", + "size_in_bytes": 936 + }, + { + "_path": "lib/python3.12/venv/scripts/posix/activate.fish", + "path_type": "hardlink", + "sha256": "a100a3f99289828886d7a4bfab657751aea2b4313ffcb5b95bc643d63469448d", + "sha256_in_prefix": "a100a3f99289828886d7a4bfab657751aea2b4313ffcb5b95bc643d63469448d", + "size_in_bytes": 2215 + }, + { + "_path": "lib/python3.12/warnings.py", + "path_type": "hardlink", + "sha256": "8eb1bb88d0beb82ebecfe7ee5cf54ed9b77b4a7acee1989e392a65de42017c49", + "sha256_in_prefix": "8eb1bb88d0beb82ebecfe7ee5cf54ed9b77b4a7acee1989e392a65de42017c49", + "size_in_bytes": 21760 + }, + { + "_path": "lib/python3.12/wave.py", + "path_type": "hardlink", + "sha256": "0330428ea9e45fee49acc4ae5bdca4c235f4236c51dab09f30442ccafa25c1f8", + "sha256_in_prefix": "0330428ea9e45fee49acc4ae5bdca4c235f4236c51dab09f30442ccafa25c1f8", + "size_in_bytes": 22769 + }, + { + "_path": "lib/python3.12/weakref.py", + "path_type": "hardlink", + "sha256": "56f8d313fb74019e53eb9287400702fbce788b7fe30e097b0b6e06296f3f080c", + "sha256_in_prefix": "56f8d313fb74019e53eb9287400702fbce788b7fe30e097b0b6e06296f3f080c", + "size_in_bytes": 21513 + }, + { + "_path": "lib/python3.12/webbrowser.py", + "path_type": "hardlink", + "sha256": "f83a36818ef51b0e2efbc3937187dc5f24062908a0e18c8ceb228139dad98348", + "sha256_in_prefix": "f83a36818ef51b0e2efbc3937187dc5f24062908a0e18c8ceb228139dad98348", + "size_in_bytes": 23628 + }, + { + "_path": "lib/python3.12/wsgiref/__init__.py", + "path_type": "hardlink", + "sha256": "c30e144025a63d267778d92f2f066fa592b476e789d888f79b96c059bf0bef60", + "sha256_in_prefix": "c30e144025a63d267778d92f2f066fa592b476e789d888f79b96c059bf0bef60", + "size_in_bytes": 657 + }, + { + "_path": "lib/python3.12/wsgiref/__pycache__/__init__.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "b4339637466bfd2fce5f9ca555afe2999705490eeeddd37d39189f42c3b8d3c6", + "sha256_in_prefix": "b4339637466bfd2fce5f9ca555afe2999705490eeeddd37d39189f42c3b8d3c6", + "size_in_bytes": 1060 + }, + { + "_path": "lib/python3.12/wsgiref/__pycache__/handlers.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "7074c4c31fc9595b9134c1e0ce476405ac28cdcc95a8cfdda00b5af960153b32", + "sha256_in_prefix": "7074c4c31fc9595b9134c1e0ce476405ac28cdcc95a8cfdda00b5af960153b32", + "size_in_bytes": 23854 + }, + { + "_path": "lib/python3.12/wsgiref/__pycache__/headers.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "7fc5975f46179dea66c7379024906b667b22b634b3c78812de75f0e24c38222b", + "sha256_in_prefix": "7fc5975f46179dea66c7379024906b667b22b634b3c78812de75f0e24c38222b", + "size_in_bytes": 9872 + }, + { + "_path": "lib/python3.12/wsgiref/__pycache__/simple_server.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "0a13dc801cee6a5f745c356f5f8cbe07f56f526af244440a8d4839bd06589600", + "sha256_in_prefix": "0a13dc801cee6a5f745c356f5f8cbe07f56f526af244440a8d4839bd06589600", + "size_in_bytes": 8429 + }, + { + "_path": "lib/python3.12/wsgiref/__pycache__/types.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "a2e75ca01315a6db2e57dc84cedf800ca29517aa46d99da45cd9bf5d681c2adc", + "sha256_in_prefix": "a2e75ca01315a6db2e57dc84cedf800ca29517aa46d99da45cd9bf5d681c2adc", + "size_in_bytes": 3913 + }, + { + "_path": "lib/python3.12/wsgiref/__pycache__/util.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "3442a680ad0d6bdaf4acee116593b1b4a8318fc331dd492d1b9c1ddff9479206", + "sha256_in_prefix": "3442a680ad0d6bdaf4acee116593b1b4a8318fc331dd492d1b9c1ddff9479206", + "size_in_bytes": 7056 + }, + { + "_path": "lib/python3.12/wsgiref/__pycache__/validate.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "d75ebac38ec42b9a66382b2b5f761c66e621296928330b17a354bb8a9fde8f9c", + "sha256_in_prefix": "d75ebac38ec42b9a66382b2b5f761c66e621296928330b17a354bb8a9fde8f9c", + "size_in_bytes": 20439 + }, + { + "_path": "lib/python3.12/wsgiref/handlers.py", + "path_type": "hardlink", + "sha256": "b4ed08869ab79d7c17065993875cdc6eb1b2a0b3645b74325bc0aab44e97cfc5", + "sha256_in_prefix": "b4ed08869ab79d7c17065993875cdc6eb1b2a0b3645b74325bc0aab44e97cfc5", + "size_in_bytes": 21664 + }, + { + "_path": "lib/python3.12/wsgiref/headers.py", + "path_type": "hardlink", + "sha256": "0fbf95a47d8e4c0d831fd52312ec43076cbf503c190269876f170a5cf5585fb9", + "sha256_in_prefix": "0fbf95a47d8e4c0d831fd52312ec43076cbf503c190269876f170a5cf5585fb9", + "size_in_bytes": 6766 + }, + { + "_path": "lib/python3.12/wsgiref/simple_server.py", + "path_type": "hardlink", + "sha256": "d435cad48b5f63c0356e1ac70755e6e35eb94b02f9844b813e5762199110bc2b", + "sha256_in_prefix": "d435cad48b5f63c0356e1ac70755e6e35eb94b02f9844b813e5762199110bc2b", + "size_in_bytes": 5171 + }, + { + "_path": "lib/python3.12/wsgiref/types.py", + "path_type": "hardlink", + "sha256": "ba66d30ce511a88eba9b809616c51e12bf89c67972102e7d976b18557f7a6387", + "sha256_in_prefix": "ba66d30ce511a88eba9b809616c51e12bf89c67972102e7d976b18557f7a6387", + "size_in_bytes": 1717 + }, + { + "_path": "lib/python3.12/wsgiref/util.py", + "path_type": "hardlink", + "sha256": "93783cda348368538525f52a5e9a5a43a3de93caec26b6a030ecfb3aedf98b98", + "sha256_in_prefix": "93783cda348368538525f52a5e9a5a43a3de93caec26b6a030ecfb3aedf98b98", + "size_in_bytes": 5472 + }, + { + "_path": "lib/python3.12/wsgiref/validate.py", + "path_type": "hardlink", + "sha256": "4132f87dcf11a332f6ec5b051e68e59ff493dd6fdcc4f716ea72373734977a0a", + "sha256_in_prefix": "4132f87dcf11a332f6ec5b051e68e59ff493dd6fdcc4f716ea72373734977a0a", + "size_in_bytes": 15036 + }, + { + "_path": "lib/python3.12/xdrlib.py", + "path_type": "hardlink", + "sha256": "983c5e8e3090bdbeb94bf4faf841c1f8c916bcbca423863f6870a142d16a4fb8", + "sha256_in_prefix": "983c5e8e3090bdbeb94bf4faf841c1f8c916bcbca423863f6870a142d16a4fb8", + "size_in_bytes": 5942 + }, + { + "_path": "lib/python3.12/xml/__init__.py", + "path_type": "hardlink", + "sha256": "34296f728e7fe68cccb97a9f6edbf3bf3a686f44044c744fe85f207a92ed4811", + "sha256_in_prefix": "34296f728e7fe68cccb97a9f6edbf3bf3a686f44044c744fe85f207a92ed4811", + "size_in_bytes": 557 + }, + { + "_path": "lib/python3.12/xml/__pycache__/__init__.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "cade69a6c61bfb28a5fcd4e0cc47053059767a98bce60c0fc3b27f8ac62095f4", + "sha256_in_prefix": "cade69a6c61bfb28a5fcd4e0cc47053059767a98bce60c0fc3b27f8ac62095f4", + "size_in_bytes": 961 + }, + { + "_path": "lib/python3.12/xml/dom/NodeFilter.py", + "path_type": "hardlink", + "sha256": "9bfacbbb64e239a75591a7260b3ed86748eeb4366e6c40f3542753e79bace9a7", + "sha256_in_prefix": "9bfacbbb64e239a75591a7260b3ed86748eeb4366e6c40f3542753e79bace9a7", + "size_in_bytes": 936 + }, + { + "_path": "lib/python3.12/xml/dom/__init__.py", + "path_type": "hardlink", + "sha256": "b415a6f3d3663c3ac332ee4a0f4213eadad9281508dc97410e258a03633b063a", + "sha256_in_prefix": "b415a6f3d3663c3ac332ee4a0f4213eadad9281508dc97410e258a03633b063a", + "size_in_bytes": 4019 + }, + { + "_path": "lib/python3.12/xml/dom/__pycache__/NodeFilter.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "89bb16a8eae76232495138098b018115b189968f6b296089d30b55dd3b29ef69", + "sha256_in_prefix": "89bb16a8eae76232495138098b018115b189968f6b296089d30b55dd3b29ef69", + "size_in_bytes": 1316 + }, + { + "_path": "lib/python3.12/xml/dom/__pycache__/__init__.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "f5ee0ee6cd6f98b409eddf51ea20c4995062cd60b2b8daf5febc208dc7bf51a9", + "sha256_in_prefix": "f5ee0ee6cd6f98b409eddf51ea20c4995062cd60b2b8daf5febc208dc7bf51a9", + "size_in_bytes": 6446 + }, + { + "_path": "lib/python3.12/xml/dom/__pycache__/domreg.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "1479ac3dc3896da6328f192c1bf227180d629565818fa7e7083c2aa428e80bcd", + "sha256_in_prefix": "1479ac3dc3896da6328f192c1bf227180d629565818fa7e7083c2aa428e80bcd", + "size_in_bytes": 4084 + }, + { + "_path": "lib/python3.12/xml/dom/__pycache__/expatbuilder.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "59a047d809b393c4299e58cbbfe4b6af03baafef0e7fd7f6dd05f80168b356da", + "sha256_in_prefix": "59a047d809b393c4299e58cbbfe4b6af03baafef0e7fd7f6dd05f80168b356da", + "size_in_bytes": 45669 + }, + { + "_path": "lib/python3.12/xml/dom/__pycache__/minicompat.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "46b2776da3d4c1c85b23cc56ac4bcb88a8aa8967115bb486f800725cba3cb79d", + "sha256_in_prefix": "46b2776da3d4c1c85b23cc56ac4bcb88a8aa8967115bb486f800725cba3cb79d", + "size_in_bytes": 3632 + }, + { + "_path": "lib/python3.12/xml/dom/__pycache__/minidom.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "bf8615db712847e93d7751ccd3a752ca2ef6b243413c433d247f3c3c9a7a9435", + "sha256_in_prefix": "bf8615db712847e93d7751ccd3a752ca2ef6b243413c433d247f3c3c9a7a9435", + "size_in_bytes": 92711 + }, + { + "_path": "lib/python3.12/xml/dom/__pycache__/pulldom.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "20b17ab58a427e1df253ea4238c42a58ce4d162eb71c9c77706bdcb17063211e", + "sha256_in_prefix": "20b17ab58a427e1df253ea4238c42a58ce4d162eb71c9c77706bdcb17063211e", + "size_in_bytes": 17713 + }, + { + "_path": "lib/python3.12/xml/dom/__pycache__/xmlbuilder.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "1460fe3f0df267867e3b7b8d3658850d87fe2cd7ac72be187efac9981297acb3", + "sha256_in_prefix": "1460fe3f0df267867e3b7b8d3658850d87fe2cd7ac72be187efac9981297acb3", + "size_in_bytes": 17259 + }, + { + "_path": "lib/python3.12/xml/dom/domreg.py", + "path_type": "hardlink", + "sha256": "826b02a803930834b96b1086cbee7db1d21c684f65dd3073706dc7bb5ba1a3e8", + "sha256_in_prefix": "826b02a803930834b96b1086cbee7db1d21c684f65dd3073706dc7bb5ba1a3e8", + "size_in_bytes": 3451 + }, + { + "_path": "lib/python3.12/xml/dom/expatbuilder.py", + "path_type": "hardlink", + "sha256": "80598dbc5970feaa36ea2b7549e3e76dd018fb80cf79e4a5e27e9e71af60c82c", + "sha256_in_prefix": "80598dbc5970feaa36ea2b7549e3e76dd018fb80cf79e4a5e27e9e71af60c82c", + "size_in_bytes": 35693 + }, + { + "_path": "lib/python3.12/xml/dom/minicompat.py", + "path_type": "hardlink", + "sha256": "42974c4c67803dfe80b016ff8aeea0d1e5c751703ab3aec5be765f4e534367be", + "sha256_in_prefix": "42974c4c67803dfe80b016ff8aeea0d1e5c751703ab3aec5be765f4e534367be", + "size_in_bytes": 3367 + }, + { + "_path": "lib/python3.12/xml/dom/minidom.py", + "path_type": "hardlink", + "sha256": "af4ee09b06efc54e7fe58032d8338c4bc8578094946d03a200740deab25d97cb", + "sha256_in_prefix": "af4ee09b06efc54e7fe58032d8338c4bc8578094946d03a200740deab25d97cb", + "size_in_bytes": 68140 + }, + { + "_path": "lib/python3.12/xml/dom/pulldom.py", + "path_type": "hardlink", + "sha256": "614b88673d496a360e6b10efe8d733c7c0826fb214470ff12f24a1e597699870", + "sha256_in_prefix": "614b88673d496a360e6b10efe8d733c7c0826fb214470ff12f24a1e597699870", + "size_in_bytes": 11637 + }, + { + "_path": "lib/python3.12/xml/dom/xmlbuilder.py", + "path_type": "hardlink", + "sha256": "d4f33a8f018755626b64557953a91c6bba21ff613da46f7558a2874aa5d08ebf", + "sha256_in_prefix": "d4f33a8f018755626b64557953a91c6bba21ff613da46f7558a2874aa5d08ebf", + "size_in_bytes": 12387 + }, + { + "_path": "lib/python3.12/xml/etree/ElementInclude.py", + "path_type": "hardlink", + "sha256": "97b513db52e9d8382d446e283583e3adf20aae86fb93d4764565ac08250399c0", + "sha256_in_prefix": "97b513db52e9d8382d446e283583e3adf20aae86fb93d4764565ac08250399c0", + "size_in_bytes": 6882 + }, + { + "_path": "lib/python3.12/xml/etree/ElementPath.py", + "path_type": "hardlink", + "sha256": "ae8a80a8b51567b4f0965481682705e70c73dd6bfa145283f630d6833f1b4975", + "sha256_in_prefix": "ae8a80a8b51567b4f0965481682705e70c73dd6bfa145283f630d6833f1b4975", + "size_in_bytes": 13997 + }, + { + "_path": "lib/python3.12/xml/etree/ElementTree.py", + "path_type": "hardlink", + "sha256": "aa0c383b6416165e0315bf5d5635e34133e65156a7c85d07edf2b411829413e3", + "sha256_in_prefix": "aa0c383b6416165e0315bf5d5635e34133e65156a7c85d07edf2b411829413e3", + "size_in_bytes": 73526 + }, + { + "_path": "lib/python3.12/xml/etree/__init__.py", + "path_type": "hardlink", + "sha256": "91950edfb196c105d93886f8af7ea3c0a79e06a6b63be3e5a4ea09804e8672a6", + "sha256_in_prefix": "91950edfb196c105d93886f8af7ea3c0a79e06a6b63be3e5a4ea09804e8672a6", + "size_in_bytes": 1605 + }, + { + "_path": "lib/python3.12/xml/etree/__pycache__/ElementInclude.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "4c1adbe58b4229072b2e81b9d1336ed895ead524a26d5b7a14c58c178b6b0e0e", + "sha256_in_prefix": "4c1adbe58b4229072b2e81b9d1336ed895ead524a26d5b7a14c58c178b6b0e0e", + "size_in_bytes": 4251 + }, + { + "_path": "lib/python3.12/xml/etree/__pycache__/ElementPath.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "7267334477d80c976ae463f0dbc0ef8df38fca5a9ed373ce7525b1786911e564", + "sha256_in_prefix": "7267334477d80c976ae463f0dbc0ef8df38fca5a9ed373ce7525b1786911e564", + "size_in_bytes": 15183 + }, + { + "_path": "lib/python3.12/xml/etree/__pycache__/ElementTree.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "539cc575de98356e18fc72a2afc048da8afa7625bda114a750b2fbb87862dab0", + "sha256_in_prefix": "539cc575de98356e18fc72a2afc048da8afa7625bda114a750b2fbb87862dab0", + "size_in_bytes": 81569 + }, + { + "_path": "lib/python3.12/xml/etree/__pycache__/__init__.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "8aae37fb35370aff3bd6dca199e5469e2a82aade3e659b7ad478f0f54aae161c", + "sha256_in_prefix": "8aae37fb35370aff3bd6dca199e5469e2a82aade3e659b7ad478f0f54aae161c", + "size_in_bytes": 392 + }, + { + "_path": "lib/python3.12/xml/etree/__pycache__/cElementTree.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "857d7c423396ae23b59ef7273155a45f2e33c28ca089b5d3727b2f4448c3db5f", + "sha256_in_prefix": "857d7c423396ae23b59ef7273155a45f2e33c28ca089b5d3727b2f4448c3db5f", + "size_in_bytes": 441 + }, + { + "_path": "lib/python3.12/xml/etree/cElementTree.py", + "path_type": "hardlink", + "sha256": "d0f57acab07fe4f9c116c3392d85946bac8e78608f409cea70005f16ea019b57", + "sha256_in_prefix": "d0f57acab07fe4f9c116c3392d85946bac8e78608f409cea70005f16ea019b57", + "size_in_bytes": 82 + }, + { + "_path": "lib/python3.12/xml/parsers/__init__.py", + "path_type": "hardlink", + "sha256": "b88497adc30d5d5eda7789c25a2206ee9270c932d584d7ac42680325651da45c", + "sha256_in_prefix": "b88497adc30d5d5eda7789c25a2206ee9270c932d584d7ac42680325651da45c", + "size_in_bytes": 167 + }, + { + "_path": "lib/python3.12/xml/parsers/__pycache__/__init__.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "894e5ade3ee88f1bb88aae36adff43c5d3e052777f377cdda674c4c273e5d630", + "sha256_in_prefix": "894e5ade3ee88f1bb88aae36adff43c5d3e052777f377cdda674c4c273e5d630", + "size_in_bytes": 571 + }, + { + "_path": "lib/python3.12/xml/parsers/__pycache__/expat.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "fe7bfe47488b4b106f886843e3eba4b99a56a8c2d702ea7d46d2b7ecc77a7860", + "sha256_in_prefix": "fe7bfe47488b4b106f886843e3eba4b99a56a8c2d702ea7d46d2b7ecc77a7860", + "size_in_bytes": 670 + }, + { + "_path": "lib/python3.12/xml/parsers/expat.py", + "path_type": "hardlink", + "sha256": "64e1947747c2874117a7458bba1f07c86620cc0ed9a4a4116d262878e4a2aa09", + "sha256_in_prefix": "64e1947747c2874117a7458bba1f07c86620cc0ed9a4a4116d262878e4a2aa09", + "size_in_bytes": 248 + }, + { + "_path": "lib/python3.12/xml/sax/__init__.py", + "path_type": "hardlink", + "sha256": "2f949d27b9eda6284482b43f4c202830fb35ea94f4101d70452119d3210bdbe0", + "sha256_in_prefix": "2f949d27b9eda6284482b43f4c202830fb35ea94f4101d70452119d3210bdbe0", + "size_in_bytes": 3238 + }, + { + "_path": "lib/python3.12/xml/sax/__pycache__/__init__.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "be3c0fc7eb10437ea69cab21bf7153c5aae21f8d0907bb5b01605d86bccade9f", + "sha256_in_prefix": "be3c0fc7eb10437ea69cab21bf7153c5aae21f8d0907bb5b01605d86bccade9f", + "size_in_bytes": 4044 + }, + { + "_path": "lib/python3.12/xml/sax/__pycache__/_exceptions.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "fd1322ca3fa5d749fa8cddde1391411111eace81069d1c70320b1f1f40d2f452", + "sha256_in_prefix": "fd1322ca3fa5d749fa8cddde1391411111eace81069d1c70320b1f1f40d2f452", + "size_in_bytes": 6471 + }, + { + "_path": "lib/python3.12/xml/sax/__pycache__/expatreader.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "2537a2592f1c943b4c52d7556887ddebaa58f692f23a011a52edab4dff7a154f", + "sha256_in_prefix": "2537a2592f1c943b4c52d7556887ddebaa58f692f23a011a52edab4dff7a154f", + "size_in_bytes": 20855 + }, + { + "_path": "lib/python3.12/xml/sax/__pycache__/handler.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "33288a712fa6fd95b1def655300267109eed8397c7ee606178ee70275b4ddd7c", + "sha256_in_prefix": "33288a712fa6fd95b1def655300267109eed8397c7ee606178ee70275b4ddd7c", + "size_in_bytes": 15143 + }, + { + "_path": "lib/python3.12/xml/sax/__pycache__/saxutils.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "03a8d83b719902a3ebfe8305566fbcca77cd1ef4a14edbe4663f5f8e9d2e075f", + "sha256_in_prefix": "03a8d83b719902a3ebfe8305566fbcca77cd1ef4a14edbe4663f5f8e9d2e075f", + "size_in_bytes": 19863 + }, + { + "_path": "lib/python3.12/xml/sax/__pycache__/xmlreader.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "5a1af017908773ebab3e29a465e63a5c501e73f2f391c12bf4b89188c905b884", + "sha256_in_prefix": "5a1af017908773ebab3e29a465e63a5c501e73f2f391c12bf4b89188c905b884", + "size_in_bytes": 19809 + }, + { + "_path": "lib/python3.12/xml/sax/_exceptions.py", + "path_type": "hardlink", + "sha256": "26564d5742496196d17a4a0ee135d28f652ec81742cf2fa4bff83e64323578ac", + "sha256_in_prefix": "26564d5742496196d17a4a0ee135d28f652ec81742cf2fa4bff83e64323578ac", + "size_in_bytes": 4699 + }, + { + "_path": "lib/python3.12/xml/sax/expatreader.py", + "path_type": "hardlink", + "sha256": "d45486127c4f81f381f68777965fb94e4adb0a886350039875f2c389c6e88c25", + "sha256_in_prefix": "d45486127c4f81f381f68777965fb94e4adb0a886350039875f2c389c6e88c25", + "size_in_bytes": 15550 + }, + { + "_path": "lib/python3.12/xml/sax/handler.py", + "path_type": "hardlink", + "sha256": "64c7aae49f1dd382a7b9012610307bfa1d43a14a5dc09a5c8da30903f6805c3d", + "sha256_in_prefix": "64c7aae49f1dd382a7b9012610307bfa1d43a14a5dc09a5c8da30903f6805c3d", + "size_in_bytes": 15617 + }, + { + "_path": "lib/python3.12/xml/sax/saxutils.py", + "path_type": "hardlink", + "sha256": "3fe2cdb6386e0c4d42d37c657bbecb78b69c57aedb1610dbd8bf4043944130ab", + "sha256_in_prefix": "3fe2cdb6386e0c4d42d37c657bbecb78b69c57aedb1610dbd8bf4043944130ab", + "size_in_bytes": 12255 + }, + { + "_path": "lib/python3.12/xml/sax/xmlreader.py", + "path_type": "hardlink", + "sha256": "0962c8d64ac8b03148d4ae62a531f544c4fd1be2116c6f4a53b480cff463dbba", + "sha256_in_prefix": "0962c8d64ac8b03148d4ae62a531f544c4fd1be2116c6f4a53b480cff463dbba", + "size_in_bytes": 12624 + }, + { + "_path": "lib/python3.12/xmlrpc/__init__.py", + "path_type": "hardlink", + "sha256": "87ad5c8954dd56fbbca04517bf87477ff4dce575170c7dd1281d7ef1f4214ac8", + "sha256_in_prefix": "87ad5c8954dd56fbbca04517bf87477ff4dce575170c7dd1281d7ef1f4214ac8", + "size_in_bytes": 38 + }, + { + "_path": "lib/python3.12/xmlrpc/__pycache__/__init__.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "417b8e833ff919402591e20c7cf99033d3cbe9df84b18ffb68c649971ae16ec7", + "sha256_in_prefix": "417b8e833ff919402591e20c7cf99033d3cbe9df84b18ffb68c649971ae16ec7", + "size_in_bytes": 389 + }, + { + "_path": "lib/python3.12/xmlrpc/__pycache__/client.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "3f8361ec22013c156a64c88fb6fb544797b4b817b0436295307ff3b5b12fc814", + "sha256_in_prefix": "3f8361ec22013c156a64c88fb6fb544797b4b817b0436295307ff3b5b12fc814", + "size_in_bytes": 51838 + }, + { + "_path": "lib/python3.12/xmlrpc/__pycache__/server.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "1282ba8024536abead2c0dde268f6ab59784bd1515acd7c63491eae615a4e3ba", + "sha256_in_prefix": "1282ba8024536abead2c0dde268f6ab59784bd1515acd7c63491eae615a4e3ba", + "size_in_bytes": 43058 + }, + { + "_path": "lib/python3.12/xmlrpc/client.py", + "path_type": "hardlink", + "sha256": "c77e7072ab9aaab6c6f16f89f2e7d528183b816df5d9f80e490f773ab45fe238", + "sha256_in_prefix": "c77e7072ab9aaab6c6f16f89f2e7d528183b816df5d9f80e490f773ab45fe238", + "size_in_bytes": 49331 + }, + { + "_path": "lib/python3.12/xmlrpc/server.py", + "path_type": "hardlink", + "sha256": "6781c25a6224b8bafe13050d26456c8a8b480c96e7974bcf60d4deb0c4ad454c", + "sha256_in_prefix": "6781c25a6224b8bafe13050d26456c8a8b480c96e7974bcf60d4deb0c4ad454c", + "size_in_bytes": 36822 + }, + { + "_path": "lib/python3.12/zipapp.py", + "path_type": "hardlink", + "sha256": "56e098b62cef6c39944bb898326dd920b70be461fe644139e2b699977d2997a1", + "sha256_in_prefix": "56e098b62cef6c39944bb898326dd920b70be461fe644139e2b699977d2997a1", + "size_in_bytes": 7543 + }, + { + "_path": "lib/python3.12/zipfile/__init__.py", + "path_type": "hardlink", + "sha256": "d670588a44cb0af08f6727cc381efdf05126c2e264549700ebbac7f9b54dd936", + "sha256_in_prefix": "d670588a44cb0af08f6727cc381efdf05126c2e264549700ebbac7f9b54dd936", + "size_in_bytes": 87082 + }, + { + "_path": "lib/python3.12/zipfile/__main__.py", + "path_type": "hardlink", + "sha256": "e418cdbb27adf0063e3cec28179ac6b7bdb6ac743bb49d157f450551fcf38be2", + "sha256_in_prefix": "e418cdbb27adf0063e3cec28179ac6b7bdb6ac743bb49d157f450551fcf38be2", + "size_in_bytes": 58 + }, + { + "_path": "lib/python3.12/zipfile/__pycache__/__init__.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "586422c62b8bf01dbf3f09e652d04da4f7a74ff6bac0551047e307015979406a", + "sha256_in_prefix": "586422c62b8bf01dbf3f09e652d04da4f7a74ff6bac0551047e307015979406a", + "size_in_bytes": 99172 + }, + { + "_path": "lib/python3.12/zipfile/__pycache__/__main__.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "d29d4f271daab5eb07473cab2ddb9dce2810cfcfe6e06ba272fddd18166ed6e1", + "sha256_in_prefix": "d29d4f271daab5eb07473cab2ddb9dce2810cfcfe6e06ba272fddd18166ed6e1", + "size_in_bytes": 486 + }, + { + "_path": "lib/python3.12/zipfile/_path/__init__.py", + "path_type": "hardlink", + "sha256": "3db24a524a31bbb4ce64f23a931dc47403058bbb90e54c4869a17b1245474165", + "sha256_in_prefix": "3db24a524a31bbb4ce64f23a931dc47403058bbb90e54c4869a17b1245474165", + "size_in_bytes": 10409 + }, + { + "_path": "lib/python3.12/zipfile/_path/__pycache__/__init__.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "147a012dbf0be140062415c988503e50985d55f865090959befcc96835321cb7", + "sha256_in_prefix": "147a012dbf0be140062415c988503e50985d55f865090959befcc96835321cb7", + "size_in_bytes": 18701 + }, + { + "_path": "lib/python3.12/zipfile/_path/__pycache__/glob.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "1396647d0c27c61a98054c5f30c5d6dbc449e3faebcf99b3d3279b52f80d95cf", + "sha256_in_prefix": "1396647d0c27c61a98054c5f30c5d6dbc449e3faebcf99b3d3279b52f80d95cf", + "size_in_bytes": 1786 + }, + { + "_path": "lib/python3.12/zipfile/_path/glob.py", + "path_type": "hardlink", + "sha256": "7020d375669c257879b5b1278e7649ef51cbfe16e9aef967e5aca51cca11f893", + "sha256_in_prefix": "7020d375669c257879b5b1278e7649ef51cbfe16e9aef967e5aca51cca11f893", + "size_in_bytes": 893 + }, + { + "_path": "lib/python3.12/zipimport.py", + "path_type": "hardlink", + "sha256": "4ac94d92219c2e1c0d67ad3fff3753ec3a3756af62a36a2f696f02cd12d518f0", + "sha256_in_prefix": "4ac94d92219c2e1c0d67ad3fff3753ec3a3756af62a36a2f696f02cd12d518f0", + "size_in_bytes": 28132 + }, + { + "_path": "lib/python3.12/zoneinfo/__init__.py", + "path_type": "hardlink", + "sha256": "ac7fb403e4371d07482ef2fda81dbcf6879484e9fc41d4be42c156d7e54c68a8", + "sha256_in_prefix": "ac7fb403e4371d07482ef2fda81dbcf6879484e9fc41d4be42c156d7e54c68a8", + "size_in_bytes": 703 + }, + { + "_path": "lib/python3.12/zoneinfo/__pycache__/__init__.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "2387c37055a233c5b2986765eda38a7dfbcd5a4d7fac8e71267d49a8aa51baed", + "sha256_in_prefix": "2387c37055a233c5b2986765eda38a7dfbcd5a4d7fac8e71267d49a8aa51baed", + "size_in_bytes": 1356 + }, + { + "_path": "lib/python3.12/zoneinfo/__pycache__/_common.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "f4ccf4bcc0a81505a7cd0e31e3c0e6d67974e09b67c982efcfeb81da78be0c2e", + "sha256_in_prefix": "f4ccf4bcc0a81505a7cd0e31e3c0e6d67974e09b67c982efcfeb81da78be0c2e", + "size_in_bytes": 5575 + }, + { + "_path": "lib/python3.12/zoneinfo/__pycache__/_tzpath.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "4f48505821c83c35b76c4ddaf58dff8b88a57b73509b41ecd7270ebd345b4ad5", + "sha256_in_prefix": "4f48505821c83c35b76c4ddaf58dff8b88a57b73509b41ecd7270ebd345b4ad5", + "size_in_bytes": 7360 + }, + { + "_path": "lib/python3.12/zoneinfo/__pycache__/_zoneinfo.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "0c6d874dbd544ae03684540c4638830b4c681e7221c70337db2736e433b56fc7", + "sha256_in_prefix": "0c6d874dbd544ae03684540c4638830b4c681e7221c70337db2736e433b56fc7", + "size_in_bytes": 27004 + }, + { + "_path": "lib/python3.12/zoneinfo/_common.py", + "path_type": "hardlink", + "sha256": "67deaf0ba41aa4865e007297677207485a89b75629eea0ee5c472be8a3e83bf6", + "sha256_in_prefix": "67deaf0ba41aa4865e007297677207485a89b75629eea0ee5c472be8a3e83bf6", + "size_in_bytes": 5294 + }, + { + "_path": "lib/python3.12/zoneinfo/_tzpath.py", + "path_type": "hardlink", + "sha256": "5dc473af6f6ae35e5531cc9705a1e4923aa07e7d35f6b4c275b90c6a3c2591c4", + "sha256_in_prefix": "5dc473af6f6ae35e5531cc9705a1e4923aa07e7d35f6b4c275b90c6a3c2591c4", + "size_in_bytes": 5388 + }, + { + "_path": "lib/python3.12/zoneinfo/_zoneinfo.py", + "path_type": "hardlink", + "sha256": "ebb9b679519a23252eb90541003a2fdbb3f2d7bc36713fd70672baa575dcdcb6", + "sha256_in_prefix": "ebb9b679519a23252eb90541003a2fdbb3f2d7bc36713fd70672baa575dcdcb6", + "size_in_bytes": 24674 + }, + { + "_path": "share/man/man1/python3.1", + "path_type": "softlink", + "sha256": "a873f4b72c962d4081f47ab3f4a992d9de7ab19a367795c95fedd5603cb293a7", + "size_in_bytes": 20092 + }, + { + "_path": "share/man/man1/python3.12.1", + "path_type": "hardlink", + "sha256": "a873f4b72c962d4081f47ab3f4a992d9de7ab19a367795c95fedd5603cb293a7", + "sha256_in_prefix": "a873f4b72c962d4081f47ab3f4a992d9de7ab19a367795c95fedd5603cb293a7", + "size_in_bytes": 20092 + } + ], + "paths_version": 1 + }, + "requested_spec": "None", + "sha256": "ccd6c55a286d51d907c878ed2bfa7d1becce0fee71374a9386c5eb90d803ac72", + "size": 13085901, + "subdir": "osx-arm64", + "timestamp": 1708117361000, + "url": "https://conda.anaconda.org/conda-forge/osx-arm64/python-3.12.2-hdf0ec26_0_cpython.conda", + "version": "3.12.2" +} \ No newline at end of file diff --git a/crates/pet-conda/tests/unix/anaconda3-2023.03/envs/env_python_3/conda-meta/python-dateutil-2.8.2-pyhd8ed1ab_0.json b/crates/pet-conda/tests/unix/anaconda3-2023.03/envs/env_python_3/conda-meta/python-dateutil-2.8.2-pyhd8ed1ab_0.json new file mode 100644 index 00000000..a22f5d23 --- /dev/null +++ b/crates/pet-conda/tests/unix/anaconda3-2023.03/envs/env_python_3/conda-meta/python-dateutil-2.8.2-pyhd8ed1ab_0.json @@ -0,0 +1,350 @@ +{ + "build": "pyhd8ed1ab_0", + "build_number": 0, + "channel": "https://conda.anaconda.org/conda-forge/noarch", + "constrains": [], + "depends": [ + "python >=3.6", + "six >=1.5" + ], + "extracted_package_dir": "/Users/donjayamanne/miniconda3/pkgs/python-dateutil-2.8.2-pyhd8ed1ab_0", + "files": [ + "lib/python3.12/site-packages/dateutil/__init__.py", + "lib/python3.12/site-packages/dateutil/_common.py", + "lib/python3.12/site-packages/dateutil/_version.py", + "lib/python3.12/site-packages/dateutil/easter.py", + "lib/python3.12/site-packages/dateutil/parser/__init__.py", + "lib/python3.12/site-packages/dateutil/parser/_parser.py", + "lib/python3.12/site-packages/dateutil/parser/isoparser.py", + "lib/python3.12/site-packages/dateutil/relativedelta.py", + "lib/python3.12/site-packages/dateutil/rrule.py", + "lib/python3.12/site-packages/dateutil/tz/__init__.py", + "lib/python3.12/site-packages/dateutil/tz/_common.py", + "lib/python3.12/site-packages/dateutil/tz/_factories.py", + "lib/python3.12/site-packages/dateutil/tz/tz.py", + "lib/python3.12/site-packages/dateutil/tz/win.py", + "lib/python3.12/site-packages/dateutil/tzwin.py", + "lib/python3.12/site-packages/dateutil/utils.py", + "lib/python3.12/site-packages/dateutil/zoneinfo/__init__.py", + "lib/python3.12/site-packages/dateutil/zoneinfo/dateutil-zoneinfo.tar.gz", + "lib/python3.12/site-packages/dateutil/zoneinfo/rebuild.py", + "lib/python3.12/site-packages/python_dateutil-2.8.2.dist-info/INSTALLER", + "lib/python3.12/site-packages/python_dateutil-2.8.2.dist-info/LICENSE", + "lib/python3.12/site-packages/python_dateutil-2.8.2.dist-info/METADATA", + "lib/python3.12/site-packages/python_dateutil-2.8.2.dist-info/RECORD", + "lib/python3.12/site-packages/python_dateutil-2.8.2.dist-info/REQUESTED", + "lib/python3.12/site-packages/python_dateutil-2.8.2.dist-info/WHEEL", + "lib/python3.12/site-packages/python_dateutil-2.8.2.dist-info/direct_url.json", + "lib/python3.12/site-packages/python_dateutil-2.8.2.dist-info/top_level.txt", + "lib/python3.12/site-packages/python_dateutil-2.8.2.dist-info/zip-safe", + "lib/python3.12/site-packages/dateutil/__pycache__/__init__.cpython-312.pyc", + "lib/python3.12/site-packages/dateutil/__pycache__/_common.cpython-312.pyc", + "lib/python3.12/site-packages/dateutil/__pycache__/_version.cpython-312.pyc", + "lib/python3.12/site-packages/dateutil/__pycache__/easter.cpython-312.pyc", + "lib/python3.12/site-packages/dateutil/parser/__pycache__/__init__.cpython-312.pyc", + "lib/python3.12/site-packages/dateutil/parser/__pycache__/_parser.cpython-312.pyc", + "lib/python3.12/site-packages/dateutil/parser/__pycache__/isoparser.cpython-312.pyc", + "lib/python3.12/site-packages/dateutil/__pycache__/relativedelta.cpython-312.pyc", + "lib/python3.12/site-packages/dateutil/__pycache__/rrule.cpython-312.pyc", + "lib/python3.12/site-packages/dateutil/tz/__pycache__/__init__.cpython-312.pyc", + "lib/python3.12/site-packages/dateutil/tz/__pycache__/_common.cpython-312.pyc", + "lib/python3.12/site-packages/dateutil/tz/__pycache__/_factories.cpython-312.pyc", + "lib/python3.12/site-packages/dateutil/tz/__pycache__/tz.cpython-312.pyc", + "lib/python3.12/site-packages/dateutil/tz/__pycache__/win.cpython-312.pyc", + "lib/python3.12/site-packages/dateutil/__pycache__/tzwin.cpython-312.pyc", + "lib/python3.12/site-packages/dateutil/__pycache__/utils.cpython-312.pyc", + "lib/python3.12/site-packages/dateutil/zoneinfo/__pycache__/__init__.cpython-312.pyc", + "lib/python3.12/site-packages/dateutil/zoneinfo/__pycache__/rebuild.cpython-312.pyc" + ], + "fn": "python-dateutil-2.8.2-pyhd8ed1ab_0.tar.bz2", + "license": "Apache-2.0", + "link": { + "source": "/Users/donjayamanne/miniconda3/pkgs/python-dateutil-2.8.2-pyhd8ed1ab_0", + "type": 1 + }, + "md5": "dd999d1cc9f79e67dbb855c8924c7984", + "name": "python-dateutil", + "noarch": "python", + "package_tarball_full_path": "/Users/donjayamanne/miniconda3/pkgs/python-dateutil-2.8.2-pyhd8ed1ab_0.tar.bz2", + "package_type": "noarch_python", + "paths_data": { + "paths": [ + { + "_path": "site-packages/dateutil/__init__.py", + "path_type": "hardlink", + "sha256": "957125012ab0606c2a96b49649e5f5f49c05e417bdb4d79c0daf5e6e4fb48269", + "sha256_in_prefix": "957125012ab0606c2a96b49649e5f5f49c05e417bdb4d79c0daf5e6e4fb48269", + "size_in_bytes": 222 + }, + { + "_path": "site-packages/dateutil/_common.py", + "path_type": "hardlink", + "sha256": "efbc34cb2b64af19586d29fefa50d53d431a6d45d147d237941bffbd0454a946", + "sha256_in_prefix": "efbc34cb2b64af19586d29fefa50d53d431a6d45d147d237941bffbd0454a946", + "size_in_bytes": 932 + }, + { + "_path": "site-packages/dateutil/_version.py", + "path_type": "hardlink", + "sha256": "6b0c87bf63d8bc347ce1dc63ac7cb39a6f2789e17032372eb9284f87e40d90ce", + "sha256_in_prefix": "6b0c87bf63d8bc347ce1dc63ac7cb39a6f2789e17032372eb9284f87e40d90ce", + "size_in_bytes": 142 + }, + { + "_path": "site-packages/dateutil/easter.py", + "path_type": "hardlink", + "sha256": "772062fa52af8a61f5bbf93aa7b6742492bbd9086a56d541b2a072be910f2af7", + "sha256_in_prefix": "772062fa52af8a61f5bbf93aa7b6742492bbd9086a56d541b2a072be910f2af7", + "size_in_bytes": 2678 + }, + { + "_path": "site-packages/dateutil/parser/__init__.py", + "path_type": "hardlink", + "sha256": "c1693a185bb14e98e8820086b6091c789a2d8b8a558e5e3f7c7417a4d39a4988", + "sha256_in_prefix": "c1693a185bb14e98e8820086b6091c789a2d8b8a558e5e3f7c7417a4d39a4988", + "size_in_bytes": 1766 + }, + { + "_path": "site-packages/dateutil/parser/_parser.py", + "path_type": "hardlink", + "sha256": "ee494377289c92c401fd7825fb7500981c33098a2bd40219aa4948713e9d1fff", + "sha256_in_prefix": "ee494377289c92c401fd7825fb7500981c33098a2bd40219aa4948713e9d1fff", + "size_in_bytes": 58796 + }, + { + "_path": "site-packages/dateutil/parser/isoparser.py", + "path_type": "hardlink", + "sha256": "12d2d8ef0db61d6c7e5c9a535b1243dd736ce8b047442a6cefbb4274b9d869df", + "sha256_in_prefix": "12d2d8ef0db61d6c7e5c9a535b1243dd736ce8b047442a6cefbb4274b9d869df", + "size_in_bytes": 13247 + }, + { + "_path": "site-packages/dateutil/relativedelta.py", + "path_type": "hardlink", + "sha256": "1a3571aa90155a71baeeb75b7fba64a08949bd0aa68eef4d49f18272a6e573b5", + "sha256_in_prefix": "1a3571aa90155a71baeeb75b7fba64a08949bd0aa68eef4d49f18272a6e573b5", + "size_in_bytes": 24904 + }, + { + "_path": "site-packages/dateutil/rrule.py", + "path_type": "hardlink", + "sha256": "6fa1955783296436c1849e6a8ad40a472c7cfbf38ac9e01b939ee8af603c0185", + "sha256_in_prefix": "6fa1955783296436c1849e6a8ad40a472c7cfbf38ac9e01b939ee8af603c0185", + "size_in_bytes": 66556 + }, + { + "_path": "site-packages/dateutil/tz/__init__.py", + "path_type": "hardlink", + "sha256": "17e333d77bfa8d8b1e92541ff537bd27a9f370b0e6ab8ee03916bad4adf9fc50", + "sha256_in_prefix": "17e333d77bfa8d8b1e92541ff537bd27a9f370b0e6ab8ee03916bad4adf9fc50", + "size_in_bytes": 444 + }, + { + "_path": "site-packages/dateutil/tz/_common.py", + "path_type": "hardlink", + "sha256": "720cc34c036c397bc473ce9c605efb12c962b9269bf0fbb0a6c979f9b5f7fd2e", + "sha256_in_prefix": "720cc34c036c397bc473ce9c605efb12c962b9269bf0fbb0a6c979f9b5f7fd2e", + "size_in_bytes": 12977 + }, + { + "_path": "site-packages/dateutil/tz/_factories.py", + "path_type": "hardlink", + "sha256": "ba76fa5d0357acf32f7a4b13094f8083c8e6559b384a88e83d47001e95a7aef5", + "sha256_in_prefix": "ba76fa5d0357acf32f7a4b13094f8083c8e6559b384a88e83d47001e95a7aef5", + "size_in_bytes": 2569 + }, + { + "_path": "site-packages/dateutil/tz/tz.py", + "path_type": "hardlink", + "sha256": "268b558c3705d7a873a28b90d24656fb998262eed78faecd23e55082759aa4a1", + "sha256_in_prefix": "268b558c3705d7a873a28b90d24656fb998262eed78faecd23e55082759aa4a1", + "size_in_bytes": 62857 + }, + { + "_path": "site-packages/dateutil/tz/win.py", + "path_type": "hardlink", + "sha256": "c49b335a04b0135c4fc7f1c98f86647a9cae902fe1372d35e9631c5e16d1681f", + "sha256_in_prefix": "c49b335a04b0135c4fc7f1c98f86647a9cae902fe1372d35e9631c5e16d1681f", + "size_in_bytes": 12935 + }, + { + "_path": "site-packages/dateutil/tzwin.py", + "path_type": "hardlink", + "sha256": "ec0af8bdd4029e733498a4773148db20ab19ac155f1e0770b0965cfe619845ec", + "sha256_in_prefix": "ec0af8bdd4029e733498a4773148db20ab19ac155f1e0770b0965cfe619845ec", + "size_in_bytes": 59 + }, + { + "_path": "site-packages/dateutil/utils.py", + "path_type": "hardlink", + "sha256": "74a09c844c3c78e6e2d25a064f1f75ba70719bfed41a5537bff16314c76ac183", + "sha256_in_prefix": "74a09c844c3c78e6e2d25a064f1f75ba70719bfed41a5537bff16314c76ac183", + "size_in_bytes": 1965 + }, + { + "_path": "site-packages/dateutil/zoneinfo/__init__.py", + "path_type": "hardlink", + "sha256": "298834a6d842323729e4c5d21220499f79cc8d978d65abfbae5270e7eb73d52e", + "sha256_in_prefix": "298834a6d842323729e4c5d21220499f79cc8d978d65abfbae5270e7eb73d52e", + "size_in_bytes": 5889 + }, + { + "_path": "site-packages/dateutil/zoneinfo/dateutil-zoneinfo.tar.gz", + "path_type": "hardlink", + "sha256": "02471d071dd7904670312a52fd398e11fac41472ef8313cd0d5230195c5355a2", + "sha256_in_prefix": "02471d071dd7904670312a52fd398e11fac41472ef8313cd0d5230195c5355a2", + "size_in_bytes": 174394 + }, + { + "_path": "site-packages/dateutil/zoneinfo/rebuild.py", + "path_type": "hardlink", + "sha256": "322a98cc2207bcd6cc1fe2dd4582effb84f410803b8432ade462d1d084532dd2", + "sha256_in_prefix": "322a98cc2207bcd6cc1fe2dd4582effb84f410803b8432ade462d1d084532dd2", + "size_in_bytes": 2392 + }, + { + "_path": "site-packages/python_dateutil-2.8.2.dist-info/INSTALLER", + "path_type": "hardlink", + "sha256": "d0edee15f91b406f3f99726e44eb990be6e34fd0345b52b910c568e0eef6a2a8", + "sha256_in_prefix": "d0edee15f91b406f3f99726e44eb990be6e34fd0345b52b910c568e0eef6a2a8", + "size_in_bytes": 5 + }, + { + "_path": "site-packages/python_dateutil-2.8.2.dist-info/LICENSE", + "path_type": "hardlink", + "sha256": "ba00f51a0d92823b5a1cde27d8b5b9d2321e67ed8da9bc163eff96d5e17e577e", + "sha256_in_prefix": "ba00f51a0d92823b5a1cde27d8b5b9d2321e67ed8da9bc163eff96d5e17e577e", + "size_in_bytes": 2889 + }, + { + "_path": "site-packages/python_dateutil-2.8.2.dist-info/METADATA", + "path_type": "hardlink", + "sha256": "9e7635278895a09fd78e8d37e28c4b5b5b517f2c4fac754d4943ef0ad69a2fbb", + "sha256_in_prefix": "9e7635278895a09fd78e8d37e28c4b5b5b517f2c4fac754d4943ef0ad69a2fbb", + "size_in_bytes": 8196 + }, + { + "_path": "site-packages/python_dateutil-2.8.2.dist-info/RECORD", + "path_type": "hardlink", + "sha256": "d8907130a0fc65b745b0cac0ef33fb628369bb42d92542f05fbf51836bcea806", + "sha256_in_prefix": "d8907130a0fc65b745b0cac0ef33fb628369bb42d92542f05fbf51836bcea806", + "size_in_bytes": 3265 + }, + { + "_path": "site-packages/python_dateutil-2.8.2.dist-info/REQUESTED", + "path_type": "hardlink", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size_in_bytes": 0 + }, + { + "_path": "site-packages/python_dateutil-2.8.2.dist-info/WHEEL", + "path_type": "hardlink", + "sha256": "67e9f2629c2b712ab17ddbb1e4c6e7fc3439db988fec9d831b72601af398c934", + "sha256_in_prefix": "67e9f2629c2b712ab17ddbb1e4c6e7fc3439db988fec9d831b72601af398c934", + "size_in_bytes": 110 + }, + { + "_path": "site-packages/python_dateutil-2.8.2.dist-info/direct_url.json", + "path_type": "hardlink", + "sha256": "6eef3c41ab527120bd71b1e07ef0e7af538f02bb0b87e3503a52d9d29ab49839", + "sha256_in_prefix": "6eef3c41ab527120bd71b1e07ef0e7af538f02bb0b87e3503a52d9d29ab49839", + "size_in_bytes": 111 + }, + { + "_path": "site-packages/python_dateutil-2.8.2.dist-info/top_level.txt", + "path_type": "hardlink", + "sha256": "e2d8dd5a485166f17b2c0fc161efcbf60076c3fa766becf9cba02b8da464a2df", + "sha256_in_prefix": "e2d8dd5a485166f17b2c0fc161efcbf60076c3fa766becf9cba02b8da464a2df", + "size_in_bytes": 9 + }, + { + "_path": "site-packages/python_dateutil-2.8.2.dist-info/zip-safe", + "path_type": "hardlink", + "sha256": "01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b", + "sha256_in_prefix": "01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b", + "size_in_bytes": 1 + }, + { + "_path": "lib/python3.12/site-packages/dateutil/__pycache__/__init__.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/dateutil/__pycache__/_common.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/dateutil/__pycache__/_version.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/dateutil/__pycache__/easter.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/dateutil/parser/__pycache__/__init__.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/dateutil/parser/__pycache__/_parser.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/dateutil/parser/__pycache__/isoparser.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/dateutil/__pycache__/relativedelta.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/dateutil/__pycache__/rrule.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/dateutil/tz/__pycache__/__init__.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/dateutil/tz/__pycache__/_common.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/dateutil/tz/__pycache__/_factories.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/dateutil/tz/__pycache__/tz.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/dateutil/tz/__pycache__/win.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/dateutil/__pycache__/tzwin.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/dateutil/__pycache__/utils.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/dateutil/zoneinfo/__pycache__/__init__.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/dateutil/zoneinfo/__pycache__/rebuild.cpython-312.pyc", + "path_type": "pyc_file" + } + ], + "paths_version": 1 + }, + "requested_spec": "None", + "sha256": "54d7785c7678166aa45adeaccfc1d2b8c3c799ca2dc05d4a82bb39b1968bd7da", + "size": 245987, + "subdir": "noarch", + "timestamp": 1626286448000, + "url": "https://conda.anaconda.org/conda-forge/noarch/python-dateutil-2.8.2-pyhd8ed1ab_0.tar.bz2", + "version": "2.8.2" +} \ No newline at end of file diff --git a/crates/pet-conda/tests/unix/anaconda3-2023.03/envs/env_python_3/conda-meta/python_abi-3.12-4_cp312.json b/crates/pet-conda/tests/unix/anaconda3-2023.03/envs/env_python_3/conda-meta/python_abi-3.12-4_cp312.json new file mode 100644 index 00000000..ae7da345 --- /dev/null +++ b/crates/pet-conda/tests/unix/anaconda3-2023.03/envs/env_python_3/conda-meta/python_abi-3.12-4_cp312.json @@ -0,0 +1,31 @@ +{ + "build": "4_cp312", + "build_number": 4, + "channel": "https://conda.anaconda.org/conda-forge/osx-arm64", + "constrains": [ + "python 3.12.* *_cpython" + ], + "depends": [], + "extracted_package_dir": "/Users/donjayamanne/miniconda3/pkgs/python_abi-3.12-4_cp312", + "files": [], + "fn": "python_abi-3.12-4_cp312.conda", + "license": "BSD-3-Clause", + "link": { + "source": "/Users/donjayamanne/miniconda3/pkgs/python_abi-3.12-4_cp312", + "type": 1 + }, + "md5": "bbb3a02c78b2d8219d7213f76d644a2a", + "name": "python_abi", + "package_tarball_full_path": "/Users/donjayamanne/miniconda3/pkgs/python_abi-3.12-4_cp312.conda", + "paths_data": { + "paths": [], + "paths_version": 1 + }, + "requested_spec": "None", + "sha256": "db25428e4f24f8693ffa39f3ff6dfbb8fd53bc298764b775b57edab1c697560f", + "size": 6508, + "subdir": "osx-arm64", + "timestamp": 1695147497000, + "url": "https://conda.anaconda.org/conda-forge/osx-arm64/python_abi-3.12-4_cp312.conda", + "version": "3.12" +} \ No newline at end of file diff --git a/crates/pet-conda/tests/unix/anaconda3-2023.03/envs/myenv/bin/python b/crates/pet-conda/tests/unix/anaconda3-2023.03/envs/myenv/bin/python new file mode 100644 index 00000000..e69de29b diff --git a/crates/pet-conda/tests/unix/anaconda3-2023.03/envs/myenv/bin/python3 b/crates/pet-conda/tests/unix/anaconda3-2023.03/envs/myenv/bin/python3 new file mode 100644 index 00000000..e69de29b diff --git a/crates/pet-conda/tests/unix/anaconda3-2023.03/envs/myenv/bin/python3.1 b/crates/pet-conda/tests/unix/anaconda3-2023.03/envs/myenv/bin/python3.1 new file mode 100644 index 00000000..e69de29b diff --git a/crates/pet-conda/tests/unix/anaconda3-2023.03/envs/myenv/bin/python3.10 b/crates/pet-conda/tests/unix/anaconda3-2023.03/envs/myenv/bin/python3.10 new file mode 100644 index 00000000..e69de29b diff --git a/crates/pet-conda/tests/unix/anaconda3-2023.03/envs/myenv/conda-meta/history b/crates/pet-conda/tests/unix/anaconda3-2023.03/envs/myenv/conda-meta/history new file mode 100644 index 00000000..ed4a0c95 --- /dev/null +++ b/crates/pet-conda/tests/unix/anaconda3-2023.03/envs/myenv/conda-meta/history @@ -0,0 +1,19 @@ +==> 2024-05-08 12:20:05 <== +# cmd: /Users/donjayamanne/.pyenv/versions/miniconda3-latest/bin/conda create -n myenv python=3.10 +# conda version: 24.3.0 ++defaults/noarch::tzdata-2024a-h04d1e81_0 ++defaults/osx-arm64::bzip2-1.0.8-h80987f9_6 ++defaults/osx-arm64::ca-certificates-2024.3.11-hca03da5_0 ++defaults/osx-arm64::libffi-3.4.4-hca03da5_1 ++defaults/osx-arm64::ncurses-6.4-h313beb8_0 ++defaults/osx-arm64::openssl-3.0.13-h1a28f6b_1 ++defaults/osx-arm64::pip-24.0-py310hca03da5_0 ++defaults/osx-arm64::python-3.10.14-hb885b13_1 ++defaults/osx-arm64::readline-8.2-h1a28f6b_0 ++defaults/osx-arm64::setuptools-69.5.1-py310hca03da5_0 ++defaults/osx-arm64::sqlite-3.45.3-h80987f9_0 ++defaults/osx-arm64::tk-8.6.14-h6ba3021_0 ++defaults/osx-arm64::wheel-0.43.0-py310hca03da5_0 ++defaults/osx-arm64::xz-5.4.6-h80987f9_1 ++defaults/osx-arm64::zlib-1.2.13-h18a0788_1 +# update specs: ['python=3.10'] diff --git a/crates/pet-conda/tests/unix/anaconda3-2023.03/envs/myenv/conda-meta/pip-24.0-py310hca03da5_0.json b/crates/pet-conda/tests/unix/anaconda3-2023.03/envs/myenv/conda-meta/pip-24.0-py310hca03da5_0.json new file mode 100644 index 00000000..fd01836e --- /dev/null +++ b/crates/pet-conda/tests/unix/anaconda3-2023.03/envs/myenv/conda-meta/pip-24.0-py310hca03da5_0.json @@ -0,0 +1,8143 @@ +{ + "build": "py310hca03da5_0", + "build_number": 0, + "channel": "https://repo.anaconda.com/pkgs/main/osx-arm64", + "constrains": [], + "depends": [ + "python >=3.10,<3.11.0a0", + "setuptools", + "wheel" + ], + "extracted_package_dir": "/Users/donjayamanne/.pyenv/versions/miniconda3-latest/pkgs/pip-24.0-py310hca03da5_0", + "files": [ + "bin/pip", + "bin/pip3", + "lib/python3.10/site-packages/pip-24.0-py3.10.egg-info/PKG-INFO", + "lib/python3.10/site-packages/pip-24.0-py3.10.egg-info/SOURCES.txt", + "lib/python3.10/site-packages/pip-24.0-py3.10.egg-info/dependency_links.txt", + "lib/python3.10/site-packages/pip-24.0-py3.10.egg-info/entry_points.txt", + "lib/python3.10/site-packages/pip-24.0-py3.10.egg-info/top_level.txt", + "lib/python3.10/site-packages/pip/__init__.py", + "lib/python3.10/site-packages/pip/__main__.py", + "lib/python3.10/site-packages/pip/__pip-runner__.py", + "lib/python3.10/site-packages/pip/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/__pycache__/__main__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/__pycache__/__pip-runner__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/__init__.py", + "lib/python3.10/site-packages/pip/_internal/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/__pycache__/build_env.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/__pycache__/cache.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/__pycache__/configuration.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/__pycache__/exceptions.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/__pycache__/main.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/__pycache__/pyproject.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/__pycache__/self_outdated_check.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/__pycache__/wheel_builder.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/build_env.py", + "lib/python3.10/site-packages/pip/_internal/cache.py", + "lib/python3.10/site-packages/pip/_internal/cli/__init__.py", + "lib/python3.10/site-packages/pip/_internal/cli/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/cli/__pycache__/autocompletion.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/cli/__pycache__/base_command.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/cli/__pycache__/cmdoptions.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/cli/__pycache__/command_context.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/cli/__pycache__/main.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/cli/__pycache__/main_parser.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/cli/__pycache__/parser.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/cli/__pycache__/progress_bars.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/cli/__pycache__/req_command.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/cli/__pycache__/spinners.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/cli/__pycache__/status_codes.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/cli/autocompletion.py", + "lib/python3.10/site-packages/pip/_internal/cli/base_command.py", + "lib/python3.10/site-packages/pip/_internal/cli/cmdoptions.py", + "lib/python3.10/site-packages/pip/_internal/cli/command_context.py", + "lib/python3.10/site-packages/pip/_internal/cli/main.py", + "lib/python3.10/site-packages/pip/_internal/cli/main_parser.py", + "lib/python3.10/site-packages/pip/_internal/cli/parser.py", + "lib/python3.10/site-packages/pip/_internal/cli/progress_bars.py", + "lib/python3.10/site-packages/pip/_internal/cli/req_command.py", + "lib/python3.10/site-packages/pip/_internal/cli/spinners.py", + "lib/python3.10/site-packages/pip/_internal/cli/status_codes.py", + "lib/python3.10/site-packages/pip/_internal/commands/__init__.py", + "lib/python3.10/site-packages/pip/_internal/commands/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/commands/__pycache__/cache.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/commands/__pycache__/check.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/commands/__pycache__/completion.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/commands/__pycache__/configuration.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/commands/__pycache__/debug.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/commands/__pycache__/download.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/commands/__pycache__/freeze.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/commands/__pycache__/hash.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/commands/__pycache__/help.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/commands/__pycache__/index.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/commands/__pycache__/inspect.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/commands/__pycache__/install.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/commands/__pycache__/list.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/commands/__pycache__/search.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/commands/__pycache__/show.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/commands/__pycache__/uninstall.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/commands/__pycache__/wheel.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/commands/cache.py", + "lib/python3.10/site-packages/pip/_internal/commands/check.py", + "lib/python3.10/site-packages/pip/_internal/commands/completion.py", + "lib/python3.10/site-packages/pip/_internal/commands/configuration.py", + "lib/python3.10/site-packages/pip/_internal/commands/debug.py", + "lib/python3.10/site-packages/pip/_internal/commands/download.py", + "lib/python3.10/site-packages/pip/_internal/commands/freeze.py", + "lib/python3.10/site-packages/pip/_internal/commands/hash.py", + "lib/python3.10/site-packages/pip/_internal/commands/help.py", + "lib/python3.10/site-packages/pip/_internal/commands/index.py", + "lib/python3.10/site-packages/pip/_internal/commands/inspect.py", + "lib/python3.10/site-packages/pip/_internal/commands/install.py", + "lib/python3.10/site-packages/pip/_internal/commands/list.py", + "lib/python3.10/site-packages/pip/_internal/commands/search.py", + "lib/python3.10/site-packages/pip/_internal/commands/show.py", + "lib/python3.10/site-packages/pip/_internal/commands/uninstall.py", + "lib/python3.10/site-packages/pip/_internal/commands/wheel.py", + "lib/python3.10/site-packages/pip/_internal/configuration.py", + "lib/python3.10/site-packages/pip/_internal/distributions/__init__.py", + "lib/python3.10/site-packages/pip/_internal/distributions/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/distributions/__pycache__/base.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/distributions/__pycache__/installed.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/distributions/__pycache__/sdist.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/distributions/__pycache__/wheel.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/distributions/base.py", + "lib/python3.10/site-packages/pip/_internal/distributions/installed.py", + "lib/python3.10/site-packages/pip/_internal/distributions/sdist.py", + "lib/python3.10/site-packages/pip/_internal/distributions/wheel.py", + "lib/python3.10/site-packages/pip/_internal/exceptions.py", + "lib/python3.10/site-packages/pip/_internal/index/__init__.py", + "lib/python3.10/site-packages/pip/_internal/index/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/index/__pycache__/collector.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/index/__pycache__/package_finder.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/index/__pycache__/sources.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/index/collector.py", + "lib/python3.10/site-packages/pip/_internal/index/package_finder.py", + "lib/python3.10/site-packages/pip/_internal/index/sources.py", + "lib/python3.10/site-packages/pip/_internal/locations/__init__.py", + "lib/python3.10/site-packages/pip/_internal/locations/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/locations/__pycache__/_distutils.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/locations/__pycache__/_sysconfig.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/locations/__pycache__/base.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/locations/_distutils.py", + "lib/python3.10/site-packages/pip/_internal/locations/_sysconfig.py", + "lib/python3.10/site-packages/pip/_internal/locations/base.py", + "lib/python3.10/site-packages/pip/_internal/main.py", + "lib/python3.10/site-packages/pip/_internal/metadata/__init__.py", + "lib/python3.10/site-packages/pip/_internal/metadata/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/metadata/__pycache__/_json.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/metadata/__pycache__/base.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/metadata/__pycache__/pkg_resources.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/metadata/_json.py", + "lib/python3.10/site-packages/pip/_internal/metadata/base.py", + "lib/python3.10/site-packages/pip/_internal/metadata/importlib/__init__.py", + "lib/python3.10/site-packages/pip/_internal/metadata/importlib/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/metadata/importlib/__pycache__/_compat.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/metadata/importlib/__pycache__/_dists.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/metadata/importlib/__pycache__/_envs.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/metadata/importlib/_compat.py", + "lib/python3.10/site-packages/pip/_internal/metadata/importlib/_dists.py", + "lib/python3.10/site-packages/pip/_internal/metadata/importlib/_envs.py", + "lib/python3.10/site-packages/pip/_internal/metadata/pkg_resources.py", + "lib/python3.10/site-packages/pip/_internal/models/__init__.py", + "lib/python3.10/site-packages/pip/_internal/models/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/models/__pycache__/candidate.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/models/__pycache__/direct_url.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/models/__pycache__/format_control.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/models/__pycache__/index.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/models/__pycache__/installation_report.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/models/__pycache__/link.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/models/__pycache__/scheme.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/models/__pycache__/search_scope.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/models/__pycache__/selection_prefs.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/models/__pycache__/target_python.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/models/__pycache__/wheel.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/models/candidate.py", + "lib/python3.10/site-packages/pip/_internal/models/direct_url.py", + "lib/python3.10/site-packages/pip/_internal/models/format_control.py", + "lib/python3.10/site-packages/pip/_internal/models/index.py", + "lib/python3.10/site-packages/pip/_internal/models/installation_report.py", + "lib/python3.10/site-packages/pip/_internal/models/link.py", + "lib/python3.10/site-packages/pip/_internal/models/scheme.py", + "lib/python3.10/site-packages/pip/_internal/models/search_scope.py", + "lib/python3.10/site-packages/pip/_internal/models/selection_prefs.py", + "lib/python3.10/site-packages/pip/_internal/models/target_python.py", + "lib/python3.10/site-packages/pip/_internal/models/wheel.py", + "lib/python3.10/site-packages/pip/_internal/network/__init__.py", + "lib/python3.10/site-packages/pip/_internal/network/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/network/__pycache__/auth.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/network/__pycache__/cache.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/network/__pycache__/download.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/network/__pycache__/lazy_wheel.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/network/__pycache__/session.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/network/__pycache__/utils.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/network/__pycache__/xmlrpc.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/network/auth.py", + "lib/python3.10/site-packages/pip/_internal/network/cache.py", + "lib/python3.10/site-packages/pip/_internal/network/download.py", + "lib/python3.10/site-packages/pip/_internal/network/lazy_wheel.py", + "lib/python3.10/site-packages/pip/_internal/network/session.py", + "lib/python3.10/site-packages/pip/_internal/network/utils.py", + "lib/python3.10/site-packages/pip/_internal/network/xmlrpc.py", + "lib/python3.10/site-packages/pip/_internal/operations/__init__.py", + "lib/python3.10/site-packages/pip/_internal/operations/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/operations/__pycache__/check.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/operations/__pycache__/freeze.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/operations/__pycache__/prepare.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/operations/build/__init__.py", + "lib/python3.10/site-packages/pip/_internal/operations/build/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/operations/build/__pycache__/build_tracker.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/operations/build/__pycache__/metadata.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/operations/build/__pycache__/metadata_editable.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/operations/build/__pycache__/metadata_legacy.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/operations/build/__pycache__/wheel.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/operations/build/__pycache__/wheel_editable.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/operations/build/__pycache__/wheel_legacy.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/operations/build/build_tracker.py", + "lib/python3.10/site-packages/pip/_internal/operations/build/metadata.py", + "lib/python3.10/site-packages/pip/_internal/operations/build/metadata_editable.py", + "lib/python3.10/site-packages/pip/_internal/operations/build/metadata_legacy.py", + "lib/python3.10/site-packages/pip/_internal/operations/build/wheel.py", + "lib/python3.10/site-packages/pip/_internal/operations/build/wheel_editable.py", + "lib/python3.10/site-packages/pip/_internal/operations/build/wheel_legacy.py", + "lib/python3.10/site-packages/pip/_internal/operations/check.py", + "lib/python3.10/site-packages/pip/_internal/operations/freeze.py", + "lib/python3.10/site-packages/pip/_internal/operations/install/__init__.py", + "lib/python3.10/site-packages/pip/_internal/operations/install/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/operations/install/__pycache__/editable_legacy.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/operations/install/__pycache__/wheel.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/operations/install/editable_legacy.py", + "lib/python3.10/site-packages/pip/_internal/operations/install/wheel.py", + "lib/python3.10/site-packages/pip/_internal/operations/prepare.py", + "lib/python3.10/site-packages/pip/_internal/pyproject.py", + "lib/python3.10/site-packages/pip/_internal/req/__init__.py", + "lib/python3.10/site-packages/pip/_internal/req/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/req/__pycache__/constructors.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/req/__pycache__/req_file.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/req/__pycache__/req_install.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/req/__pycache__/req_set.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/req/__pycache__/req_uninstall.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/req/constructors.py", + "lib/python3.10/site-packages/pip/_internal/req/req_file.py", + "lib/python3.10/site-packages/pip/_internal/req/req_install.py", + "lib/python3.10/site-packages/pip/_internal/req/req_set.py", + "lib/python3.10/site-packages/pip/_internal/req/req_uninstall.py", + "lib/python3.10/site-packages/pip/_internal/resolution/__init__.py", + "lib/python3.10/site-packages/pip/_internal/resolution/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/resolution/__pycache__/base.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/resolution/base.py", + "lib/python3.10/site-packages/pip/_internal/resolution/legacy/__init__.py", + "lib/python3.10/site-packages/pip/_internal/resolution/legacy/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/resolution/legacy/__pycache__/resolver.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/resolution/legacy/resolver.py", + "lib/python3.10/site-packages/pip/_internal/resolution/resolvelib/__init__.py", + "lib/python3.10/site-packages/pip/_internal/resolution/resolvelib/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/resolution/resolvelib/__pycache__/base.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/resolution/resolvelib/__pycache__/candidates.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/resolution/resolvelib/__pycache__/factory.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/resolution/resolvelib/__pycache__/found_candidates.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/resolution/resolvelib/__pycache__/provider.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/resolution/resolvelib/__pycache__/reporter.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/resolution/resolvelib/__pycache__/requirements.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/resolution/resolvelib/__pycache__/resolver.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/resolution/resolvelib/base.py", + "lib/python3.10/site-packages/pip/_internal/resolution/resolvelib/candidates.py", + "lib/python3.10/site-packages/pip/_internal/resolution/resolvelib/factory.py", + "lib/python3.10/site-packages/pip/_internal/resolution/resolvelib/found_candidates.py", + "lib/python3.10/site-packages/pip/_internal/resolution/resolvelib/provider.py", + "lib/python3.10/site-packages/pip/_internal/resolution/resolvelib/reporter.py", + "lib/python3.10/site-packages/pip/_internal/resolution/resolvelib/requirements.py", + "lib/python3.10/site-packages/pip/_internal/resolution/resolvelib/resolver.py", + "lib/python3.10/site-packages/pip/_internal/self_outdated_check.py", + "lib/python3.10/site-packages/pip/_internal/utils/__init__.py", + "lib/python3.10/site-packages/pip/_internal/utils/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/utils/__pycache__/_jaraco_text.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/utils/__pycache__/_log.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/utils/__pycache__/appdirs.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/utils/__pycache__/compat.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/utils/__pycache__/compatibility_tags.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/utils/__pycache__/datetime.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/utils/__pycache__/deprecation.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/utils/__pycache__/direct_url_helpers.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/utils/__pycache__/egg_link.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/utils/__pycache__/encoding.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/utils/__pycache__/entrypoints.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/utils/__pycache__/filesystem.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/utils/__pycache__/filetypes.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/utils/__pycache__/glibc.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/utils/__pycache__/hashes.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/utils/__pycache__/logging.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/utils/__pycache__/misc.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/utils/__pycache__/models.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/utils/__pycache__/packaging.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/utils/__pycache__/setuptools_build.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/utils/__pycache__/subprocess.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/utils/__pycache__/temp_dir.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/utils/__pycache__/unpacking.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/utils/__pycache__/urls.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/utils/__pycache__/virtualenv.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/utils/__pycache__/wheel.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/utils/_jaraco_text.py", + "lib/python3.10/site-packages/pip/_internal/utils/_log.py", + "lib/python3.10/site-packages/pip/_internal/utils/appdirs.py", + "lib/python3.10/site-packages/pip/_internal/utils/compat.py", + "lib/python3.10/site-packages/pip/_internal/utils/compatibility_tags.py", + "lib/python3.10/site-packages/pip/_internal/utils/datetime.py", + "lib/python3.10/site-packages/pip/_internal/utils/deprecation.py", + "lib/python3.10/site-packages/pip/_internal/utils/direct_url_helpers.py", + "lib/python3.10/site-packages/pip/_internal/utils/egg_link.py", + "lib/python3.10/site-packages/pip/_internal/utils/encoding.py", + "lib/python3.10/site-packages/pip/_internal/utils/entrypoints.py", + "lib/python3.10/site-packages/pip/_internal/utils/filesystem.py", + "lib/python3.10/site-packages/pip/_internal/utils/filetypes.py", + "lib/python3.10/site-packages/pip/_internal/utils/glibc.py", + "lib/python3.10/site-packages/pip/_internal/utils/hashes.py", + "lib/python3.10/site-packages/pip/_internal/utils/logging.py", + "lib/python3.10/site-packages/pip/_internal/utils/misc.py", + "lib/python3.10/site-packages/pip/_internal/utils/models.py", + "lib/python3.10/site-packages/pip/_internal/utils/packaging.py", + "lib/python3.10/site-packages/pip/_internal/utils/setuptools_build.py", + "lib/python3.10/site-packages/pip/_internal/utils/subprocess.py", + "lib/python3.10/site-packages/pip/_internal/utils/temp_dir.py", + "lib/python3.10/site-packages/pip/_internal/utils/unpacking.py", + "lib/python3.10/site-packages/pip/_internal/utils/urls.py", + "lib/python3.10/site-packages/pip/_internal/utils/virtualenv.py", + "lib/python3.10/site-packages/pip/_internal/utils/wheel.py", + "lib/python3.10/site-packages/pip/_internal/vcs/__init__.py", + "lib/python3.10/site-packages/pip/_internal/vcs/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/vcs/__pycache__/bazaar.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/vcs/__pycache__/git.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/vcs/__pycache__/mercurial.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/vcs/__pycache__/subversion.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/vcs/__pycache__/versioncontrol.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/vcs/bazaar.py", + "lib/python3.10/site-packages/pip/_internal/vcs/git.py", + "lib/python3.10/site-packages/pip/_internal/vcs/mercurial.py", + "lib/python3.10/site-packages/pip/_internal/vcs/subversion.py", + "lib/python3.10/site-packages/pip/_internal/vcs/versioncontrol.py", + "lib/python3.10/site-packages/pip/_internal/wheel_builder.py", + "lib/python3.10/site-packages/pip/_vendor/__init__.py", + "lib/python3.10/site-packages/pip/_vendor/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/__pycache__/six.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/__pycache__/typing_extensions.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/cachecontrol/__init__.py", + "lib/python3.10/site-packages/pip/_vendor/cachecontrol/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/cachecontrol/__pycache__/_cmd.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/cachecontrol/__pycache__/adapter.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/cachecontrol/__pycache__/cache.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/cachecontrol/__pycache__/controller.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/cachecontrol/__pycache__/filewrapper.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/cachecontrol/__pycache__/heuristics.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/cachecontrol/__pycache__/serialize.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/cachecontrol/__pycache__/wrapper.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/cachecontrol/_cmd.py", + "lib/python3.10/site-packages/pip/_vendor/cachecontrol/adapter.py", + "lib/python3.10/site-packages/pip/_vendor/cachecontrol/cache.py", + "lib/python3.10/site-packages/pip/_vendor/cachecontrol/caches/__init__.py", + "lib/python3.10/site-packages/pip/_vendor/cachecontrol/caches/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/cachecontrol/caches/__pycache__/file_cache.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/cachecontrol/caches/__pycache__/redis_cache.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/cachecontrol/caches/file_cache.py", + "lib/python3.10/site-packages/pip/_vendor/cachecontrol/caches/redis_cache.py", + "lib/python3.10/site-packages/pip/_vendor/cachecontrol/controller.py", + "lib/python3.10/site-packages/pip/_vendor/cachecontrol/filewrapper.py", + "lib/python3.10/site-packages/pip/_vendor/cachecontrol/heuristics.py", + "lib/python3.10/site-packages/pip/_vendor/cachecontrol/py.typed", + "lib/python3.10/site-packages/pip/_vendor/cachecontrol/serialize.py", + "lib/python3.10/site-packages/pip/_vendor/cachecontrol/wrapper.py", + "lib/python3.10/site-packages/pip/_vendor/certifi/__init__.py", + "lib/python3.10/site-packages/pip/_vendor/certifi/__main__.py", + "lib/python3.10/site-packages/pip/_vendor/certifi/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/certifi/__pycache__/__main__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/certifi/__pycache__/core.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/certifi/cacert.pem", + "lib/python3.10/site-packages/pip/_vendor/certifi/core.py", + "lib/python3.10/site-packages/pip/_vendor/certifi/py.typed", + "lib/python3.10/site-packages/pip/_vendor/chardet/__init__.py", + "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/big5freq.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/big5prober.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/chardistribution.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/charsetgroupprober.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/charsetprober.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/codingstatemachine.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/codingstatemachinedict.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/cp949prober.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/enums.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/escprober.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/escsm.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/eucjpprober.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/euckrfreq.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/euckrprober.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/euctwfreq.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/euctwprober.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/gb2312freq.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/gb2312prober.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/hebrewprober.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/jisfreq.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/johabfreq.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/johabprober.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/jpcntx.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/langbulgarianmodel.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/langgreekmodel.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/langhebrewmodel.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/langhungarianmodel.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/langrussianmodel.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/langthaimodel.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/langturkishmodel.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/latin1prober.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/macromanprober.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/mbcharsetprober.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/mbcsgroupprober.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/mbcssm.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/resultdict.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/sbcharsetprober.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/sbcsgroupprober.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/sjisprober.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/universaldetector.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/utf1632prober.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/utf8prober.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/version.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/chardet/big5freq.py", + "lib/python3.10/site-packages/pip/_vendor/chardet/big5prober.py", + "lib/python3.10/site-packages/pip/_vendor/chardet/chardistribution.py", + "lib/python3.10/site-packages/pip/_vendor/chardet/charsetgroupprober.py", + "lib/python3.10/site-packages/pip/_vendor/chardet/charsetprober.py", + "lib/python3.10/site-packages/pip/_vendor/chardet/cli/__init__.py", + "lib/python3.10/site-packages/pip/_vendor/chardet/cli/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/chardet/cli/__pycache__/chardetect.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/chardet/cli/chardetect.py", + "lib/python3.10/site-packages/pip/_vendor/chardet/codingstatemachine.py", + "lib/python3.10/site-packages/pip/_vendor/chardet/codingstatemachinedict.py", + "lib/python3.10/site-packages/pip/_vendor/chardet/cp949prober.py", + "lib/python3.10/site-packages/pip/_vendor/chardet/enums.py", + "lib/python3.10/site-packages/pip/_vendor/chardet/escprober.py", + "lib/python3.10/site-packages/pip/_vendor/chardet/escsm.py", + "lib/python3.10/site-packages/pip/_vendor/chardet/eucjpprober.py", + "lib/python3.10/site-packages/pip/_vendor/chardet/euckrfreq.py", + "lib/python3.10/site-packages/pip/_vendor/chardet/euckrprober.py", + "lib/python3.10/site-packages/pip/_vendor/chardet/euctwfreq.py", + "lib/python3.10/site-packages/pip/_vendor/chardet/euctwprober.py", + "lib/python3.10/site-packages/pip/_vendor/chardet/gb2312freq.py", + "lib/python3.10/site-packages/pip/_vendor/chardet/gb2312prober.py", + "lib/python3.10/site-packages/pip/_vendor/chardet/hebrewprober.py", + "lib/python3.10/site-packages/pip/_vendor/chardet/jisfreq.py", + "lib/python3.10/site-packages/pip/_vendor/chardet/johabfreq.py", + "lib/python3.10/site-packages/pip/_vendor/chardet/johabprober.py", + "lib/python3.10/site-packages/pip/_vendor/chardet/jpcntx.py", + "lib/python3.10/site-packages/pip/_vendor/chardet/langbulgarianmodel.py", + "lib/python3.10/site-packages/pip/_vendor/chardet/langgreekmodel.py", + "lib/python3.10/site-packages/pip/_vendor/chardet/langhebrewmodel.py", + "lib/python3.10/site-packages/pip/_vendor/chardet/langhungarianmodel.py", + "lib/python3.10/site-packages/pip/_vendor/chardet/langrussianmodel.py", + "lib/python3.10/site-packages/pip/_vendor/chardet/langthaimodel.py", + "lib/python3.10/site-packages/pip/_vendor/chardet/langturkishmodel.py", + "lib/python3.10/site-packages/pip/_vendor/chardet/latin1prober.py", + "lib/python3.10/site-packages/pip/_vendor/chardet/macromanprober.py", + "lib/python3.10/site-packages/pip/_vendor/chardet/mbcharsetprober.py", + "lib/python3.10/site-packages/pip/_vendor/chardet/mbcsgroupprober.py", + "lib/python3.10/site-packages/pip/_vendor/chardet/mbcssm.py", + "lib/python3.10/site-packages/pip/_vendor/chardet/metadata/__init__.py", + "lib/python3.10/site-packages/pip/_vendor/chardet/metadata/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/chardet/metadata/__pycache__/languages.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/chardet/metadata/languages.py", + "lib/python3.10/site-packages/pip/_vendor/chardet/py.typed", + "lib/python3.10/site-packages/pip/_vendor/chardet/resultdict.py", + "lib/python3.10/site-packages/pip/_vendor/chardet/sbcharsetprober.py", + "lib/python3.10/site-packages/pip/_vendor/chardet/sbcsgroupprober.py", + "lib/python3.10/site-packages/pip/_vendor/chardet/sjisprober.py", + "lib/python3.10/site-packages/pip/_vendor/chardet/universaldetector.py", + "lib/python3.10/site-packages/pip/_vendor/chardet/utf1632prober.py", + "lib/python3.10/site-packages/pip/_vendor/chardet/utf8prober.py", + "lib/python3.10/site-packages/pip/_vendor/chardet/version.py", + "lib/python3.10/site-packages/pip/_vendor/colorama/__init__.py", + "lib/python3.10/site-packages/pip/_vendor/colorama/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/colorama/__pycache__/ansi.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/colorama/__pycache__/ansitowin32.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/colorama/__pycache__/initialise.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/colorama/__pycache__/win32.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/colorama/__pycache__/winterm.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/colorama/ansi.py", + "lib/python3.10/site-packages/pip/_vendor/colorama/ansitowin32.py", + "lib/python3.10/site-packages/pip/_vendor/colorama/initialise.py", + "lib/python3.10/site-packages/pip/_vendor/colorama/tests/__init__.py", + "lib/python3.10/site-packages/pip/_vendor/colorama/tests/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/colorama/tests/__pycache__/ansi_test.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/colorama/tests/__pycache__/ansitowin32_test.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/colorama/tests/__pycache__/initialise_test.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/colorama/tests/__pycache__/isatty_test.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/colorama/tests/__pycache__/utils.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/colorama/tests/__pycache__/winterm_test.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/colorama/tests/ansi_test.py", + "lib/python3.10/site-packages/pip/_vendor/colorama/tests/ansitowin32_test.py", + "lib/python3.10/site-packages/pip/_vendor/colorama/tests/initialise_test.py", + "lib/python3.10/site-packages/pip/_vendor/colorama/tests/isatty_test.py", + "lib/python3.10/site-packages/pip/_vendor/colorama/tests/utils.py", + "lib/python3.10/site-packages/pip/_vendor/colorama/tests/winterm_test.py", + "lib/python3.10/site-packages/pip/_vendor/colorama/win32.py", + "lib/python3.10/site-packages/pip/_vendor/colorama/winterm.py", + "lib/python3.10/site-packages/pip/_vendor/distlib/__init__.py", + "lib/python3.10/site-packages/pip/_vendor/distlib/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/distlib/__pycache__/compat.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/distlib/__pycache__/database.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/distlib/__pycache__/index.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/distlib/__pycache__/locators.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/distlib/__pycache__/manifest.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/distlib/__pycache__/markers.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/distlib/__pycache__/metadata.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/distlib/__pycache__/resources.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/distlib/__pycache__/scripts.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/distlib/__pycache__/util.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/distlib/__pycache__/version.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/distlib/__pycache__/wheel.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/distlib/compat.py", + "lib/python3.10/site-packages/pip/_vendor/distlib/database.py", + "lib/python3.10/site-packages/pip/_vendor/distlib/index.py", + "lib/python3.10/site-packages/pip/_vendor/distlib/locators.py", + "lib/python3.10/site-packages/pip/_vendor/distlib/manifest.py", + "lib/python3.10/site-packages/pip/_vendor/distlib/markers.py", + "lib/python3.10/site-packages/pip/_vendor/distlib/metadata.py", + "lib/python3.10/site-packages/pip/_vendor/distlib/resources.py", + "lib/python3.10/site-packages/pip/_vendor/distlib/scripts.py", + "lib/python3.10/site-packages/pip/_vendor/distlib/util.py", + "lib/python3.10/site-packages/pip/_vendor/distlib/version.py", + "lib/python3.10/site-packages/pip/_vendor/distlib/wheel.py", + "lib/python3.10/site-packages/pip/_vendor/distro/__init__.py", + "lib/python3.10/site-packages/pip/_vendor/distro/__main__.py", + "lib/python3.10/site-packages/pip/_vendor/distro/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/distro/__pycache__/__main__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/distro/__pycache__/distro.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/distro/distro.py", + "lib/python3.10/site-packages/pip/_vendor/distro/py.typed", + "lib/python3.10/site-packages/pip/_vendor/idna/__init__.py", + "lib/python3.10/site-packages/pip/_vendor/idna/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/idna/__pycache__/codec.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/idna/__pycache__/compat.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/idna/__pycache__/core.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/idna/__pycache__/idnadata.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/idna/__pycache__/intranges.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/idna/__pycache__/package_data.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/idna/__pycache__/uts46data.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/idna/codec.py", + "lib/python3.10/site-packages/pip/_vendor/idna/compat.py", + "lib/python3.10/site-packages/pip/_vendor/idna/core.py", + "lib/python3.10/site-packages/pip/_vendor/idna/idnadata.py", + "lib/python3.10/site-packages/pip/_vendor/idna/intranges.py", + "lib/python3.10/site-packages/pip/_vendor/idna/package_data.py", + "lib/python3.10/site-packages/pip/_vendor/idna/py.typed", + "lib/python3.10/site-packages/pip/_vendor/idna/uts46data.py", + "lib/python3.10/site-packages/pip/_vendor/msgpack/__init__.py", + "lib/python3.10/site-packages/pip/_vendor/msgpack/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/msgpack/__pycache__/exceptions.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/msgpack/__pycache__/ext.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/msgpack/__pycache__/fallback.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/msgpack/exceptions.py", + "lib/python3.10/site-packages/pip/_vendor/msgpack/ext.py", + "lib/python3.10/site-packages/pip/_vendor/msgpack/fallback.py", + "lib/python3.10/site-packages/pip/_vendor/packaging/__about__.py", + "lib/python3.10/site-packages/pip/_vendor/packaging/__init__.py", + "lib/python3.10/site-packages/pip/_vendor/packaging/__pycache__/__about__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/packaging/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/packaging/__pycache__/_manylinux.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/packaging/__pycache__/_musllinux.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/packaging/__pycache__/_structures.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/packaging/__pycache__/markers.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/packaging/__pycache__/requirements.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/packaging/__pycache__/specifiers.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/packaging/__pycache__/tags.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/packaging/__pycache__/utils.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/packaging/__pycache__/version.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/packaging/_manylinux.py", + "lib/python3.10/site-packages/pip/_vendor/packaging/_musllinux.py", + "lib/python3.10/site-packages/pip/_vendor/packaging/_structures.py", + "lib/python3.10/site-packages/pip/_vendor/packaging/markers.py", + "lib/python3.10/site-packages/pip/_vendor/packaging/py.typed", + "lib/python3.10/site-packages/pip/_vendor/packaging/requirements.py", + "lib/python3.10/site-packages/pip/_vendor/packaging/specifiers.py", + "lib/python3.10/site-packages/pip/_vendor/packaging/tags.py", + "lib/python3.10/site-packages/pip/_vendor/packaging/utils.py", + "lib/python3.10/site-packages/pip/_vendor/packaging/version.py", + "lib/python3.10/site-packages/pip/_vendor/pkg_resources/__init__.py", + "lib/python3.10/site-packages/pip/_vendor/pkg_resources/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/platformdirs/__init__.py", + "lib/python3.10/site-packages/pip/_vendor/platformdirs/__main__.py", + "lib/python3.10/site-packages/pip/_vendor/platformdirs/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/platformdirs/__pycache__/__main__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/platformdirs/__pycache__/android.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/platformdirs/__pycache__/api.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/platformdirs/__pycache__/macos.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/platformdirs/__pycache__/unix.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/platformdirs/__pycache__/version.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/platformdirs/__pycache__/windows.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/platformdirs/android.py", + "lib/python3.10/site-packages/pip/_vendor/platformdirs/api.py", + "lib/python3.10/site-packages/pip/_vendor/platformdirs/macos.py", + "lib/python3.10/site-packages/pip/_vendor/platformdirs/py.typed", + "lib/python3.10/site-packages/pip/_vendor/platformdirs/unix.py", + "lib/python3.10/site-packages/pip/_vendor/platformdirs/version.py", + "lib/python3.10/site-packages/pip/_vendor/platformdirs/windows.py", + "lib/python3.10/site-packages/pip/_vendor/pygments/__init__.py", + "lib/python3.10/site-packages/pip/_vendor/pygments/__main__.py", + "lib/python3.10/site-packages/pip/_vendor/pygments/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/pygments/__pycache__/__main__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/pygments/__pycache__/cmdline.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/pygments/__pycache__/console.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/pygments/__pycache__/filter.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/pygments/__pycache__/formatter.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/pygments/__pycache__/lexer.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/pygments/__pycache__/modeline.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/pygments/__pycache__/plugin.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/pygments/__pycache__/regexopt.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/pygments/__pycache__/scanner.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/pygments/__pycache__/sphinxext.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/pygments/__pycache__/style.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/pygments/__pycache__/token.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/pygments/__pycache__/unistring.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/pygments/__pycache__/util.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/pygments/cmdline.py", + "lib/python3.10/site-packages/pip/_vendor/pygments/console.py", + "lib/python3.10/site-packages/pip/_vendor/pygments/filter.py", + "lib/python3.10/site-packages/pip/_vendor/pygments/filters/__init__.py", + "lib/python3.10/site-packages/pip/_vendor/pygments/filters/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/pygments/formatter.py", + "lib/python3.10/site-packages/pip/_vendor/pygments/formatters/__init__.py", + "lib/python3.10/site-packages/pip/_vendor/pygments/formatters/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/pygments/formatters/__pycache__/_mapping.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/pygments/formatters/__pycache__/bbcode.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/pygments/formatters/__pycache__/groff.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/pygments/formatters/__pycache__/html.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/pygments/formatters/__pycache__/img.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/pygments/formatters/__pycache__/irc.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/pygments/formatters/__pycache__/latex.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/pygments/formatters/__pycache__/other.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/pygments/formatters/__pycache__/pangomarkup.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/pygments/formatters/__pycache__/rtf.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/pygments/formatters/__pycache__/svg.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/pygments/formatters/__pycache__/terminal.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/pygments/formatters/__pycache__/terminal256.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/pygments/formatters/_mapping.py", + "lib/python3.10/site-packages/pip/_vendor/pygments/formatters/bbcode.py", + "lib/python3.10/site-packages/pip/_vendor/pygments/formatters/groff.py", + "lib/python3.10/site-packages/pip/_vendor/pygments/formatters/html.py", + "lib/python3.10/site-packages/pip/_vendor/pygments/formatters/img.py", + "lib/python3.10/site-packages/pip/_vendor/pygments/formatters/irc.py", + "lib/python3.10/site-packages/pip/_vendor/pygments/formatters/latex.py", + "lib/python3.10/site-packages/pip/_vendor/pygments/formatters/other.py", + "lib/python3.10/site-packages/pip/_vendor/pygments/formatters/pangomarkup.py", + "lib/python3.10/site-packages/pip/_vendor/pygments/formatters/rtf.py", + "lib/python3.10/site-packages/pip/_vendor/pygments/formatters/svg.py", + "lib/python3.10/site-packages/pip/_vendor/pygments/formatters/terminal.py", + "lib/python3.10/site-packages/pip/_vendor/pygments/formatters/terminal256.py", + "lib/python3.10/site-packages/pip/_vendor/pygments/lexer.py", + "lib/python3.10/site-packages/pip/_vendor/pygments/lexers/__init__.py", + "lib/python3.10/site-packages/pip/_vendor/pygments/lexers/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/pygments/lexers/__pycache__/_mapping.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/pygments/lexers/__pycache__/python.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/pygments/lexers/_mapping.py", + "lib/python3.10/site-packages/pip/_vendor/pygments/lexers/python.py", + "lib/python3.10/site-packages/pip/_vendor/pygments/modeline.py", + "lib/python3.10/site-packages/pip/_vendor/pygments/plugin.py", + "lib/python3.10/site-packages/pip/_vendor/pygments/regexopt.py", + "lib/python3.10/site-packages/pip/_vendor/pygments/scanner.py", + "lib/python3.10/site-packages/pip/_vendor/pygments/sphinxext.py", + "lib/python3.10/site-packages/pip/_vendor/pygments/style.py", + "lib/python3.10/site-packages/pip/_vendor/pygments/styles/__init__.py", + "lib/python3.10/site-packages/pip/_vendor/pygments/styles/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/pygments/token.py", + "lib/python3.10/site-packages/pip/_vendor/pygments/unistring.py", + "lib/python3.10/site-packages/pip/_vendor/pygments/util.py", + "lib/python3.10/site-packages/pip/_vendor/pyparsing/__init__.py", + "lib/python3.10/site-packages/pip/_vendor/pyparsing/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/pyparsing/__pycache__/actions.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/pyparsing/__pycache__/common.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/pyparsing/__pycache__/core.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/pyparsing/__pycache__/exceptions.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/pyparsing/__pycache__/helpers.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/pyparsing/__pycache__/results.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/pyparsing/__pycache__/testing.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/pyparsing/__pycache__/unicode.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/pyparsing/__pycache__/util.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/pyparsing/actions.py", + "lib/python3.10/site-packages/pip/_vendor/pyparsing/common.py", + "lib/python3.10/site-packages/pip/_vendor/pyparsing/core.py", + "lib/python3.10/site-packages/pip/_vendor/pyparsing/diagram/__init__.py", + "lib/python3.10/site-packages/pip/_vendor/pyparsing/diagram/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/pyparsing/exceptions.py", + "lib/python3.10/site-packages/pip/_vendor/pyparsing/helpers.py", + "lib/python3.10/site-packages/pip/_vendor/pyparsing/py.typed", + "lib/python3.10/site-packages/pip/_vendor/pyparsing/results.py", + "lib/python3.10/site-packages/pip/_vendor/pyparsing/testing.py", + "lib/python3.10/site-packages/pip/_vendor/pyparsing/unicode.py", + "lib/python3.10/site-packages/pip/_vendor/pyparsing/util.py", + "lib/python3.10/site-packages/pip/_vendor/pyproject_hooks/__init__.py", + "lib/python3.10/site-packages/pip/_vendor/pyproject_hooks/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/pyproject_hooks/__pycache__/_compat.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/pyproject_hooks/__pycache__/_impl.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/pyproject_hooks/_compat.py", + "lib/python3.10/site-packages/pip/_vendor/pyproject_hooks/_impl.py", + "lib/python3.10/site-packages/pip/_vendor/pyproject_hooks/_in_process/__init__.py", + "lib/python3.10/site-packages/pip/_vendor/pyproject_hooks/_in_process/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/pyproject_hooks/_in_process/__pycache__/_in_process.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/pyproject_hooks/_in_process/_in_process.py", + "lib/python3.10/site-packages/pip/_vendor/requests/__init__.py", + "lib/python3.10/site-packages/pip/_vendor/requests/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/requests/__pycache__/__version__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/requests/__pycache__/_internal_utils.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/requests/__pycache__/adapters.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/requests/__pycache__/api.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/requests/__pycache__/auth.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/requests/__pycache__/certs.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/requests/__pycache__/compat.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/requests/__pycache__/cookies.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/requests/__pycache__/exceptions.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/requests/__pycache__/help.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/requests/__pycache__/hooks.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/requests/__pycache__/models.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/requests/__pycache__/packages.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/requests/__pycache__/sessions.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/requests/__pycache__/status_codes.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/requests/__pycache__/structures.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/requests/__pycache__/utils.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/requests/__version__.py", + "lib/python3.10/site-packages/pip/_vendor/requests/_internal_utils.py", + "lib/python3.10/site-packages/pip/_vendor/requests/adapters.py", + "lib/python3.10/site-packages/pip/_vendor/requests/api.py", + "lib/python3.10/site-packages/pip/_vendor/requests/auth.py", + "lib/python3.10/site-packages/pip/_vendor/requests/certs.py", + "lib/python3.10/site-packages/pip/_vendor/requests/compat.py", + "lib/python3.10/site-packages/pip/_vendor/requests/cookies.py", + "lib/python3.10/site-packages/pip/_vendor/requests/exceptions.py", + "lib/python3.10/site-packages/pip/_vendor/requests/help.py", + "lib/python3.10/site-packages/pip/_vendor/requests/hooks.py", + "lib/python3.10/site-packages/pip/_vendor/requests/models.py", + "lib/python3.10/site-packages/pip/_vendor/requests/packages.py", + "lib/python3.10/site-packages/pip/_vendor/requests/sessions.py", + "lib/python3.10/site-packages/pip/_vendor/requests/status_codes.py", + "lib/python3.10/site-packages/pip/_vendor/requests/structures.py", + "lib/python3.10/site-packages/pip/_vendor/requests/utils.py", + "lib/python3.10/site-packages/pip/_vendor/resolvelib/__init__.py", + "lib/python3.10/site-packages/pip/_vendor/resolvelib/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/resolvelib/__pycache__/providers.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/resolvelib/__pycache__/reporters.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/resolvelib/__pycache__/resolvers.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/resolvelib/__pycache__/structs.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/resolvelib/compat/__init__.py", + "lib/python3.10/site-packages/pip/_vendor/resolvelib/compat/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/resolvelib/compat/__pycache__/collections_abc.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/resolvelib/compat/collections_abc.py", + "lib/python3.10/site-packages/pip/_vendor/resolvelib/providers.py", + "lib/python3.10/site-packages/pip/_vendor/resolvelib/py.typed", + "lib/python3.10/site-packages/pip/_vendor/resolvelib/reporters.py", + "lib/python3.10/site-packages/pip/_vendor/resolvelib/resolvers.py", + "lib/python3.10/site-packages/pip/_vendor/resolvelib/structs.py", + "lib/python3.10/site-packages/pip/_vendor/rich/__init__.py", + "lib/python3.10/site-packages/pip/_vendor/rich/__main__.py", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/__main__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_cell_widths.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_emoji_codes.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_emoji_replace.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_export_format.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_extension.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_fileno.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_inspect.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_log_render.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_loop.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_null_file.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_palettes.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_pick.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_ratio.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_spinners.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_stack.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_timer.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_win32_console.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_windows.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_windows_renderer.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_wrap.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/abc.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/align.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/ansi.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/bar.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/box.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/cells.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/color.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/color_triplet.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/columns.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/console.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/constrain.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/containers.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/control.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/default_styles.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/diagnose.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/emoji.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/errors.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/file_proxy.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/filesize.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/highlighter.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/json.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/jupyter.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/layout.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/live.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/live_render.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/logging.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/markup.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/measure.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/padding.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/pager.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/palette.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/panel.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/pretty.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/progress.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/progress_bar.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/prompt.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/protocol.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/region.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/repr.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/rule.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/scope.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/screen.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/segment.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/spinner.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/status.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/style.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/styled.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/syntax.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/table.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/terminal_theme.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/text.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/theme.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/themes.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/traceback.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/tree.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/_cell_widths.py", + "lib/python3.10/site-packages/pip/_vendor/rich/_emoji_codes.py", + "lib/python3.10/site-packages/pip/_vendor/rich/_emoji_replace.py", + "lib/python3.10/site-packages/pip/_vendor/rich/_export_format.py", + "lib/python3.10/site-packages/pip/_vendor/rich/_extension.py", + "lib/python3.10/site-packages/pip/_vendor/rich/_fileno.py", + "lib/python3.10/site-packages/pip/_vendor/rich/_inspect.py", + "lib/python3.10/site-packages/pip/_vendor/rich/_log_render.py", + "lib/python3.10/site-packages/pip/_vendor/rich/_loop.py", + "lib/python3.10/site-packages/pip/_vendor/rich/_null_file.py", + "lib/python3.10/site-packages/pip/_vendor/rich/_palettes.py", + "lib/python3.10/site-packages/pip/_vendor/rich/_pick.py", + "lib/python3.10/site-packages/pip/_vendor/rich/_ratio.py", + "lib/python3.10/site-packages/pip/_vendor/rich/_spinners.py", + "lib/python3.10/site-packages/pip/_vendor/rich/_stack.py", + "lib/python3.10/site-packages/pip/_vendor/rich/_timer.py", + "lib/python3.10/site-packages/pip/_vendor/rich/_win32_console.py", + "lib/python3.10/site-packages/pip/_vendor/rich/_windows.py", + "lib/python3.10/site-packages/pip/_vendor/rich/_windows_renderer.py", + "lib/python3.10/site-packages/pip/_vendor/rich/_wrap.py", + "lib/python3.10/site-packages/pip/_vendor/rich/abc.py", + "lib/python3.10/site-packages/pip/_vendor/rich/align.py", + "lib/python3.10/site-packages/pip/_vendor/rich/ansi.py", + "lib/python3.10/site-packages/pip/_vendor/rich/bar.py", + "lib/python3.10/site-packages/pip/_vendor/rich/box.py", + "lib/python3.10/site-packages/pip/_vendor/rich/cells.py", + "lib/python3.10/site-packages/pip/_vendor/rich/color.py", + "lib/python3.10/site-packages/pip/_vendor/rich/color_triplet.py", + "lib/python3.10/site-packages/pip/_vendor/rich/columns.py", + "lib/python3.10/site-packages/pip/_vendor/rich/console.py", + "lib/python3.10/site-packages/pip/_vendor/rich/constrain.py", + "lib/python3.10/site-packages/pip/_vendor/rich/containers.py", + "lib/python3.10/site-packages/pip/_vendor/rich/control.py", + "lib/python3.10/site-packages/pip/_vendor/rich/default_styles.py", + "lib/python3.10/site-packages/pip/_vendor/rich/diagnose.py", + "lib/python3.10/site-packages/pip/_vendor/rich/emoji.py", + "lib/python3.10/site-packages/pip/_vendor/rich/errors.py", + "lib/python3.10/site-packages/pip/_vendor/rich/file_proxy.py", + "lib/python3.10/site-packages/pip/_vendor/rich/filesize.py", + "lib/python3.10/site-packages/pip/_vendor/rich/highlighter.py", + "lib/python3.10/site-packages/pip/_vendor/rich/json.py", + "lib/python3.10/site-packages/pip/_vendor/rich/jupyter.py", + "lib/python3.10/site-packages/pip/_vendor/rich/layout.py", + "lib/python3.10/site-packages/pip/_vendor/rich/live.py", + "lib/python3.10/site-packages/pip/_vendor/rich/live_render.py", + "lib/python3.10/site-packages/pip/_vendor/rich/logging.py", + "lib/python3.10/site-packages/pip/_vendor/rich/markup.py", + "lib/python3.10/site-packages/pip/_vendor/rich/measure.py", + "lib/python3.10/site-packages/pip/_vendor/rich/padding.py", + "lib/python3.10/site-packages/pip/_vendor/rich/pager.py", + "lib/python3.10/site-packages/pip/_vendor/rich/palette.py", + "lib/python3.10/site-packages/pip/_vendor/rich/panel.py", + "lib/python3.10/site-packages/pip/_vendor/rich/pretty.py", + "lib/python3.10/site-packages/pip/_vendor/rich/progress.py", + "lib/python3.10/site-packages/pip/_vendor/rich/progress_bar.py", + "lib/python3.10/site-packages/pip/_vendor/rich/prompt.py", + "lib/python3.10/site-packages/pip/_vendor/rich/protocol.py", + "lib/python3.10/site-packages/pip/_vendor/rich/py.typed", + "lib/python3.10/site-packages/pip/_vendor/rich/region.py", + "lib/python3.10/site-packages/pip/_vendor/rich/repr.py", + "lib/python3.10/site-packages/pip/_vendor/rich/rule.py", + "lib/python3.10/site-packages/pip/_vendor/rich/scope.py", + "lib/python3.10/site-packages/pip/_vendor/rich/screen.py", + "lib/python3.10/site-packages/pip/_vendor/rich/segment.py", + "lib/python3.10/site-packages/pip/_vendor/rich/spinner.py", + "lib/python3.10/site-packages/pip/_vendor/rich/status.py", + "lib/python3.10/site-packages/pip/_vendor/rich/style.py", + "lib/python3.10/site-packages/pip/_vendor/rich/styled.py", + "lib/python3.10/site-packages/pip/_vendor/rich/syntax.py", + "lib/python3.10/site-packages/pip/_vendor/rich/table.py", + "lib/python3.10/site-packages/pip/_vendor/rich/terminal_theme.py", + "lib/python3.10/site-packages/pip/_vendor/rich/text.py", + "lib/python3.10/site-packages/pip/_vendor/rich/theme.py", + "lib/python3.10/site-packages/pip/_vendor/rich/themes.py", + "lib/python3.10/site-packages/pip/_vendor/rich/traceback.py", + "lib/python3.10/site-packages/pip/_vendor/rich/tree.py", + "lib/python3.10/site-packages/pip/_vendor/six.py", + "lib/python3.10/site-packages/pip/_vendor/tenacity/__init__.py", + "lib/python3.10/site-packages/pip/_vendor/tenacity/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/tenacity/__pycache__/_asyncio.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/tenacity/__pycache__/_utils.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/tenacity/__pycache__/after.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/tenacity/__pycache__/before.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/tenacity/__pycache__/before_sleep.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/tenacity/__pycache__/nap.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/tenacity/__pycache__/retry.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/tenacity/__pycache__/stop.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/tenacity/__pycache__/tornadoweb.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/tenacity/__pycache__/wait.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/tenacity/_asyncio.py", + "lib/python3.10/site-packages/pip/_vendor/tenacity/_utils.py", + "lib/python3.10/site-packages/pip/_vendor/tenacity/after.py", + "lib/python3.10/site-packages/pip/_vendor/tenacity/before.py", + "lib/python3.10/site-packages/pip/_vendor/tenacity/before_sleep.py", + "lib/python3.10/site-packages/pip/_vendor/tenacity/nap.py", + "lib/python3.10/site-packages/pip/_vendor/tenacity/py.typed", + "lib/python3.10/site-packages/pip/_vendor/tenacity/retry.py", + "lib/python3.10/site-packages/pip/_vendor/tenacity/stop.py", + "lib/python3.10/site-packages/pip/_vendor/tenacity/tornadoweb.py", + "lib/python3.10/site-packages/pip/_vendor/tenacity/wait.py", + "lib/python3.10/site-packages/pip/_vendor/tomli/__init__.py", + "lib/python3.10/site-packages/pip/_vendor/tomli/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/tomli/__pycache__/_parser.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/tomli/__pycache__/_re.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/tomli/__pycache__/_types.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/tomli/_parser.py", + "lib/python3.10/site-packages/pip/_vendor/tomli/_re.py", + "lib/python3.10/site-packages/pip/_vendor/tomli/_types.py", + "lib/python3.10/site-packages/pip/_vendor/tomli/py.typed", + "lib/python3.10/site-packages/pip/_vendor/truststore/__init__.py", + "lib/python3.10/site-packages/pip/_vendor/truststore/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/truststore/__pycache__/_api.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/truststore/__pycache__/_macos.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/truststore/__pycache__/_openssl.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/truststore/__pycache__/_ssl_constants.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/truststore/__pycache__/_windows.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/truststore/_api.py", + "lib/python3.10/site-packages/pip/_vendor/truststore/_macos.py", + "lib/python3.10/site-packages/pip/_vendor/truststore/_openssl.py", + "lib/python3.10/site-packages/pip/_vendor/truststore/_ssl_constants.py", + "lib/python3.10/site-packages/pip/_vendor/truststore/_windows.py", + "lib/python3.10/site-packages/pip/_vendor/truststore/py.typed", + "lib/python3.10/site-packages/pip/_vendor/typing_extensions.py", + "lib/python3.10/site-packages/pip/_vendor/urllib3/__init__.py", + "lib/python3.10/site-packages/pip/_vendor/urllib3/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/urllib3/__pycache__/_collections.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/urllib3/__pycache__/_version.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/urllib3/__pycache__/connection.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/urllib3/__pycache__/connectionpool.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/urllib3/__pycache__/exceptions.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/urllib3/__pycache__/fields.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/urllib3/__pycache__/filepost.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/urllib3/__pycache__/poolmanager.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/urllib3/__pycache__/request.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/urllib3/__pycache__/response.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/urllib3/_collections.py", + "lib/python3.10/site-packages/pip/_vendor/urllib3/_version.py", + "lib/python3.10/site-packages/pip/_vendor/urllib3/connection.py", + "lib/python3.10/site-packages/pip/_vendor/urllib3/connectionpool.py", + "lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/__init__.py", + "lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/__pycache__/_appengine_environ.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/__pycache__/appengine.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/__pycache__/ntlmpool.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/__pycache__/pyopenssl.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/__pycache__/securetransport.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/__pycache__/socks.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/_appengine_environ.py", + "lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/_securetransport/__init__.py", + "lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/_securetransport/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/_securetransport/__pycache__/bindings.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/_securetransport/__pycache__/low_level.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/_securetransport/bindings.py", + "lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/_securetransport/low_level.py", + "lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/appengine.py", + "lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/ntlmpool.py", + "lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/pyopenssl.py", + "lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/securetransport.py", + "lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/socks.py", + "lib/python3.10/site-packages/pip/_vendor/urllib3/exceptions.py", + "lib/python3.10/site-packages/pip/_vendor/urllib3/fields.py", + "lib/python3.10/site-packages/pip/_vendor/urllib3/filepost.py", + "lib/python3.10/site-packages/pip/_vendor/urllib3/packages/__init__.py", + "lib/python3.10/site-packages/pip/_vendor/urllib3/packages/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/urllib3/packages/__pycache__/six.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/urllib3/packages/backports/__init__.py", + "lib/python3.10/site-packages/pip/_vendor/urllib3/packages/backports/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/urllib3/packages/backports/__pycache__/makefile.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/urllib3/packages/backports/__pycache__/weakref_finalize.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/urllib3/packages/backports/makefile.py", + "lib/python3.10/site-packages/pip/_vendor/urllib3/packages/backports/weakref_finalize.py", + "lib/python3.10/site-packages/pip/_vendor/urllib3/packages/six.py", + "lib/python3.10/site-packages/pip/_vendor/urllib3/poolmanager.py", + "lib/python3.10/site-packages/pip/_vendor/urllib3/request.py", + "lib/python3.10/site-packages/pip/_vendor/urllib3/response.py", + "lib/python3.10/site-packages/pip/_vendor/urllib3/util/__init__.py", + "lib/python3.10/site-packages/pip/_vendor/urllib3/util/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/urllib3/util/__pycache__/connection.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/urllib3/util/__pycache__/proxy.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/urllib3/util/__pycache__/queue.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/urllib3/util/__pycache__/request.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/urllib3/util/__pycache__/response.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/urllib3/util/__pycache__/retry.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/urllib3/util/__pycache__/ssl_.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/urllib3/util/__pycache__/ssl_match_hostname.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/urllib3/util/__pycache__/ssltransport.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/urllib3/util/__pycache__/timeout.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/urllib3/util/__pycache__/url.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/urllib3/util/__pycache__/wait.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/urllib3/util/connection.py", + "lib/python3.10/site-packages/pip/_vendor/urllib3/util/proxy.py", + "lib/python3.10/site-packages/pip/_vendor/urllib3/util/queue.py", + "lib/python3.10/site-packages/pip/_vendor/urllib3/util/request.py", + "lib/python3.10/site-packages/pip/_vendor/urllib3/util/response.py", + "lib/python3.10/site-packages/pip/_vendor/urllib3/util/retry.py", + "lib/python3.10/site-packages/pip/_vendor/urllib3/util/ssl_.py", + "lib/python3.10/site-packages/pip/_vendor/urllib3/util/ssl_match_hostname.py", + "lib/python3.10/site-packages/pip/_vendor/urllib3/util/ssltransport.py", + "lib/python3.10/site-packages/pip/_vendor/urllib3/util/timeout.py", + "lib/python3.10/site-packages/pip/_vendor/urllib3/util/url.py", + "lib/python3.10/site-packages/pip/_vendor/urllib3/util/wait.py", + "lib/python3.10/site-packages/pip/_vendor/vendor.txt", + "lib/python3.10/site-packages/pip/_vendor/webencodings/__init__.py", + "lib/python3.10/site-packages/pip/_vendor/webencodings/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/webencodings/__pycache__/labels.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/webencodings/__pycache__/mklabels.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/webencodings/__pycache__/tests.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/webencodings/__pycache__/x_user_defined.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/webencodings/labels.py", + "lib/python3.10/site-packages/pip/_vendor/webencodings/mklabels.py", + "lib/python3.10/site-packages/pip/_vendor/webencodings/tests.py", + "lib/python3.10/site-packages/pip/_vendor/webencodings/x_user_defined.py", + "lib/python3.10/site-packages/pip/py.typed" + ], + "fn": "pip-24.0-py310hca03da5_0.conda", + "license": "MIT", + "link": { + "source": "/Users/donjayamanne/.pyenv/versions/miniconda3-latest/pkgs/pip-24.0-py310hca03da5_0", + "type": 1 + }, + "md5": "d34ad3a54a4c5a6b653bdb0cd186153f", + "name": "pip", + "package_tarball_full_path": "/Users/donjayamanne/.pyenv/versions/miniconda3-latest/pkgs/pip-24.0-py310hca03da5_0.conda", + "paths_data": { + "paths": [ + { + "_path": "bin/pip", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_cbgv4j_lrp/croot/pip_1715096990868/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_", + "sha256": "366a754e29388d827c6ddc3ad3ebe532c91403b136fe5ca552e9ba8b30c4242a", + "sha256_in_prefix": "0b9fb01801730dfd65fc78452054d96f50e69cba2f4e41eb87a722dc214a95b9", + "size_in_bytes": 475 + }, + { + "_path": "bin/pip3", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_cbgv4j_lrp/croot/pip_1715096990868/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_", + "sha256": "366a754e29388d827c6ddc3ad3ebe532c91403b136fe5ca552e9ba8b30c4242a", + "sha256_in_prefix": "0b9fb01801730dfd65fc78452054d96f50e69cba2f4e41eb87a722dc214a95b9", + "size_in_bytes": 475 + }, + { + "_path": "lib/python3.10/site-packages/pip-24.0-py3.10.egg-info/PKG-INFO", + "path_type": "hardlink", + "sha256": "90d11f277fd5868da679ee257c97656dde511c8aac7d025231407e6ce90839e2", + "sha256_in_prefix": "90d11f277fd5868da679ee257c97656dde511c8aac7d025231407e6ce90839e2", + "size_in_bytes": 3581 + }, + { + "_path": "lib/python3.10/site-packages/pip-24.0-py3.10.egg-info/SOURCES.txt", + "path_type": "hardlink", + "sha256": "8c2e778e48f6ac271da58e18be23377e88dea24ca3743a0112483cc2f0a7c6b3", + "sha256_in_prefix": "8c2e778e48f6ac271da58e18be23377e88dea24ca3743a0112483cc2f0a7c6b3", + "size_in_bytes": 24039 + }, + { + "_path": "lib/python3.10/site-packages/pip-24.0-py3.10.egg-info/dependency_links.txt", + "path_type": "hardlink", + "sha256": "01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b", + "sha256_in_prefix": "01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b", + "size_in_bytes": 1 + }, + { + "_path": "lib/python3.10/site-packages/pip-24.0-py3.10.egg-info/entry_points.txt", + "path_type": "hardlink", + "sha256": "ca764dd7fef4eff2f6dce6bcfcee4b3b112871c8f59c36b8c474f981a95f37ba", + "sha256_in_prefix": "ca764dd7fef4eff2f6dce6bcfcee4b3b112871c8f59c36b8c474f981a95f37ba", + "size_in_bytes": 125 + }, + { + "_path": "lib/python3.10/site-packages/pip-24.0-py3.10.egg-info/top_level.txt", + "path_type": "hardlink", + "sha256": "ceebae7b8927a3227e5303cf5e0f1f7b34bb542ad7250ac03fbcde36ec2f1508", + "sha256_in_prefix": "ceebae7b8927a3227e5303cf5e0f1f7b34bb542ad7250ac03fbcde36ec2f1508", + "size_in_bytes": 4 + }, + { + "_path": "lib/python3.10/site-packages/pip/__init__.py", + "path_type": "hardlink", + "sha256": "a009359c5a4b994552e4b9fb371bcda06527e55927e851908cf68d0dff10f299", + "sha256_in_prefix": "a009359c5a4b994552e4b9fb371bcda06527e55927e851908cf68d0dff10f299", + "size_in_bytes": 355 + }, + { + "_path": "lib/python3.10/site-packages/pip/__main__.py", + "path_type": "hardlink", + "sha256": "5b36e11d74db484ea0058d7d98d37d9b8b39a3fdfae4b3af4d84a0aa06dd0611", + "sha256_in_prefix": "5b36e11d74db484ea0058d7d98d37d9b8b39a3fdfae4b3af4d84a0aa06dd0611", + "size_in_bytes": 854 + }, + { + "_path": "lib/python3.10/site-packages/pip/__pip-runner__.py", + "path_type": "hardlink", + "sha256": "127adf2a628ccd601daa0fc989c2c238ff58f79531ef31e1e0e6efa8bb50723a", + "sha256_in_prefix": "127adf2a628ccd601daa0fc989c2c238ff58f79531ef31e1e0e6efa8bb50723a", + "size_in_bytes": 1444 + }, + { + "_path": "lib/python3.10/site-packages/pip/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "e0fd1e97fcfb4e26a60349e8450a3d66eb98d77607fc4a2472a7b231b96420cb", + "sha256_in_prefix": "e0fd1e97fcfb4e26a60349e8450a3d66eb98d77607fc4a2472a7b231b96420cb", + "size_in_bytes": 591 + }, + { + "_path": "lib/python3.10/site-packages/pip/__pycache__/__main__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "8fc9271253bfb9ee7b1a998d5ff7a96204657950790578224b88122f034471c5", + "sha256_in_prefix": "8fc9271253bfb9ee7b1a998d5ff7a96204657950790578224b88122f034471c5", + "size_in_bytes": 427 + }, + { + "_path": "lib/python3.10/site-packages/pip/__pycache__/__pip-runner__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "945480e1cba5b18c501ee71aff3d9144949473e970a9686632f9c425a07a57f8", + "sha256_in_prefix": "945480e1cba5b18c501ee71aff3d9144949473e970a9686632f9c425a07a57f8", + "size_in_bytes": 1591 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/__init__.py", + "path_type": "hardlink", + "sha256": "8aa679f9842c415d3cb6451cecbf34e917a8a7ab60b8b1567fbd32485e9b7b46", + "sha256_in_prefix": "8aa679f9842c415d3cb6451cecbf34e917a8a7ab60b8b1567fbd32485e9b7b46", + "size_in_bytes": 515 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "e96e59213533be0f2dcad34cdf17c850b870eda6cf4775da1c17598439f43dc4", + "sha256_in_prefix": "e96e59213533be0f2dcad34cdf17c850b870eda6cf4775da1c17598439f43dc4", + "size_in_bytes": 655 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/__pycache__/build_env.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "594628a3fe30b92516dfa2024b4779deedb8cd62ad168c9966a5953267f7689f", + "sha256_in_prefix": "594628a3fe30b92516dfa2024b4779deedb8cd62ad168c9966a5953267f7689f", + "size_in_bytes": 9672 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/__pycache__/cache.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "450e0058a879cd2fce0e5f80c294eec7f9e14eae45eabc09fa44d43bbec83416", + "sha256_in_prefix": "450e0058a879cd2fce0e5f80c294eec7f9e14eae45eabc09fa44d43bbec83416", + "size_in_bytes": 9006 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/__pycache__/configuration.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "2e4d711457821910b72f5152d063cf8dba2ae8807d166c5b7918382943f2ffaa", + "sha256_in_prefix": "2e4d711457821910b72f5152d063cf8dba2ae8807d166c5b7918382943f2ffaa", + "size_in_bytes": 11609 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/__pycache__/exceptions.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "81d79ad4a323fb68910175baaa0a04cc49d0587981cc4dbe1748486b6154cb24", + "sha256_in_prefix": "81d79ad4a323fb68910175baaa0a04cc49d0587981cc4dbe1748486b6154cb24", + "size_in_bytes": 25427 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/__pycache__/main.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "f23de3baf654be7727c55e9242a49ef6c6c97a8f4f2c848468df1c3ee6763d78", + "sha256_in_prefix": "f23de3baf654be7727c55e9242a49ef6c6c97a8f4f2c848468df1c3ee6763d78", + "size_in_bytes": 579 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/__pycache__/pyproject.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "a11518385c5a9e996bf655aeb7139447bc52d38d1a1c3f94d2fb6360212b7264", + "sha256_in_prefix": "a11518385c5a9e996bf655aeb7139447bc52d38d1a1c3f94d2fb6360212b7264", + "size_in_bytes": 3601 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/__pycache__/self_outdated_check.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "15590e5d51c40bacd2aee486ca248ae9dac3efde2d8205d751426a78fca8e4fb", + "sha256_in_prefix": "15590e5d51c40bacd2aee486ca248ae9dac3efde2d8205d751426a78fca8e4fb", + "size_in_bytes": 6905 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/__pycache__/wheel_builder.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "bf5201d2b952f16ed1f4239a56d542c45143fe85ade3678c79126abb462a17d9", + "sha256_in_prefix": "bf5201d2b952f16ed1f4239a56d542c45143fe85ade3678c79126abb462a17d9", + "size_in_bytes": 8606 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/build_env.py", + "path_type": "hardlink", + "sha256": "d444a9ab0d22ba94bf2bba6164ae73b21544e42cf2f41b462c55385ba127bdaf", + "sha256_in_prefix": "d444a9ab0d22ba94bf2bba6164ae73b21544e42cf2f41b462c55385ba127bdaf", + "size_in_bytes": 10243 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/cache.py", + "path_type": "hardlink", + "sha256": "ba2603fbd17406fd42f19c9613ce65a730e641fee17149202fdf46988f08e354", + "sha256_in_prefix": "ba2603fbd17406fd42f19c9613ce65a730e641fee17149202fdf46988f08e354", + "size_in_bytes": 10370 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/cli/__init__.py", + "path_type": "hardlink", + "sha256": "1641c1829c716fefe077aaf51639cd85f30ecc0518c97a17289e9a6e28df7055", + "sha256_in_prefix": "1641c1829c716fefe077aaf51639cd85f30ecc0518c97a17289e9a6e28df7055", + "size_in_bytes": 132 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/cli/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "7666923c7fca56cb4057bb4f4522503d8f1317defc43933f1f63f35bc9278957", + "sha256_in_prefix": "7666923c7fca56cb4057bb4f4522503d8f1317defc43933f1f63f35bc9278957", + "size_in_bytes": 234 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/cli/__pycache__/autocompletion.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "8e6831602939e44630d1e52f1c5685179af030a9b8326cf4fb8044177d73ff72", + "sha256_in_prefix": "8e6831602939e44630d1e52f1c5685179af030a9b8326cf4fb8044177d73ff72", + "size_in_bytes": 5368 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/cli/__pycache__/base_command.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "e4fd71594c88c9b96deddbbf833ed716245fef3e7f31be2faef738b8e2ee5a72", + "sha256_in_prefix": "e4fd71594c88c9b96deddbbf833ed716245fef3e7f31be2faef738b8e2ee5a72", + "size_in_bytes": 6451 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/cli/__pycache__/cmdoptions.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "312d376dbcdb029efa8ccea838e7b19fc23184bc799b8f596df5466aa1992184", + "sha256_in_prefix": "312d376dbcdb029efa8ccea838e7b19fc23184bc799b8f596df5466aa1992184", + "size_in_bytes": 23471 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/cli/__pycache__/command_context.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "58790d71fc296425fc849fe8b8a69fd3b49636a9a63f6d77b930589d384590dc", + "sha256_in_prefix": "58790d71fc296425fc849fe8b8a69fd3b49636a9a63f6d77b930589d384590dc", + "size_in_bytes": 1274 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/cli/__pycache__/main.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "dfcd85a07824030febc7f6b01dbf5cdbc6704d4a9ebd1567834cfa6083772e66", + "sha256_in_prefix": "dfcd85a07824030febc7f6b01dbf5cdbc6704d4a9ebd1567834cfa6083772e66", + "size_in_bytes": 1468 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/cli/__pycache__/main_parser.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "3c6dd424a462b0ed1f32a1d0844a9fc47b73ebe2b7ac1c6a3c22c77e0ccf7200", + "sha256_in_prefix": "3c6dd424a462b0ed1f32a1d0844a9fc47b73ebe2b7ac1c6a3c22c77e0ccf7200", + "size_in_bytes": 2957 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/cli/__pycache__/parser.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c2b87bc2f5065c9ff627b3862e9c978268e119fc8bfdd1655058b63e522f32a8", + "sha256_in_prefix": "c2b87bc2f5065c9ff627b3862e9c978268e119fc8bfdd1655058b63e522f32a8", + "size_in_bytes": 9883 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/cli/__pycache__/progress_bars.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "ed598bf92f582895286b3ffdd2e1c875ec41dcbd15da0e7b478042d6dcf5c566", + "sha256_in_prefix": "ed598bf92f582895286b3ffdd2e1c875ec41dcbd15da0e7b478042d6dcf5c566", + "size_in_bytes": 1858 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/cli/__pycache__/req_command.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "ec0edfdefad5c45b37f3c28258ff26cce191861e27ea75f0dfaed2c20697fd16", + "sha256_in_prefix": "ec0edfdefad5c45b37f3c28258ff26cce191861e27ea75f0dfaed2c20697fd16", + "size_in_bytes": 13129 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/cli/__pycache__/spinners.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "40e2fc1e64bdb305ea097d098d90ea8b1011928dc5a6b2d6d58a245e9d808e98", + "sha256_in_prefix": "40e2fc1e64bdb305ea097d098d90ea8b1011928dc5a6b2d6d58a245e9d808e98", + "size_in_bytes": 4924 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/cli/__pycache__/status_codes.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "d61474c0ff8af420c040d71def40ff657dfdf5e291c1e10c78c585f5e67b7b6f", + "sha256_in_prefix": "d61474c0ff8af420c040d71def40ff657dfdf5e291c1e10c78c585f5e67b7b6f", + "size_in_bytes": 313 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/cli/autocompletion.py", + "path_type": "hardlink", + "sha256": "fdbaffe4d812c52baf3e3305d0c2c7cd2e6ce81a529100101caacb2bcf556ae3", + "sha256_in_prefix": "fdbaffe4d812c52baf3e3305d0c2c7cd2e6ce81a529100101caacb2bcf556ae3", + "size_in_bytes": 6690 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/cli/base_command.py", + "path_type": "hardlink", + "sha256": "8ae55619ada84eaee00517a8d1eaf7674b57276a2a0480ba4230c77270e12976", + "sha256_in_prefix": "8ae55619ada84eaee00517a8d1eaf7674b57276a2a0480ba4230c77270e12976", + "size_in_bytes": 8733 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/cli/cmdoptions.py", + "path_type": "hardlink", + "sha256": "d44226f32322c503042cee10ce881d2285a4bc8950aa5016d189cf78e9a7bc40", + "sha256_in_prefix": "d44226f32322c503042cee10ce881d2285a4bc8950aa5016d189cf78e9a7bc40", + "size_in_bytes": 30064 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/cli/command_context.py", + "path_type": "hardlink", + "sha256": "4478083f0b4e6e1e4a84cadddd8653925f336d51bee8e92697b61b157e04860d", + "sha256_in_prefix": "4478083f0b4e6e1e4a84cadddd8653925f336d51bee8e92697b61b157e04860d", + "size_in_bytes": 774 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/cli/main.py", + "path_type": "hardlink", + "sha256": "533c6dfd80f5848bc1d405b99b1b7a215721b791bbd7602d32a768e7550c8664", + "sha256_in_prefix": "533c6dfd80f5848bc1d405b99b1b7a215721b791bbd7602d32a768e7550c8664", + "size_in_bytes": 2816 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/cli/main_parser.py", + "path_type": "hardlink", + "sha256": "95a0e9b2e04397a9327f2c29f5e30c03db3ce237c7d932499febe62f4186f74c", + "sha256_in_prefix": "95a0e9b2e04397a9327f2c29f5e30c03db3ce237c7d932499febe62f4186f74c", + "size_in_bytes": 4338 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/cli/parser.py", + "path_type": "hardlink", + "sha256": "296e82dfeefee04ad3341d137cb4cac0e74771dfaa79f09e1a7acea04dabd114", + "sha256_in_prefix": "296e82dfeefee04ad3341d137cb4cac0e74771dfaa79f09e1a7acea04dabd114", + "size_in_bytes": 10781 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/cli/progress_bars.py", + "path_type": "hardlink", + "sha256": "4a8e263e84a35e45e2487893cf3aae1f7555c950ff9e35e51c9484c583d7028c", + "sha256_in_prefix": "4a8e263e84a35e45e2487893cf3aae1f7555c950ff9e35e51c9484c583d7028c", + "size_in_bytes": 1968 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/cli/req_command.py", + "path_type": "hardlink", + "sha256": "73bfd71c00675e60f7fea94af7eaf7ecaa9d28101c82654abd0d96713acd2df7", + "sha256_in_prefix": "73bfd71c00675e60f7fea94af7eaf7ecaa9d28101c82654abd0d96713acd2df7", + "size_in_bytes": 18369 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/cli/spinners.py", + "path_type": "hardlink", + "sha256": "84827cdc67ab74580509da1b200db726081eb5e825fee0b84a9e7cea7cc56cf1", + "sha256_in_prefix": "84827cdc67ab74580509da1b200db726081eb5e825fee0b84a9e7cea7cc56cf1", + "size_in_bytes": 5118 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/cli/status_codes.py", + "path_type": "hardlink", + "sha256": "b0414751a5096eabfc880acbdc702d733b5666618e157d358537ac4b2b43121d", + "sha256_in_prefix": "b0414751a5096eabfc880acbdc702d733b5666618e157d358537ac4b2b43121d", + "size_in_bytes": 116 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/commands/__init__.py", + "path_type": "hardlink", + "sha256": "e6844ef4eddd336bc6ba1d1b170e0739595eb6bcabcf91c732698f5b026b1fd5", + "sha256_in_prefix": "e6844ef4eddd336bc6ba1d1b170e0739595eb6bcabcf91c732698f5b026b1fd5", + "size_in_bytes": 3882 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/commands/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "813d610ce97ca43f477492dcea148e7abfa4747ff91e4ec013e0396d9f4fae66", + "sha256_in_prefix": "813d610ce97ca43f477492dcea148e7abfa4747ff91e4ec013e0396d9f4fae66", + "size_in_bytes": 3213 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/commands/__pycache__/cache.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "b2f9f6c236010c5f71142c3b98d5574ebfe147fecc633fbef188bee339ecd263", + "sha256_in_prefix": "b2f9f6c236010c5f71142c3b98d5574ebfe147fecc633fbef188bee339ecd263", + "size_in_bytes": 6384 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/commands/__pycache__/check.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "9f90d2303ca253f0a1536cf7f8e2b6b4ac61571fd4187d4f31a86f52756bf754", + "sha256_in_prefix": "9f90d2303ca253f0a1536cf7f8e2b6b4ac61571fd4187d4f31a86f52756bf754", + "size_in_bytes": 1592 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/commands/__pycache__/completion.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "914b9f775952aff92ec497c69837cba794a44a605592c33923ce712f566776b4", + "sha256_in_prefix": "914b9f775952aff92ec497c69837cba794a44a605592c33923ce712f566776b4", + "size_in_bytes": 4280 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/commands/__pycache__/configuration.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "4be67c5d55392a9ecbf9df6337a391b8ca4d05afb94c619892ca5b00fd11c6e3", + "sha256_in_prefix": "4be67c5d55392a9ecbf9df6337a391b8ca4d05afb94c619892ca5b00fd11c6e3", + "size_in_bytes": 8897 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/commands/__pycache__/debug.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "9341a5bb30011a0524687db1da9a782b29a97a80f0285c5f57c4fa7fb26c5168", + "sha256_in_prefix": "9341a5bb30011a0524687db1da9a782b29a97a80f0285c5f57c4fa7fb26c5168", + "size_in_bytes": 6847 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/commands/__pycache__/download.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "1bf5b84d909e74414918e9feaecd53a6de65ca8f43ec1bb9cf7619b2b05bfd92", + "sha256_in_prefix": "1bf5b84d909e74414918e9feaecd53a6de65ca8f43ec1bb9cf7619b2b05bfd92", + "size_in_bytes": 4207 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/commands/__pycache__/freeze.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "d808c4b1108b80ca30692fb1e2c8e6d761d840eda5b21c42c9a9dc022a742d71", + "sha256_in_prefix": "d808c4b1108b80ca30692fb1e2c8e6d761d840eda5b21c42c9a9dc022a742d71", + "size_in_bytes": 2933 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/commands/__pycache__/hash.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "b66d9d51dfd0222fe6ebdc7d05196dde74f333916f3bc5a31f9d321ca4e9caef", + "sha256_in_prefix": "b66d9d51dfd0222fe6ebdc7d05196dde74f333916f3bc5a31f9d321ca4e9caef", + "size_in_bytes": 2110 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/commands/__pycache__/help.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "a2911791cf3600dbe76aaef25649207936f1ab16c09f78d8429e133e2d965046", + "sha256_in_prefix": "a2911791cf3600dbe76aaef25649207936f1ab16c09f78d8429e133e2d965046", + "size_in_bytes": 1271 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/commands/__pycache__/index.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "6fb3ca7885549a427aec319b9bb777a4055981f721b27ae96b52640dece145c0", + "sha256_in_prefix": "6fb3ca7885549a427aec319b9bb777a4055981f721b27ae96b52640dece145c0", + "size_in_bytes": 4548 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/commands/__pycache__/inspect.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "524c6842a83271edd4030dea4379a3ebfbb05a46390442fe5697da65edd81d81", + "sha256_in_prefix": "524c6842a83271edd4030dea4379a3ebfbb05a46390442fe5697da65edd81d81", + "size_in_bytes": 2931 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/commands/__pycache__/install.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "a63beba0af3766a94e59a72bbb5e0ab5ded892d2422ee397f9bdf88d12638a04", + "sha256_in_prefix": "a63beba0af3766a94e59a72bbb5e0ab5ded892d2422ee397f9bdf88d12638a04", + "size_in_bytes": 17681 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/commands/__pycache__/list.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "412d281088a9025e33fa7668c285107a6591fe8dce1ee053abcc72473916ebc2", + "sha256_in_prefix": "412d281088a9025e33fa7668c285107a6591fe8dce1ee053abcc72473916ebc2", + "size_in_bytes": 10329 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/commands/__pycache__/search.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "ce20e7db06341f267531c11dff9525ab3ac5077789c32501d5dac1867e0f643a", + "sha256_in_prefix": "ce20e7db06341f267531c11dff9525ab3ac5077789c32501d5dac1867e0f643a", + "size_in_bytes": 5324 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/commands/__pycache__/show.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "6b208ccd04397ff0d6a9f3480fb1f6840ac1e6eb520ba7f510ddfece4e246f25", + "sha256_in_prefix": "6b208ccd04397ff0d6a9f3480fb1f6840ac1e6eb520ba7f510ddfece4e246f25", + "size_in_bytes": 6485 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/commands/__pycache__/uninstall.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "d69503fff5de1e570fe9bfd2cd638066bfcd3fc2f62e21ac25f79122d0e63ad9", + "sha256_in_prefix": "d69503fff5de1e570fe9bfd2cd638066bfcd3fc2f62e21ac25f79122d0e63ad9", + "size_in_bytes": 3292 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/commands/__pycache__/wheel.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "311bae0a6d053c2036880fe89ddf248f92f13d29f50a666f7cd19b3f4bb6ff8b", + "sha256_in_prefix": "311bae0a6d053c2036880fe89ddf248f92f13d29f50a666f7cd19b3f4bb6ff8b", + "size_in_bytes": 4938 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/commands/cache.py", + "path_type": "hardlink", + "sha256": "c60efafd9144042eb3a10de05cb45f31925fb78cf66b44701f81841590ba9e75", + "sha256_in_prefix": "c60efafd9144042eb3a10de05cb45f31925fb78cf66b44701f81841590ba9e75", + "size_in_bytes": 7944 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/commands/check.py", + "path_type": "hardlink", + "sha256": "45bd77436f32a0b8748f5829c79494d239517ac35cb76d5e40246c9da3bdc4a0", + "sha256_in_prefix": "45bd77436f32a0b8748f5829c79494d239517ac35cb76d5e40246c9da3bdc4a0", + "size_in_bytes": 1782 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/commands/completion.py", + "path_type": "hardlink", + "sha256": "1d3e250f46e0b1f947ab62038187e211da7b2061ad13bb3a320237c67d15404c", + "sha256_in_prefix": "1d3e250f46e0b1f947ab62038187e211da7b2061ad13bb3a320237c67d15404c", + "size_in_bytes": 4287 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/commands/configuration.py", + "path_type": "hardlink", + "sha256": "9fdf1e9f0a7acb46f91ba7e24508da668e3716524a62f7bf75a32137ee0144d7", + "sha256_in_prefix": "9fdf1e9f0a7acb46f91ba7e24508da668e3716524a62f7bf75a32137ee0144d7", + "size_in_bytes": 9766 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/commands/debug.py", + "path_type": "hardlink", + "sha256": "eb7f7bdae50278c20639d30c55e2141ab3a34cea93556a65142f366be85c2b20", + "sha256_in_prefix": "eb7f7bdae50278c20639d30c55e2141ab3a34cea93556a65142f366be85c2b20", + "size_in_bytes": 6777 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/commands/download.py", + "path_type": "hardlink", + "sha256": "7b8870d3cf331a8dba5a625a30846f0a788b94b9a83a3aa8946c9f1e3b029024", + "sha256_in_prefix": "7b8870d3cf331a8dba5a625a30846f0a788b94b9a83a3aa8946c9f1e3b029024", + "size_in_bytes": 5335 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/commands/freeze.py", + "path_type": "hardlink", + "sha256": "daa8d0ac7f4a5a2e51a1abf40ae47bbdcee15a6e2e3a2ff497ab69dc448a0c73", + "sha256_in_prefix": "daa8d0ac7f4a5a2e51a1abf40ae47bbdcee15a6e2e3a2ff497ab69dc448a0c73", + "size_in_bytes": 3172 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/commands/hash.py", + "path_type": "hardlink", + "sha256": "11554ebaf1ada0f11d162f1236799daa5090ae10b157e909b1dc2d75c0a75c64", + "sha256_in_prefix": "11554ebaf1ada0f11d162f1236799daa5090ae10b157e909b1dc2d75c0a75c64", + "size_in_bytes": 1703 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/commands/help.py", + "path_type": "hardlink", + "sha256": "81c73a40391c80730eb809f9531699c004adb1106b9c64a7ff2c634b9ec92283", + "sha256_in_prefix": "81c73a40391c80730eb809f9531699c004adb1106b9c64a7ff2c634b9ec92283", + "size_in_bytes": 1132 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/commands/index.py", + "path_type": "hardlink", + "sha256": "08d5d07abfcf799292268a1445c08508110a19fc3236851660ffcc59ccc070e3", + "sha256_in_prefix": "08d5d07abfcf799292268a1445c08508110a19fc3236851660ffcc59ccc070e3", + "size_in_bytes": 4775 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/commands/inspect.py", + "path_type": "hardlink", + "sha256": "db048fb7dc9faf7afa83eb364b92fa3ef46d687355c9be13ba874c4ad277f5cc", + "sha256_in_prefix": "db048fb7dc9faf7afa83eb364b92fa3ef46d687355c9be13ba874c4ad277f5cc", + "size_in_bytes": 3188 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/commands/install.py", + "path_type": "hardlink", + "sha256": "5710ddf810f76b6ec0a5e13638adf8adf0574ba668db0b5e98af7e1c2c0fab13", + "sha256_in_prefix": "5710ddf810f76b6ec0a5e13638adf8adf0574ba668db0b5e98af7e1c2c0fab13", + "size_in_bytes": 28782 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/commands/list.py", + "path_type": "hardlink", + "sha256": "ef0454526772c8e92797e59961b3bf2ed150c47956a1dde98ce63dc981f8df9a", + "sha256_in_prefix": "ef0454526772c8e92797e59961b3bf2ed150c47956a1dde98ce63dc981f8df9a", + "size_in_bytes": 12450 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/commands/search.py", + "path_type": "hardlink", + "sha256": "b1b059880451734e7442ab8e29c0af3abd8add72eca1879b2ca646462fff8942", + "sha256_in_prefix": "b1b059880451734e7442ab8e29c0af3abd8add72eca1879b2ca646462fff8942", + "size_in_bytes": 5697 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/commands/show.py", + "path_type": "hardlink", + "sha256": "b798e26b8cdc609449672e14fd5a27ef3325d378499a67287e3ea80cd4e78fb6", + "sha256_in_prefix": "b798e26b8cdc609449672e14fd5a27ef3325d378499a67287e3ea80cd4e78fb6", + "size_in_bytes": 6419 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/commands/uninstall.py", + "path_type": "hardlink", + "sha256": "388a8ef6da9a758f243381f08457f543ad9f508a7bbfc283ad3468f3258ccfb6", + "sha256_in_prefix": "388a8ef6da9a758f243381f08457f543ad9f508a7bbfc283ad3468f3258ccfb6", + "size_in_bytes": 3886 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/commands/wheel.py", + "path_type": "hardlink", + "sha256": "0929d7f0f99fd683c29ddee3edb9f5fdfe7c1bd28736201b96f549e73ca437e0", + "sha256_in_prefix": "0929d7f0f99fd683c29ddee3edb9f5fdfe7c1bd28736201b96f549e73ca437e0", + "size_in_bytes": 6476 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/configuration.py", + "path_type": "hardlink", + "sha256": "5e4022052d21a73b0cf8b17442ee61bcf58efc1b3aefea1029160506e31b112b", + "sha256_in_prefix": "5e4022052d21a73b0cf8b17442ee61bcf58efc1b3aefea1029160506e31b112b", + "size_in_bytes": 14006 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/distributions/__init__.py", + "path_type": "hardlink", + "sha256": "1eaea4b7a8170608cd8ade614d358b03378234e2a807e374a46612a9e86b962f", + "sha256_in_prefix": "1eaea4b7a8170608cd8ade614d358b03378234e2a807e374a46612a9e86b962f", + "size_in_bytes": 858 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/distributions/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "607f0986956a297871cce6a6294892e27687408ad6a83cbd2f8dbecaf38d4dc0", + "sha256_in_prefix": "607f0986956a297871cce6a6294892e27687408ad6a83cbd2f8dbecaf38d4dc0", + "size_in_bytes": 761 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/distributions/__pycache__/base.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "45767910a2be775bb07beef7b13d3139fd61b8aaa673117bab4afaeaabd4a157", + "sha256_in_prefix": "45767910a2be775bb07beef7b13d3139fd61b8aaa673117bab4afaeaabd4a157", + "size_in_bytes": 2443 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/distributions/__pycache__/installed.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "0bf93a8b94deec8946e4eefdbff0cd3ac09868a0b7202827bf72850bf53dad17", + "sha256_in_prefix": "0bf93a8b94deec8946e4eefdbff0cd3ac09868a0b7202827bf72850bf53dad17", + "size_in_bytes": 1445 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/distributions/__pycache__/sdist.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "33263ebfe42dd4bf4c049010e596d4d506a4fbe43fb7f22d28d108c452065d56", + "sha256_in_prefix": "33263ebfe42dd4bf4c049010e596d4d506a4fbe43fb7f22d28d108c452065d56", + "size_in_bytes": 5248 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/distributions/__pycache__/wheel.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "1cfd215afa0017eef4589b5f56a706a1bd17fc7fc93d959e58f483b770b2ab10", + "sha256_in_prefix": "1cfd215afa0017eef4589b5f56a706a1bd17fc7fc93d959e58f483b770b2ab10", + "size_in_bytes": 1810 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/distributions/base.py", + "path_type": "hardlink", + "sha256": "a11484be7bf66630676ab81a9a7bf67dc25ad67ea050329a5b483a096484a56b", + "sha256_in_prefix": "a11484be7bf66630676ab81a9a7bf67dc25ad67ea050329a5b483a096484a56b", + "size_in_bytes": 1743 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/distributions/installed.py", + "path_type": "hardlink", + "sha256": "4229c715b58043ca04d296c3f0c1595a4c259df5354184dc700d6f9e1ae560e5", + "sha256_in_prefix": "4229c715b58043ca04d296c3f0c1595a4c259df5354184dc700d6f9e1ae560e5", + "size_in_bytes": 842 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/distributions/sdist.py", + "path_type": "hardlink", + "sha256": "e0add5d1534c9651db07308989b8f077fb729542a998876ed8043286996f090a", + "sha256_in_prefix": "e0add5d1534c9651db07308989b8f077fb729542a998876ed8043286996f090a", + "size_in_bytes": 6709 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/distributions/wheel.py", + "path_type": "hardlink", + "sha256": "fa66b7b0eb54423d00c570846fafc58668e5de78789370341c2dad6806f637ee", + "sha256_in_prefix": "fa66b7b0eb54423d00c570846fafc58668e5de78789370341c2dad6806f637ee", + "size_in_bytes": 1277 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/exceptions.py", + "path_type": "hardlink", + "sha256": "4e617588d1449de49669e9b0960e9ae5ba4fbaad9c3072bb775f92be3b101dbd", + "sha256_in_prefix": "4e617588d1449de49669e9b0960e9ae5ba4fbaad9c3072bb775f92be3b101dbd", + "size_in_bytes": 23634 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/index/__init__.py", + "path_type": "hardlink", + "sha256": "be9b7e25e4d979f87c6be142db665e0525c555bb817174868882e141925a3694", + "sha256_in_prefix": "be9b7e25e4d979f87c6be142db665e0525c555bb817174868882e141925a3694", + "size_in_bytes": 30 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/index/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "69a390c14c42d321c0914ec949ee92a37b01839659b49ed0d1c0e99bc74fa8b3", + "sha256_in_prefix": "69a390c14c42d321c0914ec949ee92a37b01839659b49ed0d1c0e99bc74fa8b3", + "size_in_bytes": 188 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/index/__pycache__/collector.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "031675c584ab7350ac7c0a35733640bc136e4e4d2385435c122a3a786e16aa1a", + "sha256_in_prefix": "031675c584ab7350ac7c0a35733640bc136e4e4d2385435c122a3a786e16aa1a", + "size_in_bytes": 15273 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/index/__pycache__/package_finder.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "5738cfc23be31a5de5bdc4fb8a6af2219b001e4279afdaccb9cdbe6091732cbd", + "sha256_in_prefix": "5738cfc23be31a5de5bdc4fb8a6af2219b001e4279afdaccb9cdbe6091732cbd", + "size_in_bytes": 29416 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/index/__pycache__/sources.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "31120cdc964f7ea0fb5d580e653e7df00fa5990460714094792074cfc971b99e", + "sha256_in_prefix": "31120cdc964f7ea0fb5d580e653e7df00fa5990460714094792074cfc971b99e", + "size_in_bytes": 8878 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/index/collector.py", + "path_type": "hardlink", + "sha256": "b07d2d2ff70ea0293aa4b2df0921958c5338acf109b65945f95a1bbc0bcb487e", + "sha256_in_prefix": "b07d2d2ff70ea0293aa4b2df0921958c5338acf109b65945f95a1bbc0bcb487e", + "size_in_bytes": 16590 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/index/package_finder.py", + "path_type": "hardlink", + "sha256": "4bf9c2f20cd520c63a8a459f2a848ecd1b687ac52a9df36100f97f07048ebac0", + "sha256_in_prefix": "4bf9c2f20cd520c63a8a459f2a848ecd1b687ac52a9df36100f97f07048ebac0", + "size_in_bytes": 37843 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/index/sources.py", + "path_type": "hardlink", + "sha256": "7497a0891f5ff3a92c95a00772ff7e4792ff5c17f94739bf164c8fb5e0ee3f12", + "sha256_in_prefix": "7497a0891f5ff3a92c95a00772ff7e4792ff5c17f94739bf164c8fb5e0ee3f12", + "size_in_bytes": 8688 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/locations/__init__.py", + "path_type": "hardlink", + "sha256": "0e1f0b2561bc2d19432b82488fdb1f445f7a4d113313ef8dfc0225c7b4eaa1ee", + "sha256_in_prefix": "0e1f0b2561bc2d19432b82488fdb1f445f7a4d113313ef8dfc0225c7b4eaa1ee", + "size_in_bytes": 15365 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/locations/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "543771607cf9710fc2840954e4f175764d55b1a5c11ccd3dbe3a8149267905eb", + "sha256_in_prefix": "543771607cf9710fc2840954e4f175764d55b1a5c11ccd3dbe3a8149267905eb", + "size_in_bytes": 10990 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/locations/__pycache__/_distutils.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "fa829cee9ea8c494818bc21dc0d0251590e30367ca7bcbdacfb3e2302bf43b41", + "sha256_in_prefix": "fa829cee9ea8c494818bc21dc0d0251590e30367ca7bcbdacfb3e2302bf43b41", + "size_in_bytes": 4555 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/locations/__pycache__/_sysconfig.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "e03191cb83e2edab66ef78200e6296d2d7c182046590ebb6dd2c15d610600f64", + "sha256_in_prefix": "e03191cb83e2edab66ef78200e6296d2d7c182046590ebb6dd2c15d610600f64", + "size_in_bytes": 5954 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/locations/__pycache__/base.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "cbcb41a5a229afd88823cf487064f10a7a4b2fd15faf070ae5e6da6e83ca3783", + "sha256_in_prefix": "cbcb41a5a229afd88823cf487064f10a7a4b2fd15faf070ae5e6da6e83ca3783", + "size_in_bytes": 2358 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/locations/_distutils.py", + "path_type": "hardlink", + "sha256": "1fd6472bfdf9add0d5d50b268b841e68150b8c54f831bbba42ea151a427a4072", + "sha256_in_prefix": "1fd6472bfdf9add0d5d50b268b841e68150b8c54f831bbba42ea151a427a4072", + "size_in_bytes": 6009 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/locations/_sysconfig.py", + "path_type": "hardlink", + "sha256": "8f2355b547cc21fd26b7263e5e9d66f7243c8b0102a334955459a390df5adb2c", + "sha256_in_prefix": "8f2355b547cc21fd26b7263e5e9d66f7243c8b0102a334955459a390df5adb2c", + "size_in_bytes": 7680 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/locations/base.py", + "path_type": "hardlink", + "sha256": "45088f8b5778155336071934e1d4215d9d8faa47a58c42f67d967d498a8843bf", + "sha256_in_prefix": "45088f8b5778155336071934e1d4215d9d8faa47a58c42f67d967d498a8843bf", + "size_in_bytes": 2556 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/main.py", + "path_type": "hardlink", + "sha256": "afe52751ef072e8e57149cfc8a74dc38e4e2bbfb313618076fa57094652594e2", + "sha256_in_prefix": "afe52751ef072e8e57149cfc8a74dc38e4e2bbfb313618076fa57094652594e2", + "size_in_bytes": 340 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/metadata/__init__.py", + "path_type": "hardlink", + "sha256": "f695375b7b3ee87b6316e62159c2d36159926b38a494fbfb936c7ca7b5f51a60", + "sha256_in_prefix": "f695375b7b3ee87b6316e62159c2d36159926b38a494fbfb936c7ca7b5f51a60", + "size_in_bytes": 4339 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/metadata/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "861964f842ddfa556d5de1ea9a3e609533707091361d3602e05fb9433d58107c", + "sha256_in_prefix": "861964f842ddfa556d5de1ea9a3e609533707091361d3602e05fb9433d58107c", + "size_in_bytes": 4765 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/metadata/__pycache__/_json.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "33054b9763411f70c08e133a84b4c6e5925a4ffefa2fcdb7636dd8c6500f947d", + "sha256_in_prefix": "33054b9763411f70c08e133a84b4c6e5925a4ffefa2fcdb7636dd8c6500f947d", + "size_in_bytes": 2148 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/metadata/__pycache__/base.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "f14cbca4dfda836981fd3260e4ae7222b89e173d50250a310f750c267530de0a", + "sha256_in_prefix": "f14cbca4dfda836981fd3260e4ae7222b89e173d50250a310f750c267530de0a", + "size_in_bytes": 27293 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/metadata/__pycache__/pkg_resources.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "43550af0a83b9ab255b0ede77cce1a683edc02b83fdf2de2eca92f09bfc9d423", + "sha256_in_prefix": "43550af0a83b9ab255b0ede77cce1a683edc02b83fdf2de2eca92f09bfc9d423", + "size_in_bytes": 10575 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/metadata/_json.py", + "path_type": "hardlink", + "sha256": "473e4ce5c89236f213c1a4d047a35f37c4e02a033959f4f0b380fa085927a2f1", + "sha256_in_prefix": "473e4ce5c89236f213c1a4d047a35f37c4e02a033959f4f0b380fa085927a2f1", + "size_in_bytes": 2627 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/metadata/base.py", + "path_type": "hardlink", + "sha256": "9775a092ee31960afcb38a7a7d2fb7a90e1028ea4f6d62d1c22e5df68984146e", + "sha256_in_prefix": "9775a092ee31960afcb38a7a7d2fb7a90e1028ea4f6d62d1c22e5df68984146e", + "size_in_bytes": 25907 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/metadata/importlib/__init__.py", + "path_type": "hardlink", + "sha256": "8d4522768c671dc7c84c71da0161b51b68b97dd058925bffb89723a36c7b5581", + "sha256_in_prefix": "8d4522768c671dc7c84c71da0161b51b68b97dd058925bffb89723a36c7b5581", + "size_in_bytes": 135 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/metadata/importlib/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "52dd6c236e1b15c4a1938cb7ae38a49bbf53f0322cb688200cd45b49a5a4b1c0", + "sha256_in_prefix": "52dd6c236e1b15c4a1938cb7ae38a49bbf53f0322cb688200cd45b49a5a4b1c0", + "size_in_bytes": 309 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/metadata/importlib/__pycache__/_compat.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "db84e4886b8d75889e53bca9bfd0698bc74e4d72e74f5e77f7567105dc6eaaf3", + "sha256_in_prefix": "db84e4886b8d75889e53bca9bfd0698bc74e4d72e74f5e77f7567105dc6eaaf3", + "size_in_bytes": 2711 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/metadata/importlib/__pycache__/_dists.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "742292acadd77d850af71d28ad8595ad5dc00fc447f0649faa065ad071263ea1", + "sha256_in_prefix": "742292acadd77d850af71d28ad8595ad5dc00fc447f0649faa065ad071263ea1", + "size_in_bytes": 9017 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/metadata/importlib/__pycache__/_envs.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "9cfddaee4e55bdf1e45415def89eb48e873fdc1763d5628572b107dfe23ce368", + "sha256_in_prefix": "9cfddaee4e55bdf1e45415def89eb48e873fdc1763d5628572b107dfe23ce368", + "size_in_bytes": 7709 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/metadata/importlib/_compat.py", + "path_type": "hardlink", + "sha256": "1807bfa6b21f084e2253296b9ebff67494659240554546ce89d128203ecb3e81", + "sha256_in_prefix": "1807bfa6b21f084e2253296b9ebff67494659240554546ce89d128203ecb3e81", + "size_in_bytes": 1882 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/metadata/importlib/_dists.py", + "path_type": "hardlink", + "sha256": "50f975c14ba316a8b08a5b51275b4c178d9644834ed6c4a934d958436997d269", + "sha256_in_prefix": "50f975c14ba316a8b08a5b51275b4c178d9644834ed6c4a934d958436997d269", + "size_in_bytes": 8297 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/metadata/importlib/_envs.py", + "path_type": "hardlink", + "sha256": "5d36852181113f6245d10519b8fc761138ae8176cf11c67cabc64a7a1b7a2e97", + "sha256_in_prefix": "5d36852181113f6245d10519b8fc761138ae8176cf11c67cabc64a7a1b7a2e97", + "size_in_bytes": 7456 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/metadata/pkg_resources.py", + "path_type": "hardlink", + "sha256": "a298f0e08052a87be27bab1727f71b4f8da67b28283c451f354449b96658eec9", + "sha256_in_prefix": "a298f0e08052a87be27bab1727f71b4f8da67b28283c451f354449b96658eec9", + "size_in_bytes": 10035 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/models/__init__.py", + "path_type": "hardlink", + "sha256": "dc31d477fab1a4fa337f3a2ea2a6bd83db6cd42cebe6a6877c5c5b9f1ae27a93", + "sha256_in_prefix": "dc31d477fab1a4fa337f3a2ea2a6bd83db6cd42cebe6a6877c5c5b9f1ae27a93", + "size_in_bytes": 63 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/models/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "b63a6402d5bb5d36abe55dba13dcd58db1069e4c21aa45885f05aa53f4822309", + "sha256_in_prefix": "b63a6402d5bb5d36abe55dba13dcd58db1069e4c21aa45885f05aa53f4822309", + "size_in_bytes": 222 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/models/__pycache__/candidate.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "8c994d8dbc021a43ddc837e99370390d8c83b1d1b31067b73b5f00508d01537b", + "sha256_in_prefix": "8c994d8dbc021a43ddc837e99370390d8c83b1d1b31067b73b5f00508d01537b", + "size_in_bytes": 1400 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/models/__pycache__/direct_url.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "f5588aab47ecf0ea704cb9d1320eb6599c2417fa5272cebc5fb2fb4feab42f1c", + "sha256_in_prefix": "f5588aab47ecf0ea704cb9d1320eb6599c2417fa5272cebc5fb2fb4feab42f1c", + "size_in_bytes": 7667 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/models/__pycache__/format_control.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "f2e1ca4f858597da147ca52817bc47756d4a328e38b00b96ec80f63231860ede", + "sha256_in_prefix": "f2e1ca4f858597da147ca52817bc47756d4a328e38b00b96ec80f63231860ede", + "size_in_bytes": 2693 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/models/__pycache__/index.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "835ba1d4298335c63321d77db00da004e6fcecd5fcdad837fa604cb531e8d5f7", + "sha256_in_prefix": "835ba1d4298335c63321d77db00da004e6fcecd5fcdad837fa604cb531e8d5f7", + "size_in_bytes": 1191 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/models/__pycache__/installation_report.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "688171b3b48406bd1ec254678321fad9e2344d6eb79678722a0244817f958591", + "sha256_in_prefix": "688171b3b48406bd1ec254678321fad9e2344d6eb79678722a0244817f958591", + "size_in_bytes": 1712 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/models/__pycache__/link.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "d2c7d1a09f8c51365300e10a03e84bf79da1d95af71f57775d63091d290d50e1", + "sha256_in_prefix": "d2c7d1a09f8c51365300e10a03e84bf79da1d95af71f57775d63091d290d50e1", + "size_in_bytes": 18046 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/models/__pycache__/scheme.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "f81d193dc53abdda00d423c9b2e74f54ad6fa6b0e6f4b5215e43ed7419fca2ba", + "sha256_in_prefix": "f81d193dc53abdda00d423c9b2e74f54ad6fa6b0e6f4b5215e43ed7419fca2ba", + "size_in_bytes": 990 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/models/__pycache__/search_scope.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "ec3186710a3870fdd89b70b39e509e2ad9ec7752cfbe9e4ee9f8c08556749a50", + "sha256_in_prefix": "ec3186710a3870fdd89b70b39e509e2ad9ec7752cfbe9e4ee9f8c08556749a50", + "size_in_bytes": 3509 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/models/__pycache__/selection_prefs.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "b224a792d03a0d3e4949c355ae83f2a8f63f51dba0d29c3e535ca1f79db4bf74", + "sha256_in_prefix": "b224a792d03a0d3e4949c355ae83f2a8f63f51dba0d29c3e535ca1f79db4bf74", + "size_in_bytes": 1652 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/models/__pycache__/target_python.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "285aaceef8becf406f632f4c52cba58697f3c116b491fec5033a0a498cf16a8a", + "sha256_in_prefix": "285aaceef8becf406f632f4c52cba58697f3c116b491fec5033a0a498cf16a8a", + "size_in_bytes": 3769 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/models/__pycache__/wheel.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "da2a4373cc919f36f630959b0c312336f4414c58d772bc4da11ab50de41de8cb", + "sha256_in_prefix": "da2a4373cc919f36f630959b0c312336f4414c58d772bc4da11ab50de41de8cb", + "size_in_bytes": 4422 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/models/candidate.py", + "path_type": "hardlink", + "sha256": "8443eef15746139a95012bfabcbcfe47e460879fbb2cc6da8b58e0b6130277c3", + "sha256_in_prefix": "8443eef15746139a95012bfabcbcfe47e460879fbb2cc6da8b58e0b6130277c3", + "size_in_bytes": 931 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/models/direct_url.py", + "path_type": "hardlink", + "sha256": "170a2e60129ca9c921ec1fa4d87dc75604618454ee905c2a892de47efb452d29", + "sha256_in_prefix": "170a2e60129ca9c921ec1fa4d87dc75604618454ee905c2a892de47efb452d29", + "size_in_bytes": 6889 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/models/format_control.py", + "path_type": "hardlink", + "sha256": "c2db10a922bd1da522371404b81f82eb67958a6c3a1b8fd5405c55f7efca0c11", + "sha256_in_prefix": "c2db10a922bd1da522371404b81f82eb67958a6c3a1b8fd5405c55f7efca0c11", + "size_in_bytes": 2486 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/models/index.py", + "path_type": "hardlink", + "sha256": "b589cbf28c468b8692356babd261bc0c03fbac2eb2ba16bf33024ef31c3472b2", + "sha256_in_prefix": "b589cbf28c468b8692356babd261bc0c03fbac2eb2ba16bf33024ef31c3472b2", + "size_in_bytes": 1030 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/models/installation_report.py", + "path_type": "hardlink", + "sha256": "cd1559a1acfedafb2b7b38ff1f784b3a131908af5ced36f35a00be8ce6a50f4d", + "sha256_in_prefix": "cd1559a1acfedafb2b7b38ff1f784b3a131908af5ced36f35a00be8ce6a50f4d", + "size_in_bytes": 2818 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/models/link.py", + "path_type": "hardlink", + "sha256": "5e2ace006bf58e032eeefbbcee4b8f6e88468fb547a7056b776ab729481540d8", + "sha256_in_prefix": "5e2ace006bf58e032eeefbbcee4b8f6e88468fb547a7056b776ab729481540d8", + "size_in_bytes": 20777 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/models/scheme.py", + "path_type": "hardlink", + "sha256": "dc4150a7f202bbfb211f5f9306a865d1002eb0a08f0c53a580715e3785e8c16b", + "sha256_in_prefix": "dc4150a7f202bbfb211f5f9306a865d1002eb0a08f0c53a580715e3785e8c16b", + "size_in_bytes": 738 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/models/search_scope.py", + "path_type": "hardlink", + "sha256": "012572c99c622482f0edb4c8555a49c7c276f773371e4e45df78a51a7d1ef347", + "sha256_in_prefix": "012572c99c622482f0edb4c8555a49c7c276f773371e4e45df78a51a7d1ef347", + "size_in_bytes": 4643 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/models/selection_prefs.py", + "path_type": "hardlink", + "sha256": "299762eba82c47efd151752bf6e7a3b2c937ae64c7ad054959e340dac57e5526", + "sha256_in_prefix": "299762eba82c47efd151752bf6e7a3b2c937ae64c7ad054959e340dac57e5526", + "size_in_bytes": 1907 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/models/target_python.py", + "path_type": "hardlink", + "sha256": "df8124a2baccb91bd1a7e6e3a87289f9b38eef59bdc5d8cdd9bf16585102d875", + "sha256_in_prefix": "df8124a2baccb91bd1a7e6e3a87289f9b38eef59bdc5d8cdd9bf16585102d875", + "size_in_bytes": 4272 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/models/wheel.py", + "path_type": "hardlink", + "sha256": "62a6b3a0867299afd0d5e8c56b50bb3472904515a5bd691d2bde9544a98305e2", + "sha256_in_prefix": "62a6b3a0867299afd0d5e8c56b50bb3472904515a5bd691d2bde9544a98305e2", + "size_in_bytes": 3600 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/network/__init__.py", + "path_type": "hardlink", + "sha256": "8dfe93b799d5ffbce401106b2a88c85c8b607a3be87a054954a51b8406b92287", + "sha256_in_prefix": "8dfe93b799d5ffbce401106b2a88c85c8b607a3be87a054954a51b8406b92287", + "size_in_bytes": 50 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/network/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "7193bd2d2a5b393102335fd35bb849ef8a121d15781877bdd089f76a5985baa2", + "sha256_in_prefix": "7193bd2d2a5b393102335fd35bb849ef8a121d15781877bdd089f76a5985baa2", + "size_in_bytes": 210 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/network/__pycache__/auth.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "38d5dcfdfd0166d6c5dcb3f9127c2c9d8460e68a830a3adda7c01119bd6bfe50", + "sha256_in_prefix": "38d5dcfdfd0166d6c5dcb3f9127c2c9d8460e68a830a3adda7c01119bd6bfe50", + "size_in_bytes": 14381 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/network/__pycache__/cache.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "a1902bc95cee60a60eaa5f91051315807c047270f1b7e2d775308f84197bb365", + "sha256_in_prefix": "a1902bc95cee60a60eaa5f91051315807c047270f1b7e2d775308f84197bb365", + "size_in_bytes": 4548 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/network/__pycache__/download.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "6c7940db8a0a68e655a0b3cad422ac5ee8da7a0ae6ba5b5469eb4fb890adb04a", + "sha256_in_prefix": "6c7940db8a0a68e655a0b3cad422ac5ee8da7a0ae6ba5b5469eb4fb890adb04a", + "size_in_bytes": 5486 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/network/__pycache__/lazy_wheel.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "117f6267c73f72411e6f5e7b906354c005e96b6786c8573da75ee77396da4f26", + "sha256_in_prefix": "117f6267c73f72411e6f5e7b906354c005e96b6786c8573da75ee77396da4f26", + "size_in_bytes": 8378 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/network/__pycache__/session.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "0a7da29c11d541ea861493b4fe2ecc28c8743facdc8ba37890b0153c455b3a95", + "sha256_in_prefix": "0a7da29c11d541ea861493b4fe2ecc28c8743facdc8ba37890b0153c455b3a95", + "size_in_bytes": 12479 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/network/__pycache__/utils.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "2d5734c8527604d6523a8068389af38a5135cae30aa3e515067d0e5d7cba479d", + "sha256_in_prefix": "2d5734c8527604d6523a8068389af38a5135cae30aa3e515067d0e5d7cba479d", + "size_in_bytes": 1413 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/network/__pycache__/xmlrpc.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "224acec9948602bb36268d90a56f08ac4196c835017ce92a3f7602294f189a2b", + "sha256_in_prefix": "224acec9948602bb36268d90a56f08ac4196c835017ce92a3f7602294f189a2b", + "size_in_bytes": 2066 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/network/auth.py", + "path_type": "hardlink", + "sha256": "4c2f8e716d8a5385ba475854e2a3e0417bd51f9e1a7400a9673eac5aaf91f4d0", + "sha256_in_prefix": "4c2f8e716d8a5385ba475854e2a3e0417bd51f9e1a7400a9673eac5aaf91f4d0", + "size_in_bytes": 20541 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/network/cache.py", + "path_type": "hardlink", + "sha256": "e3c03def5a82cca345be46f9eee18493bfb4c5aa8f4b41d68f6ef5d50353c645", + "sha256_in_prefix": "e3c03def5a82cca345be46f9eee18493bfb4c5aa8f4b41d68f6ef5d50353c645", + "size_in_bytes": 3935 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/network/download.py", + "path_type": "hardlink", + "sha256": "8b44e7e79083e43ed7604158dd3c6261a09fd0e69a4d0e9249c3600ac49e575e", + "sha256_in_prefix": "8b44e7e79083e43ed7604158dd3c6261a09fd0e69a4d0e9249c3600ac49e575e", + "size_in_bytes": 6086 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/network/lazy_wheel.py", + "path_type": "hardlink", + "sha256": "d8f5d576e6193c23d99244057b527519b7c725678253ef855e89c6c887f0f5e5", + "sha256_in_prefix": "d8f5d576e6193c23d99244057b527519b7c725678253ef855e89c6c887f0f5e5", + "size_in_bytes": 7638 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/network/session.py", + "path_type": "hardlink", + "sha256": "f6da840c3f0989568576994e117271368f5c8d17c167a4486b4c9043fa813623", + "sha256_in_prefix": "f6da840c3f0989568576994e117271368f5c8d17c167a4486b4c9043fa813623", + "size_in_bytes": 18698 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/network/utils.py", + "path_type": "hardlink", + "sha256": "e80e52ad42441141f16c6b5bb1cc14d8da42cb3fb7ced883946587a51461b09f", + "sha256_in_prefix": "e80e52ad42441141f16c6b5bb1cc14d8da42cb3fb7ced883946587a51461b09f", + "size_in_bytes": 4073 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/network/xmlrpc.py", + "path_type": "hardlink", + "sha256": "b00c7339a709f8dd4d5c63ef6a9f630b7cee6164a79efdc65ed811dbe13600f0", + "sha256_in_prefix": "b00c7339a709f8dd4d5c63ef6a9f630b7cee6164a79efdc65ed811dbe13600f0", + "size_in_bytes": 1838 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/operations/__init__.py", + "path_type": "hardlink", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size_in_bytes": 0 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/operations/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "3edfe6f0441b3faadd64890f7ae7a90450d919b86c9ce2efb7ee0babbd9f47cd", + "sha256_in_prefix": "3edfe6f0441b3faadd64890f7ae7a90450d919b86c9ce2efb7ee0babbd9f47cd", + "size_in_bytes": 158 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/operations/__pycache__/check.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "0bb4166bce96f9a65dd3b1500f8f286623b1a320cf4e7333ebc22081ee610847", + "sha256_in_prefix": "0bb4166bce96f9a65dd3b1500f8f286623b1a320cf4e7333ebc22081ee610847", + "size_in_bytes": 5162 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/operations/__pycache__/freeze.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "9febdfa46bd06b5ed9b424ecdecb889ac426f385078457db7a627863b591499a", + "sha256_in_prefix": "9febdfa46bd06b5ed9b424ecdecb889ac426f385078457db7a627863b591499a", + "size_in_bytes": 6179 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/operations/__pycache__/prepare.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "e57bf3dd5fae30e0b1ff8872a9e7c28acf4a09b7c9aa23953beec67ceb4f7b51", + "sha256_in_prefix": "e57bf3dd5fae30e0b1ff8872a9e7c28acf4a09b7c9aa23953beec67ceb4f7b51", + "size_in_bytes": 15616 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/operations/build/__init__.py", + "path_type": "hardlink", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size_in_bytes": 0 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/operations/build/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "deffa7a31f32811c6b017e3a5a6bc36dd664cea6b0a9cb939b1f161aa55f7886", + "sha256_in_prefix": "deffa7a31f32811c6b017e3a5a6bc36dd664cea6b0a9cb939b1f161aa55f7886", + "size_in_bytes": 164 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/operations/build/__pycache__/build_tracker.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c3500c082ce86867760da3a4f1c1e1562bcf695a83d8d2a9210fba3b43bec99f", + "sha256_in_prefix": "c3500c082ce86867760da3a4f1c1e1562bcf695a83d8d2a9210fba3b43bec99f", + "size_in_bytes": 5014 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/operations/build/__pycache__/metadata.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "bfdfe79a65289f97135d7c3800bafa089cf100b01078812c3f377f3a3a27d64c", + "sha256_in_prefix": "bfdfe79a65289f97135d7c3800bafa089cf100b01078812c3f377f3a3a27d64c", + "size_in_bytes": 1397 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/operations/build/__pycache__/metadata_editable.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "6ed16244ad15b705fc80682798314fa7267ed548ab9f9f0405fdb35a6dc7afbd", + "sha256_in_prefix": "6ed16244ad15b705fc80682798314fa7267ed548ab9f9f0405fdb35a6dc7afbd", + "size_in_bytes": 1431 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/operations/build/__pycache__/metadata_legacy.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "fc5160452eb3c3b11d3db4fe68a24b0c7cbad60c0734a9f173678c5a69c5290c", + "sha256_in_prefix": "fc5160452eb3c3b11d3db4fe68a24b0c7cbad60c0734a9f173678c5a69c5290c", + "size_in_bytes": 2336 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/operations/build/__pycache__/wheel.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "4338cbd96b0d7b010ae02cbc17f5de3acd1aa89e0bf13c9411cd606f2cabdf36", + "sha256_in_prefix": "4338cbd96b0d7b010ae02cbc17f5de3acd1aa89e0bf13c9411cd606f2cabdf36", + "size_in_bytes": 1187 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/operations/build/__pycache__/wheel_editable.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "541aa76ee61e6d688137f9ce550d77e2d56b40f739db8df300ccceb29f3adeb5", + "sha256_in_prefix": "541aa76ee61e6d688137f9ce550d77e2d56b40f739db8df300ccceb29f3adeb5", + "size_in_bytes": 1411 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/operations/build/__pycache__/wheel_legacy.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "fc02ba223b559b86d050cc77901bb1dd5e7860df9a07f335c1d68f0a1eab5e8f", + "sha256_in_prefix": "fc02ba223b559b86d050cc77901bb1dd5e7860df9a07f335c1d68f0a1eab5e8f", + "size_in_bytes": 2721 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/operations/build/build_tracker.py", + "path_type": "hardlink", + "sha256": "cfe1f90ce92765d05addd87656ae9504c639a8b6082a6963da9e821992b92dcf", + "sha256_in_prefix": "cfe1f90ce92765d05addd87656ae9504c639a8b6082a6963da9e821992b92dcf", + "size_in_bytes": 4832 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/operations/build/metadata.py", + "path_type": "hardlink", + "sha256": "f52d02503f14dd0a99797a7e672b7c1f1c14f74944e10ae760382ba990f30677", + "sha256_in_prefix": "f52d02503f14dd0a99797a7e672b7c1f1c14f74944e10ae760382ba990f30677", + "size_in_bytes": 1422 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/operations/build/metadata_editable.py", + "path_type": "hardlink", + "sha256": "54b2fb2ef9ed284f2ac5d854744261728b45cd4b0e488f0d352d38df150b29ec", + "sha256_in_prefix": "54b2fb2ef9ed284f2ac5d854744261728b45cd4b0e488f0d352d38df150b29ec", + "size_in_bytes": 1474 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/operations/build/metadata_legacy.py", + "path_type": "hardlink", + "sha256": "a3e794db502cd7be610c2edd96e3357c927f16aa244c84a1c96a6329a2291d9c", + "sha256_in_prefix": "a3e794db502cd7be610c2edd96e3357c927f16aa244c84a1c96a6329a2291d9c", + "size_in_bytes": 2198 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/operations/build/wheel.py", + "path_type": "hardlink", + "sha256": "b13d761412c0c430bac32ac3a2b87c92f719d631b9a889c2456cf33fe5242624", + "sha256_in_prefix": "b13d761412c0c430bac32ac3a2b87c92f719d631b9a889c2456cf33fe5242624", + "size_in_bytes": 1075 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/operations/build/wheel_editable.py", + "path_type": "hardlink", + "sha256": "c8eb681face9024a0a60452dafc161ceb62790d1d0690063590d8761a7b53108", + "sha256_in_prefix": "c8eb681face9024a0a60452dafc161ceb62790d1d0690063590d8761a7b53108", + "size_in_bytes": 1417 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/operations/build/wheel_legacy.py", + "path_type": "hardlink", + "sha256": "0bd8faaee920408d67fc97902e8646b8375f530cc25d287221d3d3a7a79d6cc4", + "sha256_in_prefix": "0bd8faaee920408d67fc97902e8646b8375f530cc25d287221d3d3a7a79d6cc4", + "size_in_bytes": 3064 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/operations/check.py", + "path_type": "hardlink", + "sha256": "7eca80f3c8866aa7ed0abdad94fdec494db4d824a4a0e0d1b56d0ef8953d3386", + "sha256_in_prefix": "7eca80f3c8866aa7ed0abdad94fdec494db4d824a4a0e0d1b56d0ef8953d3386", + "size_in_bytes": 6806 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/operations/freeze.py", + "path_type": "hardlink", + "sha256": "baaa1e4c07fa1ce615311d948004fc37ce54668184544a1075a9ff028e9239f9", + "sha256_in_prefix": "baaa1e4c07fa1ce615311d948004fc37ce54668184544a1075a9ff028e9239f9", + "size_in_bytes": 9816 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/operations/install/__init__.py", + "path_type": "hardlink", + "sha256": "997ee1c83d863413b69851a8903437d2bfc65efed8fcf2ddb71714bf5e387beb", + "sha256_in_prefix": "997ee1c83d863413b69851a8903437d2bfc65efed8fcf2ddb71714bf5e387beb", + "size_in_bytes": 51 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/operations/install/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "e52d15037251ac1b7b23e35816a2ab88e64476c54652b0c3341ac9f9f8a8197c", + "sha256_in_prefix": "e52d15037251ac1b7b23e35816a2ab88e64476c54652b0c3341ac9f9f8a8197c", + "size_in_bytes": 222 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/operations/install/__pycache__/editable_legacy.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c9fba6d325dae3d4ffc59a8c2e0d42e378ecf53447602d561a7c5030489d3912", + "sha256_in_prefix": "c9fba6d325dae3d4ffc59a8c2e0d42e378ecf53447602d561a7c5030489d3912", + "size_in_bytes": 1451 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/operations/install/__pycache__/wheel.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "6de7598fd3fb920cb145785b203d8449e558e421e9798089c8821f73329a56f4", + "sha256_in_prefix": "6de7598fd3fb920cb145785b203d8449e558e421e9798089c8821f73329a56f4", + "size_in_bytes": 21270 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/operations/install/editable_legacy.py", + "path_type": "hardlink", + "sha256": "61e47429a7565f0fd985e0b536d006d6a5481243a04461dcdb7c7e62d196ecd5", + "sha256_in_prefix": "61e47429a7565f0fd985e0b536d006d6a5481243a04461dcdb7c7e62d196ecd5", + "size_in_bytes": 1282 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/operations/install/wheel.py", + "path_type": "hardlink", + "sha256": "f6119bd5ce1b4673c86f6146ec2b5448f7cfc6aa6b987401b702009563cd4ed1", + "sha256_in_prefix": "f6119bd5ce1b4673c86f6146ec2b5448f7cfc6aa6b987401b702009563cd4ed1", + "size_in_bytes": 27311 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/operations/prepare.py", + "path_type": "hardlink", + "sha256": "e7b3aaf3b1dfba75f745baa9e3b15d689afd7076c02949bfde0bfb5a1040a9b1", + "sha256_in_prefix": "e7b3aaf3b1dfba75f745baa9e3b15d689afd7076c02949bfde0bfb5a1040a9b1", + "size_in_bytes": 28128 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/pyproject.py", + "path_type": "hardlink", + "sha256": "e17b33a75d7182bd76eb2cc6e816c9034a1a43d597ba16f48f251bfb2ffa94f4", + "sha256_in_prefix": "e17b33a75d7182bd76eb2cc6e816c9034a1a43d597ba16f48f251bfb2ffa94f4", + "size_in_bytes": 7152 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/req/__init__.py", + "path_type": "hardlink", + "sha256": "4c42c58193a87f796132668809558bf54ecf9615e8f4eb9fa246cc009e89d862", + "sha256_in_prefix": "4c42c58193a87f796132668809558bf54ecf9615e8f4eb9fa246cc009e89d862", + "size_in_bytes": 2738 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/req/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "b421ef150fd0b4c8f615c561263cb81a118d80dad55cef4d268a8029980b4690", + "sha256_in_prefix": "b421ef150fd0b4c8f615c561263cb81a118d80dad55cef4d268a8029980b4690", + "size_in_bytes": 2527 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/req/__pycache__/constructors.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "9ee65f3a993829d198ec85ede228bdeb065ef9d2e4a710f9472489007ccc42c9", + "sha256_in_prefix": "9ee65f3a993829d198ec85ede228bdeb065ef9d2e4a710f9472489007ccc42c9", + "size_in_bytes": 14111 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/req/__pycache__/req_file.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "6eb0738d5af2eed7ebb8403cdf95302c19b0bf65f8456ac7b869a712f2f6131c", + "sha256_in_prefix": "6eb0738d5af2eed7ebb8403cdf95302c19b0bf65f8456ac7b869a712f2f6131c", + "size_in_bytes": 13955 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/req/__pycache__/req_install.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "1e8b50ecbda0e2c2a0b26d60559b61961efd03edb99a26127ed8da469cfdd67d", + "sha256_in_prefix": "1e8b50ecbda0e2c2a0b26d60559b61961efd03edb99a26127ed8da469cfdd67d", + "size_in_bytes": 24478 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/req/__pycache__/req_set.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "625c7d0f1fe8d34856611ade9bf85c224f56c6e2f3ef60111a1c4fd415749f1d", + "sha256_in_prefix": "625c7d0f1fe8d34856611ade9bf85c224f56c6e2f3ef60111a1c4fd415749f1d", + "size_in_bytes": 5180 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/req/__pycache__/req_uninstall.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "32a450d8da2e064abb37b19a57b905c8d81fc9205596a0d46072f75d3fcfca67", + "sha256_in_prefix": "32a450d8da2e064abb37b19a57b905c8d81fc9205596a0d46072f75d3fcfca67", + "size_in_bytes": 19192 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/req/constructors.py", + "path_type": "hardlink", + "sha256": "f21958e7a8a612d84b3914709a5a322b3dd83b25f298868ab0d07a3fd7b0bcd2", + "sha256_in_prefix": "f21958e7a8a612d84b3914709a5a322b3dd83b25f298868ab0d07a3fd7b0bcd2", + "size_in_bytes": 19018 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/req/req_file.py", + "path_type": "hardlink", + "sha256": "33cb6d3992fe3f0023eec70f125856dd90f68620fd9a6ffa14900621bc00cc42", + "sha256_in_prefix": "33cb6d3992fe3f0023eec70f125856dd90f68620fd9a6ffa14900621bc00cc42", + "size_in_bytes": 17790 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/req/req_install.py", + "path_type": "hardlink", + "sha256": "c2d38fc64c9148cf1ca264e4b3ca0bd46a76a321aa6c7ec9c080d1722d9088f9", + "sha256_in_prefix": "c2d38fc64c9148cf1ca264e4b3ca0bd46a76a321aa6c7ec9c080d1722d9088f9", + "size_in_bytes": 35460 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/req/req_set.py", + "path_type": "hardlink", + "sha256": "88c603513a12824c45cab3ff3ab4ed3d2830e1dc234721910e91a8a13a9e0386", + "sha256_in_prefix": "88c603513a12824c45cab3ff3ab4ed3d2830e1dc234721910e91a8a13a9e0386", + "size_in_bytes": 4704 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/req/req_uninstall.py", + "path_type": "hardlink", + "sha256": "9e6bd341a4420b48aefb94f0d1d8e55c98528fa5a6a8746f4f7aa4904742df91", + "sha256_in_prefix": "9e6bd341a4420b48aefb94f0d1d8e55c98528fa5a6a8746f4f7aa4904742df91", + "size_in_bytes": 24551 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/resolution/__init__.py", + "path_type": "hardlink", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size_in_bytes": 0 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/resolution/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "fe5b36bd52bb995f36ec2c92a374b9219be59ca40365d05c5d8d771734010365", + "sha256_in_prefix": "fe5b36bd52bb995f36ec2c92a374b9219be59ca40365d05c5d8d771734010365", + "size_in_bytes": 158 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/resolution/__pycache__/base.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "4c4a736435a6386860a08f167dd3017f82af21984467d3ca43a5acd66e9ae1eb", + "sha256_in_prefix": "4c4a736435a6386860a08f167dd3017f82af21984467d3ca43a5acd66e9ae1eb", + "size_in_bytes": 1010 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/resolution/base.py", + "path_type": "hardlink", + "sha256": "aa59a1df6e520557ef1ba31ef6073936c879b1dc07070cc706ae9a117b4ab0b0", + "sha256_in_prefix": "aa59a1df6e520557ef1ba31ef6073936c879b1dc07070cc706ae9a117b4ab0b0", + "size_in_bytes": 583 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/resolution/legacy/__init__.py", + "path_type": "hardlink", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size_in_bytes": 0 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/resolution/legacy/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "4518bcf0ff7e35d97cd7fb5109cec1fbea799bcd62654aeebabbf108529ed754", + "sha256_in_prefix": "4518bcf0ff7e35d97cd7fb5109cec1fbea799bcd62654aeebabbf108529ed754", + "size_in_bytes": 165 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/resolution/legacy/__pycache__/resolver.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "df6fbb7a7e77a5eee5701d05774f14e5c10ff7c949aee5be1bbb3db5ac01a5b8", + "sha256_in_prefix": "df6fbb7a7e77a5eee5701d05774f14e5c10ff7c949aee5be1bbb3db5ac01a5b8", + "size_in_bytes": 14867 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/resolution/legacy/resolver.py", + "path_type": "hardlink", + "sha256": "5e4db88d0eb61af2ebe0c73b22337faa23bcf2aa740489b35663c8173f502ce1", + "sha256_in_prefix": "5e4db88d0eb61af2ebe0c73b22337faa23bcf2aa740489b35663c8173f502ce1", + "size_in_bytes": 24025 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/resolution/resolvelib/__init__.py", + "path_type": "hardlink", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size_in_bytes": 0 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/resolution/resolvelib/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "44f35f3ed68efa9a7db08477bf84fa65e0e6af23a6f36bd6a9ebdfadfd020cbd", + "sha256_in_prefix": "44f35f3ed68efa9a7db08477bf84fa65e0e6af23a6f36bd6a9ebdfadfd020cbd", + "size_in_bytes": 169 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/resolution/resolvelib/__pycache__/base.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "fcbf0dee0c57812c532d414e03b255d771ff558b08df6665dcaf8f5fec9f2db1", + "sha256_in_prefix": "fcbf0dee0c57812c532d414e03b255d771ff558b08df6665dcaf8f5fec9f2db1", + "size_in_bytes": 6222 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/resolution/resolvelib/__pycache__/candidates.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "f101be2db373f147cc04aaa3c83324a97ea8540081370cd7804b47c15a89f3f2", + "sha256_in_prefix": "f101be2db373f147cc04aaa3c83324a97ea8540081370cd7804b47c15a89f3f2", + "size_in_bytes": 20423 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/resolution/resolvelib/__pycache__/factory.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "14ec9c954dc7fd0f5e94720396e912d79e876194aa66882f57fea8e52f79ca61", + "sha256_in_prefix": "14ec9c954dc7fd0f5e94720396e912d79e876194aa66882f57fea8e52f79ca61", + "size_in_bytes": 21327 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/resolution/resolvelib/__pycache__/found_candidates.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "2cc5a71f2401e61d74e024c9ac63414d60eaca86ec536c9bda36afc4267bfcea", + "sha256_in_prefix": "2cc5a71f2401e61d74e024c9ac63414d60eaca86ec536c9bda36afc4267bfcea", + "size_in_bytes": 4829 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/resolution/resolvelib/__pycache__/provider.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "868b15665a5a3fd4b6745448b382ee58ca57bd927488c7639f4d18f09e42a78b", + "sha256_in_prefix": "868b15665a5a3fd4b6745448b382ee58ca57bd927488c7639f4d18f09e42a78b", + "size_in_bytes": 7897 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/resolution/resolvelib/__pycache__/reporter.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "a997b67a187aa59c7c6eeece5158b7cf64d25b7b3a0236e20a6fe40c9710b4a7", + "sha256_in_prefix": "a997b67a187aa59c7c6eeece5158b7cf64d25b7b3a0236e20a6fe40c9710b4a7", + "size_in_bytes": 3666 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/resolution/resolvelib/__pycache__/requirements.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "581e10b8d4e064bbc58eb15273306d0398e65458c3806c25fe3a7705e1606087", + "sha256_in_prefix": "581e10b8d4e064bbc58eb15273306d0398e65458c3806c25fe3a7705e1606087", + "size_in_bytes": 8181 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/resolution/resolvelib/__pycache__/resolver.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "98ece7d0be667bdd71071645768a9ffb27158dbf5005eec7dae8aafc39940bc2", + "sha256_in_prefix": "98ece7d0be667bdd71071645768a9ffb27158dbf5005eec7dae8aafc39940bc2", + "size_in_bytes": 8714 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/resolution/resolvelib/base.py", + "path_type": "hardlink", + "sha256": "8e0e423a61cb86604828e47ee2ca5d243de3c942d86b505db2a881bb66099c9e", + "sha256_in_prefix": "8e0e423a61cb86604828e47ee2ca5d243de3c942d86b505db2a881bb66099c9e", + "size_in_bytes": 5173 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/resolution/resolvelib/candidates.py", + "path_type": "hardlink", + "sha256": "d7d2a2f753e8f8c4b10649c621f38691a5a415d3b39cdd16fe72afee32f6f0bd", + "sha256_in_prefix": "d7d2a2f753e8f8c4b10649c621f38691a5a415d3b39cdd16fe72afee32f6f0bd", + "size_in_bytes": 21052 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/resolution/resolvelib/factory.py", + "path_type": "hardlink", + "sha256": "beaaa4fa18dc85d85287059575e5b6fc0fb965b94b844fe70bfbf7321cf84af7", + "sha256_in_prefix": "beaaa4fa18dc85d85287059575e5b6fc0fb965b94b844fe70bfbf7321cf84af7", + "size_in_bytes": 32292 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/resolution/resolvelib/found_candidates.py", + "path_type": "hardlink", + "sha256": "86f2f71e86bd55a628faa10e664062d88ab0db9d540f13f3fae30755a5a62e91", + "sha256_in_prefix": "86f2f71e86bd55a628faa10e664062d88ab0db9d540f13f3fae30755a5a62e91", + "size_in_bytes": 5705 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/resolution/resolvelib/provider.py", + "path_type": "hardlink", + "sha256": "e2ddb78af8ebbaa33a84a057d4aa46893b7e3381c68517199c62d5d1cd352bb5", + "sha256_in_prefix": "e2ddb78af8ebbaa33a84a057d4aa46893b7e3381c68517199c62d5d1cd352bb5", + "size_in_bytes": 9824 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/resolution/resolvelib/reporter.py", + "path_type": "hardlink", + "sha256": "6059bd850bf3e031426e365e153439ea14f3dc073e9830671e478d455bcc1cb6", + "sha256_in_prefix": "6059bd850bf3e031426e365e153439ea14f3dc073e9830671e478d455bcc1cb6", + "size_in_bytes": 3100 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/resolution/resolvelib/requirements.py", + "path_type": "hardlink", + "sha256": "fa424e34fd168c37dd4ef040b36bd45cf8009cec8d2011005d8e1bef6a20b4f1", + "sha256_in_prefix": "fa424e34fd168c37dd4ef040b36bd45cf8009cec8d2011005d8e1bef6a20b4f1", + "size_in_bytes": 5696 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/resolution/resolvelib/resolver.py", + "path_type": "hardlink", + "sha256": "9cb24eb15304562da0414549a1414a31901ebb67fb19132318cbcd496cb3d017", + "sha256_in_prefix": "9cb24eb15304562da0414549a1414a31901ebb67fb19132318cbcd496cb3d017", + "size_in_bytes": 12592 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/self_outdated_check.py", + "path_type": "hardlink", + "sha256": "b1ac502c1f14cc816d31272abb2b46d744ce4ec61514943f9a45b5358fb8eb01", + "sha256_in_prefix": "b1ac502c1f14cc816d31272abb2b46d744ce4ec61514943f9a45b5358fb8eb01", + "size_in_bytes": 8378 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/utils/__init__.py", + "path_type": "hardlink", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size_in_bytes": 0 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/utils/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "b57627cc2a69e3999c0a447ddfb08013ee710ac30a356ad729f4eb171bf2e56b", + "sha256_in_prefix": "b57627cc2a69e3999c0a447ddfb08013ee710ac30a356ad729f4eb171bf2e56b", + "size_in_bytes": 153 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/utils/__pycache__/_jaraco_text.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "cc4f5d69d30b17439435715006facc4c818c26236a0dd429e23c700b72c75a5a", + "sha256_in_prefix": "cc4f5d69d30b17439435715006facc4c818c26236a0dd429e23c700b72c75a5a", + "size_in_bytes": 3809 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/utils/__pycache__/_log.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "3b67e65330219af9abc60dfea70124ef8726b1767bab9e9148b9e5ebf86233b0", + "sha256_in_prefix": "3b67e65330219af9abc60dfea70124ef8726b1767bab9e9148b9e5ebf86233b0", + "size_in_bytes": 1481 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/utils/__pycache__/appdirs.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "456f516485adc0523e0f8ee1d907b9d840041496a30da69ee77865687563dd9d", + "sha256_in_prefix": "456f516485adc0523e0f8ee1d907b9d840041496a30da69ee77865687563dd9d", + "size_in_bytes": 1579 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/utils/__pycache__/compat.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "1c52266adf5da2dd6ab0b28e7a89ab00b217a5feeff98efd8c7a46b314dc62d8", + "sha256_in_prefix": "1c52266adf5da2dd6ab0b28e7a89ab00b217a5feeff98efd8c7a46b314dc62d8", + "size_in_bytes": 1469 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/utils/__pycache__/compatibility_tags.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "3cdf61336e29f7ee6f3d6771eb7d433bfb18c5ba72d8ef3f29d5a165511ce2d3", + "sha256_in_prefix": "3cdf61336e29f7ee6f3d6771eb7d433bfb18c5ba72d8ef3f29d5a165511ce2d3", + "size_in_bytes": 4038 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/utils/__pycache__/datetime.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "a053ce5c8e2532817f1de7c35c76d322d60545228226605d9335594828003dba", + "sha256_in_prefix": "a053ce5c8e2532817f1de7c35c76d322d60545228226605d9335594828003dba", + "size_in_bytes": 476 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/utils/__pycache__/deprecation.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "3ea1fce54f88473f550418d106af074ad53a304704bbc18af2588e3c023cad98", + "sha256_in_prefix": "3ea1fce54f88473f550418d106af074ad53a304704bbc18af2588e3c023cad98", + "size_in_bytes": 3274 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/utils/__pycache__/direct_url_helpers.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "3b732d101edfcc19dce0f358f2349cc60304dafa06c597e92f73b9e72e9fbb4e", + "sha256_in_prefix": "3b732d101edfcc19dce0f358f2349cc60304dafa06c597e92f73b9e72e9fbb4e", + "size_in_bytes": 2044 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/utils/__pycache__/egg_link.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "0f5b3b789c84e3f0fe8e9aaeea5f2291c818bcc9b9fbc63c00ef43dca16eb19e", + "sha256_in_prefix": "0f5b3b789c84e3f0fe8e9aaeea5f2291c818bcc9b9fbc63c00ef43dca16eb19e", + "size_in_bytes": 2374 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/utils/__pycache__/encoding.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "d38541d264281302c18b2c280cfddf3ad7adf203f220eb55a0554014d0d7e3cb", + "sha256_in_prefix": "d38541d264281302c18b2c280cfddf3ad7adf203f220eb55a0554014d0d7e3cb", + "size_in_bytes": 1266 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/utils/__pycache__/entrypoints.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "860c003be3846c3c0faa10d85cb5582176756801e34133ea31317bfeb52a1f01", + "sha256_in_prefix": "860c003be3846c3c0faa10d85cb5582176756801e34133ea31317bfeb52a1f01", + "size_in_bytes": 2659 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/utils/__pycache__/filesystem.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "07e0a645e8130ed9fb27e3346a631efbcc1ca65a9cfe26fa181068fb3e47cef7", + "sha256_in_prefix": "07e0a645e8130ed9fb27e3346a631efbcc1ca65a9cfe26fa181068fb3e47cef7", + "size_in_bytes": 4442 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/utils/__pycache__/filetypes.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "3138564866aca80e88e6e0734dff2e6705fe40a531e0b57b4c89016f8155d329", + "sha256_in_prefix": "3138564866aca80e88e6e0734dff2e6705fe40a531e0b57b4c89016f8155d329", + "size_in_bytes": 903 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/utils/__pycache__/glibc.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c995379962c25c1e32ad6ee113f4e69b587ac25f6c8577e644c9595655ae518b", + "sha256_in_prefix": "c995379962c25c1e32ad6ee113f4e69b587ac25f6c8577e644c9595655ae518b", + "size_in_bytes": 1674 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/utils/__pycache__/hashes.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "d671dfc63c0bf189bf10879f7631ad7debd7ae6f2295c0b7df4ca340798b73e4", + "sha256_in_prefix": "d671dfc63c0bf189bf10879f7631ad7debd7ae6f2295c0b7df4ca340798b73e4", + "size_in_bytes": 5442 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/utils/__pycache__/logging.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "70929c6da4ef0ec3fea7c6b3c3af4a96e07ea35cee23cda547a2d4cca684ecab", + "sha256_in_prefix": "70929c6da4ef0ec3fea7c6b3c3af4a96e07ea35cee23cda547a2d4cca684ecab", + "size_in_bytes": 9636 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/utils/__pycache__/misc.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "5adaa4ceee775f6e3f06fc925bafb44083537f5367d362f9e723eb9d7d93407d", + "sha256_in_prefix": "5adaa4ceee775f6e3f06fc925bafb44083537f5367d362f9e723eb9d7d93407d", + "size_in_bytes": 23239 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/utils/__pycache__/models.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c56c9215bef13584bd398cadbef86318d59d2922e9663e6ca06f5d3650cf9627", + "sha256_in_prefix": "c56c9215bef13584bd398cadbef86318d59d2922e9663e6ca06f5d3650cf9627", + "size_in_bytes": 1949 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/utils/__pycache__/packaging.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "6d806bc3fef50b36597d185e0af149cea5362dc95ebaf90c13be1570f00bcc95", + "sha256_in_prefix": "6d806bc3fef50b36597d185e0af149cea5362dc95ebaf90c13be1570f00bcc95", + "size_in_bytes": 2041 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/utils/__pycache__/setuptools_build.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "f2d699ed2ec93c91169ec7d4954586c3189d825fc92b7c44ec908af706074f47", + "sha256_in_prefix": "f2d699ed2ec93c91169ec7d4954586c3189d825fc92b7c44ec908af706074f47", + "size_in_bytes": 3777 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/utils/__pycache__/subprocess.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "280d0aca8edf4cfb26fbf850f15d8640db390b9035e241859f130bb6139a324c", + "sha256_in_prefix": "280d0aca8edf4cfb26fbf850f15d8640db390b9035e241859f130bb6139a324c", + "size_in_bytes": 5731 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/utils/__pycache__/temp_dir.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "fbc3e17de7ebf3c5a706d12373632d995b0ab318d000674cc73c549714059433", + "sha256_in_prefix": "fbc3e17de7ebf3c5a706d12373632d995b0ab318d000674cc73c549714059433", + "size_in_bytes": 8284 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/utils/__pycache__/unpacking.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "7aa656b6d410600a3333dcfd4fad2432d0a55ce1b16778e256f9c3d823a74ebe", + "sha256_in_prefix": "7aa656b6d410600a3333dcfd4fad2432d0a55ce1b16778e256f9c3d823a74ebe", + "size_in_bytes": 6613 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/utils/__pycache__/urls.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c198497eef932687a0967688d99209be282dddafc8ff894fe6ca0492312a14dc", + "sha256_in_prefix": "c198497eef932687a0967688d99209be282dddafc8ff894fe6ca0492312a14dc", + "size_in_bytes": 1546 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/utils/__pycache__/virtualenv.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "aa2303b139b701aca1ab4940781ffae8d8992a2f4ae60a6da68f8c480b295b6f", + "sha256_in_prefix": "aa2303b139b701aca1ab4940781ffae8d8992a2f4ae60a6da68f8c480b295b6f", + "size_in_bytes": 3249 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/utils/__pycache__/wheel.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "6256f2901b5a7bc6fabe8390d09a17072ed54deb8b7a305b6d8fe714b5a0f6c1", + "sha256_in_prefix": "6256f2901b5a7bc6fabe8390d09a17072ed54deb8b7a305b6d8fe714b5a0f6c1", + "size_in_bytes": 4361 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/utils/_jaraco_text.py", + "path_type": "hardlink", + "sha256": "caf0c67a54d5ba045ac8f68e17693869bd0acb8777b8e9007ee3908c04a32266", + "sha256_in_prefix": "caf0c67a54d5ba045ac8f68e17693869bd0acb8777b8e9007ee3908c04a32266", + "size_in_bytes": 3351 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/utils/_log.py", + "path_type": "hardlink", + "sha256": "fa31cb384fd31da673e4115c0a7a122fd11802d2749d77a6e3db3da1fe23bcac", + "sha256_in_prefix": "fa31cb384fd31da673e4115c0a7a122fd11802d2749d77a6e3db3da1fe23bcac", + "size_in_bytes": 1015 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/utils/appdirs.py", + "path_type": "hardlink", + "sha256": "b3081c4ca3a6ddd68b7974d6eafe41512d938b646f1271914181ffc835e4940a", + "sha256_in_prefix": "b3081c4ca3a6ddd68b7974d6eafe41512d938b646f1271914181ffc835e4940a", + "size_in_bytes": 1665 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/utils/compat.py", + "path_type": "hardlink", + "sha256": "002c817cb823dff5c6fa2039a26103ad7a833347102b38bc87c1d10489f31ba4", + "sha256_in_prefix": "002c817cb823dff5c6fa2039a26103ad7a833347102b38bc87c1d10489f31ba4", + "size_in_bytes": 1884 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/utils/compatibility_tags.py", + "path_type": "hardlink", + "sha256": "c9d8a7f101bc047a9846c3d8e0e2fa7266f8e026ea5e5d53d31c52f7b5611e49", + "sha256_in_prefix": "c9d8a7f101bc047a9846c3d8e0e2fa7266f8e026ea5e5d53d31c52f7b5611e49", + "size_in_bytes": 5377 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/utils/datetime.py", + "path_type": "hardlink", + "sha256": "9b6d58df002d41cfa38ba55e6fa93f33983a034672148e1e81c853767c21fa94", + "sha256_in_prefix": "9b6d58df002d41cfa38ba55e6fa93f33983a034672148e1e81c853767c21fa94", + "size_in_bytes": 242 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/utils/deprecation.py", + "path_type": "hardlink", + "sha256": "34aa3c56a2e2a09e279d75c6996e0a75ab3117dd04147919687797d5f4f4f02f", + "sha256_in_prefix": "34aa3c56a2e2a09e279d75c6996e0a75ab3117dd04147919687797d5f4f4f02f", + "size_in_bytes": 3627 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/utils/direct_url_helpers.py", + "path_type": "hardlink", + "sha256": "e85d6d736adc29a0999a07d5c2c13a39b21efcfbb1db799455803ed83f700857", + "sha256_in_prefix": "e85d6d736adc29a0999a07d5c2c13a39b21efcfbb1db799455803ed83f700857", + "size_in_bytes": 3206 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/utils/egg_link.py", + "path_type": "hardlink", + "sha256": "d0578f6685182afe11190dadeb1ef0e59e36ef06c0fd4a375999c092b82cbaaa", + "sha256_in_prefix": "d0578f6685182afe11190dadeb1ef0e59e36ef06c0fd4a375999c092b82cbaaa", + "size_in_bytes": 2463 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/utils/encoding.py", + "path_type": "hardlink", + "sha256": "aaab170ed8b03088d730488855268e8f01f96268ab09a2be748cdbebe5c9b0bd", + "sha256_in_prefix": "aaab170ed8b03088d730488855268e8f01f96268ab09a2be748cdbebe5c9b0bd", + "size_in_bytes": 1169 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/utils/entrypoints.py", + "path_type": "hardlink", + "sha256": "62584b4d1976a07040baa85cfb398bed4492ebb4cf5951c89a3780407ade6534", + "sha256_in_prefix": "62584b4d1976a07040baa85cfb398bed4492ebb4cf5951c89a3780407ade6534", + "size_in_bytes": 3064 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/utils/filesystem.py", + "path_type": "hardlink", + "sha256": "4613085d468d54c1a3737ae1b036a1590e0c6afbc440376a5ea82af85e9fa70f", + "sha256_in_prefix": "4613085d468d54c1a3737ae1b036a1590e0c6afbc440376a5ea82af85e9fa70f", + "size_in_bytes": 5122 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/utils/filetypes.py", + "path_type": "hardlink", + "sha256": "8bc5c04347850a8836e85c3dc95d186f5ca002a298075c3d0b3f67d1f8fc8195", + "sha256_in_prefix": "8bc5c04347850a8836e85c3dc95d186f5ca002a298075c3d0b3f67d1f8fc8195", + "size_in_bytes": 716 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/utils/glibc.py", + "path_type": "hardlink", + "sha256": "31eb31c6083704bc6178b671f9d49fdf46fa80aa4e81d557c3a5befae1d2b334", + "sha256_in_prefix": "31eb31c6083704bc6178b671f9d49fdf46fa80aa4e81d557c3a5befae1d2b334", + "size_in_bytes": 3113 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/utils/hashes.py", + "path_type": "hardlink", + "sha256": "3233a2802ef9cfaaa844c9201e21eaa2dedeab17f00d94ab11f94930f9be6c71", + "sha256_in_prefix": "3233a2802ef9cfaaa844c9201e21eaa2dedeab17f00d94ab11f94930f9be6c71", + "size_in_bytes": 5118 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/utils/logging.py", + "path_type": "hardlink", + "sha256": "7ddb6e649f802a4ab00d300d0ef19c044a6cb0bf1e97b4f58e7c24d429d99776", + "sha256_in_prefix": "7ddb6e649f802a4ab00d300d0ef19c044a6cb0bf1e97b4f58e7c24d429d99776", + "size_in_bytes": 11603 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/utils/misc.py", + "path_type": "hardlink", + "sha256": "7cd5f069e7a292f9d4b7808f30520be3e2106d90f1c638f88c3a730a2e19b0ec", + "sha256_in_prefix": "7cd5f069e7a292f9d4b7808f30520be3e2106d90f1c638f88c3a730a2e19b0ec", + "size_in_bytes": 23623 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/utils/models.py", + "path_type": "hardlink", + "sha256": "e46a18539f3a4abc5444cbc39ff8c13092278adbe2260e0ee7e88e53ee88d166", + "sha256_in_prefix": "e46a18539f3a4abc5444cbc39ff8c13092278adbe2260e0ee7e88e53ee88d166", + "size_in_bytes": 1193 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/utils/packaging.py", + "path_type": "hardlink", + "sha256": "e569baff1ee52ab96a5633c8e4c04dfd1bab7111f0558a10ecab2bb3ce1d7bbb", + "sha256_in_prefix": "e569baff1ee52ab96a5633c8e4c04dfd1bab7111f0558a10ecab2bb3ce1d7bbb", + "size_in_bytes": 2108 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/utils/setuptools_build.py", + "path_type": "hardlink", + "sha256": "a2e5e9b9dfa3792f313f24cfb1727e9b7e0d3ef2b9a2ce39a2d03375257f2091", + "sha256_in_prefix": "a2e5e9b9dfa3792f313f24cfb1727e9b7e0d3ef2b9a2ce39a2d03375257f2091", + "size_in_bytes": 4435 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/utils/subprocess.py", + "path_type": "hardlink", + "sha256": "cf376299bef98d52c4d465385a54d9d39e60733843ee7d72d714dc35ceef3594", + "sha256_in_prefix": "cf376299bef98d52c4d465385a54d9d39e60733843ee7d72d714dc35ceef3594", + "size_in_bytes": 9207 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/utils/temp_dir.py", + "path_type": "hardlink", + "sha256": "0d4030db6b85aee41d2b8de2d8bd8ae770be0838d108f780b01289a6efab1d0e", + "sha256_in_prefix": "0d4030db6b85aee41d2b8de2d8bd8ae770be0838d108f780b01289a6efab1d0e", + "size_in_bytes": 9312 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/utils/unpacking.py", + "path_type": "hardlink", + "sha256": "4816f6895d5cadbf3d30345310a63ce91e00fd43960294d09fd55055c3033a51", + "sha256_in_prefix": "4816f6895d5cadbf3d30345310a63ce91e00fd43960294d09fd55055c3033a51", + "size_in_bytes": 8821 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/utils/urls.py", + "path_type": "hardlink", + "sha256": "02169eb141a5fbd8adeaebc6e9fb053ceafdca716919a4cc938b795d35fb67f4", + "sha256_in_prefix": "02169eb141a5fbd8adeaebc6e9fb053ceafdca716919a4cc938b795d35fb67f4", + "size_in_bytes": 1759 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/utils/virtualenv.py", + "path_type": "hardlink", + "sha256": "4ba7fb72c628ad1a620fa72f9f78c849961cdc8f0f242e371f988c1694401035", + "sha256_in_prefix": "4ba7fb72c628ad1a620fa72f9f78c849961cdc8f0f242e371f988c1694401035", + "size_in_bytes": 3456 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/utils/wheel.py", + "path_type": "hardlink", + "sha256": "8b807050d1dab6dccdd22c72dc7040174e2d64f461d82731693eadf3abe2c241", + "sha256_in_prefix": "8b807050d1dab6dccdd22c72dc7040174e2d64f461d82731693eadf3abe2c241", + "size_in_bytes": 4499 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/vcs/__init__.py", + "path_type": "hardlink", + "sha256": "500aafce96e2d156d9a3751beac904799030fa8a08651fb35ff5a909bc720a85", + "sha256_in_prefix": "500aafce96e2d156d9a3751beac904799030fa8a08651fb35ff5a909bc720a85", + "size_in_bytes": 596 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/vcs/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "340168217b9bcf6aeeae2e125131570baf577aebea9b254057243534eaa3c3f6", + "sha256_in_prefix": "340168217b9bcf6aeeae2e125131570baf577aebea9b254057243534eaa3c3f6", + "size_in_bytes": 476 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/vcs/__pycache__/bazaar.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "5f3799a0f0bee78a88aab52d167332030a32f14e190b0871d0875fb92aa15038", + "sha256_in_prefix": "5f3799a0f0bee78a88aab52d167332030a32f14e190b0871d0875fb92aa15038", + "size_in_bytes": 3442 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/vcs/__pycache__/git.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "d593e812b6bad7c9c24b13af1d1d46171da8d22339600ec3fa68183c8a249b69", + "sha256_in_prefix": "d593e812b6bad7c9c24b13af1d1d46171da8d22339600ec3fa68183c8a249b69", + "size_in_bytes": 12365 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/vcs/__pycache__/mercurial.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "8f7ee3c09b6aaafa9a44ff815e9a93a9207f14fe797ca23747ef77e3d20b71a3", + "sha256_in_prefix": "8f7ee3c09b6aaafa9a44ff815e9a93a9207f14fe797ca23747ef77e3d20b71a3", + "size_in_bytes": 5036 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/vcs/__pycache__/subversion.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "8f7875f198d3bf0c0ed2d0f1b3f1952f84818a7c3ffbc5db0c07e77525172e29", + "sha256_in_prefix": "8f7875f198d3bf0c0ed2d0f1b3f1952f84818a7c3ffbc5db0c07e77525172e29", + "size_in_bytes": 8414 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/vcs/__pycache__/versioncontrol.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "48af04813f1167579b5fe6f9ca7fc5850a2744a584bcfb9c180b777daa1d78e4", + "sha256_in_prefix": "48af04813f1167579b5fe6f9ca7fc5850a2744a584bcfb9c180b777daa1d78e4", + "size_in_bytes": 21086 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/vcs/bazaar.py", + "path_type": "hardlink", + "sha256": "8f4a229f47e91911dc0850b111ca4f090a0512f03e0cc2d42ca7463fc36fefaa", + "sha256_in_prefix": "8f4a229f47e91911dc0850b111ca4f090a0512f03e0cc2d42ca7463fc36fefaa", + "size_in_bytes": 3519 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/vcs/git.py", + "path_type": "hardlink", + "sha256": "09e2811899e5eaeb24bef8e40145eb255c5b1c9ae94bf07fa727c57632f70917", + "sha256_in_prefix": "09e2811899e5eaeb24bef8e40145eb255c5b1c9ae94bf07fa727c57632f70917", + "size_in_bytes": 18121 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/vcs/mercurial.py", + "path_type": "hardlink", + "sha256": "a142ce8732765227bed3a775a2690bfbf19cea6786694932a20bea1bd642c8fb", + "sha256_in_prefix": "a142ce8732765227bed3a775a2690bfbf19cea6786694932a20bea1bd642c8fb", + "size_in_bytes": 5249 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/vcs/subversion.py", + "path_type": "hardlink", + "sha256": "be166cf0bf93360817a8cd5b6e197e1696f11374eb201e93827c7c7e1dd2d871", + "sha256_in_prefix": "be166cf0bf93360817a8cd5b6e197e1696f11374eb201e93827c7c7e1dd2d871", + "size_in_bytes": 11729 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/vcs/versioncontrol.py", + "path_type": "hardlink", + "sha256": "dde223b4e318bce639a8fe813182180d9dfbe424ae79cea44840746cea35712b", + "sha256_in_prefix": "dde223b4e318bce639a8fe813182180d9dfbe424ae79cea44840746cea35712b", + "size_in_bytes": 22787 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/wheel_builder.py", + "path_type": "hardlink", + "sha256": "a934f3415f05e9bd6336c14275ad534500bc27b80afa6ee2b913602a8ec38faf", + "sha256_in_prefix": "a934f3415f05e9bd6336c14275ad534500bc27b80afa6ee2b913602a8ec38faf", + "size_in_bytes": 11801 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/__init__.py", + "path_type": "hardlink", + "sha256": "539d4d3f05dd03ec173a200d2109dc62370ca7ab7181e38be671f192c25ec9ab", + "sha256_in_prefix": "539d4d3f05dd03ec173a200d2109dc62370ca7ab7181e38be671f192c25ec9ab", + "size_in_bytes": 4993 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "2c990e1eda8e9ad84eccfcb94022e8371fd425740608eb867aac2e68fffb594a", + "sha256_in_prefix": "2c990e1eda8e9ad84eccfcb94022e8371fd425740608eb867aac2e68fffb594a", + "size_in_bytes": 3111 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/__pycache__/six.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "9f9675e267e7fdd304850bc6f1d4c602f5cad370449cc4f6d09d0626d0e46890", + "sha256_in_prefix": "9f9675e267e7fdd304850bc6f1d4c602f5cad370449cc4f6d09d0626d0e46890", + "size_in_bytes": 27543 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/__pycache__/typing_extensions.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "395c0cb630531e95f0ff5c140dd34b31c9fa49f25b7a02417580984f3a940802", + "sha256_in_prefix": "395c0cb630531e95f0ff5c140dd34b31c9fa49f25b7a02417580984f3a940802", + "size_in_bytes": 89079 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/cachecontrol/__init__.py", + "path_type": "hardlink", + "sha256": "72d1da80c8505eebd00dd9b84e2ad9af00ce4f91fca0134026acdd288eaca2f9", + "sha256_in_prefix": "72d1da80c8505eebd00dd9b84e2ad9af00ce4f91fca0134026acdd288eaca2f9", + "size_in_bytes": 676 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/cachecontrol/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "4373e6c477e337abbef62d874c54b5e20e2630453a75ba4729ed9e3d9b0f6b82", + "sha256_in_prefix": "4373e6c477e337abbef62d874c54b5e20e2630453a75ba4729ed9e3d9b0f6b82", + "size_in_bytes": 724 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/cachecontrol/__pycache__/_cmd.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c41d69f2e3c0ef079f3f542d5d6c03a837413fed5ac714fcfb829355162d8c33", + "sha256_in_prefix": "c41d69f2e3c0ef079f3f542d5d6c03a837413fed5ac714fcfb829355162d8c33", + "size_in_bytes": 1793 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/cachecontrol/__pycache__/adapter.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "ac860447333a2bf4b8ac504f97228bb3d125dd69770a848bfba3387316b5b3e8", + "sha256_in_prefix": "ac860447333a2bf4b8ac504f97228bb3d125dd69770a848bfba3387316b5b3e8", + "size_in_bytes": 4376 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/cachecontrol/__pycache__/cache.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "9d23a08c8af654433d5a3b140f801a74dfd4b4de34920c01979542b65102d0bc", + "sha256_in_prefix": "9d23a08c8af654433d5a3b140f801a74dfd4b4de34920c01979542b65102d0bc", + "size_in_bytes": 3237 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/cachecontrol/__pycache__/controller.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "7308a2a1534776d861629338d3fa3b4e27aefeefc3835277442b899aecc57768", + "sha256_in_prefix": "7308a2a1534776d861629338d3fa3b4e27aefeefc3835277442b899aecc57768", + "size_in_bytes": 10087 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/cachecontrol/__pycache__/filewrapper.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "4187624fa4341b48505cf5657bd91c8497f73ed6dd0a4b81c46f2b2b19d27ea2", + "sha256_in_prefix": "4187624fa4341b48505cf5657bd91c8497f73ed6dd0a4b81c46f2b2b19d27ea2", + "size_in_bytes": 3177 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/cachecontrol/__pycache__/heuristics.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "2bed8563f9b96624d0c3143577639b32c79e2a8c95d737bd9ea644c0b3e28868", + "sha256_in_prefix": "2bed8563f9b96624d0c3143577639b32c79e2a8c95d737bd9ea644c0b3e28868", + "size_in_bytes": 5352 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/cachecontrol/__pycache__/serialize.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "3a81f5a560f65d2935a1997124aa792061c557b4416b06b3b8ae6504e54c1990", + "sha256_in_prefix": "3a81f5a560f65d2935a1997124aa792061c557b4416b06b3b8ae6504e54c1990", + "size_in_bytes": 4066 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/cachecontrol/__pycache__/wrapper.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "6c27ac1734c940748943c3f7dd5f20a6f8a6319e31e7f23ed260084449fd9167", + "sha256_in_prefix": "6c27ac1734c940748943c3f7dd5f20a6f8a6319e31e7f23ed260084449fd9167", + "size_in_bytes": 1428 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/cachecontrol/_cmd.py", + "path_type": "hardlink", + "sha256": "8a2b2dd84a7326f0d5221300c57abc8859d306c89901dea2a65c5f98d6e83729", + "sha256_in_prefix": "8a2b2dd84a7326f0d5221300c57abc8859d306c89901dea2a65c5f98d6e83729", + "size_in_bytes": 1737 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/cachecontrol/adapter.py", + "path_type": "hardlink", + "sha256": "fc2716bd43fdd38f2a0198ec36a5626876dd70bb3d9a614d8b155fa4eee879b1", + "sha256_in_prefix": "fc2716bd43fdd38f2a0198ec36a5626876dd70bb3d9a614d8b155fa4eee879b1", + "size_in_bytes": 6392 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/cachecontrol/cache.py", + "path_type": "hardlink", + "sha256": "393423ef6b547fc0b5b8481ccdd97719cf2f925752cec4c84cab4318a331e33f", + "sha256_in_prefix": "393423ef6b547fc0b5b8481ccdd97719cf2f925752cec4c84cab4318a331e33f", + "size_in_bytes": 1952 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/cachecontrol/caches/__init__.py", + "path_type": "hardlink", + "sha256": "76daebae82b90670034751968c2675f5a674b45b0c7ef141b4b410535b29fda8", + "sha256_in_prefix": "76daebae82b90670034751968c2675f5a674b45b0c7ef141b4b410535b29fda8", + "size_in_bytes": 303 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/cachecontrol/caches/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "4a9aec817a68c1bad533c02c272eed1ba44f6f3e82944577eafbc0bbd61764db", + "sha256_in_prefix": "4a9aec817a68c1bad533c02c272eed1ba44f6f3e82944577eafbc0bbd61764db", + "size_in_bytes": 387 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/cachecontrol/caches/__pycache__/file_cache.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "2ccd1465a07c2625ae8ff78c4f855be705169880382e4c824d8e6ba9b0ab75aa", + "sha256_in_prefix": "2ccd1465a07c2625ae8ff78c4f855be705169880382e4c824d8e6ba9b0ab75aa", + "size_in_bytes": 5543 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/cachecontrol/caches/__pycache__/redis_cache.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c69f5df0703fa1f5f260358d7c8cc257eca3c46ceaefefbae52752e9ad7928e3", + "sha256_in_prefix": "c69f5df0703fa1f5f260358d7c8cc257eca3c46ceaefefbae52752e9ad7928e3", + "size_in_bytes": 2002 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/cachecontrol/caches/file_cache.py", + "path_type": "hardlink", + "sha256": "df3f0058a0febdf29e889a88ccb989c8862d476c9de93b21deed53c8b450a084", + "sha256_in_prefix": "df3f0058a0febdf29e889a88ccb989c8862d476c9de93b21deed53c8b450a084", + "size_in_bytes": 5352 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/cachecontrol/caches/redis_cache.py", + "path_type": "hardlink", + "sha256": "f6b9aac2d62efe58d5916ebfa0ba9b0bb11a5ff6bc613ff22ee9daf9e4b4760a", + "sha256_in_prefix": "f6b9aac2d62efe58d5916ebfa0ba9b0bb11a5ff6bc613ff22ee9daf9e4b4760a", + "size_in_bytes": 1386 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/cachecontrol/controller.py", + "path_type": "hardlink", + "sha256": "91e08503765a3556964f01dde85d73a9685be2fcaf371fd4bd9ba8e6221831fa", + "sha256_in_prefix": "91e08503765a3556964f01dde85d73a9685be2fcaf371fd4bd9ba8e6221831fa", + "size_in_bytes": 18384 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/cachecontrol/filewrapper.py", + "path_type": "hardlink", + "sha256": "493b6d1a620f06f673b766f9d5d50ec28597e5cadc302a4a64e8ac3377f904d7", + "sha256_in_prefix": "493b6d1a620f06f673b766f9d5d50ec28597e5cadc302a4a64e8ac3377f904d7", + "size_in_bytes": 4292 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/cachecontrol/heuristics.py", + "path_type": "hardlink", + "sha256": "7dd15b93d5bc21e2eb8ed788cff7cae268f61c3fd8ec239717651cf138234f57", + "sha256_in_prefix": "7dd15b93d5bc21e2eb8ed788cff7cae268f61c3fd8ec239717651cf138234f57", + "size_in_bytes": 4828 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/cachecontrol/py.typed", + "path_type": "hardlink", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size_in_bytes": 0 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/cachecontrol/serialize.py", + "path_type": "hardlink", + "sha256": "d1d1de31a0f0cac54002719596130e3f8b43962a2180d2b427193fcec3a25b1c", + "sha256_in_prefix": "d1d1de31a0f0cac54002719596130e3f8b43962a2180d2b427193fcec3a25b1c", + "size_in_bytes": 7173 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/cachecontrol/wrapper.py", + "path_type": "hardlink", + "sha256": "86c19cee0f101904d3fb87fcb60cf700ce6ac12720e853b405274b491744be95", + "sha256_in_prefix": "86c19cee0f101904d3fb87fcb60cf700ce6ac12720e853b405274b491744be95", + "size_in_bytes": 1417 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/certifi/__init__.py", + "path_type": "hardlink", + "sha256": "2ff8fe774918b80fcccc0dbfda1ada175a2f7fa293e834eab91755de9690c0e9", + "sha256_in_prefix": "2ff8fe774918b80fcccc0dbfda1ada175a2f7fa293e834eab91755de9690c0e9", + "size_in_bytes": 94 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/certifi/__main__.py", + "path_type": "hardlink", + "sha256": "d64dc2afde6f0b1c464460e58eb5b7c0c76965d2f73617f4bb59fe936a9db026", + "sha256_in_prefix": "d64dc2afde6f0b1c464460e58eb5b7c0c76965d2f73617f4bb59fe936a9db026", + "size_in_bytes": 255 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/certifi/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "9036164331a5cd6e6ff4996f4ac698a8eb28070855e40368e564fee2d213c6ee", + "sha256_in_prefix": "9036164331a5cd6e6ff4996f4ac698a8eb28070855e40368e564fee2d213c6ee", + "size_in_bytes": 266 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/certifi/__pycache__/__main__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "6dc3ad2689b84b683e13d7c6de72766810c399948d926956bbd32437be56d5a9", + "sha256_in_prefix": "6dc3ad2689b84b683e13d7c6de72766810c399948d926956bbd32437be56d5a9", + "size_in_bytes": 416 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/certifi/__pycache__/core.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "f170978bc48e3f763f3611dc9f8158b1af63c8a7b3ea95b391ec041cf0e175a4", + "sha256_in_prefix": "f170978bc48e3f763f3611dc9f8158b1af63c8a7b3ea95b391ec041cf0e175a4", + "size_in_bytes": 1886 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/certifi/cacert.pem", + "path_type": "hardlink", + "sha256": "794d039ffdf277c047e26f2c7d58f81a5865d8a0eb7024a0fac1164fea4d27cf", + "sha256_in_prefix": "794d039ffdf277c047e26f2c7d58f81a5865d8a0eb7024a0fac1164fea4d27cf", + "size_in_bytes": 281617 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/certifi/core.py", + "path_type": "hardlink", + "sha256": "67088eb2ffac0ffa2e5357edf30cbfc59dcb43b51b715cf2aa3d97372aec662b", + "sha256_in_prefix": "67088eb2ffac0ffa2e5357edf30cbfc59dcb43b51b715cf2aa3d97372aec662b", + "size_in_bytes": 4279 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/certifi/py.typed", + "path_type": "hardlink", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size_in_bytes": 0 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/__init__.py", + "path_type": "hardlink", + "sha256": "e7b47e1d2c63d0f5a620b30dd0616650da8431fac45526a65f28c3f96ebf7dbb", + "sha256_in_prefix": "e7b47e1d2c63d0f5a620b30dd0616650da8431fac45526a65f28c3f96ebf7dbb", + "size_in_bytes": 4797 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "1237b4f5a6bdfb84a71f475847cf1f4000c70d7e6b70c2ed4f8942e03ee0edcc", + "sha256_in_prefix": "1237b4f5a6bdfb84a71f475847cf1f4000c70d7e6b70c2ed4f8942e03ee0edcc", + "size_in_bytes": 3134 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/big5freq.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "e5381dc7ecf9c9f7dddd7883681bde2b24a637246e487d153095b78916633dd5", + "sha256_in_prefix": "e5381dc7ecf9c9f7dddd7883681bde2b24a637246e487d153095b78916633dd5", + "size_in_bytes": 27140 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/big5prober.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "04d182af07c52db509a20579701902c3d12d03f60cc6ca38211bf72a648a6f99", + "sha256_in_prefix": "04d182af07c52db509a20579701902c3d12d03f60cc6ca38211bf72a648a6f99", + "size_in_bytes": 1118 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/chardistribution.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "a9bf256cae7321df601f2f59e35ae8ae925b68893b4ba6260d3ab50258569153", + "sha256_in_prefix": "a9bf256cae7321df601f2f59e35ae8ae925b68893b4ba6260d3ab50258569153", + "size_in_bytes": 6535 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/charsetgroupprober.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "b1210b4a4f288bd463d18f2a674d96db609ee677818b1341804d0a0427b75f38", + "sha256_in_prefix": "b1210b4a4f288bd463d18f2a674d96db609ee677818b1341804d0a0427b75f38", + "size_in_bytes": 2385 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/charsetprober.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "036efd2debeaf8a57e04bb0f6c4206c41b60eba86774dac6c1d2ce669438bb89", + "sha256_in_prefix": "036efd2debeaf8a57e04bb0f6c4206c41b60eba86774dac6c1d2ce669438bb89", + "size_in_bytes": 3791 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/codingstatemachine.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "be4951d455c66a9d4f1a2e0635f62fc01e2e9059f8713f458cc8c4fef4d8adbc", + "sha256_in_prefix": "be4951d455c66a9d4f1a2e0635f62fc01e2e9059f8713f458cc8c4fef4d8adbc", + "size_in_bytes": 3028 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/codingstatemachinedict.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "cb368039518b337673f6fa39b7f46dd8d5632a86eaa76878b1e69533e6cc72ee", + "sha256_in_prefix": "cb368039518b337673f6fa39b7f46dd8d5632a86eaa76878b1e69533e6cc72ee", + "size_in_bytes": 657 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/cp949prober.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "416ed333944994524f618036b939de48b2c0bd268af7189775307ee9afa7c692", + "sha256_in_prefix": "416ed333944994524f618036b939de48b2c0bd268af7189775307ee9afa7c692", + "size_in_bytes": 1125 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/enums.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "503d2986c6cf322178131bedd2e6fe310b01cc57c33577a3ea15f4adb4dce7ac", + "sha256_in_prefix": "503d2986c6cf322178131bedd2e6fe310b01cc57c33577a3ea15f4adb4dce7ac", + "size_in_bytes": 2618 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/escprober.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "951fe803a9f7be891107259b53e9d99571bba4c8ad45904efbe2c998a93b4151", + "sha256_in_prefix": "951fe803a9f7be891107259b53e9d99571bba4c8ad45904efbe2c998a93b4151", + "size_in_bytes": 2776 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/escsm.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "a71ce8e2d94e3b516b68bcd1943bb756665dad296bb0a651d9267923b859646e", + "sha256_in_prefix": "a71ce8e2d94e3b516b68bcd1943bb756665dad296bb0a651d9267923b859646e", + "size_in_bytes": 8479 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/eucjpprober.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "e95c946782ddca1a1839e407ad5f2f8c3bc555ac0151fac86733f522c88e2a1e", + "sha256_in_prefix": "e95c946782ddca1a1839e407ad5f2f8c3bc555ac0151fac86733f522c88e2a1e", + "size_in_bytes": 2562 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/euckrfreq.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "9285228e0719806b01fa78920daa765e60df7e025b3070004a22953e6bf67c6f", + "sha256_in_prefix": "9285228e0719806b01fa78920daa765e60df7e025b3070004a22953e6bf67c6f", + "size_in_bytes": 12024 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/euckrprober.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "42098890ba3a8dae536c4c1d105da8f9ddd49cdb752b9fc89c20797e96e141ee", + "sha256_in_prefix": "42098890ba3a8dae536c4c1d105da8f9ddd49cdb752b9fc89c20797e96e141ee", + "size_in_bytes": 1126 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/euctwfreq.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "233142de14eee5a92cdaac6bb3ebc25e9714841fb94aa06d83cd287dd073ef04", + "sha256_in_prefix": "233142de14eee5a92cdaac6bb3ebc25e9714841fb94aa06d83cd287dd073ef04", + "size_in_bytes": 27144 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/euctwprober.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "a6a04591e1f7098b28f05e2e3d246d271f3a6eff85b2004801b88e080b441c9e", + "sha256_in_prefix": "a6a04591e1f7098b28f05e2e3d246d271f3a6eff85b2004801b88e080b441c9e", + "size_in_bytes": 1126 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/gb2312freq.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "524d8fccaa3bd3cc1bc25c0ba94e3c6e78a0a5ec212f225c0d43e87fcff2c797", + "sha256_in_prefix": "524d8fccaa3bd3cc1bc25c0ba94e3c6e78a0a5ec212f225c0d43e87fcff2c797", + "size_in_bytes": 19068 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/gb2312prober.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "7b7b9013ed7ea36c74dd03cf8b8aae0bf495c25e12efdd904ffd39b91f5e2536", + "sha256_in_prefix": "7b7b9013ed7ea36c74dd03cf8b8aae0bf495c25e12efdd904ffd39b91f5e2536", + "size_in_bytes": 1134 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/hebrewprober.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "a3d775c730b70a165605c9d5a930a77ded2af7eed8e41877ea0dcf2c8b335276", + "sha256_in_prefix": "a3d775c730b70a165605c9d5a930a77ded2af7eed8e41877ea0dcf2c8b335276", + "size_in_bytes": 3375 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/jisfreq.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "0f9bc8a2706cd8d1ec9029e39fc7e9777c1ade223715894f91e39ae96b8e0846", + "sha256_in_prefix": "0f9bc8a2706cd8d1ec9029e39fc7e9777c1ade223715894f91e39ae96b8e0846", + "size_in_bytes": 22096 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/johabfreq.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "b9c4ff7ad86bb61354c2775789fd5deec8e65d7e2c4f0e8e4c5b789088304340", + "sha256_in_prefix": "b9c4ff7ad86bb61354c2775789fd5deec8e65d7e2c4f0e8e4c5b789088304340", + "size_in_bytes": 138720 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/johabprober.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "834b57c50eaf39ad1598a666e693fceb1ac2e6c2cccd5506eb8ba04bbc644f7b", + "sha256_in_prefix": "834b57c50eaf39ad1598a666e693fceb1ac2e6c2cccd5506eb8ba04bbc644f7b", + "size_in_bytes": 1125 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/jpcntx.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "5307ca8d3476f3d43031c767321071092139487634c1c8d9845e80deb8bdc973", + "sha256_in_prefix": "5307ca8d3476f3d43031c767321071092139487634c1c8d9845e80deb8bdc973", + "size_in_bytes": 37946 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/langbulgarianmodel.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "639f4f433b82169e8e9f7271f950bc5801d0c4c73b3679833a9038523e9f25d3", + "sha256_in_prefix": "639f4f433b82169e8e9f7271f950bc5801d0c4c73b3679833a9038523e9f25d3", + "size_in_bytes": 47888 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/langgreekmodel.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c9f4641149485996f8a675e26766147ebf3b23193e9b3e6523a46b681dbb44b1", + "sha256_in_prefix": "c9f4641149485996f8a675e26766147ebf3b23193e9b3e6523a46b681dbb44b1", + "size_in_bytes": 46078 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/langhebrewmodel.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "a1cb17f15569bec79d6e136ec39fdd62336d87bb509049f57dfdbf45589fbe73", + "sha256_in_prefix": "a1cb17f15569bec79d6e136ec39fdd62336d87bb509049f57dfdbf45589fbe73", + "size_in_bytes": 44525 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/langhungarianmodel.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "aa38387a52fd14d6c9c5fc7e7e2bca08c8e18b1b1be7c97b596e389f9f170fd1", + "sha256_in_prefix": "aa38387a52fd14d6c9c5fc7e7e2bca08c8e18b1b1be7c97b596e389f9f170fd1", + "size_in_bytes": 47848 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/langrussianmodel.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "adf4ec0d57f48efec9a32bb62546083cb1734a7cc2e54989f48fe3208500476a", + "sha256_in_prefix": "adf4ec0d57f48efec9a32bb62546083cb1734a7cc2e54989f48fe3208500476a", + "size_in_bytes": 60989 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/langthaimodel.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "3e3c3003dceff27390e55533d6353dbd9d516b33240249a616212f3d560a8356", + "sha256_in_prefix": "3e3c3003dceff27390e55533d6353dbd9d516b33240249a616212f3d560a8356", + "size_in_bytes": 44701 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/langturkishmodel.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "f153467f336e8943fc60c69e8ad429f2a97ebc2aa2b93ec27661d95aecc51929", + "sha256_in_prefix": "f153467f336e8943fc60c69e8ad429f2a97ebc2aa2b93ec27661d95aecc51929", + "size_in_bytes": 44542 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/latin1prober.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "35b3d2df00d388af35b6be74f558dc9e59fa8428eb3ec7d18c82b3d2f91503d3", + "sha256_in_prefix": "35b3d2df00d388af35b6be74f558dc9e59fa8428eb3ec7d18c82b3d2f91503d3", + "size_in_bytes": 4524 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/macromanprober.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "5258146ad3443e696a858e262a9c4676e410f098a9b0442ca933a5be498065dc", + "sha256_in_prefix": "5258146ad3443e696a858e262a9c4676e410f098a9b0442ca933a5be498065dc", + "size_in_bytes": 4665 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/mbcharsetprober.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "7d98b2b75d507e58d503bfbcd68988cb11a3b5e45a088aec27385497723e915b", + "sha256_in_prefix": "7d98b2b75d507e58d503bfbcd68988cb11a3b5e45a088aec27385497723e915b", + "size_in_bytes": 2274 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/mbcsgroupprober.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "4c06a7687a7a3d0045c5a95bdd84ea778d9acc1e2584d23ec871a3b73fa22b97", + "sha256_in_prefix": "4c06a7687a7a3d0045c5a95bdd84ea778d9acc1e2584d23ec871a3b73fa22b97", + "size_in_bytes": 1222 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/mbcssm.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "3ca9cd6118f68d8847120879afebf2f20f028f0e2ad8289e36d83d48635ccf67", + "sha256_in_prefix": "3ca9cd6118f68d8847120879afebf2f20f028f0e2ad8289e36d83d48635ccf67", + "size_in_bytes": 20897 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/resultdict.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "9b4ce78ade13c6496b3d4566f37ed8270129562671ab3026e474df8aa83fc613", + "sha256_in_prefix": "9b4ce78ade13c6496b3d4566f37ed8270129562671ab3026e474df8aa83fc613", + "size_in_bytes": 537 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/sbcharsetprober.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "7bf897fef2dda86a1a0e7b81b31f153034b3c6d2865a351bd23f711c714c26e7", + "sha256_in_prefix": "7bf897fef2dda86a1a0e7b81b31f153034b3c6d2865a351bd23f711c714c26e7", + "size_in_bytes": 3643 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/sbcsgroupprober.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "e4a0c833bfa3997acee5e82209a83028afb9cc6d39eec713cc9f740e285df686", + "sha256_in_prefix": "e4a0c833bfa3997acee5e82209a83028afb9cc6d39eec713cc9f740e285df686", + "size_in_bytes": 1701 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/sjisprober.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "a1031b30377608088f96fffbd15100da9b1d404458cbdc4461cd308c4f43d48d", + "sha256_in_prefix": "a1031b30377608088f96fffbd15100da9b1d404458cbdc4461cd308c4f43d48d", + "size_in_bytes": 2600 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/universaldetector.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "83e9dbcd72ac7c054fdc0f85a481ebecfa526e24f944375697d66b48e2c86b31", + "sha256_in_prefix": "83e9dbcd72ac7c054fdc0f85a481ebecfa526e24f944375697d66b48e2c86b31", + "size_in_bytes": 7088 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/utf1632prober.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "009e4769a3ff5f4134dbcc7d607417336b9430e910044c6a99daa36d1fa0c118", + "sha256_in_prefix": "009e4769a3ff5f4134dbcc7d607417336b9430e910044c6a99daa36d1fa0c118", + "size_in_bytes": 6060 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/utf8prober.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "57bdcc7f402c554e105807753f1cb7428a8eb1865ce74ce30aa6ba856ee0308c", + "sha256_in_prefix": "57bdcc7f402c554e105807753f1cb7428a8eb1865ce74ce30aa6ba856ee0308c", + "size_in_bytes": 2070 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/version.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c224b5367ac22d62b0e7cd59c35bd139075f9d87b2ee5e4766960b49b008eec2", + "sha256_in_prefix": "c224b5367ac22d62b0e7cd59c35bd139075f9d87b2ee5e4766960b49b008eec2", + "size_in_bytes": 402 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/big5freq.py", + "path_type": "hardlink", + "sha256": "96d71f3fedcf8e53470a8a397b86bb0b8cfed838414d745f63a8db31b07b3f7d", + "sha256_in_prefix": "96d71f3fedcf8e53470a8a397b86bb0b8cfed838414d745f63a8db31b07b3f7d", + "size_in_bytes": 31274 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/big5prober.py", + "path_type": "hardlink", + "sha256": "94f31fc025fabf601a3e0bc587f7125997202c36d68850872d9fe9f5143dbb11", + "sha256_in_prefix": "94f31fc025fabf601a3e0bc587f7125997202c36d68850872d9fe9f5143dbb11", + "size_in_bytes": 1763 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/chardistribution.py", + "path_type": "hardlink", + "sha256": "d7707c5d41b8a170ee2dd5ef7db216c0b15e47e654db502a4d2d7371d38df1b5", + "sha256_in_prefix": "d7707c5d41b8a170ee2dd5ef7db216c0b15e47e654db502a4d2d7371d38df1b5", + "size_in_bytes": 10032 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/charsetgroupprober.py", + "path_type": "hardlink", + "sha256": "50a2b749a2190763c274a4884b4827bccb4b47d2495fad8cf9f649bb73a55b28", + "sha256_in_prefix": "50a2b749a2190763c274a4884b4827bccb4b47d2495fad8cf9f649bb73a55b28", + "size_in_bytes": 3915 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/charsetprober.py", + "path_type": "hardlink", + "sha256": "2f7b7cff020ea2ff1e9bebd958e71b91db2bc1ee3737afe0a8d879a47ed63dde", + "sha256_in_prefix": "2f7b7cff020ea2ff1e9bebd958e71b91db2bc1ee3737afe0a8d879a47ed63dde", + "size_in_bytes": 5420 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/cli/__init__.py", + "path_type": "hardlink", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size_in_bytes": 0 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/cli/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "8254ef167211ab320d9973a976734a481aec3ac297e704e5ad124fe7dc32b02a", + "sha256_in_prefix": "8254ef167211ab320d9973a976734a481aec3ac297e704e5ad124fe7dc32b02a", + "size_in_bytes": 157 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/cli/__pycache__/chardetect.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "325f7717071a9f8b63fb0c6421293289b4df937b3008430e20a78754589018d0", + "sha256_in_prefix": "325f7717071a9f8b63fb0c6421293289b4df937b3008430e20a78754589018d0", + "size_in_bytes": 2999 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/cli/chardetect.py", + "path_type": "hardlink", + "sha256": "ce26cc560e51a4a6fe304f7fec4606e1933649fd3b347710cd9d7653ead8261a", + "sha256_in_prefix": "ce26cc560e51a4a6fe304f7fec4606e1933649fd3b347710cd9d7653ead8261a", + "size_in_bytes": 3242 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/codingstatemachine.py", + "path_type": "hardlink", + "sha256": "2bb93af6cc378d8e439935e8489415b14b452102983d054e48926106e1afff21", + "sha256_in_prefix": "2bb93af6cc378d8e439935e8489415b14b452102983d054e48926106e1afff21", + "size_in_bytes": 3732 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/codingstatemachinedict.py", + "path_type": "hardlink", + "sha256": "d066371e2daa219bc3ace389dc0b6aa6933546c631affeba111e041e3b8c88c7", + "sha256_in_prefix": "d066371e2daa219bc3ace389dc0b6aa6933546c631affeba111e041e3b8c88c7", + "size_in_bytes": 542 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/cp949prober.py", + "path_type": "hardlink", + "sha256": "d2329157b7c40ae588d7aacd9e4b3464408a03589960220468ff00d59be35122", + "sha256_in_prefix": "d2329157b7c40ae588d7aacd9e4b3464408a03589960220468ff00d59be35122", + "size_in_bytes": 1860 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/enums.py", + "path_type": "hardlink", + "sha256": "4f3102899a0228d32a83053be9c3c278a58506a696bc074b31ebf9fdb0a4858f", + "sha256_in_prefix": "4f3102899a0228d32a83053be9c3c278a58506a696bc074b31ebf9fdb0a4858f", + "size_in_bytes": 1683 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/escprober.py", + "path_type": "hardlink", + "sha256": "2a1a38f17eb9c44d2c705ca521d7898ccd9b71bbd1befd21d1651b316ac90f70", + "sha256_in_prefix": "2a1a38f17eb9c44d2c705ca521d7898ccd9b71bbd1befd21d1651b316ac90f70", + "size_in_bytes": 4006 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/escsm.py", + "path_type": "hardlink", + "sha256": "02ac97a40d854050fb93e6ee06dcbfee2b461189219956bc5f4f4d2d1ba5dd03", + "sha256_in_prefix": "02ac97a40d854050fb93e6ee06dcbfee2b461189219956bc5f4f4d2d1ba5dd03", + "size_in_bytes": 12176 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/eucjpprober.py", + "path_type": "hardlink", + "sha256": "e4a61a33d7ecc64458cf0d5be64d1f2fe8fff9ecc8c3e8a3f6bf7b6bd307c4b6", + "sha256_in_prefix": "e4a61a33d7ecc64458cf0d5be64d1f2fe8fff9ecc8c3e8a3f6bf7b6bd307c4b6", + "size_in_bytes": 3934 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/euckrfreq.py", + "path_type": "hardlink", + "sha256": "de61ee46f5dfb2afd0710cac0d015bf2a4ae76f4e2a25ef50ba21cdb0e7bb4a3", + "sha256_in_prefix": "de61ee46f5dfb2afd0710cac0d015bf2a4ae76f4e2a25ef50ba21cdb0e7bb4a3", + "size_in_bytes": 13566 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/euckrprober.py", + "path_type": "hardlink", + "sha256": "862153eb0335ef8188c11bea0ec21cb8e73e743b2adae3ca30a6f257cfb55e77", + "sha256_in_prefix": "862153eb0335ef8188c11bea0ec21cb8e73e743b2adae3ca30a6f257cfb55e77", + "size_in_bytes": 1753 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/euctwfreq.py", + "path_type": "hardlink", + "sha256": "d9a9482c4d4b8797aa8852598f34643105e894d2511d8e6805077ebe66581453", + "sha256_in_prefix": "d9a9482c4d4b8797aa8852598f34643105e894d2511d8e6805077ebe66581453", + "size_in_bytes": 36913 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/euctwprober.py", + "path_type": "hardlink", + "sha256": "3716e935d06d5345452346ca7c67c39293fb4b6ffcffa1653bcedd547d28830b", + "sha256_in_prefix": "3716e935d06d5345452346ca7c67c39293fb4b6ffcffa1653bcedd547d28830b", + "size_in_bytes": 1753 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/gb2312freq.py", + "path_type": "hardlink", + "sha256": "e3d3ab757cc3f875eac1abe4aa3a3c67b82fb39f2138d3730e103230434d92f6", + "sha256_in_prefix": "e3d3ab757cc3f875eac1abe4aa3a3c67b82fb39f2138d3730e103230434d92f6", + "size_in_bytes": 20735 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/gb2312prober.py", + "path_type": "hardlink", + "sha256": "28f101b9e6922d2bc1a4578834cbb40fa4e01dc47dd1ee4f6906b089fcc5e28d", + "sha256_in_prefix": "28f101b9e6922d2bc1a4578834cbb40fa4e01dc47dd1ee4f6906b089fcc5e28d", + "size_in_bytes": 1759 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/hebrewprober.py", + "path_type": "hardlink", + "sha256": "f7a4ff2e3fce996f9f2bb26b487a23623c86ddfb0681bce4a13365799de47d81", + "sha256_in_prefix": "f7a4ff2e3fce996f9f2bb26b487a23623c86ddfb0681bce4a13365799de47d81", + "size_in_bytes": 14537 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/jisfreq.py", + "path_type": "hardlink", + "sha256": "9a6f2d7ebc2a86939ddf0cd9292e0d26a91805055c0df4ccd89890e5a5bddf61", + "sha256_in_prefix": "9a6f2d7ebc2a86939ddf0cd9292e0d26a91805055c0df4ccd89890e5a5bddf61", + "size_in_bytes": 25796 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/johabfreq.py", + "path_type": "hardlink", + "sha256": "741a4e606df81915fa48bf24fcb6d2f6bc593cc8cb8e8325819d373f3e479aa7", + "sha256_in_prefix": "741a4e606df81915fa48bf24fcb6d2f6bc593cc8cb8e8325819d373f3e479aa7", + "size_in_bytes": 42498 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/johabprober.py", + "path_type": "hardlink", + "sha256": "3b5430f67573467ba7eef669e1464cef0bc94aff56f78d66114f6e0cc9d8dc35", + "sha256_in_prefix": "3b5430f67573467ba7eef669e1464cef0bc94aff56f78d66114f6e0cc9d8dc35", + "size_in_bytes": 1752 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/jpcntx.py", + "path_type": "hardlink", + "sha256": "ba11eb61690bc44feb1793a41ca2279b41d4b2b8e02871d542fb6ddd472fa2d0", + "sha256_in_prefix": "ba11eb61690bc44feb1793a41ca2279b41d4b2b8e02871d542fb6ddd472fa2d0", + "size_in_bytes": 27055 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/langbulgarianmodel.py", + "path_type": "hardlink", + "sha256": "be66ef6053fc499912c6806f2e416a2a21f5b2399ae62864dcf4e9772ef546be", + "sha256_in_prefix": "be66ef6053fc499912c6806f2e416a2a21f5b2399ae62864dcf4e9772ef546be", + "size_in_bytes": 104562 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/langgreekmodel.py", + "path_type": "hardlink", + "sha256": "25f07b6eea638c91f6c375ff9989d0afd70903fec4b884c2d9c456d777d48de2", + "sha256_in_prefix": "25f07b6eea638c91f6c375ff9989d0afd70903fec4b884c2d9c456d777d48de2", + "size_in_bytes": 98484 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/langhebrewmodel.py", + "path_type": "hardlink", + "sha256": "dc75c768b40f34019c5e726390825fa333592d3bd32667f85b90308bacd144a7", + "sha256_in_prefix": "dc75c768b40f34019c5e726390825fa333592d3bd32667f85b90308bacd144a7", + "size_in_bytes": 98196 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/langhungarianmodel.py", + "path_type": "hardlink", + "sha256": "5b16de408c64bfc62d02988dab141cbe3fad33272ca08e17cbe7f09031e93ff6", + "sha256_in_prefix": "5b16de408c64bfc62d02988dab141cbe3fad33272ca08e17cbe7f09031e93ff6", + "size_in_bytes": 101363 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/langrussianmodel.py", + "path_type": "hardlink", + "sha256": "b37f796d367cec4493ad908e7605db12367d3f58863f00a5ffcc52b1a73f0cb6", + "sha256_in_prefix": "b37f796d367cec4493ad908e7605db12367d3f58863f00a5ffcc52b1a73f0cb6", + "size_in_bytes": 128035 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/langthaimodel.py", + "path_type": "hardlink", + "sha256": "edb265422b51a539d51800666d2ce71e72703870f2dc89e44efb45531d775902", + "sha256_in_prefix": "edb265422b51a539d51800666d2ce71e72703870f2dc89e44efb45531d775902", + "size_in_bytes": 102774 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/langturkishmodel.py", + "path_type": "hardlink", + "sha256": "5d8d1e19d4c8cb8790f578352d53d969c6fe501847051f9cab42293d51e8c0a7", + "sha256_in_prefix": "5d8d1e19d4c8cb8790f578352d53d969c6fe501847051f9cab42293d51e8c0a7", + "size_in_bytes": 95372 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/latin1prober.py", + "path_type": "hardlink", + "sha256": "a75e4412615b9905306ca2c2ee53895461c4670706e39b9b1196131aed352798", + "sha256_in_prefix": "a75e4412615b9905306ca2c2ee53895461c4670706e39b9b1196131aed352798", + "size_in_bytes": 5380 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/macromanprober.py", + "path_type": "hardlink", + "sha256": "f5a9dfce663a4c17d43c3c810ce758d3b92a9931e9675b4ad232fea7525670e6", + "sha256_in_prefix": "f5a9dfce663a4c17d43c3c810ce758d3b92a9931e9675b4ad232fea7525670e6", + "size_in_bytes": 6077 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/mbcharsetprober.py", + "path_type": "hardlink", + "sha256": "5abd3858d2381775ff57112f7ab346f87db983bbbe3030ca94db7e2468fefee5", + "sha256_in_prefix": "5abd3858d2381775ff57112f7ab346f87db983bbbe3030ca94db7e2468fefee5", + "size_in_bytes": 3715 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/mbcsgroupprober.py", + "path_type": "hardlink", + "sha256": "891a5a3418d5d0337060fbbfcfa4e21e0469c186a188cef3b48ff8919e14cfd0", + "sha256_in_prefix": "891a5a3418d5d0337060fbbfcfa4e21e0469c186a188cef3b48ff8919e14cfd0", + "size_in_bytes": 2131 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/mbcssm.py", + "path_type": "hardlink", + "sha256": "854b4fbc3620583680d9d59d80bb2c85bc117e6dd0e5846546881d99e454350c", + "sha256_in_prefix": "854b4fbc3620583680d9d59d80bb2c85bc117e6dd0e5846546881d99e454350c", + "size_in_bytes": 30391 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/metadata/__init__.py", + "path_type": "hardlink", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size_in_bytes": 0 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/metadata/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "91239a0a26e8dc8404dc2d26b5d1daa690ad00cd1a93ab7c8150ceb69d1780bb", + "sha256_in_prefix": "91239a0a26e8dc8404dc2d26b5d1daa690ad00cd1a93ab7c8150ceb69d1780bb", + "size_in_bytes": 162 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/metadata/__pycache__/languages.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c876a32c2aeac89a7c6fcc494401a5ab96eae488139d642d77ba633dcb189cc3", + "sha256_in_prefix": "c876a32c2aeac89a7c6fcc494401a5ab96eae488139d642d77ba633dcb189cc3", + "size_in_bytes": 8145 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/metadata/languages.py", + "path_type": "hardlink", + "sha256": "161bc121d645c5143e753c246ffd2669d44a815042694310cfd239c6a8c4e624", + "sha256_in_prefix": "161bc121d645c5143e753c246ffd2669d44a815042694310cfd239c6a8c4e624", + "size_in_bytes": 13560 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/py.typed", + "path_type": "hardlink", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size_in_bytes": 0 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/resultdict.py", + "path_type": "hardlink", + "sha256": "7b3e0546f37929a4a8b09789d96cd4c8a743760df91c3cbf4922cf5ca09db793", + "sha256_in_prefix": "7b3e0546f37929a4a8b09789d96cd4c8a743760df91c3cbf4922cf5ca09db793", + "size_in_bytes": 402 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/sbcharsetprober.py", + "path_type": "hardlink", + "sha256": "fa777717dd22ec6a572e37a12d51ea5411342a55b31af4143c44cb04d9f8a3a5", + "sha256_in_prefix": "fa777717dd22ec6a572e37a12d51ea5411342a55b31af4143c44cb04d9f8a3a5", + "size_in_bytes": 6400 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/sbcsgroupprober.py", + "path_type": "hardlink", + "sha256": "81c808d1f39f830ff76130a5a5badafcc371c321322777945eb6a82c761be7d1", + "sha256_in_prefix": "81c808d1f39f830ff76130a5a5badafcc371c321322777945eb6a82c761be7d1", + "size_in_bytes": 4137 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/sjisprober.py", + "path_type": "hardlink", + "sha256": "6aa42e7cccd1c38e99a45973998698793dbe9f398a6fe86672b029a6927ceb69", + "sha256_in_prefix": "6aa42e7cccd1c38e99a45973998698793dbe9f398a6fe86672b029a6927ceb69", + "size_in_bytes": 4007 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/universaldetector.py", + "path_type": "hardlink", + "sha256": "c5806b838c7475df569d3f2a7257c00d50fda2776b50d92a3e6bed7b5a5ae76d", + "sha256_in_prefix": "c5806b838c7475df569d3f2a7257c00d50fda2776b50d92a3e6bed7b5a5ae76d", + "size_in_bytes": 14848 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/utf1632prober.py", + "path_type": "hardlink", + "sha256": "a70d5ea4674c8f58431a20aed401eaab33847e35fc3157625bb3b50654fcf9e4", + "sha256_in_prefix": "a70d5ea4674c8f58431a20aed401eaab33847e35fc3157625bb3b50654fcf9e4", + "size_in_bytes": 8505 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/utf8prober.py", + "path_type": "hardlink", + "sha256": "f26d3c51be78f741f88d0e8b617bc5cac1ad80aa0ab0751ddb31ff8bcfd39d5c", + "sha256_in_prefix": "f26d3c51be78f741f88d0e8b617bc5cac1ad80aa0ab0751ddb31ff8bcfd39d5c", + "size_in_bytes": 2812 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/version.py", + "path_type": "hardlink", + "sha256": "946b4973118ce38433e026e4e2b6db9ab2b19cdaf5fbded4db94da99e2de859c", + "sha256_in_prefix": "946b4973118ce38433e026e4e2b6db9ab2b19cdaf5fbded4db94da99e2de859c", + "size_in_bytes": 244 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/colorama/__init__.py", + "path_type": "hardlink", + "sha256": "c1e3d0038536d2d2a060047248b102d38eee70d5fe83ca512e9601ba21e52dbf", + "sha256_in_prefix": "c1e3d0038536d2d2a060047248b102d38eee70d5fe83ca512e9601ba21e52dbf", + "size_in_bytes": 266 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/colorama/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "7ae10c95e34a1707777d56e5df9801a80664a9a304dfcf7b34ac8289cdf4f2f1", + "sha256_in_prefix": "7ae10c95e34a1707777d56e5df9801a80664a9a304dfcf7b34ac8289cdf4f2f1", + "size_in_bytes": 440 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/colorama/__pycache__/ansi.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "6873742d61cd2b346eb522ff97ad17161e69053cf7049b19933c47306edf8102", + "sha256_in_prefix": "6873742d61cd2b346eb522ff97ad17161e69053cf7049b19933c47306edf8102", + "size_in_bytes": 2966 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/colorama/__pycache__/ansitowin32.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "903855256ebe6f6cec37492ed9040dccbfdef78c738992d89998719ffb87f683", + "sha256_in_prefix": "903855256ebe6f6cec37492ed9040dccbfdef78c738992d89998719ffb87f683", + "size_in_bytes": 8478 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/colorama/__pycache__/initialise.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "6aa6cf02b1aed3188b98ea8106cc9ad6a6b6265f4e7032d3ceadf90fd92238b1", + "sha256_in_prefix": "6aa6cf02b1aed3188b98ea8106cc9ad6a6b6265f4e7032d3ceadf90fd92238b1", + "size_in_bytes": 2223 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/colorama/__pycache__/win32.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "3007f5f127a250bf25a05214637037254d9a683e3431317366e806dbee6a2131", + "sha256_in_prefix": "3007f5f127a250bf25a05214637037254d9a683e3431317366e806dbee6a2131", + "size_in_bytes": 4433 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/colorama/__pycache__/winterm.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "d9b3256add4d650a8a87cbdb17158ed8cd7b697e6c7b7e3c5ee89ffefd3caa25", + "sha256_in_prefix": "d9b3256add4d650a8a87cbdb17158ed8cd7b697e6c7b7e3c5ee89ffefd3caa25", + "size_in_bytes": 5129 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/colorama/ansi.py", + "path_type": "hardlink", + "sha256": "4e8a7811e12e69074159db5e28c11c18e4de29e175f50f96a3febf0a3e643b34", + "sha256_in_prefix": "4e8a7811e12e69074159db5e28c11c18e4de29e175f50f96a3febf0a3e643b34", + "size_in_bytes": 2522 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/colorama/ansitowin32.py", + "path_type": "hardlink", + "sha256": "bcf3586b73996f18dbb85c9a568d139a19b2d4567594a3160a74fba1d5e922d9", + "sha256_in_prefix": "bcf3586b73996f18dbb85c9a568d139a19b2d4567594a3160a74fba1d5e922d9", + "size_in_bytes": 11128 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/colorama/initialise.py", + "path_type": "hardlink", + "sha256": "fa1227cbce82957a37f62c61e624827d421ad9ffe1fdb80a4435bb82ab3e28b5", + "sha256_in_prefix": "fa1227cbce82957a37f62c61e624827d421ad9ffe1fdb80a4435bb82ab3e28b5", + "size_in_bytes": 3325 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/colorama/tests/__init__.py", + "path_type": "hardlink", + "sha256": "32480f004cc641df91ab4c343d95d25f62da7515a150409c8ac258f254ab9b84", + "sha256_in_prefix": "32480f004cc641df91ab4c343d95d25f62da7515a150409c8ac258f254ab9b84", + "size_in_bytes": 75 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/colorama/tests/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "ec68c518f1bcd3113f794229cf22ddf8456e6d872e6bfa5c71177b39017511d7", + "sha256_in_prefix": "ec68c518f1bcd3113f794229cf22ddf8456e6d872e6bfa5c71177b39017511d7", + "size_in_bytes": 160 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/colorama/tests/__pycache__/ansi_test.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "3ff05ba81ce64ba9d7b4e4990fdf507b4119c6de1a109bf5e0f6abd5d6b65208", + "sha256_in_prefix": "3ff05ba81ce64ba9d7b4e4990fdf507b4119c6de1a109bf5e0f6abd5d6b65208", + "size_in_bytes": 2252 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/colorama/tests/__pycache__/ansitowin32_test.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "617f61b1e6b2aedb28e883563eba38c693e1e38d715a1d32306ff5b50b804044", + "sha256_in_prefix": "617f61b1e6b2aedb28e883563eba38c693e1e38d715a1d32306ff5b50b804044", + "size_in_bytes": 11563 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/colorama/tests/__pycache__/initialise_test.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "f8d46565dfbfb0813f3f8c6f6b6ccc64a137fdaef9192a8cd2897e85a8ee96ec", + "sha256_in_prefix": "f8d46565dfbfb0813f3f8c6f6b6ccc64a137fdaef9192a8cd2897e85a8ee96ec", + "size_in_bytes": 6860 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/colorama/tests/__pycache__/isatty_test.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "293b181b36b963f19a6bfadd2bbfa1ec41f4fae048553448430bff78942a31dc", + "sha256_in_prefix": "293b181b36b963f19a6bfadd2bbfa1ec41f4fae048553448430bff78942a31dc", + "size_in_bytes": 2651 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/colorama/tests/__pycache__/utils.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "78a35cc414680e5f669d9beb930565a4e36b4c4553bfe2f9ae25b5b4a0d9ed19", + "sha256_in_prefix": "78a35cc414680e5f669d9beb930565a4e36b4c4553bfe2f9ae25b5b4a0d9ed19", + "size_in_bytes": 1560 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/colorama/tests/__pycache__/winterm_test.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "ff224c4554d32735d36f2c22c8e76cb0ccee448c924cf282056f4b67d06678da", + "sha256_in_prefix": "ff224c4554d32735d36f2c22c8e76cb0ccee448c924cf282056f4b67d06678da", + "size_in_bytes": 3153 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/colorama/tests/ansi_test.py", + "path_type": "hardlink", + "sha256": "15e5620eb50834865caf9d393c0c6f5380235f3d5ab048802ecf465cc87045a1", + "sha256_in_prefix": "15e5620eb50834865caf9d393c0c6f5380235f3d5ab048802ecf465cc87045a1", + "size_in_bytes": 2839 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/colorama/tests/ansitowin32_test.py", + "path_type": "hardlink", + "sha256": "44dec0221309e44a83b186828d5a3ea38bbc2730c3e2e9096e67af58a4bbd2b6", + "sha256_in_prefix": "44dec0221309e44a83b186828d5a3ea38bbc2730c3e2e9096e67af58a4bbd2b6", + "size_in_bytes": 10678 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/colorama/tests/initialise_test.py", + "path_type": "hardlink", + "sha256": "05b3f2f977f21f027accaa33b903af36f419cecc7dbdd6ffd1b6179fb86c0537", + "sha256_in_prefix": "05b3f2f977f21f027accaa33b903af36f419cecc7dbdd6ffd1b6179fb86c0537", + "size_in_bytes": 6741 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/colorama/tests/isatty_test.py", + "path_type": "hardlink", + "sha256": "3e0dba2d1a6fd3240307901cfacc605571bb86c035358bdaa45800a597d8cd98", + "sha256_in_prefix": "3e0dba2d1a6fd3240307901cfacc605571bb86c035358bdaa45800a597d8cd98", + "size_in_bytes": 1866 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/colorama/tests/utils.py", + "path_type": "hardlink", + "sha256": "d48211ca51b7f73e7e773ab4f51fe782e7f1c8f67182574d6ebc4ac541b018a1", + "sha256_in_prefix": "d48211ca51b7f73e7e773ab4f51fe782e7f1c8f67182574d6ebc4ac541b018a1", + "size_in_bytes": 1079 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/colorama/tests/winterm_test.py", + "path_type": "hardlink", + "sha256": "aa85853c48f29b9826d91b8cc297f7a4e8acddae6bfcf259142ccadb9e092fc0", + "sha256_in_prefix": "aa85853c48f29b9826d91b8cc297f7a4e8acddae6bfcf259142ccadb9e092fc0", + "size_in_bytes": 3709 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/colorama/win32.py", + "path_type": "hardlink", + "sha256": "61038ac0c4f0b4605bb18e1d2f91d84efc1378ff70210adae4cbcf35d769c59b", + "sha256_in_prefix": "61038ac0c4f0b4605bb18e1d2f91d84efc1378ff70210adae4cbcf35d769c59b", + "size_in_bytes": 6181 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/colorama/winterm.py", + "path_type": "hardlink", + "sha256": "5c24050c78cf8ba00760d759c32d2d034d87f89878f09a7e1ef0a378b78ba775", + "sha256_in_prefix": "5c24050c78cf8ba00760d759c32d2d034d87f89878f09a7e1ef0a378b78ba775", + "size_in_bytes": 7134 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/distlib/__init__.py", + "path_type": "hardlink", + "sha256": "849285ec51e8a9b9867249dc0ee108356a3f3989033621ce0ed61748c72f8dc7", + "sha256_in_prefix": "849285ec51e8a9b9867249dc0ee108356a3f3989033621ce0ed61748c72f8dc7", + "size_in_bytes": 625 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/distlib/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "735c7dd4836f2cfd3bb8742277047cc5e248058cb83683ec5c80aaedefd96379", + "sha256_in_prefix": "735c7dd4836f2cfd3bb8742277047cc5e248058cb83683ec5c80aaedefd96379", + "size_in_bytes": 1024 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/distlib/__pycache__/compat.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "ad32d4dd96dd338a5ed81b518166b4c2b8c3fe1ce987f061a55fa79cfd605dce", + "sha256_in_prefix": "ad32d4dd96dd338a5ed81b518166b4c2b8c3fe1ce987f061a55fa79cfd605dce", + "size_in_bytes": 31401 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/distlib/__pycache__/database.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "2e4364d9bcf3571b6b1ee2382c7189905eb8fc93f0c3cbce669894cb15ba23b6", + "sha256_in_prefix": "2e4364d9bcf3571b6b1ee2382c7189905eb8fc93f0c3cbce669894cb15ba23b6", + "size_in_bytes": 43138 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/distlib/__pycache__/index.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c07234afca246420f1f3aed3696beef0a54ef61b1e8289a76be804d15bd0ee45", + "sha256_in_prefix": "c07234afca246420f1f3aed3696beef0a54ef61b1e8289a76be804d15bd0ee45", + "size_in_bytes": 17261 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/distlib/__pycache__/locators.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "8692eb0bbd43726371dbfabb6bc9312d144fdefb07b07ee6726a839a135fca84", + "sha256_in_prefix": "8692eb0bbd43726371dbfabb6bc9312d144fdefb07b07ee6726a839a135fca84", + "size_in_bytes": 38288 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/distlib/__pycache__/manifest.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "0cc13bcdc4ef5c9fd17b34a7875d8118e1e5646de9ed28fa6934f25cc5d91111", + "sha256_in_prefix": "0cc13bcdc4ef5c9fd17b34a7875d8118e1e5646de9ed28fa6934f25cc5d91111", + "size_in_bytes": 10189 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/distlib/__pycache__/markers.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "7a90ea52aadac35a1d28e21eebd675d3870dc5b3197c06344d64af22e9e76931", + "sha256_in_prefix": "7a90ea52aadac35a1d28e21eebd675d3870dc5b3197c06344d64af22e9e76931", + "size_in_bytes": 5277 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/distlib/__pycache__/metadata.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "0e05f9c67c401312417a23cb7d5cb2df906c4529af48326cb8eb599a00e7f0fd", + "sha256_in_prefix": "0e05f9c67c401312417a23cb7d5cb2df906c4529af48326cb8eb599a00e7f0fd", + "size_in_bytes": 26992 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/distlib/__pycache__/resources.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "f786b8bb3f525579a2358fed487f9198f084a6e63655cef686b86eb36ecd31d3", + "sha256_in_prefix": "f786b8bb3f525579a2358fed487f9198f084a6e63655cef686b86eb36ecd31d3", + "size_in_bytes": 10998 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/distlib/__pycache__/scripts.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "322e81cc763970b588570ce3f7e7dfc2b41d9f08a03033769af9d4d52ada9dc1", + "sha256_in_prefix": "322e81cc763970b588570ce3f7e7dfc2b41d9f08a03033769af9d4d52ada9dc1", + "size_in_bytes": 11484 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/distlib/__pycache__/util.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "a6e1a3b54f011588b91828e4c3b7446cc282fe583fb896efe9479cecd82f53fe", + "sha256_in_prefix": "a6e1a3b54f011588b91828e4c3b7446cc282fe583fb896efe9479cecd82f53fe", + "size_in_bytes": 52102 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/distlib/__pycache__/version.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "6c9f4a71f2519bae6049aef937aaa73248e3b18a33ff63863ac60b6a45429851", + "sha256_in_prefix": "6c9f4a71f2519bae6049aef937aaa73248e3b18a33ff63863ac60b6a45429851", + "size_in_bytes": 20245 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/distlib/__pycache__/wheel.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "d59188ff0145602b044cb407e28c02fe290dc65b94c85cce8be41ea78febd23a", + "sha256_in_prefix": "d59188ff0145602b044cb407e28c02fe290dc65b94c85cce8be41ea78febd23a", + "size_in_bytes": 27640 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/distlib/compat.py", + "path_type": "hardlink", + "sha256": "527fae201bf2d36c3e0f6ebb386e15121b9d76a5a02a3f67364c5596d01bef9c", + "sha256_in_prefix": "527fae201bf2d36c3e0f6ebb386e15121b9d76a5a02a3f67364c5596d01bef9c", + "size_in_bytes": 41487 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/distlib/database.py", + "path_type": "hardlink", + "sha256": "d15f50becd15af16b617ffa12d68ad2325724627c9d290b1c8e23e904381c2c0", + "sha256_in_prefix": "d15f50becd15af16b617ffa12d68ad2325724627c9d290b1c8e23e904381c2c0", + "size_in_bytes": 51965 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/distlib/index.py", + "path_type": "hardlink", + "sha256": "9536f0dbaf2b4618fc770d6c89bdd567fd048521a0a093b714a27348530e69e0", + "sha256_in_prefix": "9536f0dbaf2b4618fc770d6c89bdd567fd048521a0a093b714a27348530e69e0", + "size_in_bytes": 20797 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/distlib/locators.py", + "path_type": "hardlink", + "sha256": "a35aff33cebf6d12da7d2a5eb66c9f5fc291b45bbefd0e7c69bbd0ae73929db0", + "sha256_in_prefix": "a35aff33cebf6d12da7d2a5eb66c9f5fc291b45bbefd0e7c69bbd0ae73929db0", + "size_in_bytes": 51767 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/distlib/manifest.py", + "path_type": "hardlink", + "sha256": "dea7e6026570c51a94d68db70257d7ad0199ce1ea0fc61b34c03ff1dbf42e734", + "sha256_in_prefix": "dea7e6026570c51a94d68db70257d7ad0199ce1ea0fc61b34c03ff1dbf42e734", + "size_in_bytes": 14168 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/distlib/markers.py", + "path_type": "hardlink", + "sha256": "9f70df3a1d72bd9ffc116edab4cca861e6455e36256b4373d22b509688c27740", + "sha256_in_prefix": "9f70df3a1d72bd9ffc116edab4cca861e6455e36256b4373d22b509688c27740", + "size_in_bytes": 5268 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/distlib/metadata.py", + "path_type": "hardlink", + "sha256": "a41f5667d9817e643173d39522574b4b90a33a8411bca02f530c10c8ac0a42d4", + "sha256_in_prefix": "a41f5667d9817e643173d39522574b4b90a33a8411bca02f530c10c8ac0a42d4", + "size_in_bytes": 39693 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/distlib/resources.py", + "path_type": "hardlink", + "sha256": "2f06cf92c73403524c6e2e979ee3dd301527f375fb04fb85356a8f184288ebdf", + "sha256_in_prefix": "2f06cf92c73403524c6e2e979ee3dd301527f375fb04fb85356a8f184288ebdf", + "size_in_bytes": 10820 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/distlib/scripts.py", + "path_type": "hardlink", + "sha256": "9d015737a1bb9ce58d0d4cb18ab51ea7edd63a526107b31cbc2b3dcce9e41932", + "sha256_in_prefix": "9d015737a1bb9ce58d0d4cb18ab51ea7edd63a526107b31cbc2b3dcce9e41932", + "size_in_bytes": 18315 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/distlib/util.py", + "path_type": "hardlink", + "sha256": "5d2ce7c448bf8b74f6d1426e695734a971f3e64b065025b5921625069acdfd01", + "sha256_in_prefix": "5d2ce7c448bf8b74f6d1426e695734a971f3e64b065025b5921625069acdfd01", + "size_in_bytes": 67530 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/distlib/version.py", + "path_type": "hardlink", + "sha256": "f695e476e721bdefda37b246ea22fd553615fe4a8d486a1cd83c25f09bb24a74", + "sha256_in_prefix": "f695e476e721bdefda37b246ea22fd553615fe4a8d486a1cd83c25f09bb24a74", + "size_in_bytes": 23747 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/distlib/wheel.py", + "path_type": "hardlink", + "sha256": "155402bdef2ef8bd10624e7e61365ceece1698d41dbe34564cad3c297cd9557e", + "sha256_in_prefix": "155402bdef2ef8bd10624e7e61365ceece1698d41dbe34564cad3c297cd9557e", + "size_in_bytes": 43958 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/distro/__init__.py", + "path_type": "hardlink", + "sha256": "d9f1e317e49f80fbe3c8d67588787fc23a96751fd8a393831f0642d232c13e17", + "sha256_in_prefix": "d9f1e317e49f80fbe3c8d67588787fc23a96751fd8a393831f0642d232c13e17", + "size_in_bytes": 981 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/distro/__main__.py", + "path_type": "hardlink", + "sha256": "6eef5ddd389fa0a72264572a441bb2815dc64ae4e19d50ff9b620ae1ccfde95b", + "sha256_in_prefix": "6eef5ddd389fa0a72264572a441bb2815dc64ae4e19d50ff9b620ae1ccfde95b", + "size_in_bytes": 64 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/distro/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "4108224ca1acb459860da5bbecae343a64230c1a206887a636aae81f59db284b", + "sha256_in_prefix": "4108224ca1acb459860da5bbecae343a64230c1a206887a636aae81f59db284b", + "size_in_bytes": 877 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/distro/__pycache__/__main__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "d96b1c1a76f62b5158b881965264aac8f6e07490998c0e5ccfe89560a0d2dfc9", + "sha256_in_prefix": "d96b1c1a76f62b5158b881965264aac8f6e07490998c0e5ccfe89560a0d2dfc9", + "size_in_bytes": 231 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/distro/__pycache__/distro.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "ccb20259f579b322aaaacd24a6348d55d6913ccbc6391550c253d7e5bf3d668e", + "sha256_in_prefix": "ccb20259f579b322aaaacd24a6348d55d6913ccbc6391550c253d7e5bf3d668e", + "size_in_bytes": 42025 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/distro/distro.py", + "path_type": "hardlink", + "sha256": "5193b52e3221b4508c7656e2cf7f608f7ada57e0267f7481c331b37c0a62307c", + "sha256_in_prefix": "5193b52e3221b4508c7656e2cf7f608f7ada57e0267f7481c331b37c0a62307c", + "size_in_bytes": 49330 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/distro/py.typed", + "path_type": "hardlink", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size_in_bytes": 0 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/idna/__init__.py", + "path_type": "hardlink", + "sha256": "28940dd5e401afc8882b948aac9e3b957bf11b4049ecb9b7f16e334f4bfff259", + "sha256_in_prefix": "28940dd5e401afc8882b948aac9e3b957bf11b4049ecb9b7f16e334f4bfff259", + "size_in_bytes": 849 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/idna/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "797a5b0e0bd097375894925a9752a99ea482c1c0b1478b8e7f5076a210febacb", + "sha256_in_prefix": "797a5b0e0bd097375894925a9752a99ea482c1c0b1478b8e7f5076a210febacb", + "size_in_bytes": 809 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/idna/__pycache__/codec.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "fd20e606e7c1734f781466205aaeaed3059157ef5ee8b76d8085eff265861ca6", + "sha256_in_prefix": "fd20e606e7c1734f781466205aaeaed3059157ef5ee8b76d8085eff265861ca6", + "size_in_bytes": 2780 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/idna/__pycache__/compat.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "b5a5f4bb55fe2327ad3013a3af913ecd998a8b81e8d8e14b3b9710d29792f061", + "sha256_in_prefix": "b5a5f4bb55fe2327ad3013a3af913ecd998a8b81e8d8e14b3b9710d29792f061", + "size_in_bytes": 709 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/idna/__pycache__/core.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "5e1b7493896bf31b6ea74d7ee4b4e36a065808d5d2a058663eecb3f37c3d2262", + "sha256_in_prefix": "5e1b7493896bf31b6ea74d7ee4b4e36a065808d5d2a058663eecb3f37c3d2262", + "size_in_bytes": 9638 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/idna/__pycache__/idnadata.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "59ec76a29255ec7fb86ff74288b30d2044558db61b4dda457b6b9e0ab3462bd7", + "sha256_in_prefix": "59ec76a29255ec7fb86ff74288b30d2044558db61b4dda457b6b9e0ab3462bd7", + "size_in_bytes": 38345 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/idna/__pycache__/intranges.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "ef1872d73aa6c98fe1a8e2eb8708276734cf6a66f172053a27da1d4fbd5be20c", + "sha256_in_prefix": "ef1872d73aa6c98fe1a8e2eb8708276734cf6a66f172053a27da1d4fbd5be20c", + "size_in_bytes": 1946 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/idna/__pycache__/package_data.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "59370787ec713c0d67ab38e57e538865b900a314c2a63441f12786417444c4d1", + "sha256_in_prefix": "59370787ec713c0d67ab38e57e538865b900a314c2a63441f12786417444c4d1", + "size_in_bytes": 173 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/idna/__pycache__/uts46data.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "a3f4596b3426bfe3d9927abed7960303aa3770a6f619b6db31ccd756ab4e2329", + "sha256_in_prefix": "a3f4596b3426bfe3d9927abed7960303aa3770a6f619b6db31ccd756ab4e2329", + "size_in_bytes": 152360 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/idna/codec.py", + "path_type": "hardlink", + "sha256": "ea5cb9a1d29faabcad293f7fed4ae51a49479dfd4348adabf42e9c48ce2c6b6f", + "sha256_in_prefix": "ea5cb9a1d29faabcad293f7fed4ae51a49479dfd4348adabf42e9c48ce2c6b6f", + "size_in_bytes": 3374 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/idna/compat.py", + "path_type": "hardlink", + "sha256": "d3fb0e114313e02570f5da03defc91857f345f5f4fc2a168501b3b816b05304e", + "sha256_in_prefix": "d3fb0e114313e02570f5da03defc91857f345f5f4fc2a168501b3b816b05304e", + "size_in_bytes": 321 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/idna/core.py", + "path_type": "hardlink", + "sha256": "d49c5c8702b39310529fb47fa02135da806edde56ec74573771a2598869ddb83", + "sha256_in_prefix": "d49c5c8702b39310529fb47fa02135da806edde56ec74573771a2598869ddb83", + "size_in_bytes": 12950 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/idna/idnadata.py", + "path_type": "hardlink", + "sha256": "c548ea2aa88957c1e8fd7cc1a40b6fe4916854f4aea4af92517bed8f28141eac", + "sha256_in_prefix": "c548ea2aa88957c1e8fd7cc1a40b6fe4916854f4aea4af92517bed8f28141eac", + "size_in_bytes": 44375 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/idna/intranges.py", + "path_type": "hardlink", + "sha256": "601af87d162e587ee44ca4b6b579458ccdb8645d4f76f722afe6b2c278889ea8", + "sha256_in_prefix": "601af87d162e587ee44ca4b6b579458ccdb8645d4f76f722afe6b2c278889ea8", + "size_in_bytes": 1881 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/idna/package_data.py", + "path_type": "hardlink", + "sha256": "0bf8c7273997f0f238c6ad23a7399c4ccc696f9943b2ae28e55cb1433955ad91", + "sha256_in_prefix": "0bf8c7273997f0f238c6ad23a7399c4ccc696f9943b2ae28e55cb1433955ad91", + "size_in_bytes": 21 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/idna/py.typed", + "path_type": "hardlink", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size_in_bytes": 0 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/idna/uts46data.py", + "path_type": "hardlink", + "sha256": "cef8d9536e2ce7cfee012f39d0c71dd0d9c3d17eff802300323cd634879425d7", + "sha256_in_prefix": "cef8d9536e2ce7cfee012f39d0c71dd0d9c3d17eff802300323cd634879425d7", + "size_in_bytes": 206539 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/msgpack/__init__.py", + "path_type": "hardlink", + "sha256": "8721a196799c264c6bc8904a0b75f9167129877ef9910a0bfe61bc2d952e5e06", + "sha256_in_prefix": "8721a196799c264c6bc8904a0b75f9167129877ef9910a0bfe61bc2d952e5e06", + "size_in_bytes": 1132 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/msgpack/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "9e52f52fb6722818fc2a771955cbfdc0a7af3c57d4b44a88454a9f083ab7a39f", + "sha256_in_prefix": "9e52f52fb6722818fc2a771955cbfdc0a7af3c57d4b44a88454a9f083ab7a39f", + "size_in_bytes": 1407 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/msgpack/__pycache__/exceptions.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "bcace68ce4a5552f1a85bebc57bb64f7803023735b2a36a25eaf56e0aaa9d967", + "sha256_in_prefix": "bcace68ce4a5552f1a85bebc57bb64f7803023735b2a36a25eaf56e0aaa9d967", + "size_in_bytes": 1770 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/msgpack/__pycache__/ext.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "6ff6996578fb5e80fa86e1fbf5c139d61e8adec5294090a743187bde4783728f", + "sha256_in_prefix": "6ff6996578fb5e80fa86e1fbf5c139d61e8adec5294090a743187bde4783728f", + "size_in_bytes": 6277 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/msgpack/__pycache__/fallback.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "048cd8afcf30ede12db0a12402c6c491bfa66f6bc3b4fc8b372ca48e5c39862f", + "sha256_in_prefix": "048cd8afcf30ede12db0a12402c6c491bfa66f6bc3b4fc8b372ca48e5c39862f", + "size_in_bytes": 25440 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/msgpack/exceptions.py", + "path_type": "hardlink", + "sha256": "7424d67a2f1da64accb100dc8d093be004e5f47b08047d326edf3338f36a3187", + "sha256_in_prefix": "7424d67a2f1da64accb100dc8d093be004e5f47b08047d326edf3338f36a3187", + "size_in_bytes": 1081 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/msgpack/ext.py", + "path_type": "hardlink", + "sha256": "0b930af0985560660558fbf1b0e46ca99027bce5de7d8439ee6d589b496e5b93", + "sha256_in_prefix": "0b930af0985560660558fbf1b0e46ca99027bce5de7d8439ee6d589b496e5b93", + "size_in_bytes": 6079 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/msgpack/fallback.py", + "path_type": "hardlink", + "sha256": "b6f3411f2c7115bb95942f066528444c2949c632e20cc3a36b85f0c32bcd9b68", + "sha256_in_prefix": "b6f3411f2c7115bb95942f066528444c2949c632e20cc3a36b85f0c32bcd9b68", + "size_in_bytes": 34544 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/packaging/__about__.py", + "path_type": "hardlink", + "sha256": "ba001220edb0d685321fcfc23aa4365ffb34ac38636e1402df2268703d378767", + "sha256_in_prefix": "ba001220edb0d685321fcfc23aa4365ffb34ac38636e1402df2268703d378767", + "size_in_bytes": 661 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/packaging/__init__.py", + "path_type": "hardlink", + "sha256": "6fd2a4e4c17b2b18612e07039a2516ba437e2dab561713dd36e8348e83e11d29", + "sha256_in_prefix": "6fd2a4e4c17b2b18612e07039a2516ba437e2dab561713dd36e8348e83e11d29", + "size_in_bytes": 497 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/packaging/__pycache__/__about__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "3fde662d326eae1d320fe419a33d8d1d7ad596dfc2e2a50b22fefbd0c5ae5df5", + "sha256_in_prefix": "3fde662d326eae1d320fe419a33d8d1d7ad596dfc2e2a50b22fefbd0c5ae5df5", + "size_in_bytes": 552 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/packaging/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "5a5f3ebefeb65c2d4c02afbf055dc9dfcb20f51aed7ec1866eea21b7cc93919f", + "sha256_in_prefix": "5a5f3ebefeb65c2d4c02afbf055dc9dfcb20f51aed7ec1866eea21b7cc93919f", + "size_in_bytes": 408 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/packaging/__pycache__/_manylinux.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "017889b56e54eb0af523229107ad05521a1149a3b30dec25de022fa4c34b73e4", + "sha256_in_prefix": "017889b56e54eb0af523229107ad05521a1149a3b30dec25de022fa4c34b73e4", + "size_in_bytes": 7262 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/packaging/__pycache__/_musllinux.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "d5d30f58ba6fc75b2f3c3d1ea8370aff585ef0c39c4414a3d15a432dda377029", + "sha256_in_prefix": "d5d30f58ba6fc75b2f3c3d1ea8370aff585ef0c39c4414a3d15a432dda377029", + "size_in_bytes": 4574 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/packaging/__pycache__/_structures.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "f791d63df6a29f7682dc7cba8d03db7f75f4c6b4a0f020afeb7ed629e49e3a77", + "sha256_in_prefix": "f791d63df6a29f7682dc7cba8d03db7f75f4c6b4a0f020afeb7ed629e49e3a77", + "size_in_bytes": 2667 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/packaging/__pycache__/markers.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "1d57d7e3a97d7e2fe4660f00f107379d6e942bf895c346fd2c4424e345ebf5b9", + "sha256_in_prefix": "1d57d7e3a97d7e2fe4660f00f107379d6e942bf895c346fd2c4424e345ebf5b9", + "size_in_bytes": 9249 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/packaging/__pycache__/requirements.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "146f9d51723112be0c7cadb431bd562a56582842810f2e4cdff322bbafae9670", + "sha256_in_prefix": "146f9d51723112be0c7cadb431bd562a56582842810f2e4cdff322bbafae9670", + "size_in_bytes": 3937 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/packaging/__pycache__/specifiers.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "1c5604ea8a1ec21d85da4b3fcb1f55cd1882b07cffc8c64894e6dc42d993f8f3", + "sha256_in_prefix": "1c5604ea8a1ec21d85da4b3fcb1f55cd1882b07cffc8c64894e6dc42d993f8f3", + "size_in_bytes": 21489 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/packaging/__pycache__/tags.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "ce5aa9d79e32abf2253f7626598b578d13463f19954165e652921e3e405217b0", + "sha256_in_prefix": "ce5aa9d79e32abf2253f7626598b578d13463f19954165e652921e3e405217b0", + "size_in_bytes": 12152 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/packaging/__pycache__/utils.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "19323ef89e3c0af0e897b77f9bfacb01430b9fc1f63f91d991a6e62472e4fdf3", + "sha256_in_prefix": "19323ef89e3c0af0e897b77f9bfacb01430b9fc1f63f91d991a6e62472e4fdf3", + "size_in_bytes": 3537 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/packaging/__pycache__/version.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "f7a7ac846a7a3c7cd1e675658f6cb7a420203e5ac9e59b765e8dd0409a04443e", + "sha256_in_prefix": "f7a7ac846a7a3c7cd1e675658f6cb7a420203e5ac9e59b765e8dd0409a04443e", + "size_in_bytes": 12887 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/packaging/_manylinux.py", + "path_type": "hardlink", + "sha256": "5dc6e25c1faa723bf76dca21a7a37df1332938fe3f8f79be88e03ca6d2b61966", + "sha256_in_prefix": "5dc6e25c1faa723bf76dca21a7a37df1332938fe3f8f79be88e03ca6d2b61966", + "size_in_bytes": 11488 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/packaging/_musllinux.py", + "path_type": "hardlink", + "sha256": "fca1a063fa9ceef84c1a9a2ab2cdb99f68622c234a46dbf3f660ab4bb824ab27", + "sha256_in_prefix": "fca1a063fa9ceef84c1a9a2ab2cdb99f68622c234a46dbf3f660ab4bb824ab27", + "size_in_bytes": 4378 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/packaging/_structures.py", + "path_type": "hardlink", + "sha256": "ab77953666d62461bf4b40e2b7f4b7028f2a42acffe4f6135c500a0597b9cabe", + "sha256_in_prefix": "ab77953666d62461bf4b40e2b7f4b7028f2a42acffe4f6135c500a0597b9cabe", + "size_in_bytes": 1431 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/packaging/markers.py", + "path_type": "hardlink", + "sha256": "00904e718f0eab4918739ef42aeb8f4e4beeaa302586e7da13673db0251b9bae", + "sha256_in_prefix": "00904e718f0eab4918739ef42aeb8f4e4beeaa302586e7da13673db0251b9bae", + "size_in_bytes": 8487 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/packaging/py.typed", + "path_type": "hardlink", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size_in_bytes": 0 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/packaging/requirements.py", + "path_type": "hardlink", + "sha256": "36d0e53c1b688e99f52140bce623233cdb149ae7e3a529709cd03e5dbe26e4d0", + "sha256_in_prefix": "36d0e53c1b688e99f52140bce623233cdb149ae7e3a529709cd03e5dbe26e4d0", + "size_in_bytes": 4676 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/packaging/specifiers.py", + "path_type": "hardlink", + "sha256": "2d1434905b07ae5e6a7dc14d10426b20562c9c81d05095d8f5f22c6a44ebaea1", + "sha256_in_prefix": "2d1434905b07ae5e6a7dc14d10426b20562c9c81d05095d8f5f22c6a44ebaea1", + "size_in_bytes": 30110 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/packaging/tags.py", + "path_type": "hardlink", + "sha256": "966b2718d889f02e03fcf7fd3db334aa06d9bc3f64981f65a590505196b747f6", + "sha256_in_prefix": "966b2718d889f02e03fcf7fd3db334aa06d9bc3f64981f65a590505196b747f6", + "size_in_bytes": 15699 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/packaging/utils.py", + "path_type": "hardlink", + "sha256": "7498de6addc14be4d89f546b505570b9f50c6ac6edccb7d8468cbf1d710d7854", + "sha256_in_prefix": "7498de6addc14be4d89f546b505570b9f50c6ac6edccb7d8468cbf1d710d7854", + "size_in_bytes": 4200 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/packaging/version.py", + "path_type": "hardlink", + "sha256": "fdf2d136b16bc5870755fca8f2f93d8fcb3a24cf0dff1b12c5516be91272728f", + "sha256_in_prefix": "fdf2d136b16bc5870755fca8f2f93d8fcb3a24cf0dff1b12c5516be91272728f", + "size_in_bytes": 14665 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pkg_resources/__init__.py", + "path_type": "hardlink", + "sha256": "85301e2423586fb749b1e20356c60ade63d07a9fe0a618f8b5087e6eca57f1b8", + "sha256_in_prefix": "85301e2423586fb749b1e20356c60ade63d07a9fe0a618f8b5087e6eca57f1b8", + "size_in_bytes": 109364 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pkg_resources/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "effe427e2f1cb68f0d2959c0cf4efc23fe1b9d9f0b07e69713f8cba95b1628a3", + "sha256_in_prefix": "effe427e2f1cb68f0d2959c0cf4efc23fe1b9d9f0b07e69713f8cba95b1628a3", + "size_in_bytes": 101023 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/platformdirs/__init__.py", + "path_type": "hardlink", + "sha256": "4a4844615c82fc75070ba297ee7e0cffa728c9132d101dfc40cc8e608017e989", + "sha256_in_prefix": "4a4844615c82fc75070ba297ee7e0cffa728c9132d101dfc40cc8e608017e989", + "size_in_bytes": 20155 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/platformdirs/__main__.py", + "path_type": "hardlink", + "sha256": "7d5bd2893cebdbe44ce88b235a38f87e468eb433a00e1516bfab00f7d768e024", + "sha256_in_prefix": "7d5bd2893cebdbe44ce88b235a38f87e468eb433a00e1516bfab00f7d768e024", + "size_in_bytes": 1476 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/platformdirs/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "2047028397230c9d73df6a11a3e9f52514dcabcceb98e6270cae244b2d0bda83", + "sha256_in_prefix": "2047028397230c9d73df6a11a3e9f52514dcabcceb98e6270cae244b2d0bda83", + "size_in_bytes": 14331 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/platformdirs/__pycache__/__main__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "791a93aa098b43f42a25c4056437f79df29df9a53a691ec7c37c092391f829cf", + "sha256_in_prefix": "791a93aa098b43f42a25c4056437f79df29df9a53a691ec7c37c092391f829cf", + "size_in_bytes": 1343 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/platformdirs/__pycache__/android.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "e61cc80988d556522a267a77ac95a5f4197617b71a3311d3e139e916474821d1", + "sha256_in_prefix": "e61cc80988d556522a267a77ac95a5f4197617b71a3311d3e139e916474821d1", + "size_in_bytes": 6581 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/platformdirs/__pycache__/api.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c4d86ea8abf63de321b601f82200441592dca3bacf05f1f2d57eb4f22f938425", + "sha256_in_prefix": "c4d86ea8abf63de321b601f82200441592dca3bacf05f1f2d57eb4f22f938425", + "size_in_bytes": 7579 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/platformdirs/__pycache__/macos.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "66618b8e7f7622f6df8ae0afeb676bc30e8ae1aeeaeda537ad7f20a5314ef7c4", + "sha256_in_prefix": "66618b8e7f7622f6df8ae0afeb676bc30e8ae1aeeaeda537ad7f20a5314ef7c4", + "size_in_bytes": 4220 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/platformdirs/__pycache__/unix.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "03a637c47f6fccfaf0b8860205008f360b309db956e58af8bd7fd81d0b74a4d7", + "sha256_in_prefix": "03a637c47f6fccfaf0b8860205008f360b309db956e58af8bd7fd81d0b74a4d7", + "size_in_bytes": 8811 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/platformdirs/__pycache__/version.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "148ce11fa23bb340c80c4bf624eb71a59607305b273c02708787fc583dd8ae9d", + "sha256_in_prefix": "148ce11fa23bb340c80c4bf624eb71a59607305b273c02708787fc583dd8ae9d", + "size_in_bytes": 252 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/platformdirs/__pycache__/windows.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "d643a2bb6a52e197bd8cfade7099859b93baddf0c229c585a2e3fbde4c41a4a5", + "sha256_in_prefix": "d643a2bb6a52e197bd8cfade7099859b93baddf0c229c585a2e3fbde4c41a4a5", + "size_in_bytes": 8585 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/platformdirs/android.py", + "path_type": "hardlink", + "sha256": "cbf10430ac18976f9bcd8043a2f92c4a7f26efaa27d0b75af1ec8992c55013d5", + "sha256_in_prefix": "cbf10430ac18976f9bcd8043a2f92c4a7f26efaa27d0b75af1ec8992c55013d5", + "size_in_bytes": 7211 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/platformdirs/api.py", + "path_type": "hardlink", + "sha256": "8d6b57d3a8c0272b58ae42433aa125b3dee60a4c87452664a2a5256cc2b941ec", + "sha256_in_prefix": "8d6b57d3a8c0272b58ae42433aa125b3dee60a4c87452664a2a5256cc2b941ec", + "size_in_bytes": 7132 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/platformdirs/macos.py", + "path_type": "hardlink", + "sha256": "2ee7953a85601960c1c106fc385c1791529f567df708cd4b9307f5f80f3ab514", + "sha256_in_prefix": "2ee7953a85601960c1c106fc385c1791529f567df708cd4b9307f5f80f3ab514", + "size_in_bytes": 3678 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/platformdirs/py.typed", + "path_type": "hardlink", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size_in_bytes": 0 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/platformdirs/unix.py", + "path_type": "hardlink", + "sha256": "db626147c658d1a2f14950859caadce9fd62cfa1afe362b6e036a3eda4e37d28", + "sha256_in_prefix": "db626147c658d1a2f14950859caadce9fd62cfa1afe362b6e036a3eda4e37d28", + "size_in_bytes": 8809 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/platformdirs/version.py", + "path_type": "hardlink", + "sha256": "99abd94d02092177dd7b011a4939fb116acd7cf656791a1f6feef8c6a5b97f63", + "sha256_in_prefix": "99abd94d02092177dd7b011a4939fb116acd7cf656791a1f6feef8c6a5b97f63", + "size_in_bytes": 160 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/platformdirs/windows.py", + "path_type": "hardlink", + "sha256": "e13b5b3c6a161b63d1808d75baab836bb79193c4dcc6f9d436eb8c19922d9d77", + "sha256_in_prefix": "e13b5b3c6a161b63d1808d75baab836bb79193c4dcc6f9d436eb8c19922d9d77", + "size_in_bytes": 9573 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/__init__.py", + "path_type": "hardlink", + "sha256": "e80b8396342dbdff3d0d3354c9633b937a1494ffe5abbd0d53e20d28ab5e3816", + "sha256_in_prefix": "e80b8396342dbdff3d0d3354c9633b937a1494ffe5abbd0d53e20d28ab5e3816", + "size_in_bytes": 2983 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/__main__.py", + "path_type": "hardlink", + "sha256": "7acf0428cbd78f9c93a087d0fa97f70efe539c879e33ab0c1342d6fa7e1e707a", + "sha256_in_prefix": "7acf0428cbd78f9c93a087d0fa97f70efe539c879e33ab0c1342d6fa7e1e707a", + "size_in_bytes": 353 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "e18ec420e2da325f7c741ef7781c13773150ee9df3652dada47304d9f146c272", + "sha256_in_prefix": "e18ec420e2da325f7c741ef7781c13773150ee9df3652dada47304d9f146c272", + "size_in_bytes": 2897 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/__pycache__/__main__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "fa789f177345019bd0cf94432487f1bf68fcc8cf728196ff6be65db0f7a8a9b9", + "sha256_in_prefix": "fa789f177345019bd0cf94432487f1bf68fcc8cf728196ff6be65db0f7a8a9b9", + "size_in_bytes": 550 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/__pycache__/cmdline.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "80333407989c3500a3b6ae8e6983c308080fb651ced15afc706a968da6ba6328", + "sha256_in_prefix": "80333407989c3500a3b6ae8e6983c308080fb651ced15afc706a968da6ba6328", + "size_in_bytes": 15565 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/__pycache__/console.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "edeafafe45bdfd7cd90bc50f3e9b1e33d7dc92e1645483df6e7975c5a33b5f57", + "sha256_in_prefix": "edeafafe45bdfd7cd90bc50f3e9b1e33d7dc92e1645483df6e7975c5a33b5f57", + "size_in_bytes": 1845 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/__pycache__/filter.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "973c95204ca790731b1399b954664f77097843666373c8af821b2c6b2da3dc98", + "sha256_in_prefix": "973c95204ca790731b1399b954664f77097843666373c8af821b2c6b2da3dc98", + "size_in_bytes": 2616 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/__pycache__/formatter.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "a04f7311f4028dd2875eab5d7493ee8f4597ab4d0cec57b843415ce7949e7385", + "sha256_in_prefix": "a04f7311f4028dd2875eab5d7493ee8f4597ab4d0cec57b843415ce7949e7385", + "size_in_bytes": 3918 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/__pycache__/lexer.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "f79e598b753426055957fa6c2d6d01d49dc1d288c769af047227287deb701991", + "sha256_in_prefix": "f79e598b753426055957fa6c2d6d01d49dc1d288c769af047227287deb701991", + "size_in_bytes": 26193 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/__pycache__/modeline.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "e9d3c418ba42b6c5d4b7f264c130d84684c730a180e65214df271632cfa8645b", + "sha256_in_prefix": "e9d3c418ba42b6c5d4b7f264c130d84684c730a180e65214df271632cfa8645b", + "size_in_bytes": 1154 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/__pycache__/plugin.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "99fe2394d14239d0e4d82c4b3b528d90761ede41ff642376de2729d50abcf318", + "sha256_in_prefix": "99fe2394d14239d0e4d82c4b3b528d90761ede41ff642376de2729d50abcf318", + "size_in_bytes": 2482 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/__pycache__/regexopt.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "35de4b7f5c5f2a6a2084ad7a41ee108f6df27e891a6b905a9e326ea842103022", + "sha256_in_prefix": "35de4b7f5c5f2a6a2084ad7a41ee108f6df27e891a6b905a9e326ea842103022", + "size_in_bytes": 2918 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/__pycache__/scanner.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "65e4fdd414b544c90bce4b268bea8bcb9a1adce878292ec011fe40e14455e4eb", + "sha256_in_prefix": "65e4fdd414b544c90bce4b268bea8bcb9a1adce878292ec011fe40e14455e4eb", + "size_in_bytes": 3520 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/__pycache__/sphinxext.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c90089060672343d0cbcd39586c9cdfce95711a6de511b1a588b1c9f6f358fb1", + "sha256_in_prefix": "c90089060672343d0cbcd39586c9cdfce95711a6de511b1a588b1c9f6f358fb1", + "size_in_bytes": 7083 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/__pycache__/style.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "9dc2e71d5a0b9691d2cf343b8df6ff20347e464b44b47f9d6c7be2313bdcc581", + "sha256_in_prefix": "9dc2e71d5a0b9691d2cf343b8df6ff20347e464b44b47f9d6c7be2313bdcc581", + "size_in_bytes": 4541 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/__pycache__/token.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "b720d5e43e07aa134c31d1feb912a94da78cfbd22bd0af9b17674b01b3a477fb", + "sha256_in_prefix": "b720d5e43e07aa134c31d1feb912a94da78cfbd22bd0af9b17674b01b3a477fb", + "size_in_bytes": 4633 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/__pycache__/unistring.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "fa36e0952129993cc6bf3dacf58eb39dce4adf983f1b1a32eb1020582bbe515d", + "sha256_in_prefix": "fa36e0952129993cc6bf3dacf58eb39dce4adf983f1b1a32eb1020582bbe515d", + "size_in_bytes": 31194 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/__pycache__/util.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "da9f9735e4b86c9878b9ca711f49d1bd2758574c9ce7302a5ad6cfe75f7f6a7b", + "sha256_in_prefix": "da9f9735e4b86c9878b9ca711f49d1bd2758574c9ce7302a5ad6cfe75f7f6a7b", + "size_in_bytes": 10166 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/cmdline.py", + "path_type": "hardlink", + "sha256": "6f2c58269f609e355eca1465677513320a3f2e191787569fbcdf30241b4071cf", + "sha256_in_prefix": "6f2c58269f609e355eca1465677513320a3f2e191787569fbcdf30241b4071cf", + "size_in_bytes": 23685 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/console.py", + "path_type": "hardlink", + "sha256": "db06795be53a4ee7490f5fcd2d4c237253296e898533dd6536fd75ffad2c7c66", + "sha256_in_prefix": "db06795be53a4ee7490f5fcd2d4c237253296e898533dd6536fd75ffad2c7c66", + "size_in_bytes": 1697 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/filter.py", + "path_type": "hardlink", + "sha256": "8f968b33d6bdc12c7a787d68cb8ef7a12909d3684658da6d065568e2cd60ff7d", + "sha256_in_prefix": "8f968b33d6bdc12c7a787d68cb8ef7a12909d3684658da6d065568e2cd60ff7d", + "size_in_bytes": 1938 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/filters/__init__.py", + "path_type": "hardlink", + "sha256": "87f928624505a3e1455318ece7ae091d4033ecedf226957023a7ca377318cc6d", + "sha256_in_prefix": "87f928624505a3e1455318ece7ae091d4033ecedf226957023a7ca377318cc6d", + "size_in_bytes": 40386 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/filters/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "7afcc19be08d1ad4ab786948fcf68048eea0dfe1c35addfb016cda194db5a78f", + "sha256_in_prefix": "7afcc19be08d1ad4ab786948fcf68048eea0dfe1c35addfb016cda194db5a78f", + "size_in_bytes": 29570 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/formatter.py", + "path_type": "hardlink", + "sha256": "27d38bf615cb24a664ee6a1480ac298d6f4735fe16949160fe8ffe67f4bfb536", + "sha256_in_prefix": "27d38bf615cb24a664ee6a1480ac298d6f4735fe16949160fe8ffe67f4bfb536", + "size_in_bytes": 4178 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/formatters/__init__.py", + "path_type": "hardlink", + "sha256": "ff180071d14aaf440d63087f8bdf0053d86f7cfdd7db0024844945711445dd4a", + "sha256_in_prefix": "ff180071d14aaf440d63087f8bdf0053d86f7cfdd7db0024844945711445dd4a", + "size_in_bytes": 5424 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/formatters/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "75a7a65de6ab611b8a6cbbd9eca23e557e3df74658b321ddcf7d761623c3e118", + "sha256_in_prefix": "75a7a65de6ab611b8a6cbbd9eca23e557e3df74658b321ddcf7d761623c3e118", + "size_in_bytes": 4970 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/formatters/__pycache__/_mapping.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "316a0f2f12c8f3937f9b92cf4c1a79a7e468456062fbea37518a7da3876f19c9", + "sha256_in_prefix": "316a0f2f12c8f3937f9b92cf4c1a79a7e468456062fbea37518a7da3876f19c9", + "size_in_bytes": 3962 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/formatters/__pycache__/bbcode.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "2c17a3806e9c95a9e6a4035b309d41c1990da5081f0c2872e684f21be5308c15", + "sha256_in_prefix": "2c17a3806e9c95a9e6a4035b309d41c1990da5081f0c2872e684f21be5308c15", + "size_in_bytes": 3047 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/formatters/__pycache__/groff.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c1d5023ca05fec7a6278e1e53b14e7ff41e4dda586195f8472f6285b86503268", + "sha256_in_prefix": "c1d5023ca05fec7a6278e1e53b14e7ff41e4dda586195f8472f6285b86503268", + "size_in_bytes": 4372 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/formatters/__pycache__/html.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "ec1fcf2837e503d2a7c2b35bb766fe865701a3ecb6854e9c2ab343fb24776acd", + "sha256_in_prefix": "ec1fcf2837e503d2a7c2b35bb766fe865701a3ecb6854e9c2ab343fb24776acd", + "size_in_bytes": 29125 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/formatters/__pycache__/img.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "f1278b87f090986ca56035f74b3d88881afbabee79148349d956c01c723caa6d", + "sha256_in_prefix": "f1278b87f090986ca56035f74b3d88881afbabee79148349d956c01c723caa6d", + "size_in_bytes": 17524 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/formatters/__pycache__/irc.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c1929d1a0430bae3c7d55eef3fc79373bf010e69c5a749c1c0c059941468135f", + "sha256_in_prefix": "c1929d1a0430bae3c7d55eef3fc79373bf010e69c5a749c1c0c059941468135f", + "size_in_bytes": 4060 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/formatters/__pycache__/latex.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "dccb472a1e2ad26318689e4e240e737c679797daafad01c47842566d0e84edad", + "sha256_in_prefix": "dccb472a1e2ad26318689e4e240e737c679797daafad01c47842566d0e84edad", + "size_in_bytes": 13760 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/formatters/__pycache__/other.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "910dd91e476bd96f44ae8ab0027faf25ff464814e5a4cf8476db7963281b2e28", + "sha256_in_prefix": "910dd91e476bd96f44ae8ab0027faf25ff464814e5a4cf8476db7963281b2e28", + "size_in_bytes": 4766 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/formatters/__pycache__/pangomarkup.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "06cc22af681d0137ca1648edc5687d9562c96e9f892d0539f17223297238dd73", + "sha256_in_prefix": "06cc22af681d0137ca1648edc5687d9562c96e9f892d0539f17223297238dd73", + "size_in_bytes": 2066 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/formatters/__pycache__/rtf.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "e3eb19771956e7d3bc422869cc3e397ecc906b57fdb892850cbff2a38dcb65fc", + "sha256_in_prefix": "e3eb19771956e7d3bc422869cc3e397ecc906b57fdb892850cbff2a38dcb65fc", + "size_in_bytes": 4096 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/formatters/__pycache__/svg.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "4c420666d86d8395f8a9b6a952253fd4ab5556293b0b68f1585477e143f4531e", + "sha256_in_prefix": "4c420666d86d8395f8a9b6a952253fd4ab5556293b0b68f1585477e143f4531e", + "size_in_bytes": 6294 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/formatters/__pycache__/terminal.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "40987a134b956195cbf612c7e7f7eb67298088ee86c005993c791b1c7222e52d", + "sha256_in_prefix": "40987a134b956195cbf612c7e7f7eb67298088ee86c005993c791b1c7222e52d", + "size_in_bytes": 3961 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/formatters/__pycache__/terminal256.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "ec638e24541d13559ef2f37b67c23da3adcf7009cd059f310d49c984dba38051", + "sha256_in_prefix": "ec638e24541d13559ef2f37b67c23da3adcf7009cd059f310d49c984dba38051", + "size_in_bytes": 9211 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/formatters/_mapping.py", + "path_type": "hardlink", + "sha256": "d42c37ec5b9094d69c9f144a9ad94f5f89f22e85fdfedb64a39670b1c354659e", + "sha256_in_prefix": "d42c37ec5b9094d69c9f144a9ad94f5f89f22e85fdfedb64a39670b1c354659e", + "size_in_bytes": 4176 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/formatters/bbcode.py", + "path_type": "hardlink", + "sha256": "af56fbc33593268b800c32e1f99d758918b8890c43d09289d6a1e5ea6398c6c0", + "sha256_in_prefix": "af56fbc33593268b800c32e1f99d758918b8890c43d09289d6a1e5ea6398c6c0", + "size_in_bytes": 3314 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/formatters/groff.py", + "path_type": "hardlink", + "sha256": "c72f197f7b573a8e8c5ab5e1ef23c65b1de5544920fc3858e02c66b036f4215a", + "sha256_in_prefix": "c72f197f7b573a8e8c5ab5e1ef23c65b1de5544920fc3858e02c66b036f4215a", + "size_in_bytes": 5094 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/formatters/html.py", + "path_type": "hardlink", + "sha256": "3c8cc0ca294da9a4f34923f6b250c6d950cb137a8d8a85b2dab82d492a2f8ae2", + "sha256_in_prefix": "3c8cc0ca294da9a4f34923f6b250c6d950cb137a8d8a85b2dab82d492a2f8ae2", + "size_in_bytes": 35610 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/formatters/img.py", + "path_type": "hardlink", + "sha256": "5ca5e6836fd738dad1e26b6ada37c453c5c2b28967dd54864f0f94622128932b", + "sha256_in_prefix": "5ca5e6836fd738dad1e26b6ada37c453c5c2b28967dd54864f0f94622128932b", + "size_in_bytes": 21938 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/formatters/irc.py", + "path_type": "hardlink", + "sha256": "129fa6f23777be814ee85bf9edc506166cfa25503aec8120ca204ec2fd0de1ad", + "sha256_in_prefix": "129fa6f23777be814ee85bf9edc506166cfa25503aec8120ca204ec2fd0de1ad", + "size_in_bytes": 4981 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/formatters/latex.py", + "path_type": "hardlink", + "sha256": "146cc9f98a924c4f33fefa163ddcef2d8e53abc8c4ff28231a333a757649f3e9", + "sha256_in_prefix": "146cc9f98a924c4f33fefa163ddcef2d8e53abc8c4ff28231a333a757649f3e9", + "size_in_bytes": 19351 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/formatters/other.py", + "path_type": "hardlink", + "sha256": "80fc6493905d0335930a06c41e0d65a4b8bed45e993e1e40fdaa2d80b5c79f38", + "sha256_in_prefix": "80fc6493905d0335930a06c41e0d65a4b8bed45e993e1e40fdaa2d80b5c79f38", + "size_in_bytes": 5073 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/formatters/pangomarkup.py", + "path_type": "hardlink", + "sha256": "e8b2a741cf32878f5ff34d9b174b0fbdbcdc938422bcc62aaa85c03da60ff2e5", + "sha256_in_prefix": "e8b2a741cf32878f5ff34d9b174b0fbdbcdc938422bcc62aaa85c03da60ff2e5", + "size_in_bytes": 2212 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/formatters/rtf.py", + "path_type": "hardlink", + "sha256": "680d2ffe9b16e8a648dcdd7c4ca0e27f178bea6705f040d770f5c3588e2f8554", + "sha256_in_prefix": "680d2ffe9b16e8a648dcdd7c4ca0e27f178bea6705f040d770f5c3588e2f8554", + "size_in_bytes": 5014 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/formatters/svg.py", + "path_type": "hardlink", + "sha256": "75038d5b2a5bcdfbf31820ed769dccfcd25ac12709bccd838876f1d64fb0c3b8", + "sha256_in_prefix": "75038d5b2a5bcdfbf31820ed769dccfcd25ac12709bccd838876f1d64fb0c3b8", + "size_in_bytes": 7335 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/formatters/terminal.py", + "path_type": "hardlink", + "sha256": "146faba6346916636988607837322e72fc6aeac4085c1dc7393a3699e4cab6b5", + "sha256_in_prefix": "146faba6346916636988607837322e72fc6aeac4085c1dc7393a3699e4cab6b5", + "size_in_bytes": 4674 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/formatters/terminal256.py", + "path_type": "hardlink", + "sha256": "d77489dc3e6915da99f7344e13a1db5a7043c07bce184f0696c9aa1a1a6b469e", + "sha256_in_prefix": "d77489dc3e6915da99f7344e13a1db5a7043c07bce184f0696c9aa1a1a6b469e", + "size_in_bytes": 11753 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/lexer.py", + "path_type": "hardlink", + "sha256": "d81a6a2e54f6131bce3a2eef9e32b99c1e05a7e9b9da57623da5cca31e6ec2e8", + "sha256_in_prefix": "d81a6a2e54f6131bce3a2eef9e32b99c1e05a7e9b9da57623da5cca31e6ec2e8", + "size_in_bytes": 34618 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/lexers/__init__.py", + "path_type": "hardlink", + "sha256": "8f92848b93bf550e464b9f47e3d97ed7483350e9162b197019e54c9463b630c9", + "sha256_in_prefix": "8f92848b93bf550e464b9f47e3d97ed7483350e9162b197019e54c9463b630c9", + "size_in_bytes": 12130 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/lexers/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "05d5faf0601899fba12fc97bcdc5bc683972e3426dfcae38c50a944d86b4fd4a", + "sha256_in_prefix": "05d5faf0601899fba12fc97bcdc5bc683972e3426dfcae38c50a944d86b4fd4a", + "size_in_bytes": 9964 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/lexers/__pycache__/_mapping.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "2094e2a21ba38b7661634052aaf1b09f307339a109785e292be46e40e1d7b939", + "sha256_in_prefix": "2094e2a21ba38b7661634052aaf1b09f307339a109785e292be46e40e1d7b939", + "size_in_bytes": 60909 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/lexers/__pycache__/python.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "ded64e872ec87bfa39d9ad79fff7653d56843148236bacc6cb3adc4e23d34a78", + "sha256_in_prefix": "ded64e872ec87bfa39d9ad79fff7653d56843148236bacc6cb3adc4e23d34a78", + "size_in_bytes": 29966 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/lexers/_mapping.py", + "path_type": "hardlink", + "sha256": "1edb38aff650f2271fb4633b82404f7840f9972552bf869f7c5817604e80a74e", + "sha256_in_prefix": "1edb38aff650f2271fb4633b82404f7840f9972552bf869f7c5817604e80a74e", + "size_in_bytes": 72281 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/lexers/python.py", + "path_type": "hardlink", + "sha256": "73b8e798a154f432f14c95b451bc17b7a67d149a9b06556c580d50afdc5203fc", + "sha256_in_prefix": "73b8e798a154f432f14c95b451bc17b7a67d149a9b06556c580d50afdc5203fc", + "size_in_bytes": 53424 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/modeline.py", + "path_type": "hardlink", + "sha256": "785daf3b82e9386a0fbc828a91b3df9f2badf214f852279b64fa5bf8160641d2", + "sha256_in_prefix": "785daf3b82e9386a0fbc828a91b3df9f2badf214f852279b64fa5bf8160641d2", + "size_in_bytes": 986 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/plugin.py", + "path_type": "hardlink", + "sha256": "8f5161df5d116d5d8343d9ef92692abe58f7f20772b982a594b9c6c5b73cb093", + "sha256_in_prefix": "8f5161df5d116d5d8343d9ef92692abe58f7f20772b982a594b9c6c5b73cb093", + "size_in_bytes": 2591 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/regexopt.py", + "path_type": "hardlink", + "sha256": "8e0d402e881c60653de93412f62b0197a742aefc39cb9fbe04ffcafae164ffcb", + "sha256_in_prefix": "8e0d402e881c60653de93412f62b0197a742aefc39cb9fbe04ffcafae164ffcb", + "size_in_bytes": 3072 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/scanner.py", + "path_type": "hardlink", + "sha256": "6ff9eee7f7f71c2812769e52fda351050d4c4829b86630f079cd8e993462724c", + "sha256_in_prefix": "6ff9eee7f7f71c2812769e52fda351050d4c4829b86630f079cd8e993462724c", + "size_in_bytes": 3092 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/sphinxext.py", + "path_type": "hardlink", + "sha256": "c011589b5f34a9e6bd24ab7ffd4ce14653513617333c31436aa183db5b1bbaca", + "sha256_in_prefix": "c011589b5f34a9e6bd24ab7ffd4ce14653513617333c31436aa183db5b1bbaca", + "size_in_bytes": 6882 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/style.py", + "path_type": "hardlink", + "sha256": "0b8ab2a09ad44e4abe395de23bef15cf752d598a49c124dd879fef94608674d4", + "sha256_in_prefix": "0b8ab2a09ad44e4abe395de23bef15cf752d598a49c124dd879fef94608674d4", + "size_in_bytes": 6257 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/styles/__init__.py", + "path_type": "hardlink", + "sha256": "85eec78d0c7bb02d1dda47d354b8d4b34275e66b53a0933a3356ebc089bdfbe4", + "sha256_in_prefix": "85eec78d0c7bb02d1dda47d354b8d4b34275e66b53a0933a3356ebc089bdfbe4", + "size_in_bytes": 3700 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/styles/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "6eefbe4413f01eb68bf2da8984f36e163714d263a48314405f550b8f1df4c228", + "sha256_in_prefix": "6eefbe4413f01eb68bf2da8984f36e163714d263a48314405f550b8f1df4c228", + "size_in_bytes": 3555 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/token.py", + "path_type": "hardlink", + "sha256": "b1e36c99c721f4e1075d88ab87c3a897bc3cc4385f3536cb8f9ac7002fa073fa", + "sha256_in_prefix": "b1e36c99c721f4e1075d88ab87c3a897bc3cc4385f3536cb8f9ac7002fa073fa", + "size_in_bytes": 6184 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/unistring.py", + "path_type": "hardlink", + "sha256": "15a51f1b5e0d04910a2d0a18f6a8fa258797ae961c2e62ae96085dc4e18568e7", + "sha256_in_prefix": "15a51f1b5e0d04910a2d0a18f6a8fa258797ae961c2e62ae96085dc4e18568e7", + "size_in_bytes": 63223 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/util.py", + "path_type": "hardlink", + "sha256": "004558d2aa27cb210c82fe03a3674836baea500c149365d84aa1cceb9d2ecde9", + "sha256_in_prefix": "004558d2aa27cb210c82fe03a3674836baea500c149365d84aa1cceb9d2ecde9", + "size_in_bytes": 10230 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pyparsing/__init__.py", + "path_type": "hardlink", + "sha256": "f66d496c4d894cb7411b431be81d2511a663d7cd56c7972e3d7669b1b1c46201", + "sha256_in_prefix": "f66d496c4d894cb7411b431be81d2511a663d7cd56c7972e3d7669b1b1c46201", + "size_in_bytes": 9116 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pyparsing/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "2cd056cd135205305db1e2673de7b83391c0fe5f9f08e43b18f98f7265afd21d", + "sha256_in_prefix": "2cd056cd135205305db1e2673de7b83391c0fe5f9f08e43b18f98f7265afd21d", + "size_in_bytes": 7067 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pyparsing/__pycache__/actions.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "1e963c991fa0d2c9eba1ae79c4ce4444a7722400edfc02b1670161a77971541b", + "sha256_in_prefix": "1e963c991fa0d2c9eba1ae79c4ce4444a7722400edfc02b1670161a77971541b", + "size_in_bytes": 7613 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pyparsing/__pycache__/common.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "53384a4548baab387dbaa69e62ac1bad20e9602351fbea3f1ff820eaa4d57568", + "sha256_in_prefix": "53384a4548baab387dbaa69e62ac1bad20e9602351fbea3f1ff820eaa4d57568", + "size_in_bytes": 10141 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pyparsing/__pycache__/core.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "482de43465d985edd46715a4525306e6cdce6ff37f1bdb390955a2d56c0e3caf", + "sha256_in_prefix": "482de43465d985edd46715a4525306e6cdce6ff37f1bdb390955a2d56c0e3caf", + "size_in_bytes": 188204 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pyparsing/__pycache__/exceptions.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "08e57dc1d4db6ef92f15b630197cd8c056b1f0598f82ad42e9243534e3b75983", + "sha256_in_prefix": "08e57dc1d4db6ef92f15b630197cd8c056b1f0598f82ad42e9243534e3b75983", + "size_in_bytes": 9573 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pyparsing/__pycache__/helpers.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "1711cc98dfff050dffc15cbb3cae0bed2ff9a5c032453bc994e427770ff89f10", + "sha256_in_prefix": "1711cc98dfff050dffc15cbb3cae0bed2ff9a5c032453bc994e427770ff89f10", + "size_in_bytes": 35631 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pyparsing/__pycache__/results.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "1e54f5b9d024f3d766a7760928546d1e445f133625cb67c4987f7a2b776b8ff9", + "sha256_in_prefix": "1e54f5b9d024f3d766a7760928546d1e445f133625cb67c4987f7a2b776b8ff9", + "size_in_bytes": 25607 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pyparsing/__pycache__/testing.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "04f298cd1fb20b8ed14ff911379a7f50b3b7dfc800232ab2f16ddd8c6bd34158", + "sha256_in_prefix": "04f298cd1fb20b8ed14ff911379a7f50b3b7dfc800232ab2f16ddd8c6bd34158", + "size_in_bytes": 12107 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pyparsing/__pycache__/unicode.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "eef8e5ecc12a89d243f263b66816a5509f423c4bd9933a3b6c2db22bcdd54f36", + "sha256_in_prefix": "eef8e5ecc12a89d243f263b66816a5509f423c4bd9933a3b6c2db22bcdd54f36", + "size_in_bytes": 10220 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pyparsing/__pycache__/util.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "ab427244ca1f8f785b355f744b2463dc090cf05d76ad5c46cc653c08d4fe1ce1", + "sha256_in_prefix": "ab427244ca1f8f785b355f744b2463dc090cf05d76ad5c46cc653c08d4fe1ce1", + "size_in_bytes": 10014 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pyparsing/actions.py", + "path_type": "hardlink", + "sha256": "d39b9a20f3b39c93d0ed5811766182986e2c0e750fb7082fe6a39822a6cbd946", + "sha256_in_prefix": "d39b9a20f3b39c93d0ed5811766182986e2c0e750fb7082fe6a39822a6cbd946", + "size_in_bytes": 6567 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pyparsing/common.py", + "path_type": "hardlink", + "sha256": "a7eddcf37139f838e5905df91b43bdfa48d0469a1e8cffb6ff3d21c59f9ea25e", + "sha256_in_prefix": "a7eddcf37139f838e5905df91b43bdfa48d0469a1e8cffb6ff3d21c59f9ea25e", + "size_in_bytes": 13387 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pyparsing/core.py", + "path_type": "hardlink", + "sha256": "cafb9194ba57485f26824f908625b73952ea0fd4f4aec8fdb5b89b8511f861ac", + "sha256_in_prefix": "cafb9194ba57485f26824f908625b73952ea0fd4f4aec8fdb5b89b8511f861ac", + "size_in_bytes": 224445 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pyparsing/diagram/__init__.py", + "path_type": "hardlink", + "sha256": "9f19833a8605f4d5ee2da198cb4d6d2858e4351796265ac616e24d584893a3ce", + "sha256_in_prefix": "9f19833a8605f4d5ee2da198cb4d6d2858e4351796265ac616e24d584893a3ce", + "size_in_bytes": 24215 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pyparsing/diagram/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "33ffe43a094349c60cbbbf7139b8722b2728e10aaf6322677b04be76484e5292", + "sha256_in_prefix": "33ffe43a094349c60cbbbf7139b8722b2728e10aaf6322677b04be76484e5292", + "size_in_bytes": 16860 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pyparsing/exceptions.py", + "path_type": "hardlink", + "sha256": "e8973a5b5783641cf216ed49d18adc74d155042f9120dba3666bde4a707c471c", + "sha256_in_prefix": "e8973a5b5783641cf216ed49d18adc74d155042f9120dba3666bde4a707c471c", + "size_in_bytes": 9523 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pyparsing/helpers.py", + "path_type": "hardlink", + "sha256": "059247080f124b4a588a8df428641373dc36a8c39a2b862967b85cbc76e74e09", + "sha256_in_prefix": "059247080f124b4a588a8df428641373dc36a8c39a2b862967b85cbc76e74e09", + "size_in_bytes": 38646 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pyparsing/py.typed", + "path_type": "hardlink", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size_in_bytes": 0 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pyparsing/results.py", + "path_type": "hardlink", + "sha256": "f5dcaa43ec373237e6c566c5b7c2843d4e887d77b245da16a763a0f34dab5106", + "sha256_in_prefix": "f5dcaa43ec373237e6c566c5b7c2843d4e887d77b245da16a763a0f34dab5106", + "size_in_bytes": 26692 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pyparsing/testing.py", + "path_type": "hardlink", + "sha256": "7899dc834a7cdf39b51533ef33d6ae353ea86af22f5da89b9911437f5aa6c246", + "sha256_in_prefix": "7899dc834a7cdf39b51533ef33d6ae353ea86af22f5da89b9911437f5aa6c246", + "size_in_bytes": 13488 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pyparsing/unicode.py", + "path_type": "hardlink", + "sha256": "7c03ddb098804456e43c08a1e8d918af2d1da63e233ea7a5195325138c16156f", + "sha256_in_prefix": "7c03ddb098804456e43c08a1e8d918af2d1da63e233ea7a5195325138c16156f", + "size_in_bytes": 10646 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pyparsing/util.py", + "path_type": "hardlink", + "sha256": "bd33334ddc120f257c77f75282ab944dd5a0045a00fd6df49dfc44243b2c8514", + "sha256_in_prefix": "bd33334ddc120f257c77f75282ab944dd5a0045a00fd6df49dfc44243b2c8514", + "size_in_bytes": 8670 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pyproject_hooks/__init__.py", + "path_type": "hardlink", + "sha256": "9027a19b2d146816bda15303ed9219ae7b307e73f72d767996f9cd2402f92413", + "sha256_in_prefix": "9027a19b2d146816bda15303ed9219ae7b307e73f72d767996f9cd2402f92413", + "size_in_bytes": 491 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pyproject_hooks/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "881311ac3f70a1232669e80069e67775ffd3fffb01052fc71aa037e8595bfe8d", + "sha256_in_prefix": "881311ac3f70a1232669e80069e67775ffd3fffb01052fc71aa037e8595bfe8d", + "size_in_bytes": 548 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pyproject_hooks/__pycache__/_compat.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "664012a801f1fbaad62c5e1597a0ef79ea41bb193e717e0a475ae99273d73183", + "sha256_in_prefix": "664012a801f1fbaad62c5e1597a0ef79ea41bb193e717e0a475ae99273d73183", + "size_in_bytes": 299 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pyproject_hooks/__pycache__/_impl.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "6cd419bb2f8e27fddf07f7b7b0cb36a8473fbbf04da41323c6bfcf6992c94adf", + "sha256_in_prefix": "6cd419bb2f8e27fddf07f7b7b0cb36a8473fbbf04da41323c6bfcf6992c94adf", + "size_in_bytes": 11351 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pyproject_hooks/_compat.py", + "path_type": "hardlink", + "sha256": "6f2e9ebeb627aa48ac88cf8c41cbce2ace5b80333394e4a066a44736a7f4e331", + "sha256_in_prefix": "6f2e9ebeb627aa48ac88cf8c41cbce2ace5b80333394e4a066a44736a7f4e331", + "size_in_bytes": 138 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pyproject_hooks/_impl.py", + "path_type": "hardlink", + "sha256": "eb5189c73422a742089e1b8eebd648e466cd43cd97103501ff51a0e7f2ad5287", + "sha256_in_prefix": "eb5189c73422a742089e1b8eebd648e466cd43cd97103501ff51a0e7f2ad5287", + "size_in_bytes": 11920 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pyproject_hooks/_in_process/__init__.py", + "path_type": "hardlink", + "sha256": "f604004e9b5b1647a5908cb439f5851000b3ab15c93100d6087f6b04e0195704", + "sha256_in_prefix": "f604004e9b5b1647a5908cb439f5851000b3ab15c93100d6087f6b04e0195704", + "size_in_bytes": 546 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pyproject_hooks/_in_process/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "b92dd5dbf0055252685755b5b0430c7e1b9a2fc2cc8382a29e799244e2c086d3", + "sha256_in_prefix": "b92dd5dbf0055252685755b5b0430c7e1b9a2fc2cc8382a29e799244e2c086d3", + "size_in_bytes": 786 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pyproject_hooks/_in_process/__pycache__/_in_process.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "236ce07351e670b5a067c341d88fe20e5ac5fa13546142196e8d9b4718be6aef", + "sha256_in_prefix": "236ce07351e670b5a067c341d88fe20e5ac5fa13546142196e8d9b4718be6aef", + "size_in_bytes": 9668 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pyproject_hooks/_in_process/_in_process.py", + "path_type": "hardlink", + "sha256": "9b66f7e1cf75ec85b9a3e43fe936081e5b0af6549494d8b2ac84d3507ff3c1ec", + "sha256_in_prefix": "9b66f7e1cf75ec85b9a3e43fe936081e5b0af6549494d8b2ac84d3507ff3c1ec", + "size_in_bytes": 10927 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/requests/__init__.py", + "path_type": "hardlink", + "sha256": "a30ba3a1be1d938e528b2e0462d6c2291eb0705a61ec4d386bfbff3ae01a7010", + "sha256_in_prefix": "a30ba3a1be1d938e528b2e0462d6c2291eb0705a61ec4d386bfbff3ae01a7010", + "size_in_bytes": 5169 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/requests/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "464a7a63d23e7e9f1d227cef57e8b33da1f06f483cb4a05a428521b689fcfb6d", + "sha256_in_prefix": "464a7a63d23e7e9f1d227cef57e8b33da1f06f483cb4a05a428521b689fcfb6d", + "size_in_bytes": 3969 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/requests/__pycache__/__version__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "6643a37c4c940ccb849c72b527c06400a7c7c6d418a15132592a1a8bdca16e95", + "sha256_in_prefix": "6643a37c4c940ccb849c72b527c06400a7c7c6d418a15132592a1a8bdca16e95", + "size_in_bytes": 512 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/requests/__pycache__/_internal_utils.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "9dfe5dfbac9dbe133f0b2f264a7b9005eeba7a775d02687654c1c865d95ed1be", + "sha256_in_prefix": "9dfe5dfbac9dbe133f0b2f264a7b9005eeba7a775d02687654c1c865d95ed1be", + "size_in_bytes": 1588 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/requests/__pycache__/adapters.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "026a8abfc2531d693541fa73bc3c42b0ca850e083f8b52756a9ce9ca20d87401", + "sha256_in_prefix": "026a8abfc2531d693541fa73bc3c42b0ca850e083f8b52756a9ce9ca20d87401", + "size_in_bytes": 16174 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/requests/__pycache__/api.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "b490669fba82f0f286e3e4a92d8569398c4ea7ec16efc04f73d5d3ba65baf9a2", + "sha256_in_prefix": "b490669fba82f0f286e3e4a92d8569398c4ea7ec16efc04f73d5d3ba65baf9a2", + "size_in_bytes": 6688 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/requests/__pycache__/auth.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "04065e7751aac604c0082b5d289102166079e2ae234dbc88990e63aebdb0a4a4", + "sha256_in_prefix": "04065e7751aac604c0082b5d289102166079e2ae234dbc88990e63aebdb0a4a4", + "size_in_bytes": 8084 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/requests/__pycache__/certs.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "367c928af82e254aa533d0f26d0ddfbfd1ad16fbe65de10bd9ea181a9170e2da", + "sha256_in_prefix": "367c928af82e254aa533d0f26d0ddfbfd1ad16fbe65de10bd9ea181a9170e2da", + "size_in_bytes": 771 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/requests/__pycache__/compat.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "fc894b66460fe17e0b6854f71d5d6916a2b61d34bbbb9f647786f8a9e444c12a", + "sha256_in_prefix": "fc894b66460fe17e0b6854f71d5d6916a2b61d34bbbb9f647786f8a9e444c12a", + "size_in_bytes": 1333 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/requests/__pycache__/cookies.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "2e94d122f37cd5887af2eac8a6063dafdc9154917ce5c45b9bde835eb74c3df1", + "sha256_in_prefix": "2e94d122f37cd5887af2eac8a6063dafdc9154917ce5c45b9bde835eb74c3df1", + "size_in_bytes": 18653 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/requests/__pycache__/exceptions.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "6250c8d49d7e814bcdc2fd0ec133d133d04ed4ce54de3551f6465e273ccf91ee", + "sha256_in_prefix": "6250c8d49d7e814bcdc2fd0ec133d133d04ed4ce54de3551f6465e273ccf91ee", + "size_in_bytes": 5703 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/requests/__pycache__/help.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "bc39609a8474013be8a88643711d096f3d0b18e97e5bd51fcb732a47045e6495", + "sha256_in_prefix": "bc39609a8474013be8a88643711d096f3d0b18e97e5bd51fcb732a47045e6495", + "size_in_bytes": 2829 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/requests/__pycache__/hooks.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "ce66de4b79583d476f1fec4653aff245d26f387775d3b265fd513af60a3a3f93", + "sha256_in_prefix": "ce66de4b79583d476f1fec4653aff245d26f387775d3b265fd513af60a3a3f93", + "size_in_bytes": 956 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/requests/__pycache__/models.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "34cac582e15f9fbc6d8541365b6a710aa31df1e5eb2ba1995fdcde3017d72d39", + "sha256_in_prefix": "34cac582e15f9fbc6d8541365b6a710aa31df1e5eb2ba1995fdcde3017d72d39", + "size_in_bytes": 24228 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/requests/__pycache__/packages.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "fcda5cd429c112c5c69bfe4327139e716e180e1b48cfe9a0bd119b999750dc29", + "sha256_in_prefix": "fcda5cd429c112c5c69bfe4327139e716e180e1b48cfe9a0bd119b999750dc29", + "size_in_bytes": 470 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/requests/__pycache__/sessions.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c626d12277f7e35d4a6f2a631c7c2966a86740ee4730351f120379cbff35d769", + "sha256_in_prefix": "c626d12277f7e35d4a6f2a631c7c2966a86740ee4730351f120379cbff35d769", + "size_in_bytes": 19556 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/requests/__pycache__/status_codes.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "e32914c8ef2e873832580ed2d9f6b2d358b644758892d6fd177bbf0ff63dd3e0", + "sha256_in_prefix": "e32914c8ef2e873832580ed2d9f6b2d358b644758892d6fd177bbf0ff63dd3e0", + "size_in_bytes": 4635 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/requests/__pycache__/structures.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "bdfe6df460b0c3f30678d05c6db64c4f4ec48a41d66e201ec536ee427af2afd8", + "sha256_in_prefix": "bdfe6df460b0c3f30678d05c6db64c4f4ec48a41d66e201ec536ee427af2afd8", + "size_in_bytes": 4400 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/requests/__pycache__/utils.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "3304d31a2ae713f5bf09437041fd3fcce3273bcba8bacdd0f735f64b454b6cdc", + "sha256_in_prefix": "3304d31a2ae713f5bf09437041fd3fcce3273bcba8bacdd0f735f64b454b6cdc", + "size_in_bytes": 24409 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/requests/__version__.py", + "path_type": "hardlink", + "sha256": "b2c237133b7b3dac6090e5b8e4686dc0f51c968fd23bfca0b489b803be0839fc", + "sha256_in_prefix": "b2c237133b7b3dac6090e5b8e4686dc0f51c968fd23bfca0b489b803be0839fc", + "size_in_bytes": 435 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/requests/_internal_utils.py", + "path_type": "hardlink", + "sha256": "9cc4329abe21b37d93a95a3901b0ab99c24486f3d487bc57965bb2ab0b252e24", + "sha256_in_prefix": "9cc4329abe21b37d93a95a3901b0ab99c24486f3d487bc57965bb2ab0b252e24", + "size_in_bytes": 1495 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/requests/adapters.py", + "path_type": "hardlink", + "sha256": "89d8fa7197087772f9c4d35e27b89e38bb70ddac0993903ae3151f7ad1f0ab73", + "sha256_in_prefix": "89d8fa7197087772f9c4d35e27b89e38bb70ddac0993903ae3151f7ad1f0ab73", + "size_in_bytes": 19697 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/requests/api.py", + "path_type": "hardlink", + "sha256": "abad71717ab8b668889abbdc4952d36c5c82883d85f8bffe8562866f3e32f2f8", + "sha256_in_prefix": "abad71717ab8b668889abbdc4952d36c5c82883d85f8bffe8562866f3e32f2f8", + "size_in_bytes": 6449 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/requests/auth.py", + "path_type": "hardlink", + "sha256": "87e1cb955c7d8fcaca57985f480c9c3f60293928254f3efb474b73eea09b6c41", + "sha256_in_prefix": "87e1cb955c7d8fcaca57985f480c9c3f60293928254f3efb474b73eea09b6c41", + "size_in_bytes": 10187 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/requests/certs.py", + "path_type": "hardlink", + "sha256": "3d53e8a01d233f986464450b482c02d3be39df65056d1d8fb60bb4239cf0982b", + "sha256_in_prefix": "3d53e8a01d233f986464450b482c02d3be39df65056d1d8fb60bb4239cf0982b", + "size_in_bytes": 575 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/requests/compat.py", + "path_type": "hardlink", + "sha256": "2212bdaaec97d1146e59335c83a7762464803946ccea6ca6da9ff65e32d3c1fe", + "sha256_in_prefix": "2212bdaaec97d1146e59335c83a7762464803946ccea6ca6da9ff65e32d3c1fe", + "size_in_bytes": 1286 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/requests/cookies.py", + "path_type": "hardlink", + "sha256": "903de43447028fe9b16ed7f97c9b12693f3a786a046290f75f4092829ce5ec13", + "sha256_in_prefix": "903de43447028fe9b16ed7f97c9b12693f3a786a046290f75f4092829ce5ec13", + "size_in_bytes": 18560 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/requests/exceptions.py", + "path_type": "hardlink", + "sha256": "140fbf915c016768e15dab9172d37f7b01d52b6e5bf9f8f4033cb3d531d0d0a9", + "sha256_in_prefix": "140fbf915c016768e15dab9172d37f7b01d52b6e5bf9f8f4033cb3d531d0d0a9", + "size_in_bytes": 3823 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/requests/help.py", + "path_type": "hardlink", + "sha256": "167000925bfc3069bfa9bd948a50d0812ea5d1c52db620852948f1d339f65cd0", + "sha256_in_prefix": "167000925bfc3069bfa9bd948a50d0812ea5d1c52db620852948f1d339f65cd0", + "size_in_bytes": 3879 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/requests/hooks.py", + "path_type": "hardlink", + "sha256": "0a2bb2b221c0dfd57951f702057148c7cdc8ac3a6ec1f37d45c4d482fdbc7ed4", + "sha256_in_prefix": "0a2bb2b221c0dfd57951f702057148c7cdc8ac3a6ec1f37d45c4d482fdbc7ed4", + "size_in_bytes": 733 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/requests/models.py", + "path_type": "hardlink", + "sha256": "74367e893868b64cbe368abdcb2f7b71410986bdf09d8ea6bfec51fde3e0fe59", + "sha256_in_prefix": "74367e893868b64cbe368abdcb2f7b71410986bdf09d8ea6bfec51fde3e0fe59", + "size_in_bytes": 35288 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/requests/packages.py", + "path_type": "hardlink", + "sha256": "9e32665627d8e1a49cb6e5b73cfe441510b18c4c0c4433ba27f7de1b674a5ac2", + "sha256_in_prefix": "9e32665627d8e1a49cb6e5b73cfe441510b18c4c0c4433ba27f7de1b674a5ac2", + "size_in_bytes": 695 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/requests/sessions.py", + "path_type": "hardlink", + "sha256": "f8bbd3ceb3ed7ad493ad1ddbbb1bb85e176032b2452c1d6ae43ecffbe2f65e1c", + "sha256_in_prefix": "f8bbd3ceb3ed7ad493ad1ddbbb1bb85e176032b2452c1d6ae43ecffbe2f65e1c", + "size_in_bytes": 30373 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/requests/status_codes.py", + "path_type": "hardlink", + "sha256": "16f1e64f9b87fbfba29ad473e611fd5426eded557e35e8b627dba96de8fa8fc8", + "sha256_in_prefix": "16f1e64f9b87fbfba29ad473e611fd5426eded557e35e8b627dba96de8fa8fc8", + "size_in_bytes": 4235 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/requests/structures.py", + "path_type": "hardlink", + "sha256": "f886e6855cf4e92fb968f499b94b6167afba0fd5ce8d1b935c739a6d8d38d573", + "sha256_in_prefix": "f886e6855cf4e92fb968f499b94b6167afba0fd5ce8d1b935c739a6d8d38d573", + "size_in_bytes": 2912 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/requests/utils.py", + "path_type": "hardlink", + "sha256": "90e3e7d2a603eb1453cdac5ba937588922270591e5eb7efd009b32220cd818b6", + "sha256_in_prefix": "90e3e7d2a603eb1453cdac5ba937588922270591e5eb7efd009b32220cd818b6", + "size_in_bytes": 33460 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/resolvelib/__init__.py", + "path_type": "hardlink", + "sha256": "879d3d4dd11ca5be7ee382689da5377b1d93335e465412e333d08d08fc274d3b", + "sha256_in_prefix": "879d3d4dd11ca5be7ee382689da5377b1d93335e465412e333d08d08fc274d3b", + "size_in_bytes": 537 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/resolvelib/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "bb362a28d35a3ca6e4c1a46b2965ccb5d4b90f6ce2cc70620d6d53882d818708", + "sha256_in_prefix": "bb362a28d35a3ca6e4c1a46b2965ccb5d4b90f6ce2cc70620d6d53882d818708", + "size_in_bytes": 568 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/resolvelib/__pycache__/providers.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "5b8564258264b07ffaabacf294687b024778c119fcd5c7debba22cc09f9c7f7f", + "sha256_in_prefix": "5b8564258264b07ffaabacf294687b024778c119fcd5c7debba22cc09f9c7f7f", + "size_in_bytes": 6618 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/resolvelib/__pycache__/reporters.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "bf4e51578f69861cbd2df3fd009a7eaa4acc12c11751ec1767187bf2748d31b1", + "sha256_in_prefix": "bf4e51578f69861cbd2df3fd009a7eaa4acc12c11751ec1767187bf2748d31b1", + "size_in_bytes": 2571 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/resolvelib/__pycache__/resolvers.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "597fd8e6a1a029b412066f23bf0d1a7f2adc34c9ad747813a6ec2af831efc4d2", + "sha256_in_prefix": "597fd8e6a1a029b412066f23bf0d1a7f2adc34c9ad747813a6ec2af831efc4d2", + "size_in_bytes": 17399 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/resolvelib/__pycache__/structs.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "25970352ab3976d640b266c8b0bb6ec1ceaa42be947e7bed9ad007befb1d0c71", + "sha256_in_prefix": "25970352ab3976d640b266c8b0bb6ec1ceaa42be947e7bed9ad007befb1d0c71", + "size_in_bytes": 7227 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/resolvelib/compat/__init__.py", + "path_type": "hardlink", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size_in_bytes": 0 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/resolvelib/compat/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "d8b507f77e3012d0c23fe4b2b6bf29da6fb89a16228ec57b04cf4ba421af5cb8", + "sha256_in_prefix": "d8b507f77e3012d0c23fe4b2b6bf29da6fb89a16228ec57b04cf4ba421af5cb8", + "size_in_bytes": 163 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/resolvelib/compat/__pycache__/collections_abc.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "48bb745b41f77d5135466bb3badd0f48312a7e75ded91f4f76dafe89b7e74580", + "sha256_in_prefix": "48bb745b41f77d5135466bb3badd0f48312a7e75ded91f4f76dafe89b7e74580", + "size_in_bytes": 339 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/resolvelib/compat/collections_abc.py", + "path_type": "hardlink", + "sha256": "bb2f31519f8d0c4c3dd7ab6e8145e6f0783008688c3b47fe45c767a647d77ceb", + "sha256_in_prefix": "bb2f31519f8d0c4c3dd7ab6e8145e6f0783008688c3b47fe45c767a647d77ceb", + "size_in_bytes": 156 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/resolvelib/providers.py", + "path_type": "hardlink", + "sha256": "7eebaf56b09eb6ee60b313c1e37111ca37cef1a45e4b7ac5407a4382222d6ece", + "sha256_in_prefix": "7eebaf56b09eb6ee60b313c1e37111ca37cef1a45e4b7ac5407a4382222d6ece", + "size_in_bytes": 5871 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/resolvelib/py.typed", + "path_type": "hardlink", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size_in_bytes": 0 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/resolvelib/reporters.py", + "path_type": "hardlink", + "sha256": "4d26d1996cd3736eb0d2082c5756f15697960c1f10348adeeadc1897b1886411", + "sha256_in_prefix": "4d26d1996cd3736eb0d2082c5756f15697960c1f10348adeeadc1897b1886411", + "size_in_bytes": 1601 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/resolvelib/resolvers.py", + "path_type": "hardlink", + "sha256": "1bcaec2d94aaeb883956622afa507b51c209d608c0c48409993178444665790d", + "sha256_in_prefix": "1bcaec2d94aaeb883956622afa507b51c209d608c0c48409993178444665790d", + "size_in_bytes": 20511 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/resolvelib/structs.py", + "path_type": "hardlink", + "sha256": "d3fd7f5cef33fc22e17a03f75697fd549df325c7cb9b434e1d133e8b4624cf7a", + "sha256_in_prefix": "d3fd7f5cef33fc22e17a03f75697fd549df325c7cb9b434e1d133e8b4624cf7a", + "size_in_bytes": 4963 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__init__.py", + "path_type": "hardlink", + "sha256": "751c6320bf926c5558d2adc88d232b7e00531eb9b52d90e02ceca0541c226197", + "sha256_in_prefix": "751c6320bf926c5558d2adc88d232b7e00531eb9b52d90e02ceca0541c226197", + "size_in_bytes": 6090 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__main__.py", + "path_type": "hardlink", + "sha256": "4d3f2c6fd3d39ec9ca861ac6b8790b3748dd37476d2a1b4f904afd0a27436cf3", + "sha256_in_prefix": "4d3f2c6fd3d39ec9ca861ac6b8790b3748dd37476d2a1b4f904afd0a27436cf3", + "size_in_bytes": 8478 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "4c2a8c79ba7096383b0f495f694e6600e2974f3255a74321b72851c94a3ad17d", + "sha256_in_prefix": "4c2a8c79ba7096383b0f495f694e6600e2974f3255a74321b72851c94a3ad17d", + "size_in_bytes": 6075 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/__main__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "a38043b678cfc8cde2e224f3c61889cde057b73741ddc93bd0bf37012dfa6d50", + "sha256_in_prefix": "a38043b678cfc8cde2e224f3c61889cde057b73741ddc93bd0bf37012dfa6d50", + "size_in_bytes": 7145 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_cell_widths.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "19850302d1b0ccfa140cea8afd1b697c99753876158c97c334ee64647da861ce", + "sha256_in_prefix": "19850302d1b0ccfa140cea8afd1b697c99753876158c97c334ee64647da861ce", + "size_in_bytes": 7776 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_emoji_codes.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "d6dc962d95945a83204c3b68f6069baf781995423c36e6fcbc8b12dc3d25f1d4", + "sha256_in_prefix": "d6dc962d95945a83204c3b68f6069baf781995423c36e6fcbc8b12dc3d25f1d4", + "size_in_bytes": 360016 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_emoji_replace.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "0c7ac70c552d2755f4066a5c2ba2e6211ff6abb5ce604eadb5558e890c26c819", + "sha256_in_prefix": "0c7ac70c552d2755f4066a5c2ba2e6211ff6abb5ce604eadb5558e890c26c819", + "size_in_bytes": 1156 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_export_format.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "a96d8084df02044fd5546a03b7ad7c9e3578a29e784c0ad3ff9ce27571653758", + "sha256_in_prefix": "a96d8084df02044fd5546a03b7ad7c9e3578a29e784c0ad3ff9ce27571653758", + "size_in_bytes": 2259 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_extension.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "7dda90e8cc2466e1589c8d501a236246ee4c77bce64ca680d5dd1ce03794600b", + "sha256_in_prefix": "7dda90e8cc2466e1589c8d501a236246ee4c77bce64ca680d5dd1ce03794600b", + "size_in_bytes": 457 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_fileno.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "9e004e31cb721d7cf5f3c0d76f41f5dd0579c91433bf505dc42417e332731d62", + "sha256_in_prefix": "9e004e31cb721d7cf5f3c0d76f41f5dd0579c91433bf505dc42417e332731d62", + "size_in_bytes": 750 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_inspect.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "180de43b84571bd3d464f67916261719acd7e13bbb6c440fac73f45933c9bc28", + "sha256_in_prefix": "180de43b84571bd3d464f67916261719acd7e13bbb6c440fac73f45933c9bc28", + "size_in_bytes": 8634 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_log_render.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "e82433ca8b3839fe90b7da3d97d653d0e4ae1a708e120b4a5a784dd9a7461525", + "sha256_in_prefix": "e82433ca8b3839fe90b7da3d97d653d0e4ae1a708e120b4a5a784dd9a7461525", + "size_in_bytes": 2602 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_loop.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "9935a98cc5f67763ffc8c47995a2ffef416b3d59614101d30651bf90bec33d94", + "sha256_in_prefix": "9935a98cc5f67763ffc8c47995a2ffef416b3d59614101d30651bf90bec33d94", + "size_in_bytes": 1254 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_null_file.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c4a618a6c77c865a042b666a5034a09dfc1f88663f881848d3c3deec1d4d3c82", + "sha256_in_prefix": "c4a618a6c77c865a042b666a5034a09dfc1f88663f881848d3c3deec1d4d3c82", + "size_in_bytes": 3201 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_palettes.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "479087b864c8db3bc25aa88fe2e72a42b486639833aef199f4b802553b0efcf9", + "sha256_in_prefix": "479087b864c8db3bc25aa88fe2e72a42b486639833aef199f4b802553b0efcf9", + "size_in_bytes": 5059 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_pick.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "5ead11dd4b3affdb98e3ae6608a1117a31801e2b90221b091c9c54b5a01efd94", + "sha256_in_prefix": "5ead11dd4b3affdb98e3ae6608a1117a31801e2b90221b091c9c54b5a01efd94", + "size_in_bytes": 602 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_ratio.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "00983ae4c5dfffaad671a5f410e42d26cb46bec59995fcbf03f16d5352aac13a", + "sha256_in_prefix": "00983ae4c5dfffaad671a5f410e42d26cb46bec59995fcbf03f16d5352aac13a", + "size_in_bytes": 5119 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_spinners.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "8ff7cfc4b0b74b0302b55105729f585ce7f544bdaf63ecec8fe9a0cc5491003e", + "sha256_in_prefix": "8ff7cfc4b0b74b0302b55105729f585ce7f544bdaf63ecec8fe9a0cc5491003e", + "size_in_bytes": 12233 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_stack.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "1bf77f449f207d01cb746f2a078630f130ade2d95a76526f5b52a905acd36496", + "sha256_in_prefix": "1bf77f449f207d01cb746f2a078630f130ade2d95a76526f5b52a905acd36496", + "size_in_bytes": 800 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_timer.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c5cfed99ca5ba392103a953706a9e03a5c1e8bc6f744c0233866f90e8ef80188", + "sha256_in_prefix": "c5cfed99ca5ba392103a953706a9e03a5c1e8bc6f744c0233866f90e8ef80188", + "size_in_bytes": 649 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_win32_console.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "328bcbcf4b0ec0c6a53df86b991942a9f6dbeadd778d00f269db0f9d2db410d6", + "sha256_in_prefix": "328bcbcf4b0ec0c6a53df86b991942a9f6dbeadd778d00f269db0f9d2db410d6", + "size_in_bytes": 18969 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_windows.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "3fdd62a2564fc6601c5b3058327751fff8a3db165a37754d1ba1de9f469e249c", + "sha256_in_prefix": "3fdd62a2564fc6601c5b3058327751fff8a3db165a37754d1ba1de9f469e249c", + "size_in_bytes": 1751 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_windows_renderer.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "5fc18c680e384a539c7af7d617ba6a389e1f03a44b792419b5c51db7d696ed82", + "sha256_in_prefix": "5fc18c680e384a539c7af7d617ba6a389e1f03a44b792419b5c51db7d696ed82", + "size_in_bytes": 2005 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_wrap.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "77812796815e1e87ceb6d86f96f42be4a47d977864d41b3b922afa5652b5d412", + "sha256_in_prefix": "77812796815e1e87ceb6d86f96f42be4a47d977864d41b3b922afa5652b5d412", + "size_in_bytes": 1513 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/abc.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "b1dce194605b7dbfcc2830e4879e58a6dda4d37bc5638b3c8c1ea28a482e6f3d", + "sha256_in_prefix": "b1dce194605b7dbfcc2830e4879e58a6dda4d37bc5638b3c8c1ea28a482e6f3d", + "size_in_bytes": 1276 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/align.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "73c0c6d33856757032905ac08da42fcbf5f898f58bb23514a1805f039c3f1acd", + "sha256_in_prefix": "73c0c6d33856757032905ac08da42fcbf5f898f58bb23514a1805f039c3f1acd", + "size_in_bytes": 7904 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/ansi.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c8d817aad8c93feb2cfd3ede3c6620e5d02b355a562705cef4aa6494b39f53d7", + "sha256_in_prefix": "c8d817aad8c93feb2cfd3ede3c6620e5d02b355a562705cef4aa6494b39f53d7", + "size_in_bytes": 5942 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/bar.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "b323ba72a93810f498769270aa820c03dd4aa73d37c6f39d604d4549f8b9219e", + "sha256_in_prefix": "b323ba72a93810f498769270aa820c03dd4aa73d37c6f39d604d4549f8b9219e", + "size_in_bytes": 2945 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/box.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "963db199103cf520e94c9d3328b95176463271709c46ec7bd84d7e0ca84f90d7", + "sha256_in_prefix": "963db199103cf520e94c9d3328b95176463271709c46ec7bd84d7e0ca84f90d7", + "size_in_bytes": 8365 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/cells.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "b9e12c3824468267bea6965c45b8330e1dee7a60505fff4e083a3baea43e240b", + "sha256_in_prefix": "b9e12c3824468267bea6965c45b8330e1dee7a60505fff4e083a3baea43e240b", + "size_in_bytes": 4115 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/color.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "6a10644ceb4309b1c5df9f16c733688fd908275d7d5d0b19c5f6543b4c96285d", + "sha256_in_prefix": "6a10644ceb4309b1c5df9f16c733688fd908275d7d5d0b19c5f6543b4c96285d", + "size_in_bytes": 17682 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/color_triplet.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "75771d6411d3e6454a9061955a30e3c5a95f7ab7125c1cf95200872ea9532ffd", + "sha256_in_prefix": "75771d6411d3e6454a9061955a30e3c5a95f7ab7125c1cf95200872ea9532ffd", + "size_in_bytes": 1399 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/columns.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "de8a0ec3ae03522994fc184c6d82d42cf73459453ec9e3ada2369446c1d252b2", + "sha256_in_prefix": "de8a0ec3ae03522994fc184c6d82d42cf73459453ec9e3ada2369446c1d252b2", + "size_in_bytes": 6159 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/console.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c5d1d7025d49041d0f20a6e000a9d990d9175ac08f24ef502d2bed5a40819acb", + "sha256_in_prefix": "c5d1d7025d49041d0f20a6e000a9d990d9175ac08f24ef502d2bed5a40819acb", + "size_in_bytes": 82760 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/constrain.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "b042207d24a71e9650bbc62ba6b9338e5ba77a2135e133dba0722750248cb829", + "sha256_in_prefix": "b042207d24a71e9650bbc62ba6b9338e5ba77a2135e133dba0722750248cb829", + "size_in_bytes": 1716 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/containers.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "71d82581ff0846b66e66440904042ba2df2ff28094c560cc0da9754d1cd93667", + "sha256_in_prefix": "71d82581ff0846b66e66440904042ba2df2ff28094c560cc0da9754d1cd93667", + "size_in_bytes": 6448 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/control.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "9fc003f3b5167757662184498623f4ff5d6397ffede39d745d0df294f266257f", + "sha256_in_prefix": "9fc003f3b5167757662184498623f4ff5d6397ffede39d745d0df294f266257f", + "size_in_bytes": 8121 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/default_styles.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "d849fe17927e3466059fbb2508963ddde9c887675571085c015dd5a33fb96dbe", + "sha256_in_prefix": "d849fe17927e3466059fbb2508963ddde9c887675571085c015dd5a33fb96dbe", + "size_in_bytes": 6205 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/diagnose.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c4293f062f75d01f2842ad6682c1332f6b7d213f5f9e7429018b4346bc2b2a75", + "sha256_in_prefix": "c4293f062f75d01f2842ad6682c1332f6b7d213f5f9e7429018b4346bc2b2a75", + "size_in_bytes": 1183 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/emoji.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "a44c3dba88cba2aed3e78fad51371e2d733f6e76bb43595da820743e0f8e5b64", + "sha256_in_prefix": "a44c3dba88cba2aed3e78fad51371e2d733f6e76bb43595da820743e0f8e5b64", + "size_in_bytes": 3229 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/errors.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "5fda56496e27eac6497af7a88762ab1121283dba89916ba8adb9775c9f4fd575", + "sha256_in_prefix": "5fda56496e27eac6497af7a88762ab1121283dba89916ba8adb9775c9f4fd575", + "size_in_bytes": 1489 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/file_proxy.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "63ac3518af5e723c039904f463a30787680b2347f17dc358e17ea2777e6a8ea5", + "sha256_in_prefix": "63ac3518af5e723c039904f463a30787680b2347f17dc358e17ea2777e6a8ea5", + "size_in_bytes": 2362 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/filesize.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "168be941d33b02245de47b00dca682ca30f73480ee26813545ce798007ec768f", + "sha256_in_prefix": "168be941d33b02245de47b00dca682ca30f73480ee26813545ce798007ec768f", + "size_in_bytes": 2579 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/highlighter.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "29a7abd80ca011aa1db125e89b28e2c5c783a4c8a0201c781fd08e1d2422de9d", + "sha256_in_prefix": "29a7abd80ca011aa1db125e89b28e2c5c783a4c8a0201c781fd08e1d2422de9d", + "size_in_bytes": 8021 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/json.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "d3729c146c883dbccba66b38d323cbc9cf7107aee73ddebc0560c6f7062b775f", + "sha256_in_prefix": "d3729c146c883dbccba66b38d323cbc9cf7107aee73ddebc0560c6f7062b775f", + "size_in_bytes": 4693 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/jupyter.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "e75789fa1b3f8b3abc3d5a952573d13741015604ca2ab6097a749b1ec4068f1c", + "sha256_in_prefix": "e75789fa1b3f8b3abc3d5a952573d13741015604ca2ab6097a749b1ec4068f1c", + "size_in_bytes": 3961 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/layout.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "35c5ae41ac211a5bf507c3f501f4c875db493ef69086d0a23f182afb4fed2538", + "sha256_in_prefix": "35c5ae41ac211a5bf507c3f501f4c875db493ef69086d0a23f182afb4fed2538", + "size_in_bytes": 14609 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/live.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "dafdd5821adb7bbfe17406f6c45d21af28dbbc984cdbff9f2600338c9521e1c9", + "sha256_in_prefix": "dafdd5821adb7bbfe17406f6c45d21af28dbbc984cdbff9f2600338c9521e1c9", + "size_in_bytes": 11639 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/live_render.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "86cc083f3d02d247687ff878f8bd1287630a3a5e1cc3e94bf8359aa0b484f5e3", + "sha256_in_prefix": "86cc083f3d02d247687ff878f8bd1287630a3a5e1cc3e94bf8359aa0b484f5e3", + "size_in_bytes": 3364 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/logging.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "6cf060f1c65f31eda26ff7c004792f441bcbb2ab186e083640d42abbc76a4a6b", + "sha256_in_prefix": "6cf060f1c65f31eda26ff7c004792f441bcbb2ab186e083640d42abbc76a4a6b", + "size_in_bytes": 9870 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/markup.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "8cbc91043b235c79dfb3eecdcf27d9347b70f493b003fa38def19b2662528b35", + "sha256_in_prefix": "8cbc91043b235c79dfb3eecdcf27d9347b70f493b003fa38def19b2662528b35", + "size_in_bytes": 5903 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/measure.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "b9810b06ee350bd4ac5fbe70bb5c7da9894bdd4cc32494060043619fc462b8b8", + "sha256_in_prefix": "b9810b06ee350bd4ac5fbe70bb5c7da9894bdd4cc32494060043619fc462b8b8", + "size_in_bytes": 5038 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/padding.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "112cc0adb8ba05fa90a42bd539dfb1e64d5485b7cade9a5c4a3d9ab41fd7e654", + "sha256_in_prefix": "112cc0adb8ba05fa90a42bd539dfb1e64d5485b7cade9a5c4a3d9ab41fd7e654", + "size_in_bytes": 4444 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/pager.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "2830d97811a32927940227a3fab13348e6c4e75b23625cd54e98a3eb3bada39c", + "sha256_in_prefix": "2830d97811a32927940227a3fab13348e6c4e75b23625cd54e98a3eb3bada39c", + "size_in_bytes": 1438 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/palette.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "43159700fc1f80acb1168de67488f77dbcfffd00f7114fe55a534783245e8279", + "sha256_in_prefix": "43159700fc1f80acb1168de67488f77dbcfffd00f7114fe55a534783245e8279", + "size_in_bytes": 3670 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/panel.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "91ef6f768f37e523969bf766b21ee85609504fed335ee1bab8d27ccdc7f6066d", + "sha256_in_prefix": "91ef6f768f37e523969bf766b21ee85609504fed335ee1bab8d27ccdc7f6066d", + "size_in_bytes": 7390 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/pretty.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c0a4d3e62a4d4d5b87001cbcebfd924a8f0791208ad886d6355572e977da0526", + "sha256_in_prefix": "c0a4d3e62a4d4d5b87001cbcebfd924a8f0791208ad886d6355572e977da0526", + "size_in_bytes": 27479 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/progress.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c5f781582c92800b7d67b4114485808ddbc659e902efdd7c3496e0524d191b0e", + "sha256_in_prefix": "c5f781582c92800b7d67b4114485808ddbc659e902efdd7c3496e0524d191b0e", + "size_in_bytes": 53968 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/progress_bar.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "9fd338c3518bc9fe1bdac4c19137193ab4fc1f874f78bbf500d61d3d079fd4fa", + "sha256_in_prefix": "9fd338c3518bc9fe1bdac4c19137193ab4fc1f874f78bbf500d61d3d079fd4fa", + "size_in_bytes": 6873 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/prompt.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "0b7279c057c85e48a43768a062fd448508ac2f2da49ade8847efad32bddf4176", + "sha256_in_prefix": "0b7279c057c85e48a43768a062fd448508ac2f2da49ade8847efad32bddf4176", + "size_in_bytes": 11261 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/protocol.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "e76b004383f7b926ffed88f6a27b6b89102ccd045a0f4c77e325b59da5a37609", + "sha256_in_prefix": "e76b004383f7b926ffed88f6a27b6b89102ccd045a0f4c77e325b59da5a37609", + "size_in_bytes": 1314 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/region.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "84ae084905f7e5b70f0efa269e40276b2adbc2857c067108a4c26e09ae57c5a4", + "sha256_in_prefix": "84ae084905f7e5b70f0efa269e40276b2adbc2857c067108a4c26e09ae57c5a4", + "size_in_bytes": 489 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/repr.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c96571f39834e90476d8a41fc92a31d3e35769909c9ba1ab7a8b6916ce2a3cc2", + "sha256_in_prefix": "c96571f39834e90476d8a41fc92a31d3e35769909c9ba1ab7a8b6916ce2a3cc2", + "size_in_bytes": 4058 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/rule.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "41878e4ca597d027e9c8e5aeb43a6bc4f590428da12134e30dc2317a8d943053", + "sha256_in_prefix": "41878e4ca597d027e9c8e5aeb43a6bc4f590428da12134e30dc2317a8d943053", + "size_in_bytes": 3905 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/scope.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "5a8cc70fb3f259ad82c25825e540be35987ef6867258fff54ebbaa24a554767c", + "sha256_in_prefix": "5a8cc70fb3f259ad82c25825e540be35987ef6867258fff54ebbaa24a554767c", + "size_in_bytes": 2951 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/screen.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "e2f38688c3b8ddae3b874ee74595fdc454b991903d4e9ef2cd7263c736f691c2", + "sha256_in_prefix": "e2f38688c3b8ddae3b874ee74595fdc454b991903d4e9ef2cd7263c736f691c2", + "size_in_bytes": 1841 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/segment.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "eb677be1e4c0a7ca76e8bb7ded07656a6084b1ee2acc0631e19de827ac2fcc9b", + "sha256_in_prefix": "eb677be1e4c0a7ca76e8bb7ded07656a6084b1ee2acc0631e19de827ac2fcc9b", + "size_in_bytes": 20745 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/spinner.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "30abb46c5fe49356be44b9392a852dedbb6894b669f277b50788837d0c446070", + "sha256_in_prefix": "30abb46c5fe49356be44b9392a852dedbb6894b669f277b50788837d0c446070", + "size_in_bytes": 4362 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/status.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "6dcfa664d377ec965c0f92cb4b71373ede37b059b2b0206ce5cd096f4facd77f", + "sha256_in_prefix": "6dcfa664d377ec965c0f92cb4b71373ede37b059b2b0206ce5cd096f4facd77f", + "size_in_bytes": 4555 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/style.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "168e2286ab9862ae924cb72eff5a2f1f70e10c5602054120be69f5fa031c700b", + "sha256_in_prefix": "168e2286ab9862ae924cb72eff5a2f1f70e10c5602054120be69f5fa031c700b", + "size_in_bytes": 21292 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/styled.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "9ea3d864ccaef97b3c84f5ee4962c3758fc72c7619fa31bffa7718ddfb0060ab", + "sha256_in_prefix": "9ea3d864ccaef97b3c84f5ee4962c3758fc72c7619fa31bffa7718ddfb0060ab", + "size_in_bytes": 1725 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/syntax.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "9aeac93d9804d6eb148307a3042c5e15c223187b1e9e6efcaa130edddb40eda4", + "sha256_in_prefix": "9aeac93d9804d6eb148307a3042c5e15c223187b1e9e6efcaa130edddb40eda4", + "size_in_bytes": 25712 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/table.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "9deadd051bccafd937d9ebb10d3e45181eb788c6bf9ea5fca72ca4ec3020806d", + "sha256_in_prefix": "9deadd051bccafd937d9ebb10d3e45181eb788c6bf9ea5fca72ca4ec3020806d", + "size_in_bytes": 29904 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/terminal_theme.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "ad563c6fe943f854f285fd09271ec0dea4b70fa0be5d63830073be1b07531a3c", + "sha256_in_prefix": "ad563c6fe943f854f285fd09271ec0dea4b70fa0be5d63830073be1b07531a3c", + "size_in_bytes": 2978 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/text.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "b35da8e575411c799ff1807d6bcd9612baccd1deccaf815c4d1f4b4ef8a006ac", + "sha256_in_prefix": "b35da8e575411c799ff1807d6bcd9612baccd1deccaf815c4d1f4b4ef8a006ac", + "size_in_bytes": 40066 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/theme.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "94992c029e3aefd6adece2f6533aaa9ac7e2dbc86bc51cd1a12336195901b432", + "sha256_in_prefix": "94992c029e3aefd6adece2f6533aaa9ac7e2dbc86bc51cd1a12336195901b432", + "size_in_bytes": 4800 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/themes.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "2e1a012f623d6a25ea11713374f87592cd71a7d97475a1dc0946f32819bc9272", + "sha256_in_prefix": "2e1a012f623d6a25ea11713374f87592cd71a7d97475a1dc0946f32819bc9272", + "size_in_bytes": 255 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/traceback.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "6ac287a58a39fda5e89424a773e76dffa4cad7f24b9f289139f82585a4182390", + "sha256_in_prefix": "6ac287a58a39fda5e89424a773e76dffa4cad7f24b9f289139f82585a4182390", + "size_in_bytes": 21671 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/tree.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "2041ad2b2168040e0071be16ad76d7907fbff6d50a7dc8faf1e1ffded5a61b21", + "sha256_in_prefix": "2041ad2b2168040e0071be16ad76d7907fbff6d50a7dc8faf1e1ffded5a61b21", + "size_in_bytes": 7296 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/_cell_widths.py", + "path_type": "hardlink", + "sha256": "da7e048898b75fdb2a22ad0ed7a91467fcf2e9460c777c457c286529f9d6d477", + "sha256_in_prefix": "da7e048898b75fdb2a22ad0ed7a91467fcf2e9460c777c457c286529f9d6d477", + "size_in_bytes": 10096 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/_emoji_codes.py", + "path_type": "hardlink", + "sha256": "86ed552fd9db55da6926b5688a356c85195c4517bfbf7763bb7326776b0a65d6", + "sha256_in_prefix": "86ed552fd9db55da6926b5688a356c85195c4517bfbf7763bb7326776b0a65d6", + "size_in_bytes": 140235 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/_emoji_replace.py", + "path_type": "hardlink", + "sha256": "9fe91c7adb04531d99526850adf78c35cfad79e1a1a6e490e45f153c1b32bc3a", + "sha256_in_prefix": "9fe91c7adb04531d99526850adf78c35cfad79e1a1a6e490e45f153c1b32bc3a", + "size_in_bytes": 1064 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/_export_format.py", + "path_type": "hardlink", + "sha256": "ab1815de72a75d0bb585f6e7455b303d8cbe030220d57d0b482e3b70ae6cf239", + "sha256_in_prefix": "ab1815de72a75d0bb585f6e7455b303d8cbe030220d57d0b482e3b70ae6cf239", + "size_in_bytes": 2100 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/_extension.py", + "path_type": "hardlink", + "sha256": "5ede3b41a7022b062bbb38c38be80e06aef6e0945e0e3f429bdc548b97ebfb7e", + "sha256_in_prefix": "5ede3b41a7022b062bbb38c38be80e06aef6e0945e0e3f429bdc548b97ebfb7e", + "size_in_bytes": 265 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/_fileno.py", + "path_type": "hardlink", + "sha256": "1d66713f90b66a331b1ebcaf01066c79f9557d0a06cec28e1f3286b0b0fcca74", + "sha256_in_prefix": "1d66713f90b66a331b1ebcaf01066c79f9557d0a06cec28e1f3286b0b0fcca74", + "size_in_bytes": 799 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/_inspect.py", + "path_type": "hardlink", + "sha256": "a19246c37d5eeb87705d20a6ac39ef65bc156f564a8567d4f30237556a218c99", + "sha256_in_prefix": "a19246c37d5eeb87705d20a6ac39ef65bc156f564a8567d4f30237556a218c99", + "size_in_bytes": 9695 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/_log_render.py", + "path_type": "hardlink", + "sha256": "d41c88d0f035669c5963708624e2b9e218e5ab85fe073fdba088c8a8277c2a7b", + "sha256_in_prefix": "d41c88d0f035669c5963708624e2b9e218e5ab85fe073fdba088c8a8277c2a7b", + "size_in_bytes": 3225 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/_loop.py", + "path_type": "hardlink", + "sha256": "855ffa08b7683e6d2f6b6d96a70e332aa334458b33dd36715e3d0fa12fbd7834", + "sha256_in_prefix": "855ffa08b7683e6d2f6b6d96a70e332aa334458b33dd36715e3d0fa12fbd7834", + "size_in_bytes": 1236 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/_null_file.py", + "path_type": "hardlink", + "sha256": "b4649793fbfe21999b8f5180cc78adf00de460840c882a55b0215fb02fbf289e", + "sha256_in_prefix": "b4649793fbfe21999b8f5180cc78adf00de460840c882a55b0215fb02fbf289e", + "size_in_bytes": 1387 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/_palettes.py", + "path_type": "hardlink", + "sha256": "71d7afd4940a67426f960b95f62a478339d3767be52335050c16f422dd8fce32", + "sha256_in_prefix": "71d7afd4940a67426f960b95f62a478339d3767be52335050c16f422dd8fce32", + "size_in_bytes": 7063 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/_pick.py", + "path_type": "hardlink", + "sha256": "7af0edf10378945e428b0ad421794e2429ed8ad0423ac23764b3c42005512c95", + "sha256_in_prefix": "7af0edf10378945e428b0ad421794e2429ed8ad0423ac23764b3c42005512c95", + "size_in_bytes": 423 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/_ratio.py", + "path_type": "hardlink", + "sha256": "da52d29622f4db963e60c7dd7c66eeb644037af85cc83a9cf83b54616f6653bd", + "sha256_in_prefix": "da52d29622f4db963e60c7dd7c66eeb644037af85cc83a9cf83b54616f6653bd", + "size_in_bytes": 5472 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/_spinners.py", + "path_type": "hardlink", + "sha256": "536af5fe0ff5cd28ec8e251d00449cda200c7378b8ae2fd2f0f60fea4439cf52", + "sha256_in_prefix": "536af5fe0ff5cd28ec8e251d00449cda200c7378b8ae2fd2f0f60fea4439cf52", + "size_in_bytes": 19919 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/_stack.py", + "path_type": "hardlink", + "sha256": "f82f0e2bbaf19f7b0851d570c59041a5e1e12335f4788f9533731e9987da5e6d", + "sha256_in_prefix": "f82f0e2bbaf19f7b0851d570c59041a5e1e12335f4788f9533731e9987da5e6d", + "size_in_bytes": 351 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/_timer.py", + "path_type": "hardlink", + "sha256": "cde9716d3ea83c566736bc163e973592d51e013f957387ee15c4592d018bb4c2", + "sha256_in_prefix": "cde9716d3ea83c566736bc163e973592d51e013f957387ee15c4592d018bb4c2", + "size_in_bytes": 417 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/_win32_console.py", + "path_type": "hardlink", + "sha256": "3f4bf12367dc9ddca6d545354b7ed703343342793263b62a00a9b19b6e3f82e8", + "sha256_in_prefix": "3f4bf12367dc9ddca6d545354b7ed703343342793263b62a00a9b19b6e3f82e8", + "size_in_bytes": 22820 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/_windows.py", + "path_type": "hardlink", + "sha256": "76f365f5399f3f3355c622a4e560c58a112b679efdea0d940bdf8a186c9f5e69", + "sha256_in_prefix": "76f365f5399f3f3355c622a4e560c58a112b679efdea0d940bdf8a186c9f5e69", + "size_in_bytes": 1926 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/_windows_renderer.py", + "path_type": "hardlink", + "sha256": "b7be192f7c6e0c23f79e64e9f691f52f92e223671a909b9045095e1c225eae59", + "sha256_in_prefix": "b7be192f7c6e0c23f79e64e9f691f52f92e223671a909b9045095e1c225eae59", + "size_in_bytes": 2783 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/_wrap.py", + "path_type": "hardlink", + "sha256": "c5f57ff6dd1283aaf38a69ab0ebbbc7c25665256a56007072c37eb2599db6f04", + "sha256_in_prefix": "c5f57ff6dd1283aaf38a69ab0ebbbc7c25665256a56007072c37eb2599db6f04", + "size_in_bytes": 1840 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/abc.py", + "path_type": "hardlink", + "sha256": "38df84f99a924a1799f3c56b297d8cdcf5e915b18451464f31afc07f497ee1fd", + "sha256_in_prefix": "38df84f99a924a1799f3c56b297d8cdcf5e915b18451464f31afc07f497ee1fd", + "size_in_bytes": 890 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/align.py", + "path_type": "hardlink", + "sha256": "262f98a247e48677deff1326af82128d9074ed3257820042398a186be1c302bf", + "sha256_in_prefix": "262f98a247e48677deff1326af82128d9074ed3257820042398a186be1c302bf", + "size_in_bytes": 10368 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/ansi.py", + "path_type": "hardlink", + "sha256": "883eb9df6418aa7066ea1003ba52a3ad5f25f24149fbd7c4568a072471f784c8", + "sha256_in_prefix": "883eb9df6418aa7066ea1003ba52a3ad5f25f24149fbd7c4568a072471f784c8", + "size_in_bytes": 6906 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/bar.py", + "path_type": "hardlink", + "sha256": "6bb503df4dc171c442ac48468df304969bf94456088a7680840baa62a854be6c", + "sha256_in_prefix": "6bb503df4dc171c442ac48468df304969bf94456088a7680840baa62a854be6c", + "size_in_bytes": 3264 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/box.py", + "path_type": "hardlink", + "sha256": "149ea72378c3ee1d97345535dfc6c952dd8762658e9516e5b68084b8801985ec", + "sha256_in_prefix": "149ea72378c3ee1d97345535dfc6c952dd8762658e9516e5b68084b8801985ec", + "size_in_bytes": 9842 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/cells.py", + "path_type": "hardlink", + "sha256": "eb6ef3b49b3dcce2fedfc1c9ee45c17ab47e813f0a05f602f14cc4c0c243618a", + "sha256_in_prefix": "eb6ef3b49b3dcce2fedfc1c9ee45c17ab47e813f0a05f602f14cc4c0c243618a", + "size_in_bytes": 4509 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/color.py", + "path_type": "hardlink", + "sha256": "f4687de7c5377fbe5655d2d3782d14f679064e7da7d309e88caa49ea34049081", + "sha256_in_prefix": "f4687de7c5377fbe5655d2d3782d14f679064e7da7d309e88caa49ea34049081", + "size_in_bytes": 18224 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/color_triplet.py", + "path_type": "hardlink", + "sha256": "de585091d25bbd63e82c33be0276089805a626f579765818342559f7b39168de", + "sha256_in_prefix": "de585091d25bbd63e82c33be0276089805a626f579765818342559f7b39168de", + "size_in_bytes": 1054 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/columns.py", + "path_type": "hardlink", + "sha256": "1d45f429c326f5db0a362d757d36e233f876883b65f3248269573195a944ceaf", + "sha256_in_prefix": "1d45f429c326f5db0a362d757d36e233f876883b65f3248269573195a944ceaf", + "size_in_bytes": 7131 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/console.py", + "path_type": "hardlink", + "sha256": "a43be46cb92fb5920c230431fe3919fac7b2365e331812ef897a165ed7bd7f08", + "sha256_in_prefix": "a43be46cb92fb5920c230431fe3919fac7b2365e331812ef897a165ed7bd7f08", + "size_in_bytes": 99218 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/constrain.py", + "path_type": "hardlink", + "sha256": "d5520fb82f0082d296adc9dc42b8c1758a80dc9556cacbba8d9a35aeb87b73b4", + "sha256_in_prefix": "d5520fb82f0082d296adc9dc42b8c1758a80dc9556cacbba8d9a35aeb87b73b4", + "size_in_bytes": 1288 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/containers.py", + "path_type": "hardlink", + "sha256": "68a826e540c79f9366ba2e8825a29db1985b1c2961fd7ec3fbf5a0f0486bafbb", + "sha256_in_prefix": "68a826e540c79f9366ba2e8825a29db1985b1c2961fd7ec3fbf5a0f0486bafbb", + "size_in_bytes": 5497 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/control.py", + "path_type": "hardlink", + "sha256": "0d29074d440ba2b7d211100a13fa1300450579f667669e1b41be2af2b1db2b0b", + "sha256_in_prefix": "0d29074d440ba2b7d211100a13fa1300450579f667669e1b41be2af2b1db2b0b", + "size_in_bytes": 6630 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/default_styles.py", + "path_type": "hardlink", + "sha256": "f857b7d7c90c548fc8c1c88ae4f3a94e170ed3ef43609ebb4d900de839669663", + "sha256_in_prefix": "f857b7d7c90c548fc8c1c88ae4f3a94e170ed3ef43609ebb4d900de839669663", + "size_in_bytes": 8082 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/diagnose.py", + "path_type": "hardlink", + "sha256": "6a7eaea2ec2128f025bd0858a4d3691aaf44272b1f3083afbc26cede84a8476e", + "sha256_in_prefix": "6a7eaea2ec2128f025bd0858a4d3691aaf44272b1f3083afbc26cede84a8476e", + "size_in_bytes": 972 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/emoji.py", + "path_type": "hardlink", + "sha256": "a264c5f5ab1a027b0ce322d8f78791ffd7604514a6d651d4b335f6d03d726024", + "sha256_in_prefix": "a264c5f5ab1a027b0ce322d8f78791ffd7604514a6d651d4b335f6d03d726024", + "size_in_bytes": 2501 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/errors.py", + "path_type": "hardlink", + "sha256": "e693f729ce5de1027f734285b31adfca18e23d57bb275ccea9215b140cdc57e6", + "sha256_in_prefix": "e693f729ce5de1027f734285b31adfca18e23d57bb275ccea9215b140cdc57e6", + "size_in_bytes": 642 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/file_proxy.py", + "path_type": "hardlink", + "sha256": "4e5f531cc0d9f8f9395a6f2c23580683f5390e1bac9b10fe159d1f51b714d16d", + "sha256_in_prefix": "4e5f531cc0d9f8f9395a6f2c23580683f5390e1bac9b10fe159d1f51b714d16d", + "size_in_bytes": 1683 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/filesize.py", + "path_type": "hardlink", + "sha256": "f5f4cb00f080c079815dd46feca654d7de234a036b45be96c7b448a0182a78a6", + "sha256_in_prefix": "f5f4cb00f080c079815dd46feca654d7de234a036b45be96c7b448a0182a78a6", + "size_in_bytes": 2508 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/highlighter.py", + "path_type": "hardlink", + "sha256": "a770b5838418cdecc529d47b345f4484f6f3403bdd3d48464604b21861263e4a", + "sha256_in_prefix": "a770b5838418cdecc529d47b345f4484f6f3403bdd3d48464604b21861263e4a", + "size_in_bytes": 9584 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/json.py", + "path_type": "hardlink", + "sha256": "118a7db9c8fe9c38d80e41c257a324d6f7bc9d43a9b852da5bbe97e74322b363", + "sha256_in_prefix": "118a7db9c8fe9c38d80e41c257a324d6f7bc9d43a9b852da5bbe97e74322b363", + "size_in_bytes": 5032 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/jupyter.py", + "path_type": "hardlink", + "sha256": "432a0aa04ffc21d09baed8921e9f53b1348dc931d8d053b9c2113b8ce4ddf541", + "sha256_in_prefix": "432a0aa04ffc21d09baed8921e9f53b1348dc931d8d053b9c2113b8ce4ddf541", + "size_in_bytes": 3252 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/layout.py", + "path_type": "hardlink", + "sha256": "44560be8774216c1dff5646972f8b7c3e7e98fef0ee5d319f16f7a55d28d75b2", + "sha256_in_prefix": "44560be8774216c1dff5646972f8b7c3e7e98fef0ee5d319f16f7a55d28d75b2", + "size_in_bytes": 14007 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/live.py", + "path_type": "hardlink", + "sha256": "bd9cd8beeedfab096fdc6b61976c62c350dcfcef3456519c095d03387c02c833", + "sha256_in_prefix": "bd9cd8beeedfab096fdc6b61976c62c350dcfcef3456519c095d03387c02c833", + "size_in_bytes": 14273 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/live_render.py", + "path_type": "hardlink", + "sha256": "cc4966dcfadf488be339c7b6f331131cc2147fda45612500e68d007e58143fae", + "sha256_in_prefix": "cc4966dcfadf488be339c7b6f331131cc2147fda45612500e68d007e58143fae", + "size_in_bytes": 3667 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/logging.py", + "path_type": "hardlink", + "sha256": "b81f9c07edd0e1b9970cb2e96ce5a4985be2c3e15d7b7f73c8c57ab4a2765874", + "sha256_in_prefix": "b81f9c07edd0e1b9970cb2e96ce5a4985be2c3e15d7b7f73c8c57ab4a2765874", + "size_in_bytes": 11903 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/markup.py", + "path_type": "hardlink", + "sha256": "c73178b8069f884784603258b7fbd49c9386a1353c46b1fe3c7ed67166178c28", + "sha256_in_prefix": "c73178b8069f884784603258b7fbd49c9386a1353c46b1fe3c7ed67166178c28", + "size_in_bytes": 8198 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/measure.py", + "path_type": "hardlink", + "sha256": "1e6ac8257f2c5914c76e087c33111acbff37564a8d5bfef4b3c68a3f965c608f", + "sha256_in_prefix": "1e6ac8257f2c5914c76e087c33111acbff37564a8d5bfef4b3c68a3f965c608f", + "size_in_bytes": 5305 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/padding.py", + "path_type": "hardlink", + "sha256": "913146b1d19ed28b3bb572e71caa704c8f7409712fadc79e6460ac866272e73c", + "sha256_in_prefix": "913146b1d19ed28b3bb572e71caa704c8f7409712fadc79e6460ac866272e73c", + "size_in_bytes": 4970 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/pager.py", + "path_type": "hardlink", + "sha256": "48efc44c114a6e0de7fc080ecd79b8d52bf7e98c57032237fd1f8a398dbfb927", + "sha256_in_prefix": "48efc44c114a6e0de7fc080ecd79b8d52bf7e98c57032237fd1f8a398dbfb927", + "size_in_bytes": 828 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/palette.py", + "path_type": "hardlink", + "sha256": "9489ef4753830d3d9fdd464c7cbd60aeaedd63fa4374a1f0e1b75480e19a3386", + "sha256_in_prefix": "9489ef4753830d3d9fdd464c7cbd60aeaedd63fa4374a1f0e1b75480e19a3386", + "size_in_bytes": 3396 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/panel.py", + "path_type": "hardlink", + "sha256": "c0631ee3427c2821a04283342f28d112b986224bf66ec600ef54425d3843d311", + "sha256_in_prefix": "c0631ee3427c2821a04283342f28d112b986224bf66ec600ef54425d3843d311", + "size_in_bytes": 10574 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/pretty.py", + "path_type": "hardlink", + "sha256": "78b11837dc5568c36e03a1095589b8962ec774e1f10aa9952af9cea89a7216dd", + "sha256_in_prefix": "78b11837dc5568c36e03a1095589b8962ec774e1f10aa9952af9cea89a7216dd", + "size_in_bytes": 35852 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/progress.py", + "path_type": "hardlink", + "sha256": "9f8285f6f932f3fe6261e5dcc993c4bf3c8ba655a50ef14b90ce4923406cd3c0", + "sha256_in_prefix": "9f8285f6f932f3fe6261e5dcc993c4bf3c8ba655a50ef14b90ce4923406cd3c0", + "size_in_bytes": 59706 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/progress_bar.py", + "path_type": "hardlink", + "sha256": "704a017e473794bc2a6dae172ac529cb8bd240a0e1d9043927627de3e002168a", + "sha256_in_prefix": "704a017e473794bc2a6dae172ac529cb8bd240a0e1d9043927627de3e002168a", + "size_in_bytes": 8165 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/prompt.py", + "path_type": "hardlink", + "sha256": "c74996fa920fa1d24ce2bcba82b82698bae5f15669f7d92a72676705eef46180", + "sha256_in_prefix": "c74996fa920fa1d24ce2bcba82b82698bae5f15669f7d92a72676705eef46180", + "size_in_bytes": 11303 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/protocol.py", + "path_type": "hardlink", + "sha256": "e611c70c3347724764f22587e7311b8becee215485e616d4da3228e3b47b9531", + "sha256_in_prefix": "e611c70c3347724764f22587e7311b8becee215485e616d4da3228e3b47b9531", + "size_in_bytes": 1391 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/py.typed", + "path_type": "hardlink", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size_in_bytes": 0 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/region.py", + "path_type": "hardlink", + "sha256": "acd4fdc59ad56536085d90b43589f8d42250c1835b47e29e70f3b14e042f07c6", + "sha256_in_prefix": "acd4fdc59ad56536085d90b43589f8d42250c1835b47e29e70f3b14e042f07c6", + "size_in_bytes": 166 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/repr.py", + "path_type": "hardlink", + "sha256": "f59f28b4e98cfadcb19f24e876f5e579cb4feb49706a18c68834eb6ebc4f4938", + "sha256_in_prefix": "f59f28b4e98cfadcb19f24e876f5e579cb4feb49706a18c68834eb6ebc4f4938", + "size_in_bytes": 4431 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/rule.py", + "path_type": "hardlink", + "sha256": "d1f35a4bf68445add43117374f958ca4dfecba6b43c5f6a8af6cb7a1fd5fb419", + "sha256_in_prefix": "d1f35a4bf68445add43117374f958ca4dfecba6b43c5f6a8af6cb7a1fd5fb419", + "size_in_bytes": 4602 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/scope.py", + "path_type": "hardlink", + "sha256": "4cc514f2aa35eed872a9008faa30cb62983f514d64e6a55df96c2226f9c955ab", + "sha256_in_prefix": "4cc514f2aa35eed872a9008faa30cb62983f514d64e6a55df96c2226f9c955ab", + "size_in_bytes": 2843 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/screen.py", + "path_type": "hardlink", + "sha256": "628791784494871ef882ba9bd264926fd960861cac5a6147621b1b3154235cef", + "sha256_in_prefix": "628791784494871ef882ba9bd264926fd960861cac5a6147621b1b3154235cef", + "size_in_bytes": 1591 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/segment.py", + "path_type": "hardlink", + "sha256": "5cb9c9105bdc5776e3695ccc3542627a6de7f25bef23d4c9e4f4eef881b6b938", + "sha256_in_prefix": "5cb9c9105bdc5776e3695ccc3542627a6de7f25bef23d4c9e4f4eef881b6b938", + "size_in_bytes": 24247 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/spinner.py", + "path_type": "hardlink", + "sha256": "d799280a61740d0783f3e936f0ba6de97ff3250525cc4860a3fe80eaecb8ee57", + "sha256_in_prefix": "d799280a61740d0783f3e936f0ba6de97ff3250525cc4860a3fe80eaecb8ee57", + "size_in_bytes": 4339 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/status.py", + "path_type": "hardlink", + "sha256": "809b085c865e4a8deeacecb14548ece95ae15f9099ac0d0dc4843e7718429f0a", + "sha256_in_prefix": "809b085c865e4a8deeacecb14548ece95ae15f9099ac0d0dc4843e7718429f0a", + "size_in_bytes": 4425 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/style.py", + "path_type": "hardlink", + "sha256": "de18a8707ff837cbf0466dfef32156ccceed4b08e312f7a7ebd5ea59ab124303", + "sha256_in_prefix": "de18a8707ff837cbf0466dfef32156ccceed4b08e312f7a7ebd5ea59ab124303", + "size_in_bytes": 27073 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/styled.py", + "path_type": "hardlink", + "sha256": "799367cc6ac8e248bfe78a606373a3d13fb1de5c5d5d3621e3faf20c1db8c015", + "sha256_in_prefix": "799367cc6ac8e248bfe78a606373a3d13fb1de5c5d5d3621e3faf20c1db8c015", + "size_in_bytes": 1258 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/syntax.py", + "path_type": "hardlink", + "sha256": "8e00e25422ba72947436604ea59988bbe51de1e696edf1ef8c96640db8e97120", + "sha256_in_prefix": "8e00e25422ba72947436604ea59988bbe51de1e696edf1ef8c96640db8e97120", + "size_in_bytes": 35173 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/table.py", + "path_type": "hardlink", + "sha256": "f96cdeb0bf9524ab1a883537bb2733a49307cba5426927b0058270c7c46e748f", + "sha256_in_prefix": "f96cdeb0bf9524ab1a883537bb2733a49307cba5426927b0058270c7c46e748f", + "size_in_bytes": 39684 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/terminal_theme.py", + "path_type": "hardlink", + "sha256": "d63e7eb9f25f9ef940a3942c8bf0026625c39b0317cea826141c8e6d3f7ec896", + "sha256_in_prefix": "d63e7eb9f25f9ef940a3942c8bf0026625c39b0317cea826141c8e6d3f7ec896", + "size_in_bytes": 3370 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/text.py", + "path_type": "hardlink", + "sha256": "ffc2419526aed1cdb3f0434e64c8b5849eccd59198e34f04e3e8578c7cb28350", + "sha256_in_prefix": "ffc2419526aed1cdb3f0434e64c8b5849eccd59198e34f04e3e8578c7cb28350", + "size_in_bytes": 45525 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/theme.py", + "path_type": "hardlink", + "sha256": "6de9452688330345b41f2b1069b29a1ce7374561f6928ddf400261a0df8015da", + "sha256_in_prefix": "6de9452688330345b41f2b1069b29a1ce7374561f6928ddf400261a0df8015da", + "size_in_bytes": 3777 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/themes.py", + "path_type": "hardlink", + "sha256": "d318132e8cdf69b79b62d709b43742e50917e4855411abe2a83509261e185459", + "sha256_in_prefix": "d318132e8cdf69b79b62d709b43742e50917e4855411abe2a83509261e185459", + "size_in_bytes": 102 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/traceback.py", + "path_type": "hardlink", + "sha256": "c822d5ac2b72a0534435df66926db1786dca9aa913c07f71a4538eee9d81ab40", + "sha256_in_prefix": "c822d5ac2b72a0534435df66926db1786dca9aa913c07f71a4538eee9d81ab40", + "size_in_bytes": 29604 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/tree.py", + "path_type": "hardlink", + "sha256": "04c6d460d8d2f6ea1d34f7efb58fe8766534f4603943370c6d0e5c2598659502", + "sha256_in_prefix": "04c6d460d8d2f6ea1d34f7efb58fe8766534f4603943370c6d0e5c2598659502", + "size_in_bytes": 9169 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/six.py", + "path_type": "hardlink", + "sha256": "4ce39f422ee71467ccac8bed76beb05f8c321c7f0ceda9279ae2dfa3670106b3", + "sha256_in_prefix": "4ce39f422ee71467ccac8bed76beb05f8c321c7f0ceda9279ae2dfa3670106b3", + "size_in_bytes": 34549 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/tenacity/__init__.py", + "path_type": "hardlink", + "sha256": "de4bc02fa28296af06168d8a16198ecec9112920d023eb9bae57d9f00404108d", + "sha256_in_prefix": "de4bc02fa28296af06168d8a16198ecec9112920d023eb9bae57d9f00404108d", + "size_in_bytes": 20493 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/tenacity/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "3779066dbe1f60fd1b522cf3b013d7e26dc55ace3f8ee6c37892a820accc2b8e", + "sha256_in_prefix": "3779066dbe1f60fd1b522cf3b013d7e26dc55ace3f8ee6c37892a820accc2b8e", + "size_in_bytes": 17220 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/tenacity/__pycache__/_asyncio.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "9c4d15212d142701d338cecbb74adb5b65f6cdc45fc35bdd9a0a73f825f2aa1a", + "sha256_in_prefix": "9c4d15212d142701d338cecbb74adb5b65f6cdc45fc35bdd9a0a73f825f2aa1a", + "size_in_bytes": 2834 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/tenacity/__pycache__/_utils.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "1d502ed9c77508f5d2a3bc24b9b6b0974991ed1a76acc9e003dfbf959e13e0f2", + "sha256_in_prefix": "1d502ed9c77508f5d2a3bc24b9b6b0974991ed1a76acc9e003dfbf959e13e0f2", + "size_in_bytes": 1467 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/tenacity/__pycache__/after.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "e15dc4cc8c49f3fdeb434a2f90a8c6cc5178cf60747e9b332dda2a8eac5ba871", + "sha256_in_prefix": "e15dc4cc8c49f3fdeb434a2f90a8c6cc5178cf60747e9b332dda2a8eac5ba871", + "size_in_bytes": 1241 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/tenacity/__pycache__/before.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "57e1e2eae34ac83c4df5642a09ef917a83c668f64bd74a37c3571224ac0f9185", + "sha256_in_prefix": "57e1e2eae34ac83c4df5642a09ef917a83c668f64bd74a37c3571224ac0f9185", + "size_in_bytes": 1119 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/tenacity/__pycache__/before_sleep.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "585541d32d60685d30501d9b3d7ba3a6657822a3153a16dd2c6472f8997d576b", + "sha256_in_prefix": "585541d32d60685d30501d9b3d7ba3a6657822a3153a16dd2c6472f8997d576b", + "size_in_bytes": 1549 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/tenacity/__pycache__/nap.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "34e709c47fc4c31141e5e555748b7a03f0aa505a8b2d0c62fdcac10e12a13313", + "sha256_in_prefix": "34e709c47fc4c31141e5e555748b7a03f0aa505a8b2d0c62fdcac10e12a13313", + "size_in_bytes": 1161 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/tenacity/__pycache__/retry.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "9fd76910c3e5d5c9e91e65a0d8526de9e314154dd91bc44677e42100fa56202a", + "sha256_in_prefix": "9fd76910c3e5d5c9e91e65a0d8526de9e314154dd91bc44677e42100fa56202a", + "size_in_bytes": 9733 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/tenacity/__pycache__/stop.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "e1e71922cb080f786608fed55f432ac3fb604ff403c112baadcdbbb58e4afbfc", + "sha256_in_prefix": "e1e71922cb080f786608fed55f432ac3fb604ff403c112baadcdbbb58e4afbfc", + "size_in_bytes": 4287 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/tenacity/__pycache__/tornadoweb.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "b00e36be00b6984070bfb10c6c6a94d8b922a670796d9f43e24b18b6f2dfefe7", + "sha256_in_prefix": "b00e36be00b6984070bfb10c6c6a94d8b922a670796d9f43e24b18b6f2dfefe7", + "size_in_bytes": 1726 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/tenacity/__pycache__/wait.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "142496959a199941bc3982a68a5817b9f6c829857fe724af5345a05a74f94df3", + "sha256_in_prefix": "142496959a199941bc3982a68a5817b9f6c829857fe724af5345a05a74f94df3", + "size_in_bytes": 9248 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/tenacity/_asyncio.py", + "path_type": "hardlink", + "sha256": "422eb0810b066bd31089b611cb7397a9c0d0b30219674d1d2cea1250637eea8f", + "sha256_in_prefix": "422eb0810b066bd31089b611cb7397a9c0d0b30219674d1d2cea1250637eea8f", + "size_in_bytes": 3551 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/tenacity/_utils.py", + "path_type": "hardlink", + "sha256": "b9bb3a6bbb318f72433512960b2094da3e6bd4207bae0c8e360673619aba0ffe", + "sha256_in_prefix": "b9bb3a6bbb318f72433512960b2094da3e6bd4207bae0c8e360673619aba0ffe", + "size_in_bytes": 2179 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/tenacity/after.py", + "path_type": "hardlink", + "sha256": "4b934221249c3de22b2b021e5d1c1d265de457d4389ea65f9cd3c3c7a1dffff8", + "sha256_in_prefix": "4b934221249c3de22b2b021e5d1c1d265de457d4389ea65f9cd3c3c7a1dffff8", + "size_in_bytes": 1682 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/tenacity/before.py", + "path_type": "hardlink", + "sha256": "748644f609814df7e2b1fc0d90ad05d7117018f578d6ee462bbd146383e2e4a7", + "sha256_in_prefix": "748644f609814df7e2b1fc0d90ad05d7117018f578d6ee462bbd146383e2e4a7", + "size_in_bytes": 1562 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/tenacity/before_sleep.py", + "path_type": "hardlink", + "sha256": "626a6037d63b1c6947f7b536e2fbeafd859be5d79a2b8fc36e20fc66e166cbe1", + "sha256_in_prefix": "626a6037d63b1c6947f7b536e2fbeafd859be5d79a2b8fc36e20fc66e166cbe1", + "size_in_bytes": 2372 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/tenacity/nap.py", + "path_type": "hardlink", + "sha256": "7d15af9f3d5a2336c8abd029de00240198031faa28e73c4cad4e99395072ab42", + "sha256_in_prefix": "7d15af9f3d5a2336c8abd029de00240198031faa28e73c4cad4e99395072ab42", + "size_in_bytes": 1383 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/tenacity/py.typed", + "path_type": "hardlink", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size_in_bytes": 0 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/tenacity/retry.py", + "path_type": "hardlink", + "sha256": "8ebcc3fe6c40e66493504762601ed21e9c65b6384f4986529d24404dbfa08117", + "sha256_in_prefix": "8ebcc3fe6c40e66493504762601ed21e9c65b6384f4986529d24404dbfa08117", + "size_in_bytes": 8746 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/tenacity/stop.py", + "path_type": "hardlink", + "sha256": "60c26ced98197cd0fae4f44baa5181fda8297c65e57a6c7fe479b83ca9c1aa94", + "sha256_in_prefix": "60c26ced98197cd0fae4f44baa5181fda8297c65e57a6c7fe479b83ca9c1aa94", + "size_in_bytes": 3086 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/tenacity/tornadoweb.py", + "path_type": "hardlink", + "sha256": "a68dbdfc5d4cb7ca99a6c1635fb115c004f4c9d0bf35b5626bd8158bb47fc170", + "sha256_in_prefix": "a68dbdfc5d4cb7ca99a6c1635fb115c004f4c9d0bf35b5626bd8158bb47fc170", + "size_in_bytes": 2142 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/tenacity/wait.py", + "path_type": "hardlink", + "sha256": "dc57012680838329b5dbf74deb17caf02d6044e6341e7e0d488daef31bf9d2e1", + "sha256_in_prefix": "dc57012680838329b5dbf74deb17caf02d6044e6341e7e0d488daef31bf9d2e1", + "size_in_bytes": 8024 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/tomli/__init__.py", + "path_type": "hardlink", + "sha256": "26153057ae830758381efb7551009531d7c2bbe220015f055e6bc353da27c5de", + "sha256_in_prefix": "26153057ae830758381efb7551009531d7c2bbe220015f055e6bc353da27c5de", + "size_in_bytes": 396 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/tomli/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "2d1788f149595b33d9a1e4c296572b550c95ba741fe6dbfa8b0272efa952a9bc", + "sha256_in_prefix": "2d1788f149595b33d9a1e4c296572b550c95ba741fe6dbfa8b0272efa952a9bc", + "size_in_bytes": 317 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/tomli/__pycache__/_parser.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "415d77b2f7eb8fe239e686878f6afa5ebf498d3be31fcf6cbd05b52a776fe88f", + "sha256_in_prefix": "415d77b2f7eb8fe239e686878f6afa5ebf498d3be31fcf6cbd05b52a776fe88f", + "size_in_bytes": 17031 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/tomli/__pycache__/_re.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "8681b55608bd673c9ff73e856966a11041b5be83412f216cdda76760f7998c45", + "sha256_in_prefix": "8681b55608bd673c9ff73e856966a11041b5be83412f216cdda76760f7998c45", + "size_in_bytes": 2863 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/tomli/__pycache__/_types.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "5e54f6f4d29777c7db096da56e797b9cd432ecdba89b9b4c97387c550bc96320", + "sha256_in_prefix": "5e54f6f4d29777c7db096da56e797b9cd432ecdba89b9b4c97387c550bc96320", + "size_in_bytes": 287 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/tomli/_parser.py", + "path_type": "hardlink", + "sha256": "83df8435a00b4be07c768918a42bb35056a55a5a20ed3f922183232d9496aed3", + "sha256_in_prefix": "83df8435a00b4be07c768918a42bb35056a55a5a20ed3f922183232d9496aed3", + "size_in_bytes": 22633 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/tomli/_re.py", + "path_type": "hardlink", + "sha256": "75b8e0e428594f6dca6bdcfd0c73977ddb52a4fc147dd80c5e78fc34ea25cbec", + "sha256_in_prefix": "75b8e0e428594f6dca6bdcfd0c73977ddb52a4fc147dd80c5e78fc34ea25cbec", + "size_in_bytes": 2943 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/tomli/_types.py", + "path_type": "hardlink", + "sha256": "f864c6d9552a929c7032ace654ee05ef26ca75d21b027b801d77e65907138b74", + "sha256_in_prefix": "f864c6d9552a929c7032ace654ee05ef26ca75d21b027b801d77e65907138b74", + "size_in_bytes": 254 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/tomli/py.typed", + "path_type": "hardlink", + "sha256": "f0f8f2675695a10a5156fb7bd66bafbaae6a13e8d315990af862c792175e6e67", + "sha256_in_prefix": "f0f8f2675695a10a5156fb7bd66bafbaae6a13e8d315990af862c792175e6e67", + "size_in_bytes": 26 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/truststore/__init__.py", + "path_type": "hardlink", + "sha256": "ab34cb487f0fbc0918d5fafa410daf57e2b013f33cdf0757ba0b6925a3ff01b3", + "sha256_in_prefix": "ab34cb487f0fbc0918d5fafa410daf57e2b013f33cdf0757ba0b6925a3ff01b3", + "size_in_bytes": 403 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/truststore/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c68d6389a41e8457d3541e311e5dcb59a8f1eb4bfd10fd8f62c3cc9ae12c7f4b", + "sha256_in_prefix": "c68d6389a41e8457d3541e311e5dcb59a8f1eb4bfd10fd8f62c3cc9ae12c7f4b", + "size_in_bytes": 514 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/truststore/__pycache__/_api.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "735bb09ad2f6eea7025f97f9dbb71eb1f05555ae2d4f7bfe26cf0994594d65c9", + "sha256_in_prefix": "735bb09ad2f6eea7025f97f9dbb71eb1f05555ae2d4f7bfe26cf0994594d65c9", + "size_in_bytes": 9703 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/truststore/__pycache__/_macos.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "374fec501a51ab1eccba48a00e4b958c3a3cef13adf9880dae1471df50a697ec", + "sha256_in_prefix": "374fec501a51ab1eccba48a00e4b958c3a3cef13adf9880dae1471df50a697ec", + "size_in_bytes": 8611 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/truststore/__pycache__/_openssl.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "9b0ceb368b04fb518d132bd3b1cf789912addedba7b9fe65959d5537c7543d01", + "sha256_in_prefix": "9b0ceb368b04fb518d132bd3b1cf789912addedba7b9fe65959d5537c7543d01", + "size_in_bytes": 1444 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/truststore/__pycache__/_ssl_constants.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "2e9bc3f3445677b438e3aa793e4269f03f616b442b3e68c1f4a361d41f14f547", + "sha256_in_prefix": "2e9bc3f3445677b438e3aa793e4269f03f616b442b3e68c1f4a361d41f14f547", + "size_in_bytes": 758 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/truststore/__pycache__/_windows.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "99913aab3434618f68ffc3a376ce4df72972c44cbaf3efd98fe09ddf072b4a80", + "sha256_in_prefix": "99913aab3434618f68ffc3a376ce4df72972c44cbaf3efd98fe09ddf072b4a80", + "size_in_bytes": 10383 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/truststore/_api.py", + "path_type": "hardlink", + "sha256": "c63b84bbfae51f885c7494d1388984c8e12a770f85f2de6f3b61f6053a18d11a", + "sha256_in_prefix": "c63b84bbfae51f885c7494d1388984c8e12a770f85f2de6f3b61f6053a18d11a", + "size_in_bytes": 9893 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/truststore/_macos.py", + "path_type": "hardlink", + "sha256": "063bc02a80235e17483eec69635db81c9205b300dbd29abc0e3ca7cc9395c2a7", + "sha256_in_prefix": "063bc02a80235e17483eec69635db81c9205b300dbd29abc0e3ca7cc9395c2a7", + "size_in_bytes": 17694 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/truststore/_openssl.py", + "path_type": "hardlink", + "sha256": "2cb519ed919a8a8fa2e5da4a2a328249e4ae7e69fa4fca62f650dc167bd2caad", + "sha256_in_prefix": "2cb519ed919a8a8fa2e5da4a2a328249e4ae7e69fa4fca62f650dc167bd2caad", + "size_in_bytes": 2324 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/truststore/_ssl_constants.py", + "path_type": "hardlink", + "sha256": "3540f87d529d483d36ae2efe75bd2d9ced15a8b3fd687bb3992b5c5bbb40974f", + "sha256_in_prefix": "3540f87d529d483d36ae2efe75bd2d9ced15a8b3fd687bb3992b5c5bbb40974f", + "size_in_bytes": 1130 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/truststore/_windows.py", + "path_type": "hardlink", + "sha256": "d71fc485139e27d40ad6c3008df9d90bb6b0608f149c12582fe4e30025182380", + "sha256_in_prefix": "d71fc485139e27d40ad6c3008df9d90bb6b0608f149c12582fe4e30025182380", + "size_in_bytes": 17468 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/truststore/py.typed", + "path_type": "hardlink", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size_in_bytes": 0 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/typing_extensions.py", + "path_type": "hardlink", + "sha256": "116a5ca72427566738f04f5f4b23c6b3ebd780770093db50001408c6632c0869", + "sha256_in_prefix": "116a5ca72427566738f04f5f4b23c6b3ebd780770093db50001408c6632c0869", + "size_in_bytes": 111130 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/__init__.py", + "path_type": "hardlink", + "sha256": "8972dc6222724a7d0635b58e3990c30298012f52603f8e0467c8b5efad12f0c7", + "sha256_in_prefix": "8972dc6222724a7d0635b58e3990c30298012f52603f8e0467c8b5efad12f0c7", + "size_in_bytes": 3333 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "52644315dbbf55a36aae8a6a794ee09169163cdfe4b5557beab8ea7eab1411b0", + "sha256_in_prefix": "52644315dbbf55a36aae8a6a794ee09169163cdfe4b5557beab8ea7eab1411b0", + "size_in_bytes": 2471 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/__pycache__/_collections.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "636a3fa6fc94e3ade50a8d1a22889cdfe7fe6d4163d6a9a160c3c6fe3fc767e7", + "sha256_in_prefix": "636a3fa6fc94e3ade50a8d1a22889cdfe7fe6d4163d6a9a160c3c6fe3fc767e7", + "size_in_bytes": 10825 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/__pycache__/_version.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "29b6681b9419659826ffb4c5873b3151cac4041443aed865cf10322d6b1b879f", + "sha256_in_prefix": "29b6681b9419659826ffb4c5873b3151cac4041443aed865cf10322d6b1b879f", + "size_in_bytes": 176 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/__pycache__/connection.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "9f93c5747916c5163f06fe61bb72da77d65e682d056eedf486515fb7db6a0efa", + "sha256_in_prefix": "9f93c5747916c5163f06fe61bb72da77d65e682d056eedf486515fb7db6a0efa", + "size_in_bytes": 13663 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/__pycache__/connectionpool.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "23e9efc5e5c36c352a637dbc2784cab734240c2be516b0366133a2911c361f4c", + "sha256_in_prefix": "23e9efc5e5c36c352a637dbc2784cab734240c2be516b0366133a2911c361f4c", + "size_in_bytes": 25745 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/__pycache__/exceptions.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "7857acf73bca39331093d2592e96ef7484f1b211a15cc7d1bbdccba86cb07e0f", + "sha256_in_prefix": "7857acf73bca39331093d2592e96ef7484f1b211a15cc7d1bbdccba86cb07e0f", + "size_in_bytes": 10956 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/__pycache__/fields.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "19907a39fce01171d168d8ebb7c64c9db5fd2dcd1d069ff1ac21c8a02de28bae", + "sha256_in_prefix": "19907a39fce01171d168d8ebb7c64c9db5fd2dcd1d069ff1ac21c8a02de28bae", + "size_in_bytes": 8145 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/__pycache__/filepost.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "09626fe16e6fa7eafae8e9d9f7b90b522534906273a0638afa31f09265fea232", + "sha256_in_prefix": "09626fe16e6fa7eafae8e9d9f7b90b522534906273a0638afa31f09265fea232", + "size_in_bytes": 2712 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/__pycache__/poolmanager.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "427d98ca0542af0f0dfe1146b75164bdaf975db2d5b5483010a9c171fdfb370d", + "sha256_in_prefix": "427d98ca0542af0f0dfe1146b75164bdaf975db2d5b5483010a9c171fdfb370d", + "size_in_bytes": 15026 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/__pycache__/request.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "e6e2e7e126badb9a7f71291008164cc12d80d9f712fbb6eecaec45dd663db2e9", + "sha256_in_prefix": "e6e2e7e126badb9a7f71291008164cc12d80d9f712fbb6eecaec45dd663db2e9", + "size_in_bytes": 6344 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/__pycache__/response.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "e221d803bd689ee1ed20bc84b89dd7b71de638200d36426c6d4b215d5ee22a6d", + "sha256_in_prefix": "e221d803bd689ee1ed20bc84b89dd7b71de638200d36426c6d4b215d5ee22a6d", + "size_in_bytes": 22462 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/_collections.py", + "path_type": "hardlink", + "sha256": "469d6657206073f52501ca7a3376add6c909057479278dcd6b0453bd6da0fd76", + "sha256_in_prefix": "469d6657206073f52501ca7a3376add6c909057479278dcd6b0453bd6da0fd76", + "size_in_bytes": 10811 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/_version.py", + "path_type": "hardlink", + "sha256": "6b3a0ceccec15000e5da406131547a3cf7f61a104323dd267b57dc9f34f075cc", + "sha256_in_prefix": "6b3a0ceccec15000e5da406131547a3cf7f61a104323dd267b57dc9f34f075cc", + "size_in_bytes": 64 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/connection.py", + "path_type": "hardlink", + "sha256": "f7693db5dff2e0f1224c88cdb9f0946b5373301dc9df0d0b11dca89188179d6f", + "sha256_in_prefix": "f7693db5dff2e0f1224c88cdb9f0946b5373301dc9df0d0b11dca89188179d6f", + "size_in_bytes": 20300 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/connectionpool.py", + "path_type": "hardlink", + "sha256": "22d5436ac0e73d13cff51f1b37163bb4f0650bbdb89c9f679715605c6fd22db2", + "sha256_in_prefix": "22d5436ac0e73d13cff51f1b37163bb4f0650bbdb89c9f679715605c6fd22db2", + "size_in_bytes": 39990 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/__init__.py", + "path_type": "hardlink", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size_in_bytes": 0 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "f707ad8531b2110f857d489555440f9cb8852b7bbe6b0f3114a404053f72999c", + "sha256_in_prefix": "f707ad8531b2110f857d489555440f9cb8852b7bbe6b0f3114a404053f72999c", + "size_in_bytes": 161 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/__pycache__/_appengine_environ.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "46623de22f31d5a8a525933f1b3b614e33b3b5bc24d6425e21c020d41e37fe30", + "sha256_in_prefix": "46623de22f31d5a8a525933f1b3b614e33b3b5bc24d6425e21c020d41e37fe30", + "size_in_bytes": 1341 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/__pycache__/appengine.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "b6f0e92a8d7b82b893ad1212bb036579cc6555c0552e95efbbdfc5f7bd373cfc", + "sha256_in_prefix": "b6f0e92a8d7b82b893ad1212bb036579cc6555c0552e95efbbdfc5f7bd373cfc", + "size_in_bytes": 8158 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/__pycache__/ntlmpool.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "51094f81322cfb7ff541ca11de6e1b84445f1682609f51e0b1f58d2514d111c8", + "sha256_in_prefix": "51094f81322cfb7ff541ca11de6e1b84445f1682609f51e0b1f58d2514d111c8", + "size_in_bytes": 3585 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/__pycache__/pyopenssl.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "94e7d71ed8fa200886cd9e2720f0f255f98ba0cd891115c659c263cfd0932e34", + "sha256_in_prefix": "94e7d71ed8fa200886cd9e2720f0f255f98ba0cd891115c659c263cfd0932e34", + "size_in_bytes": 15771 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/__pycache__/securetransport.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "f2e98515a603ff143812b3e36ae8b83d68a066103cb16f2bcd6d520eb0409791", + "sha256_in_prefix": "f2e98515a603ff143812b3e36ae8b83d68a066103cb16f2bcd6d520eb0409791", + "size_in_bytes": 21903 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/__pycache__/socks.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "4ab61f893b4011d61a68eb0e3afbcb3ca4c8c2868016da607cb2706a72926ac6", + "sha256_in_prefix": "4ab61f893b4011d61a68eb0e3afbcb3ca4c8c2868016da607cb2706a72926ac6", + "size_in_bytes": 5563 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/_appengine_environ.py", + "path_type": "hardlink", + "sha256": "6c36f2384856d8228b25c42a00a032ac41cdf9a925b321c52aaeaf17c645b269", + "sha256_in_prefix": "6c36f2384856d8228b25c42a00a032ac41cdf9a925b321c52aaeaf17c645b269", + "size_in_bytes": 957 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/_securetransport/__init__.py", + "path_type": "hardlink", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size_in_bytes": 0 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/_securetransport/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "cacbdbb60874be684368966f7fa863a69c27e7180434839dc8cb345ce6295ecb", + "sha256_in_prefix": "cacbdbb60874be684368966f7fa863a69c27e7180434839dc8cb345ce6295ecb", + "size_in_bytes": 178 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/_securetransport/__pycache__/bindings.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "5fe2cd93e2d08e0405e5c81cf32cf17e6475ddca1e3876ab99dd603903a18fd0", + "sha256_in_prefix": "5fe2cd93e2d08e0405e5c81cf32cf17e6475ddca1e3876ab99dd603903a18fd0", + "size_in_bytes": 10674 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/_securetransport/__pycache__/low_level.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "2673079b2508bf890644273cfbd7cfcc436768704262b8ddc1ed10b508c597b3", + "sha256_in_prefix": "2673079b2508bf890644273cfbd7cfcc436768704262b8ddc1ed10b508c597b3", + "size_in_bytes": 9061 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/_securetransport/bindings.py", + "path_type": "hardlink", + "sha256": "e1793ae2a2243c1b74f40e6af9120552e0e135cf665e29556a99bb5a7627cd1c", + "sha256_in_prefix": "e1793ae2a2243c1b74f40e6af9120552e0e135cf665e29556a99bb5a7627cd1c", + "size_in_bytes": 17632 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/_securetransport/low_level.py", + "path_type": "hardlink", + "sha256": "076241076fcd44fd36c4ae8309ad4f6bd22ec6b3f0c730f365b8b14246fb53d3", + "sha256_in_prefix": "076241076fcd44fd36c4ae8309ad4f6bd22ec6b3f0c730f365b8b14246fb53d3", + "size_in_bytes": 13922 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/appengine.py", + "path_type": "hardlink", + "sha256": "551ebc780544d77ee5c53823043c029dae5488165338a6b4d408fffb905a0b3e", + "sha256_in_prefix": "551ebc780544d77ee5c53823043c029dae5488165338a6b4d408fffb905a0b3e", + "size_in_bytes": 11036 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/ntlmpool.py", + "path_type": "hardlink", + "sha256": "3657e45bb58c756f338aab9da298c7a16dbdf688350535a2d0878889baae1709", + "sha256_in_prefix": "3657e45bb58c756f338aab9da298c7a16dbdf688350535a2d0878889baae1709", + "size_in_bytes": 4528 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/pyopenssl.py", + "path_type": "hardlink", + "sha256": "843261e0c87263fa7ea0a9457187106954110efe86326046b96f728f1c9e7a33", + "sha256_in_prefix": "843261e0c87263fa7ea0a9457187106954110efe86326046b96f728f1c9e7a33", + "size_in_bytes": 17081 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/securetransport.py", + "path_type": "hardlink", + "sha256": "ca165d9958d8e8f23a11e15ba7ba983a9ebebe9d5192fd8d32e3866848fba667", + "sha256_in_prefix": "ca165d9958d8e8f23a11e15ba7ba983a9ebebe9d5192fd8d32e3866848fba667", + "size_in_bytes": 34448 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/socks.py", + "path_type": "hardlink", + "sha256": "6918bd7965e8f5911bf795d4c5e7f8676d421659e78db122028f473ac7a832de", + "sha256_in_prefix": "6918bd7965e8f5911bf795d4c5e7f8676d421659e78db122028f473ac7a832de", + "size_in_bytes": 7097 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/exceptions.py", + "path_type": "hardlink", + "sha256": "d0c9e7a372874cd7d745f63beb7f0db9f38f9146fa9973a6f8baa3fb8c76c3c0", + "sha256_in_prefix": "d0c9e7a372874cd7d745f63beb7f0db9f38f9146fa9973a6f8baa3fb8c76c3c0", + "size_in_bytes": 8217 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/fields.py", + "path_type": "hardlink", + "sha256": "92f2c30a0fc9987d652e3514118fc52d2f14858ee106f0cfb951136d8f2676b3", + "sha256_in_prefix": "92f2c30a0fc9987d652e3514118fc52d2f14858ee106f0cfb951136d8f2676b3", + "size_in_bytes": 8579 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/filepost.py", + "path_type": "hardlink", + "sha256": "e5bfeaaa04475652fbb8bb5d018073061f861e653901f255b7fd8dd174b73de6", + "sha256_in_prefix": "e5bfeaaa04475652fbb8bb5d018073061f861e653901f255b7fd8dd174b73de6", + "size_in_bytes": 2440 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/packages/__init__.py", + "path_type": "hardlink", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size_in_bytes": 0 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/packages/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "b6a22bfe51c846109fcbf9e5a730c981fb9d1d2c0bcb8628de38cbb43e647740", + "sha256_in_prefix": "b6a22bfe51c846109fcbf9e5a730c981fb9d1d2c0bcb8628de38cbb43e647740", + "size_in_bytes": 162 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/packages/__pycache__/six.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "a88f91e7ef0a1bed32ce7acec93210b424875b71943e5446084a03ee1c7ecdba", + "sha256_in_prefix": "a88f91e7ef0a1bed32ce7acec93210b424875b71943e5446084a03ee1c7ecdba", + "size_in_bytes": 27616 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/packages/backports/__init__.py", + "path_type": "hardlink", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size_in_bytes": 0 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/packages/backports/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "67f20bca75a46e07248577171ea00a86eb9949089dc1d8893724361780462974", + "sha256_in_prefix": "67f20bca75a46e07248577171ea00a86eb9949089dc1d8893724361780462974", + "size_in_bytes": 172 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/packages/backports/__pycache__/makefile.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "213c6849d9f0fb799d42eeefb7d49c7c8c1c7d9c84b677551d4ddd49d538dba0", + "sha256_in_prefix": "213c6849d9f0fb799d42eeefb7d49c7c8c1c7d9c84b677551d4ddd49d538dba0", + "size_in_bytes": 1272 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/packages/backports/__pycache__/weakref_finalize.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "e9352201598c6f9a4e43e18eab193efb806c6406c4b748cb1a3bef1c37d20e00", + "sha256_in_prefix": "e9352201598c6f9a4e43e18eab193efb806c6406c4b748cb1a3bef1c37d20e00", + "size_in_bytes": 4870 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/packages/backports/makefile.py", + "path_type": "hardlink", + "sha256": "9dbcedde2d1a80f54fd3b8eaaa08e16988cc9ae022fd6e44d04cb0662bd53bc1", + "sha256_in_prefix": "9dbcedde2d1a80f54fd3b8eaaa08e16988cc9ae022fd6e44d04cb0662bd53bc1", + "size_in_bytes": 1417 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/packages/backports/weakref_finalize.py", + "path_type": "hardlink", + "sha256": "b5109a97938084d491c9bd03847a7edfc02d2250ac44ff01c45dcd5feeaba880", + "sha256_in_prefix": "b5109a97938084d491c9bd03847a7edfc02d2250ac44ff01c45dcd5feeaba880", + "size_in_bytes": 5343 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/packages/six.py", + "path_type": "hardlink", + "sha256": "6fd2ccd30057bfb13b4ab6c28c09b8c3037e86b1fe88dc6fd7c2e058d30c28fa", + "sha256_in_prefix": "6fd2ccd30057bfb13b4ab6c28c09b8c3037e86b1fe88dc6fd7c2e058d30c28fa", + "size_in_bytes": 34665 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/poolmanager.py", + "path_type": "hardlink", + "sha256": "d22f1c260aeaba9cdaebb2013d9feef635ef9d2c6be54065544894a9d90fb582", + "sha256_in_prefix": "d22f1c260aeaba9cdaebb2013d9feef635ef9d2c6be54065544894a9d90fb582", + "size_in_bytes": 19752 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/request.py", + "path_type": "hardlink", + "sha256": "61358536bed023087b1355bd75d7bd2ccefbbf65564c9e55efc5ee4d3c3b0f50", + "sha256_in_prefix": "61358536bed023087b1355bd75d7bd2ccefbbf65564c9e55efc5ee4d3c3b0f50", + "size_in_bytes": 6691 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/response.py", + "path_type": "hardlink", + "sha256": "7e60c9005906ef5b854e7fac5524e1d88c345a6717418aa46d18e286fc018d4f", + "sha256_in_prefix": "7e60c9005906ef5b854e7fac5524e1d88c345a6717418aa46d18e286fc018d4f", + "size_in_bytes": 30641 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/util/__init__.py", + "path_type": "hardlink", + "sha256": "2449929a6aaa2f26b0f0fe75814226661f06c20f62d7349ef83a2a022b67da77", + "sha256_in_prefix": "2449929a6aaa2f26b0f0fe75814226661f06c20f62d7349ef83a2a022b67da77", + "size_in_bytes": 1155 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/util/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "0cac42599ca3b182a4b370bb18c0be4ba95a6e947c991a3bd76e39cdb54e9b3b", + "sha256_in_prefix": "0cac42599ca3b182a4b370bb18c0be4ba95a6e947c991a3bd76e39cdb54e9b3b", + "size_in_bytes": 1071 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/util/__pycache__/connection.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "976f4f0f03d37ed557068c7220b08397ad18226efa7025f7fc3e8bdfc0e73e1e", + "sha256_in_prefix": "976f4f0f03d37ed557068c7220b08397ad18226efa7025f7fc3e8bdfc0e73e1e", + "size_in_bytes": 3399 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/util/__pycache__/proxy.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "133c2816f612381ebf38610cc7c2fe88dccc4db95f3c1f332cf214288ebf7080", + "sha256_in_prefix": "133c2816f612381ebf38610cc7c2fe88dccc4db95f3c1f332cf214288ebf7080", + "size_in_bytes": 1304 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/util/__pycache__/queue.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "119ce857e73465c8ea55f191db0210c0284d6cd640914c6ceda8e0b29bb3a2f6", + "sha256_in_prefix": "119ce857e73465c8ea55f191db0210c0284d6cd640914c6ceda8e0b29bb3a2f6", + "size_in_bytes": 1026 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/util/__pycache__/request.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "fac2c362734c71211ca8e37ada09ae5c051757b94402c71ef38e9b2e697f027a", + "sha256_in_prefix": "fac2c362734c71211ca8e37ada09ae5c051757b94402c71ef38e9b2e697f027a", + "size_in_bytes": 3333 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/util/__pycache__/response.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "768ab695d44016a6600b3762687162e914756039f9e411bba361bf687dadd701", + "sha256_in_prefix": "768ab695d44016a6600b3762687162e914756039f9e411bba361bf687dadd701", + "size_in_bytes": 2319 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/util/__pycache__/retry.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "8f6eca7f27972948c61103b057c00c287e245b8157b66124136d86a90af54338", + "sha256_in_prefix": "8f6eca7f27972948c61103b057c00c287e245b8157b66124136d86a90af54338", + "size_in_bytes": 16119 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/util/__pycache__/ssl_.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "a7fd3e19ffe22dc81105fee31ab57c56a3c9badf8894a1c33df3d7e907fbf8e9", + "sha256_in_prefix": "a7fd3e19ffe22dc81105fee31ab57c56a3c9badf8894a1c33df3d7e907fbf8e9", + "size_in_bytes": 11271 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/util/__pycache__/ssl_match_hostname.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "e41f0cafc66d9c6fd3f69b77df7e75a46491d6cc7e60ea532b1a1967f786053b", + "sha256_in_prefix": "e41f0cafc66d9c6fd3f69b77df7e75a46491d6cc7e60ea532b1a1967f786053b", + "size_in_bytes": 3223 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/util/__pycache__/ssltransport.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "3c647271721194f1c66749fdca98a50fbacfd01369acc113a206fa1f0d9acb1d", + "sha256_in_prefix": "3c647271721194f1c66749fdca98a50fbacfd01369acc113a206fa1f0d9acb1d", + "size_in_bytes": 7361 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/util/__pycache__/timeout.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "df4bf59953f460d6768b13f7617b84100e6e8c1012a9eb9105c9526eb553672d", + "sha256_in_prefix": "df4bf59953f460d6768b13f7617b84100e6e8c1012a9eb9105c9526eb553672d", + "size_in_bytes": 9098 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/util/__pycache__/url.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "9f0f24d22e081f829b3c59b89856b3dff82b062bfd87ffbc78bc67a0d28d9fa8", + "sha256_in_prefix": "9f0f24d22e081f829b3c59b89856b3dff82b062bfd87ffbc78bc67a0d28d9fa8", + "size_in_bytes": 10675 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/util/__pycache__/wait.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "0bc9af756f0a0eb7fd5ed5106342f86fc56df64a1fcf4a25d69c783ee7c836d2", + "sha256_in_prefix": "0bc9af756f0a0eb7fd5ed5106342f86fc56df64a1fcf4a25d69c783ee7c836d2", + "size_in_bytes": 3055 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/util/connection.py", + "path_type": "hardlink", + "sha256": "e4bc760753d6dbd2b1067d93d3190dd420604416b780654904aa10a11a201159", + "sha256_in_prefix": "e4bc760753d6dbd2b1067d93d3190dd420604416b780654904aa10a11a201159", + "size_in_bytes": 4901 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/util/proxy.py", + "path_type": "hardlink", + "sha256": "cd4bcf3c226ba7a74e17437818055b39c97aa3ee2e5ca4ab1a24e492be6f512e", + "sha256_in_prefix": "cd4bcf3c226ba7a74e17437818055b39c97aa3ee2e5ca4ab1a24e492be6f512e", + "size_in_bytes": 1605 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/util/queue.py", + "path_type": "hardlink", + "sha256": "9d1817f3f797fbf564bf1a17d3de905a8cfc3ecd101d4004c482c263fecf9dc3", + "sha256_in_prefix": "9d1817f3f797fbf564bf1a17d3de905a8cfc3ecd101d4004c482c263fecf9dc3", + "size_in_bytes": 498 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/util/request.py", + "path_type": "hardlink", + "sha256": "0b4394b76b5c53a2d189027b61834ff46bcfad2be5ef388805e910fb99e50599", + "sha256_in_prefix": "0b4394b76b5c53a2d189027b61834ff46bcfad2be5ef388805e910fb99e50599", + "size_in_bytes": 3997 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/util/response.py", + "path_type": "hardlink", + "sha256": "189a60dc4822f6a6895d1c01879c2ff8c36e4566a7e4122ee34a117a8c563f6f", + "sha256_in_prefix": "189a60dc4822f6a6895d1c01879c2ff8c36e4566a7e4122ee34a117a8c563f6f", + "size_in_bytes": 3510 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/util/retry.py", + "path_type": "hardlink", + "sha256": "67a5847f9d7c7933973f98ebe50490f60a892340d562ddd7b3710a9d86939aeb", + "sha256_in_prefix": "67a5847f9d7c7933973f98ebe50490f60a892340d562ddd7b3710a9d86939aeb", + "size_in_bytes": 22013 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/util/ssl_.py", + "path_type": "hardlink", + "sha256": "5f8f80a96f756983e13f1ebec5b7faeb21c540a6eaa9f0bfe59b785a42d7d477", + "sha256_in_prefix": "5f8f80a96f756983e13f1ebec5b7faeb21c540a6eaa9f0bfe59b785a42d7d477", + "size_in_bytes": 17177 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/util/ssl_match_hostname.py", + "path_type": "hardlink", + "sha256": "22be1c65512398093c8140081d64a2ef0b4e3bcdd4098001636c450f5425fd60", + "sha256_in_prefix": "22be1c65512398093c8140081d64a2ef0b4e3bcdd4098001636c450f5425fd60", + "size_in_bytes": 5758 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/util/ssltransport.py", + "path_type": "hardlink", + "sha256": "340faee6b313ac3143142f10cd129410a306d39eb584e0f8a814ebdd9e29bfa1", + "sha256_in_prefix": "340faee6b313ac3143142f10cd129410a306d39eb584e0f8a814ebdd9e29bfa1", + "size_in_bytes": 6895 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/util/timeout.py", + "path_type": "hardlink", + "sha256": "730ab874c93cee624748192d2b59a2609fbce46fb74f74664f6d2fed2142a67a", + "sha256_in_prefix": "730ab874c93cee624748192d2b59a2609fbce46fb74f74664f6d2fed2142a67a", + "size_in_bytes": 10168 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/util/url.py", + "path_type": "hardlink", + "sha256": "942004ecce66c80f040dd5b4b09bb2c9985507d2bf8f7f258d684702715a5a81", + "sha256_in_prefix": "942004ecce66c80f040dd5b4b09bb2c9985507d2bf8f7f258d684702715a5a81", + "size_in_bytes": 14296 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/util/wait.py", + "path_type": "hardlink", + "sha256": "7ce5f4fdf6a8cc6d8fee25688d0a04d666f277078dc93726fa15c47c5ad3b4b2", + "sha256_in_prefix": "7ce5f4fdf6a8cc6d8fee25688d0a04d666f277078dc93726fa15c47c5ad3b4b2", + "size_in_bytes": 5403 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/vendor.txt", + "path_type": "hardlink", + "sha256": "e0d2a4edf42156c670d14fb4ce69bd4362e01b268f5da7056e7240692d10e846", + "sha256_in_prefix": "e0d2a4edf42156c670d14fb4ce69bd4362e01b268f5da7056e7240692d10e846", + "size_in_bytes": 493 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/webencodings/__init__.py", + "path_type": "hardlink", + "sha256": "a8e04922e3f2ff8072607e96fdb360245faa610d83a14f9d2ac0eee724560978", + "sha256_in_prefix": "a8e04922e3f2ff8072607e96fdb360245faa610d83a14f9d2ac0eee724560978", + "size_in_bytes": 10579 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/webencodings/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "4895a1870f77a3efc45f71c38a54c3f070f80dfd9bc228d4fd2fd7f945ae08e0", + "sha256_in_prefix": "4895a1870f77a3efc45f71c38a54c3f070f80dfd9bc228d4fd2fd7f945ae08e0", + "size_in_bytes": 9708 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/webencodings/__pycache__/labels.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "629af76f8600c75d39d01ef45acbe6edd99a6374dacf208bdf2d2fda6e644c09", + "sha256_in_prefix": "629af76f8600c75d39d01ef45acbe6edd99a6374dacf208bdf2d2fda6e644c09", + "size_in_bytes": 5198 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/webencodings/__pycache__/mklabels.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "b1f44b093279377569f742eb445d673010e69c7a35ad583081d72ee03cfd10b3", + "sha256_in_prefix": "b1f44b093279377569f742eb445d673010e69c7a35ad583081d72ee03cfd10b3", + "size_in_bytes": 1903 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/webencodings/__pycache__/tests.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "5a866f16ca3fa07af5159b69fcc1f44177878b9255ed8db27192a723805c27b9", + "sha256_in_prefix": "5a866f16ca3fa07af5159b69fcc1f44177878b9255ed8db27192a723805c27b9", + "size_in_bytes": 5005 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/webencodings/__pycache__/x_user_defined.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "6218a6fd8a36b1d978ab53d10aecd9aeffe4883663b435d3b1982c7f04d64572", + "sha256_in_prefix": "6218a6fd8a36b1d978ab53d10aecd9aeffe4883663b435d3b1982c7f04d64572", + "size_in_bytes": 2554 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/webencodings/labels.py", + "path_type": "hardlink", + "sha256": "e003bf2b14dd76a1adacbf67b3b9003e36f409c37ac6c088c5b2b7ec763daf71", + "sha256_in_prefix": "e003bf2b14dd76a1adacbf67b3b9003e36f409c37ac6c088c5b2b7ec763daf71", + "size_in_bytes": 8979 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/webencodings/mklabels.py", + "path_type": "hardlink", + "sha256": "19821ecb09e968b9cfd064a273c2c55a0774515bcefe5d4d73a62817ef3b47fe", + "sha256_in_prefix": "19821ecb09e968b9cfd064a273c2c55a0774515bcefe5d4d73a62817ef3b47fe", + "size_in_bytes": 1305 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/webencodings/tests.py", + "path_type": "hardlink", + "sha256": "3ad18bca384d6357ef916d46bcb27f155f59a2a0bd027ca3afbab79314dbccdb", + "sha256_in_prefix": "3ad18bca384d6357ef916d46bcb27f155f59a2a0bd027ca3afbab79314dbccdb", + "size_in_bytes": 6563 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/webencodings/x_user_defined.py", + "path_type": "hardlink", + "sha256": "c8ea9649d9a9cad19f52087f67a258803361a1cf81007cb279e4f5e45af8dad3", + "sha256_in_prefix": "c8ea9649d9a9cad19f52087f67a258803361a1cf81007cb279e4f5e45af8dad3", + "size_in_bytes": 4307 + }, + { + "_path": "lib/python3.10/site-packages/pip/py.typed", + "path_type": "hardlink", + "sha256": "10156fbcf4539ff788a73e5ee50ced48276b317ed0c1ded53fddd14a82256762", + "sha256_in_prefix": "10156fbcf4539ff788a73e5ee50ced48276b317ed0c1ded53fddd14a82256762", + "size_in_bytes": 286 + } + ], + "paths_version": 1 + }, + "requested_spec": "None", + "sha256": "eb38f82c554fbc36664304cc91b719f55f82421fcfb650edc3b695c87add2a50", + "size": 2816873, + "subdir": "osx-arm64", + "timestamp": 1715097127000, + "url": "https://repo.anaconda.com/pkgs/main/osx-arm64/pip-24.0-py310hca03da5_0.conda", + "version": "24.0" +} \ No newline at end of file diff --git a/crates/pet-conda/tests/unix/anaconda3-2023.03/envs/myenv/conda-meta/python-3.10.14-hb885b13_1.json b/crates/pet-conda/tests/unix/anaconda3-2023.03/envs/myenv/conda-meta/python-3.10.14-hb885b13_1.json new file mode 100644 index 00000000..8a159391 --- /dev/null +++ b/crates/pet-conda/tests/unix/anaconda3-2023.03/envs/myenv/conda-meta/python-3.10.14-hb885b13_1.json @@ -0,0 +1,16514 @@ +{ + "build": "hb885b13_1", + "build_number": 1, + "channel": "https://repo.anaconda.com/pkgs/main/osx-arm64", + "constrains": [], + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "libffi >=3.4,<3.5", + "libffi >=3.4,<4.0a0", + "ncurses >=6.4,<7.0a0", + "openssl >=3.0.13,<4.0a0", + "readline >=8.1.2,<9.0a0", + "sqlite >=3.45.3,<4.0a0", + "tk >=8.6.14,<8.7.0a0", + "tzdata", + "xz >=5.4.6,<6.0a0", + "zlib >=1.2.13,<1.3.0a0", + "pip" + ], + "extracted_package_dir": "/Users/donjayamanne/.pyenv/versions/miniconda3-latest/pkgs/python-3.10.14-hb885b13_1", + "files": [ + "bin/2to3", + "bin/2to3-3.10", + "bin/idle3", + "bin/idle3.10", + "bin/pydoc", + "bin/pydoc3", + "bin/pydoc3.10", + "bin/python", + "bin/python3", + "bin/python3-config", + "bin/python3.1", + "bin/python3.10", + "bin/python3.10-config", + "include/python3.10/Python.h", + "include/python3.10/abstract.h", + "include/python3.10/bltinmodule.h", + "include/python3.10/boolobject.h", + "include/python3.10/bytearrayobject.h", + "include/python3.10/bytesobject.h", + "include/python3.10/cellobject.h", + "include/python3.10/ceval.h", + "include/python3.10/classobject.h", + "include/python3.10/code.h", + "include/python3.10/codecs.h", + "include/python3.10/compile.h", + "include/python3.10/complexobject.h", + "include/python3.10/context.h", + "include/python3.10/cpython/abstract.h", + "include/python3.10/cpython/bytearrayobject.h", + "include/python3.10/cpython/bytesobject.h", + "include/python3.10/cpython/ceval.h", + "include/python3.10/cpython/code.h", + "include/python3.10/cpython/compile.h", + "include/python3.10/cpython/dictobject.h", + "include/python3.10/cpython/fileobject.h", + "include/python3.10/cpython/fileutils.h", + "include/python3.10/cpython/frameobject.h", + "include/python3.10/cpython/import.h", + "include/python3.10/cpython/initconfig.h", + "include/python3.10/cpython/interpreteridobject.h", + "include/python3.10/cpython/listobject.h", + "include/python3.10/cpython/methodobject.h", + "include/python3.10/cpython/object.h", + "include/python3.10/cpython/objimpl.h", + "include/python3.10/cpython/odictobject.h", + "include/python3.10/cpython/picklebufobject.h", + "include/python3.10/cpython/pyctype.h", + "include/python3.10/cpython/pydebug.h", + "include/python3.10/cpython/pyerrors.h", + "include/python3.10/cpython/pyfpe.h", + "include/python3.10/cpython/pylifecycle.h", + "include/python3.10/cpython/pymem.h", + "include/python3.10/cpython/pystate.h", + "include/python3.10/cpython/pythonrun.h", + "include/python3.10/cpython/pytime.h", + "include/python3.10/cpython/sysmodule.h", + "include/python3.10/cpython/traceback.h", + "include/python3.10/cpython/tupleobject.h", + "include/python3.10/cpython/unicodeobject.h", + "include/python3.10/datetime.h", + "include/python3.10/descrobject.h", + "include/python3.10/dictobject.h", + "include/python3.10/dynamic_annotations.h", + "include/python3.10/enumobject.h", + "include/python3.10/errcode.h", + "include/python3.10/eval.h", + "include/python3.10/exports.h", + "include/python3.10/fileobject.h", + "include/python3.10/fileutils.h", + "include/python3.10/floatobject.h", + "include/python3.10/frameobject.h", + "include/python3.10/funcobject.h", + "include/python3.10/genericaliasobject.h", + "include/python3.10/genobject.h", + "include/python3.10/import.h", + "include/python3.10/internal/pycore_abstract.h", + "include/python3.10/internal/pycore_accu.h", + "include/python3.10/internal/pycore_asdl.h", + "include/python3.10/internal/pycore_ast.h", + "include/python3.10/internal/pycore_ast_state.h", + "include/python3.10/internal/pycore_atomic.h", + "include/python3.10/internal/pycore_atomic_funcs.h", + "include/python3.10/internal/pycore_bitutils.h", + "include/python3.10/internal/pycore_blocks_output_buffer.h", + "include/python3.10/internal/pycore_bytes_methods.h", + "include/python3.10/internal/pycore_call.h", + "include/python3.10/internal/pycore_ceval.h", + "include/python3.10/internal/pycore_code.h", + "include/python3.10/internal/pycore_compile.h", + "include/python3.10/internal/pycore_condvar.h", + "include/python3.10/internal/pycore_context.h", + "include/python3.10/internal/pycore_dtoa.h", + "include/python3.10/internal/pycore_fileutils.h", + "include/python3.10/internal/pycore_format.h", + "include/python3.10/internal/pycore_gc.h", + "include/python3.10/internal/pycore_getopt.h", + "include/python3.10/internal/pycore_gil.h", + "include/python3.10/internal/pycore_hamt.h", + "include/python3.10/internal/pycore_hashtable.h", + "include/python3.10/internal/pycore_import.h", + "include/python3.10/internal/pycore_initconfig.h", + "include/python3.10/internal/pycore_interp.h", + "include/python3.10/internal/pycore_list.h", + "include/python3.10/internal/pycore_long.h", + "include/python3.10/internal/pycore_moduleobject.h", + "include/python3.10/internal/pycore_object.h", + "include/python3.10/internal/pycore_parser.h", + "include/python3.10/internal/pycore_pathconfig.h", + "include/python3.10/internal/pycore_pyarena.h", + "include/python3.10/internal/pycore_pyerrors.h", + "include/python3.10/internal/pycore_pyhash.h", + "include/python3.10/internal/pycore_pylifecycle.h", + "include/python3.10/internal/pycore_pymem.h", + "include/python3.10/internal/pycore_pystate.h", + "include/python3.10/internal/pycore_runtime.h", + "include/python3.10/internal/pycore_structseq.h", + "include/python3.10/internal/pycore_symtable.h", + "include/python3.10/internal/pycore_sysmodule.h", + "include/python3.10/internal/pycore_traceback.h", + "include/python3.10/internal/pycore_tuple.h", + "include/python3.10/internal/pycore_ucnhash.h", + "include/python3.10/internal/pycore_unionobject.h", + "include/python3.10/internal/pycore_warnings.h", + "include/python3.10/interpreteridobject.h", + "include/python3.10/intrcheck.h", + "include/python3.10/iterobject.h", + "include/python3.10/listobject.h", + "include/python3.10/longintrepr.h", + "include/python3.10/longobject.h", + "include/python3.10/marshal.h", + "include/python3.10/memoryobject.h", + "include/python3.10/methodobject.h", + "include/python3.10/modsupport.h", + "include/python3.10/moduleobject.h", + "include/python3.10/namespaceobject.h", + "include/python3.10/object.h", + "include/python3.10/objimpl.h", + "include/python3.10/opcode.h", + "include/python3.10/osdefs.h", + "include/python3.10/osmodule.h", + "include/python3.10/patchlevel.h", + "include/python3.10/py_curses.h", + "include/python3.10/pycapsule.h", + "include/python3.10/pyconfig.h", + "include/python3.10/pydtrace.h", + "include/python3.10/pyerrors.h", + "include/python3.10/pyexpat.h", + "include/python3.10/pyframe.h", + "include/python3.10/pyhash.h", + "include/python3.10/pylifecycle.h", + "include/python3.10/pymacconfig.h", + "include/python3.10/pymacro.h", + "include/python3.10/pymath.h", + "include/python3.10/pymem.h", + "include/python3.10/pyport.h", + "include/python3.10/pystate.h", + "include/python3.10/pystrcmp.h", + "include/python3.10/pystrhex.h", + "include/python3.10/pystrtod.h", + "include/python3.10/pythonrun.h", + "include/python3.10/pythread.h", + "include/python3.10/rangeobject.h", + "include/python3.10/setobject.h", + "include/python3.10/sliceobject.h", + "include/python3.10/structmember.h", + "include/python3.10/structseq.h", + "include/python3.10/sysmodule.h", + "include/python3.10/token.h", + "include/python3.10/traceback.h", + "include/python3.10/tracemalloc.h", + "include/python3.10/tupleobject.h", + "include/python3.10/typeslots.h", + "include/python3.10/unicodeobject.h", + "include/python3.10/warnings.h", + "include/python3.10/weakrefobject.h", + "lib/libpython3.10.dylib", + "lib/pkgconfig/python-3.10-embed.pc", + "lib/pkgconfig/python-3.10.pc", + "lib/pkgconfig/python3-embed.pc", + "lib/pkgconfig/python3.pc", + "lib/python3.1", + "lib/python3.10/LICENSE.txt", + "lib/python3.10/__future__.py", + "lib/python3.10/__phello__.foo.py", + "lib/python3.10/__pycache__/__future__.cpython-310.pyc", + "lib/python3.10/__pycache__/__phello__.foo.cpython-310.pyc", + "lib/python3.10/__pycache__/_aix_support.cpython-310.pyc", + "lib/python3.10/__pycache__/_bootsubprocess.cpython-310.pyc", + "lib/python3.10/__pycache__/_collections_abc.cpython-310.pyc", + "lib/python3.10/__pycache__/_compat_pickle.cpython-310.pyc", + "lib/python3.10/__pycache__/_compression.cpython-310.pyc", + "lib/python3.10/__pycache__/_markupbase.cpython-310.pyc", + "lib/python3.10/__pycache__/_osx_support.cpython-310.pyc", + "lib/python3.10/__pycache__/_py_abc.cpython-310.pyc", + "lib/python3.10/__pycache__/_pydecimal.cpython-310.pyc", + "lib/python3.10/__pycache__/_pyio.cpython-310.pyc", + "lib/python3.10/__pycache__/_sitebuiltins.cpython-310.pyc", + "lib/python3.10/__pycache__/_strptime.cpython-310.pyc", + "lib/python3.10/__pycache__/_sysconfigdata__darwin_darwin.cpython-310.pyc", + "lib/python3.10/__pycache__/_sysconfigdata_arm64_apple_darwin20_0_0.cpython-310.pyc", + "lib/python3.10/__pycache__/_threading_local.cpython-310.pyc", + "lib/python3.10/__pycache__/_weakrefset.cpython-310.pyc", + "lib/python3.10/__pycache__/abc.cpython-310.pyc", + "lib/python3.10/__pycache__/aifc.cpython-310.pyc", + "lib/python3.10/__pycache__/antigravity.cpython-310.pyc", + "lib/python3.10/__pycache__/argparse.cpython-310.pyc", + "lib/python3.10/__pycache__/ast.cpython-310.pyc", + "lib/python3.10/__pycache__/asynchat.cpython-310.pyc", + "lib/python3.10/__pycache__/asyncore.cpython-310.pyc", + "lib/python3.10/__pycache__/base64.cpython-310.pyc", + "lib/python3.10/__pycache__/bdb.cpython-310.pyc", + "lib/python3.10/__pycache__/binhex.cpython-310.pyc", + "lib/python3.10/__pycache__/bisect.cpython-310.pyc", + "lib/python3.10/__pycache__/bz2.cpython-310.pyc", + "lib/python3.10/__pycache__/cProfile.cpython-310.pyc", + "lib/python3.10/__pycache__/calendar.cpython-310.pyc", + "lib/python3.10/__pycache__/cgi.cpython-310.pyc", + "lib/python3.10/__pycache__/cgitb.cpython-310.pyc", + "lib/python3.10/__pycache__/chunk.cpython-310.pyc", + "lib/python3.10/__pycache__/cmd.cpython-310.pyc", + "lib/python3.10/__pycache__/code.cpython-310.pyc", + "lib/python3.10/__pycache__/codecs.cpython-310.pyc", + "lib/python3.10/__pycache__/codeop.cpython-310.pyc", + "lib/python3.10/__pycache__/colorsys.cpython-310.pyc", + "lib/python3.10/__pycache__/compileall.cpython-310.pyc", + "lib/python3.10/__pycache__/configparser.cpython-310.pyc", + "lib/python3.10/__pycache__/contextlib.cpython-310.pyc", + "lib/python3.10/__pycache__/contextvars.cpython-310.pyc", + "lib/python3.10/__pycache__/copy.cpython-310.pyc", + "lib/python3.10/__pycache__/copyreg.cpython-310.pyc", + "lib/python3.10/__pycache__/crypt.cpython-310.pyc", + "lib/python3.10/__pycache__/csv.cpython-310.pyc", + "lib/python3.10/__pycache__/dataclasses.cpython-310.pyc", + "lib/python3.10/__pycache__/datetime.cpython-310.pyc", + "lib/python3.10/__pycache__/decimal.cpython-310.pyc", + "lib/python3.10/__pycache__/difflib.cpython-310.pyc", + "lib/python3.10/__pycache__/dis.cpython-310.pyc", + "lib/python3.10/__pycache__/doctest.cpython-310.pyc", + "lib/python3.10/__pycache__/enum.cpython-310.pyc", + "lib/python3.10/__pycache__/filecmp.cpython-310.pyc", + "lib/python3.10/__pycache__/fileinput.cpython-310.pyc", + "lib/python3.10/__pycache__/fnmatch.cpython-310.pyc", + "lib/python3.10/__pycache__/fractions.cpython-310.pyc", + "lib/python3.10/__pycache__/ftplib.cpython-310.pyc", + "lib/python3.10/__pycache__/functools.cpython-310.pyc", + "lib/python3.10/__pycache__/genericpath.cpython-310.pyc", + "lib/python3.10/__pycache__/getopt.cpython-310.pyc", + "lib/python3.10/__pycache__/getpass.cpython-310.pyc", + "lib/python3.10/__pycache__/gettext.cpython-310.pyc", + "lib/python3.10/__pycache__/glob.cpython-310.pyc", + "lib/python3.10/__pycache__/graphlib.cpython-310.pyc", + "lib/python3.10/__pycache__/gzip.cpython-310.pyc", + "lib/python3.10/__pycache__/hashlib.cpython-310.pyc", + "lib/python3.10/__pycache__/heapq.cpython-310.pyc", + "lib/python3.10/__pycache__/hmac.cpython-310.pyc", + "lib/python3.10/__pycache__/imaplib.cpython-310.pyc", + "lib/python3.10/__pycache__/imghdr.cpython-310.pyc", + "lib/python3.10/__pycache__/imp.cpython-310.pyc", + "lib/python3.10/__pycache__/inspect.cpython-310.pyc", + "lib/python3.10/__pycache__/io.cpython-310.pyc", + "lib/python3.10/__pycache__/ipaddress.cpython-310.pyc", + "lib/python3.10/__pycache__/keyword.cpython-310.pyc", + "lib/python3.10/__pycache__/linecache.cpython-310.pyc", + "lib/python3.10/__pycache__/locale.cpython-310.pyc", + "lib/python3.10/__pycache__/lzma.cpython-310.pyc", + "lib/python3.10/__pycache__/mailbox.cpython-310.pyc", + "lib/python3.10/__pycache__/mailcap.cpython-310.pyc", + "lib/python3.10/__pycache__/mimetypes.cpython-310.pyc", + "lib/python3.10/__pycache__/modulefinder.cpython-310.pyc", + "lib/python3.10/__pycache__/netrc.cpython-310.pyc", + "lib/python3.10/__pycache__/nntplib.cpython-310.pyc", + "lib/python3.10/__pycache__/ntpath.cpython-310.pyc", + "lib/python3.10/__pycache__/nturl2path.cpython-310.pyc", + "lib/python3.10/__pycache__/numbers.cpython-310.pyc", + "lib/python3.10/__pycache__/opcode.cpython-310.pyc", + "lib/python3.10/__pycache__/operator.cpython-310.pyc", + "lib/python3.10/__pycache__/optparse.cpython-310.pyc", + "lib/python3.10/__pycache__/os.cpython-310.pyc", + "lib/python3.10/__pycache__/pathlib.cpython-310.pyc", + "lib/python3.10/__pycache__/pdb.cpython-310.pyc", + "lib/python3.10/__pycache__/pickle.cpython-310.pyc", + "lib/python3.10/__pycache__/pickletools.cpython-310.pyc", + "lib/python3.10/__pycache__/pipes.cpython-310.pyc", + "lib/python3.10/__pycache__/pkgutil.cpython-310.pyc", + "lib/python3.10/__pycache__/platform.cpython-310.pyc", + "lib/python3.10/__pycache__/plistlib.cpython-310.pyc", + "lib/python3.10/__pycache__/poplib.cpython-310.pyc", + "lib/python3.10/__pycache__/posixpath.cpython-310.pyc", + "lib/python3.10/__pycache__/pprint.cpython-310.pyc", + "lib/python3.10/__pycache__/profile.cpython-310.pyc", + "lib/python3.10/__pycache__/pstats.cpython-310.pyc", + "lib/python3.10/__pycache__/pty.cpython-310.pyc", + "lib/python3.10/__pycache__/py_compile.cpython-310.pyc", + "lib/python3.10/__pycache__/pyclbr.cpython-310.pyc", + "lib/python3.10/__pycache__/pydoc.cpython-310.pyc", + "lib/python3.10/__pycache__/queue.cpython-310.pyc", + "lib/python3.10/__pycache__/quopri.cpython-310.pyc", + "lib/python3.10/__pycache__/random.cpython-310.pyc", + "lib/python3.10/__pycache__/re.cpython-310.pyc", + "lib/python3.10/__pycache__/reprlib.cpython-310.pyc", + "lib/python3.10/__pycache__/rlcompleter.cpython-310.pyc", + "lib/python3.10/__pycache__/runpy.cpython-310.pyc", + "lib/python3.10/__pycache__/sched.cpython-310.pyc", + "lib/python3.10/__pycache__/secrets.cpython-310.pyc", + "lib/python3.10/__pycache__/selectors.cpython-310.pyc", + "lib/python3.10/__pycache__/shelve.cpython-310.pyc", + "lib/python3.10/__pycache__/shlex.cpython-310.pyc", + "lib/python3.10/__pycache__/shutil.cpython-310.pyc", + "lib/python3.10/__pycache__/signal.cpython-310.pyc", + "lib/python3.10/__pycache__/site.cpython-310.pyc", + "lib/python3.10/__pycache__/smtpd.cpython-310.pyc", + "lib/python3.10/__pycache__/smtplib.cpython-310.pyc", + "lib/python3.10/__pycache__/sndhdr.cpython-310.pyc", + "lib/python3.10/__pycache__/socket.cpython-310.pyc", + "lib/python3.10/__pycache__/socketserver.cpython-310.pyc", + "lib/python3.10/__pycache__/sre_compile.cpython-310.pyc", + "lib/python3.10/__pycache__/sre_constants.cpython-310.pyc", + "lib/python3.10/__pycache__/sre_parse.cpython-310.pyc", + "lib/python3.10/__pycache__/ssl.cpython-310.pyc", + "lib/python3.10/__pycache__/stat.cpython-310.pyc", + "lib/python3.10/__pycache__/statistics.cpython-310.pyc", + "lib/python3.10/__pycache__/string.cpython-310.pyc", + "lib/python3.10/__pycache__/stringprep.cpython-310.pyc", + "lib/python3.10/__pycache__/struct.cpython-310.pyc", + "lib/python3.10/__pycache__/subprocess.cpython-310.pyc", + "lib/python3.10/__pycache__/sunau.cpython-310.pyc", + "lib/python3.10/__pycache__/symtable.cpython-310.pyc", + "lib/python3.10/__pycache__/sysconfig.cpython-310.pyc", + "lib/python3.10/__pycache__/tabnanny.cpython-310.pyc", + "lib/python3.10/__pycache__/tarfile.cpython-310.pyc", + "lib/python3.10/__pycache__/telnetlib.cpython-310.pyc", + "lib/python3.10/__pycache__/tempfile.cpython-310.pyc", + "lib/python3.10/__pycache__/textwrap.cpython-310.pyc", + "lib/python3.10/__pycache__/this.cpython-310.pyc", + "lib/python3.10/__pycache__/threading.cpython-310.pyc", + "lib/python3.10/__pycache__/timeit.cpython-310.pyc", + "lib/python3.10/__pycache__/token.cpython-310.pyc", + "lib/python3.10/__pycache__/tokenize.cpython-310.pyc", + "lib/python3.10/__pycache__/trace.cpython-310.pyc", + "lib/python3.10/__pycache__/traceback.cpython-310.pyc", + "lib/python3.10/__pycache__/tracemalloc.cpython-310.pyc", + "lib/python3.10/__pycache__/tty.cpython-310.pyc", + "lib/python3.10/__pycache__/turtle.cpython-310.pyc", + "lib/python3.10/__pycache__/types.cpython-310.pyc", + "lib/python3.10/__pycache__/typing.cpython-310.pyc", + "lib/python3.10/__pycache__/uu.cpython-310.pyc", + "lib/python3.10/__pycache__/uuid.cpython-310.pyc", + "lib/python3.10/__pycache__/warnings.cpython-310.pyc", + "lib/python3.10/__pycache__/wave.cpython-310.pyc", + "lib/python3.10/__pycache__/weakref.cpython-310.pyc", + "lib/python3.10/__pycache__/webbrowser.cpython-310.pyc", + "lib/python3.10/__pycache__/xdrlib.cpython-310.pyc", + "lib/python3.10/__pycache__/zipapp.cpython-310.pyc", + "lib/python3.10/__pycache__/zipfile.cpython-310.pyc", + "lib/python3.10/__pycache__/zipimport.cpython-310.pyc", + "lib/python3.10/_aix_support.py", + "lib/python3.10/_bootsubprocess.py", + "lib/python3.10/_collections_abc.py", + "lib/python3.10/_compat_pickle.py", + "lib/python3.10/_compression.py", + "lib/python3.10/_markupbase.py", + "lib/python3.10/_osx_support.py", + "lib/python3.10/_py_abc.py", + "lib/python3.10/_pydecimal.py", + "lib/python3.10/_pyio.py", + "lib/python3.10/_sitebuiltins.py", + "lib/python3.10/_strptime.py", + "lib/python3.10/_sysconfigdata__darwin_darwin.py", + "lib/python3.10/_sysconfigdata__darwin_darwin.py.orig", + "lib/python3.10/_sysconfigdata_arm64_apple_darwin20_0_0.py", + "lib/python3.10/_threading_local.py", + "lib/python3.10/_weakrefset.py", + "lib/python3.10/abc.py", + "lib/python3.10/aifc.py", + "lib/python3.10/antigravity.py", + "lib/python3.10/argparse.py", + "lib/python3.10/ast.py", + "lib/python3.10/asynchat.py", + "lib/python3.10/asyncio/__init__.py", + "lib/python3.10/asyncio/__main__.py", + "lib/python3.10/asyncio/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/__main__.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/base_events.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/base_futures.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/base_subprocess.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/base_tasks.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/constants.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/coroutines.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/events.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/exceptions.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/format_helpers.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/futures.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/locks.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/log.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/mixins.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/proactor_events.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/protocols.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/queues.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/runners.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/selector_events.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/sslproto.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/staggered.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/streams.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/subprocess.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/tasks.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/threads.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/transports.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/trsock.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/unix_events.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/windows_events.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/windows_utils.cpython-310.pyc", + "lib/python3.10/asyncio/base_events.py", + "lib/python3.10/asyncio/base_futures.py", + "lib/python3.10/asyncio/base_subprocess.py", + "lib/python3.10/asyncio/base_tasks.py", + "lib/python3.10/asyncio/constants.py", + "lib/python3.10/asyncio/coroutines.py", + "lib/python3.10/asyncio/events.py", + "lib/python3.10/asyncio/exceptions.py", + "lib/python3.10/asyncio/format_helpers.py", + "lib/python3.10/asyncio/futures.py", + "lib/python3.10/asyncio/locks.py", + "lib/python3.10/asyncio/log.py", + "lib/python3.10/asyncio/mixins.py", + "lib/python3.10/asyncio/proactor_events.py", + "lib/python3.10/asyncio/protocols.py", + "lib/python3.10/asyncio/queues.py", + "lib/python3.10/asyncio/runners.py", + "lib/python3.10/asyncio/selector_events.py", + "lib/python3.10/asyncio/sslproto.py", + "lib/python3.10/asyncio/staggered.py", + "lib/python3.10/asyncio/streams.py", + "lib/python3.10/asyncio/subprocess.py", + "lib/python3.10/asyncio/tasks.py", + "lib/python3.10/asyncio/threads.py", + "lib/python3.10/asyncio/transports.py", + "lib/python3.10/asyncio/trsock.py", + "lib/python3.10/asyncio/unix_events.py", + "lib/python3.10/asyncio/windows_events.py", + "lib/python3.10/asyncio/windows_utils.py", + "lib/python3.10/asyncore.py", + "lib/python3.10/base64.py", + "lib/python3.10/bdb.py", + "lib/python3.10/binhex.py", + "lib/python3.10/bisect.py", + "lib/python3.10/bz2.py", + "lib/python3.10/cProfile.py", + "lib/python3.10/calendar.py", + "lib/python3.10/cgi.py", + "lib/python3.10/cgitb.py", + "lib/python3.10/chunk.py", + "lib/python3.10/cmd.py", + "lib/python3.10/code.py", + "lib/python3.10/codecs.py", + "lib/python3.10/codeop.py", + "lib/python3.10/collections/__init__.py", + "lib/python3.10/collections/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/collections/__pycache__/abc.cpython-310.pyc", + "lib/python3.10/collections/abc.py", + "lib/python3.10/colorsys.py", + "lib/python3.10/compileall.py", + "lib/python3.10/concurrent/__init__.py", + "lib/python3.10/concurrent/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/concurrent/futures/__init__.py", + "lib/python3.10/concurrent/futures/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/concurrent/futures/__pycache__/_base.cpython-310.pyc", + "lib/python3.10/concurrent/futures/__pycache__/process.cpython-310.pyc", + "lib/python3.10/concurrent/futures/__pycache__/thread.cpython-310.pyc", + "lib/python3.10/concurrent/futures/_base.py", + "lib/python3.10/concurrent/futures/process.py", + "lib/python3.10/concurrent/futures/thread.py", + "lib/python3.10/config-3.10-darwin/Makefile", + "lib/python3.10/config-3.10-darwin/Setup", + "lib/python3.10/config-3.10-darwin/Setup.local", + "lib/python3.10/config-3.10-darwin/__pycache__/python-config.cpython-310.pyc", + "lib/python3.10/config-3.10-darwin/config.c", + "lib/python3.10/config-3.10-darwin/config.c.in", + "lib/python3.10/config-3.10-darwin/install-sh", + "lib/python3.10/config-3.10-darwin/makesetup", + "lib/python3.10/config-3.10-darwin/python-config.py", + "lib/python3.10/config-3.10-darwin/python.o", + "lib/python3.10/configparser.py", + "lib/python3.10/contextlib.py", + "lib/python3.10/contextvars.py", + "lib/python3.10/copy.py", + "lib/python3.10/copyreg.py", + "lib/python3.10/crypt.py", + "lib/python3.10/csv.py", + "lib/python3.10/ctypes/__init__.py", + "lib/python3.10/ctypes/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/ctypes/__pycache__/_aix.cpython-310.pyc", + "lib/python3.10/ctypes/__pycache__/_endian.cpython-310.pyc", + "lib/python3.10/ctypes/__pycache__/util.cpython-310.pyc", + "lib/python3.10/ctypes/__pycache__/wintypes.cpython-310.pyc", + "lib/python3.10/ctypes/_aix.py", + "lib/python3.10/ctypes/_endian.py", + "lib/python3.10/ctypes/macholib/README.ctypes", + "lib/python3.10/ctypes/macholib/__init__.py", + "lib/python3.10/ctypes/macholib/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/ctypes/macholib/__pycache__/dyld.cpython-310.pyc", + "lib/python3.10/ctypes/macholib/__pycache__/dylib.cpython-310.pyc", + "lib/python3.10/ctypes/macholib/__pycache__/framework.cpython-310.pyc", + "lib/python3.10/ctypes/macholib/dyld.py", + "lib/python3.10/ctypes/macholib/dylib.py", + "lib/python3.10/ctypes/macholib/fetch_macholib", + "lib/python3.10/ctypes/macholib/fetch_macholib.bat", + "lib/python3.10/ctypes/macholib/framework.py", + "lib/python3.10/ctypes/util.py", + "lib/python3.10/ctypes/wintypes.py", + "lib/python3.10/curses/__init__.py", + "lib/python3.10/curses/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/curses/__pycache__/ascii.cpython-310.pyc", + "lib/python3.10/curses/__pycache__/has_key.cpython-310.pyc", + "lib/python3.10/curses/__pycache__/panel.cpython-310.pyc", + "lib/python3.10/curses/__pycache__/textpad.cpython-310.pyc", + "lib/python3.10/curses/ascii.py", + "lib/python3.10/curses/has_key.py", + "lib/python3.10/curses/panel.py", + "lib/python3.10/curses/textpad.py", + "lib/python3.10/dataclasses.py", + "lib/python3.10/datetime.py", + "lib/python3.10/dbm/__init__.py", + "lib/python3.10/dbm/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/dbm/__pycache__/dumb.cpython-310.pyc", + "lib/python3.10/dbm/__pycache__/gnu.cpython-310.pyc", + "lib/python3.10/dbm/__pycache__/ndbm.cpython-310.pyc", + "lib/python3.10/dbm/dumb.py", + "lib/python3.10/dbm/gnu.py", + "lib/python3.10/dbm/ndbm.py", + "lib/python3.10/decimal.py", + "lib/python3.10/difflib.py", + "lib/python3.10/dis.py", + "lib/python3.10/distutils/README", + "lib/python3.10/distutils/__init__.py", + "lib/python3.10/distutils/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/_msvccompiler.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/archive_util.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/bcppcompiler.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/ccompiler.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/cmd.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/config.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/core.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/cygwinccompiler.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/debug.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/dep_util.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/dir_util.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/dist.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/errors.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/extension.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/fancy_getopt.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/file_util.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/filelist.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/log.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/msvc9compiler.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/msvccompiler.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/spawn.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/sysconfig.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/text_file.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/unixccompiler.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/util.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/version.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/versionpredicate.cpython-310.pyc", + "lib/python3.10/distutils/_msvccompiler.py", + "lib/python3.10/distutils/archive_util.py", + "lib/python3.10/distutils/bcppcompiler.py", + "lib/python3.10/distutils/ccompiler.py", + "lib/python3.10/distutils/cmd.py", + "lib/python3.10/distutils/command/__init__.py", + "lib/python3.10/distutils/command/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/distutils/command/__pycache__/bdist.cpython-310.pyc", + "lib/python3.10/distutils/command/__pycache__/bdist_dumb.cpython-310.pyc", + "lib/python3.10/distutils/command/__pycache__/bdist_msi.cpython-310.pyc", + "lib/python3.10/distutils/command/__pycache__/bdist_rpm.cpython-310.pyc", + "lib/python3.10/distutils/command/__pycache__/build.cpython-310.pyc", + "lib/python3.10/distutils/command/__pycache__/build_clib.cpython-310.pyc", + "lib/python3.10/distutils/command/__pycache__/build_ext.cpython-310.pyc", + "lib/python3.10/distutils/command/__pycache__/build_py.cpython-310.pyc", + "lib/python3.10/distutils/command/__pycache__/build_scripts.cpython-310.pyc", + "lib/python3.10/distutils/command/__pycache__/check.cpython-310.pyc", + "lib/python3.10/distutils/command/__pycache__/clean.cpython-310.pyc", + "lib/python3.10/distutils/command/__pycache__/config.cpython-310.pyc", + "lib/python3.10/distutils/command/__pycache__/install.cpython-310.pyc", + "lib/python3.10/distutils/command/__pycache__/install_data.cpython-310.pyc", + "lib/python3.10/distutils/command/__pycache__/install_egg_info.cpython-310.pyc", + "lib/python3.10/distutils/command/__pycache__/install_headers.cpython-310.pyc", + "lib/python3.10/distutils/command/__pycache__/install_lib.cpython-310.pyc", + "lib/python3.10/distutils/command/__pycache__/install_scripts.cpython-310.pyc", + "lib/python3.10/distutils/command/__pycache__/register.cpython-310.pyc", + "lib/python3.10/distutils/command/__pycache__/sdist.cpython-310.pyc", + "lib/python3.10/distutils/command/__pycache__/upload.cpython-310.pyc", + "lib/python3.10/distutils/command/bdist.py", + "lib/python3.10/distutils/command/bdist_dumb.py", + "lib/python3.10/distutils/command/bdist_msi.py", + "lib/python3.10/distutils/command/bdist_rpm.py", + "lib/python3.10/distutils/command/build.py", + "lib/python3.10/distutils/command/build_clib.py", + "lib/python3.10/distutils/command/build_ext.py", + "lib/python3.10/distutils/command/build_py.py", + "lib/python3.10/distutils/command/build_scripts.py", + "lib/python3.10/distutils/command/check.py", + "lib/python3.10/distutils/command/clean.py", + "lib/python3.10/distutils/command/command_template", + "lib/python3.10/distutils/command/config.py", + "lib/python3.10/distutils/command/install.py", + "lib/python3.10/distutils/command/install_data.py", + "lib/python3.10/distutils/command/install_egg_info.py", + "lib/python3.10/distutils/command/install_headers.py", + "lib/python3.10/distutils/command/install_lib.py", + "lib/python3.10/distutils/command/install_scripts.py", + "lib/python3.10/distutils/command/register.py", + "lib/python3.10/distutils/command/sdist.py", + "lib/python3.10/distutils/command/upload.py", + "lib/python3.10/distutils/config.py", + "lib/python3.10/distutils/core.py", + "lib/python3.10/distutils/cygwinccompiler.py", + "lib/python3.10/distutils/debug.py", + "lib/python3.10/distutils/dep_util.py", + "lib/python3.10/distutils/dir_util.py", + "lib/python3.10/distutils/dist.py", + "lib/python3.10/distutils/errors.py", + "lib/python3.10/distutils/extension.py", + "lib/python3.10/distutils/fancy_getopt.py", + "lib/python3.10/distutils/file_util.py", + "lib/python3.10/distutils/filelist.py", + "lib/python3.10/distutils/log.py", + "lib/python3.10/distutils/msvc9compiler.py", + "lib/python3.10/distutils/msvccompiler.py", + "lib/python3.10/distutils/spawn.py", + "lib/python3.10/distutils/sysconfig.py", + "lib/python3.10/distutils/tests/Setup.sample", + "lib/python3.10/distutils/tests/__init__.py", + "lib/python3.10/distutils/tests/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/support.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_archive_util.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_bdist.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_bdist_dumb.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_bdist_msi.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_bdist_rpm.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_build.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_build_clib.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_build_ext.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_build_py.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_build_scripts.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_check.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_clean.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_cmd.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_config.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_config_cmd.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_core.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_cygwinccompiler.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_dep_util.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_dir_util.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_dist.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_extension.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_file_util.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_filelist.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_install.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_install_data.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_install_headers.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_install_lib.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_install_scripts.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_log.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_msvc9compiler.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_msvccompiler.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_register.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_sdist.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_spawn.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_sysconfig.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_text_file.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_unixccompiler.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_upload.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_util.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_version.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_versionpredicate.cpython-310.pyc", + "lib/python3.10/distutils/tests/includetest.rst", + "lib/python3.10/distutils/tests/support.py", + "lib/python3.10/distutils/tests/test_archive_util.py", + "lib/python3.10/distutils/tests/test_bdist.py", + "lib/python3.10/distutils/tests/test_bdist_dumb.py", + "lib/python3.10/distutils/tests/test_bdist_msi.py", + "lib/python3.10/distutils/tests/test_bdist_rpm.py", + "lib/python3.10/distutils/tests/test_build.py", + "lib/python3.10/distutils/tests/test_build_clib.py", + "lib/python3.10/distutils/tests/test_build_ext.py", + "lib/python3.10/distutils/tests/test_build_py.py", + "lib/python3.10/distutils/tests/test_build_scripts.py", + "lib/python3.10/distutils/tests/test_check.py", + "lib/python3.10/distutils/tests/test_clean.py", + "lib/python3.10/distutils/tests/test_cmd.py", + "lib/python3.10/distutils/tests/test_config.py", + "lib/python3.10/distutils/tests/test_config_cmd.py", + "lib/python3.10/distutils/tests/test_core.py", + "lib/python3.10/distutils/tests/test_cygwinccompiler.py", + "lib/python3.10/distutils/tests/test_dep_util.py", + "lib/python3.10/distutils/tests/test_dir_util.py", + "lib/python3.10/distutils/tests/test_dist.py", + "lib/python3.10/distutils/tests/test_extension.py", + "lib/python3.10/distutils/tests/test_file_util.py", + "lib/python3.10/distutils/tests/test_filelist.py", + "lib/python3.10/distutils/tests/test_install.py", + "lib/python3.10/distutils/tests/test_install_data.py", + "lib/python3.10/distutils/tests/test_install_headers.py", + "lib/python3.10/distutils/tests/test_install_lib.py", + "lib/python3.10/distutils/tests/test_install_scripts.py", + "lib/python3.10/distutils/tests/test_log.py", + "lib/python3.10/distutils/tests/test_msvc9compiler.py", + "lib/python3.10/distutils/tests/test_msvccompiler.py", + "lib/python3.10/distutils/tests/test_register.py", + "lib/python3.10/distutils/tests/test_sdist.py", + "lib/python3.10/distutils/tests/test_spawn.py", + "lib/python3.10/distutils/tests/test_sysconfig.py", + "lib/python3.10/distutils/tests/test_text_file.py", + "lib/python3.10/distutils/tests/test_unixccompiler.py", + "lib/python3.10/distutils/tests/test_upload.py", + "lib/python3.10/distutils/tests/test_util.py", + "lib/python3.10/distutils/tests/test_version.py", + "lib/python3.10/distutils/tests/test_versionpredicate.py", + "lib/python3.10/distutils/tests/xxmodule.c", + "lib/python3.10/distutils/text_file.py", + "lib/python3.10/distutils/unixccompiler.py", + "lib/python3.10/distutils/util.py", + "lib/python3.10/distutils/version.py", + "lib/python3.10/distutils/versionpredicate.py", + "lib/python3.10/doctest.py", + "lib/python3.10/email/__init__.py", + "lib/python3.10/email/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/email/__pycache__/_encoded_words.cpython-310.pyc", + "lib/python3.10/email/__pycache__/_header_value_parser.cpython-310.pyc", + "lib/python3.10/email/__pycache__/_parseaddr.cpython-310.pyc", + "lib/python3.10/email/__pycache__/_policybase.cpython-310.pyc", + "lib/python3.10/email/__pycache__/base64mime.cpython-310.pyc", + "lib/python3.10/email/__pycache__/charset.cpython-310.pyc", + "lib/python3.10/email/__pycache__/contentmanager.cpython-310.pyc", + "lib/python3.10/email/__pycache__/encoders.cpython-310.pyc", + "lib/python3.10/email/__pycache__/errors.cpython-310.pyc", + "lib/python3.10/email/__pycache__/feedparser.cpython-310.pyc", + "lib/python3.10/email/__pycache__/generator.cpython-310.pyc", + "lib/python3.10/email/__pycache__/header.cpython-310.pyc", + "lib/python3.10/email/__pycache__/headerregistry.cpython-310.pyc", + "lib/python3.10/email/__pycache__/iterators.cpython-310.pyc", + "lib/python3.10/email/__pycache__/message.cpython-310.pyc", + "lib/python3.10/email/__pycache__/parser.cpython-310.pyc", + "lib/python3.10/email/__pycache__/policy.cpython-310.pyc", + "lib/python3.10/email/__pycache__/quoprimime.cpython-310.pyc", + "lib/python3.10/email/__pycache__/utils.cpython-310.pyc", + "lib/python3.10/email/_encoded_words.py", + "lib/python3.10/email/_header_value_parser.py", + "lib/python3.10/email/_parseaddr.py", + "lib/python3.10/email/_policybase.py", + "lib/python3.10/email/architecture.rst", + "lib/python3.10/email/base64mime.py", + "lib/python3.10/email/charset.py", + "lib/python3.10/email/contentmanager.py", + "lib/python3.10/email/encoders.py", + "lib/python3.10/email/errors.py", + "lib/python3.10/email/feedparser.py", + "lib/python3.10/email/generator.py", + "lib/python3.10/email/header.py", + "lib/python3.10/email/headerregistry.py", + "lib/python3.10/email/iterators.py", + "lib/python3.10/email/message.py", + "lib/python3.10/email/mime/__init__.py", + "lib/python3.10/email/mime/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/email/mime/__pycache__/application.cpython-310.pyc", + "lib/python3.10/email/mime/__pycache__/audio.cpython-310.pyc", + "lib/python3.10/email/mime/__pycache__/base.cpython-310.pyc", + "lib/python3.10/email/mime/__pycache__/image.cpython-310.pyc", + "lib/python3.10/email/mime/__pycache__/message.cpython-310.pyc", + "lib/python3.10/email/mime/__pycache__/multipart.cpython-310.pyc", + "lib/python3.10/email/mime/__pycache__/nonmultipart.cpython-310.pyc", + "lib/python3.10/email/mime/__pycache__/text.cpython-310.pyc", + "lib/python3.10/email/mime/application.py", + "lib/python3.10/email/mime/audio.py", + "lib/python3.10/email/mime/base.py", + "lib/python3.10/email/mime/image.py", + "lib/python3.10/email/mime/message.py", + "lib/python3.10/email/mime/multipart.py", + "lib/python3.10/email/mime/nonmultipart.py", + "lib/python3.10/email/mime/text.py", + "lib/python3.10/email/parser.py", + "lib/python3.10/email/policy.py", + "lib/python3.10/email/quoprimime.py", + "lib/python3.10/email/utils.py", + "lib/python3.10/encodings/__init__.py", + "lib/python3.10/encodings/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/aliases.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/ascii.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/base64_codec.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/big5.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/big5hkscs.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/bz2_codec.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/charmap.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp037.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp1006.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp1026.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp1125.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp1140.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp1250.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp1251.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp1252.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp1253.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp1254.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp1255.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp1256.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp1257.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp1258.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp273.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp424.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp437.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp500.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp720.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp737.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp775.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp850.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp852.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp855.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp856.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp857.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp858.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp860.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp861.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp862.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp863.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp864.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp865.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp866.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp869.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp874.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp875.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp932.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp949.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp950.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/euc_jis_2004.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/euc_jisx0213.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/euc_jp.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/euc_kr.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/gb18030.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/gb2312.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/gbk.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/hex_codec.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/hp_roman8.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/hz.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/idna.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/iso2022_jp.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/iso2022_jp_1.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/iso2022_jp_2.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/iso2022_jp_2004.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/iso2022_jp_3.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/iso2022_jp_ext.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/iso2022_kr.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/iso8859_1.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/iso8859_10.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/iso8859_11.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/iso8859_13.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/iso8859_14.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/iso8859_15.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/iso8859_16.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/iso8859_2.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/iso8859_3.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/iso8859_4.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/iso8859_5.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/iso8859_6.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/iso8859_7.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/iso8859_8.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/iso8859_9.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/johab.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/koi8_r.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/koi8_t.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/koi8_u.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/kz1048.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/latin_1.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/mac_arabic.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/mac_croatian.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/mac_cyrillic.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/mac_farsi.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/mac_greek.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/mac_iceland.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/mac_latin2.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/mac_roman.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/mac_romanian.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/mac_turkish.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/mbcs.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/oem.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/palmos.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/ptcp154.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/punycode.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/quopri_codec.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/raw_unicode_escape.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/rot_13.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/shift_jis.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/shift_jis_2004.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/shift_jisx0213.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/tis_620.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/undefined.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/unicode_escape.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/utf_16.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/utf_16_be.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/utf_16_le.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/utf_32.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/utf_32_be.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/utf_32_le.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/utf_7.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/utf_8.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/utf_8_sig.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/uu_codec.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/zlib_codec.cpython-310.pyc", + "lib/python3.10/encodings/aliases.py", + "lib/python3.10/encodings/ascii.py", + "lib/python3.10/encodings/base64_codec.py", + "lib/python3.10/encodings/big5.py", + "lib/python3.10/encodings/big5hkscs.py", + "lib/python3.10/encodings/bz2_codec.py", + "lib/python3.10/encodings/charmap.py", + "lib/python3.10/encodings/cp037.py", + "lib/python3.10/encodings/cp1006.py", + "lib/python3.10/encodings/cp1026.py", + "lib/python3.10/encodings/cp1125.py", + "lib/python3.10/encodings/cp1140.py", + "lib/python3.10/encodings/cp1250.py", + "lib/python3.10/encodings/cp1251.py", + "lib/python3.10/encodings/cp1252.py", + "lib/python3.10/encodings/cp1253.py", + "lib/python3.10/encodings/cp1254.py", + "lib/python3.10/encodings/cp1255.py", + "lib/python3.10/encodings/cp1256.py", + "lib/python3.10/encodings/cp1257.py", + "lib/python3.10/encodings/cp1258.py", + "lib/python3.10/encodings/cp273.py", + "lib/python3.10/encodings/cp424.py", + "lib/python3.10/encodings/cp437.py", + "lib/python3.10/encodings/cp500.py", + "lib/python3.10/encodings/cp720.py", + "lib/python3.10/encodings/cp737.py", + "lib/python3.10/encodings/cp775.py", + "lib/python3.10/encodings/cp850.py", + "lib/python3.10/encodings/cp852.py", + "lib/python3.10/encodings/cp855.py", + "lib/python3.10/encodings/cp856.py", + "lib/python3.10/encodings/cp857.py", + "lib/python3.10/encodings/cp858.py", + "lib/python3.10/encodings/cp860.py", + "lib/python3.10/encodings/cp861.py", + "lib/python3.10/encodings/cp862.py", + "lib/python3.10/encodings/cp863.py", + "lib/python3.10/encodings/cp864.py", + "lib/python3.10/encodings/cp865.py", + "lib/python3.10/encodings/cp866.py", + "lib/python3.10/encodings/cp869.py", + "lib/python3.10/encodings/cp874.py", + "lib/python3.10/encodings/cp875.py", + "lib/python3.10/encodings/cp932.py", + "lib/python3.10/encodings/cp949.py", + "lib/python3.10/encodings/cp950.py", + "lib/python3.10/encodings/euc_jis_2004.py", + "lib/python3.10/encodings/euc_jisx0213.py", + "lib/python3.10/encodings/euc_jp.py", + "lib/python3.10/encodings/euc_kr.py", + "lib/python3.10/encodings/gb18030.py", + "lib/python3.10/encodings/gb2312.py", + "lib/python3.10/encodings/gbk.py", + "lib/python3.10/encodings/hex_codec.py", + "lib/python3.10/encodings/hp_roman8.py", + "lib/python3.10/encodings/hz.py", + "lib/python3.10/encodings/idna.py", + "lib/python3.10/encodings/iso2022_jp.py", + "lib/python3.10/encodings/iso2022_jp_1.py", + "lib/python3.10/encodings/iso2022_jp_2.py", + "lib/python3.10/encodings/iso2022_jp_2004.py", + "lib/python3.10/encodings/iso2022_jp_3.py", + "lib/python3.10/encodings/iso2022_jp_ext.py", + "lib/python3.10/encodings/iso2022_kr.py", + "lib/python3.10/encodings/iso8859_1.py", + "lib/python3.10/encodings/iso8859_10.py", + "lib/python3.10/encodings/iso8859_11.py", + "lib/python3.10/encodings/iso8859_13.py", + "lib/python3.10/encodings/iso8859_14.py", + "lib/python3.10/encodings/iso8859_15.py", + "lib/python3.10/encodings/iso8859_16.py", + "lib/python3.10/encodings/iso8859_2.py", + "lib/python3.10/encodings/iso8859_3.py", + "lib/python3.10/encodings/iso8859_4.py", + "lib/python3.10/encodings/iso8859_5.py", + "lib/python3.10/encodings/iso8859_6.py", + "lib/python3.10/encodings/iso8859_7.py", + "lib/python3.10/encodings/iso8859_8.py", + "lib/python3.10/encodings/iso8859_9.py", + "lib/python3.10/encodings/johab.py", + "lib/python3.10/encodings/koi8_r.py", + "lib/python3.10/encodings/koi8_t.py", + "lib/python3.10/encodings/koi8_u.py", + "lib/python3.10/encodings/kz1048.py", + "lib/python3.10/encodings/latin_1.py", + "lib/python3.10/encodings/mac_arabic.py", + "lib/python3.10/encodings/mac_croatian.py", + "lib/python3.10/encodings/mac_cyrillic.py", + "lib/python3.10/encodings/mac_farsi.py", + "lib/python3.10/encodings/mac_greek.py", + "lib/python3.10/encodings/mac_iceland.py", + "lib/python3.10/encodings/mac_latin2.py", + "lib/python3.10/encodings/mac_roman.py", + "lib/python3.10/encodings/mac_romanian.py", + "lib/python3.10/encodings/mac_turkish.py", + "lib/python3.10/encodings/mbcs.py", + "lib/python3.10/encodings/oem.py", + "lib/python3.10/encodings/palmos.py", + "lib/python3.10/encodings/ptcp154.py", + "lib/python3.10/encodings/punycode.py", + "lib/python3.10/encodings/quopri_codec.py", + "lib/python3.10/encodings/raw_unicode_escape.py", + "lib/python3.10/encodings/rot_13.py", + "lib/python3.10/encodings/shift_jis.py", + "lib/python3.10/encodings/shift_jis_2004.py", + "lib/python3.10/encodings/shift_jisx0213.py", + "lib/python3.10/encodings/tis_620.py", + "lib/python3.10/encodings/undefined.py", + "lib/python3.10/encodings/unicode_escape.py", + "lib/python3.10/encodings/utf_16.py", + "lib/python3.10/encodings/utf_16_be.py", + "lib/python3.10/encodings/utf_16_le.py", + "lib/python3.10/encodings/utf_32.py", + "lib/python3.10/encodings/utf_32_be.py", + "lib/python3.10/encodings/utf_32_le.py", + "lib/python3.10/encodings/utf_7.py", + "lib/python3.10/encodings/utf_8.py", + "lib/python3.10/encodings/utf_8_sig.py", + "lib/python3.10/encodings/uu_codec.py", + "lib/python3.10/encodings/zlib_codec.py", + "lib/python3.10/ensurepip/__init__.py", + "lib/python3.10/ensurepip/__main__.py", + "lib/python3.10/ensurepip/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/ensurepip/__pycache__/__main__.cpython-310.pyc", + "lib/python3.10/ensurepip/__pycache__/_uninstall.cpython-310.pyc", + "lib/python3.10/ensurepip/_bundled/__init__.py", + "lib/python3.10/ensurepip/_bundled/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/ensurepip/_bundled/pip-23.0.1-py3-none-any.whl", + "lib/python3.10/ensurepip/_bundled/setuptools-65.5.0-py3-none-any.whl", + "lib/python3.10/ensurepip/_uninstall.py", + "lib/python3.10/enum.py", + "lib/python3.10/filecmp.py", + "lib/python3.10/fileinput.py", + "lib/python3.10/fnmatch.py", + "lib/python3.10/fractions.py", + "lib/python3.10/ftplib.py", + "lib/python3.10/functools.py", + "lib/python3.10/genericpath.py", + "lib/python3.10/getopt.py", + "lib/python3.10/getpass.py", + "lib/python3.10/gettext.py", + "lib/python3.10/glob.py", + "lib/python3.10/graphlib.py", + "lib/python3.10/gzip.py", + "lib/python3.10/hashlib.py", + "lib/python3.10/heapq.py", + "lib/python3.10/hmac.py", + "lib/python3.10/html/__init__.py", + "lib/python3.10/html/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/html/__pycache__/entities.cpython-310.pyc", + "lib/python3.10/html/__pycache__/parser.cpython-310.pyc", + "lib/python3.10/html/entities.py", + "lib/python3.10/html/parser.py", + "lib/python3.10/http/__init__.py", + "lib/python3.10/http/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/http/__pycache__/client.cpython-310.pyc", + "lib/python3.10/http/__pycache__/cookiejar.cpython-310.pyc", + "lib/python3.10/http/__pycache__/cookies.cpython-310.pyc", + "lib/python3.10/http/__pycache__/server.cpython-310.pyc", + "lib/python3.10/http/client.py", + "lib/python3.10/http/cookiejar.py", + "lib/python3.10/http/cookies.py", + "lib/python3.10/http/server.py", + "lib/python3.10/idlelib/CREDITS.txt", + "lib/python3.10/idlelib/ChangeLog", + "lib/python3.10/idlelib/HISTORY.txt", + "lib/python3.10/idlelib/Icons/README.txt", + "lib/python3.10/idlelib/Icons/folder.gif", + "lib/python3.10/idlelib/Icons/idle.ico", + "lib/python3.10/idlelib/Icons/idle_16.gif", + "lib/python3.10/idlelib/Icons/idle_16.png", + "lib/python3.10/idlelib/Icons/idle_256.png", + "lib/python3.10/idlelib/Icons/idle_32.gif", + "lib/python3.10/idlelib/Icons/idle_32.png", + "lib/python3.10/idlelib/Icons/idle_48.gif", + "lib/python3.10/idlelib/Icons/idle_48.png", + "lib/python3.10/idlelib/Icons/minusnode.gif", + "lib/python3.10/idlelib/Icons/openfolder.gif", + "lib/python3.10/idlelib/Icons/plusnode.gif", + "lib/python3.10/idlelib/Icons/python.gif", + "lib/python3.10/idlelib/Icons/tk.gif", + "lib/python3.10/idlelib/NEWS.txt", + "lib/python3.10/idlelib/NEWS2x.txt", + "lib/python3.10/idlelib/README.txt", + "lib/python3.10/idlelib/TODO.txt", + "lib/python3.10/idlelib/__init__.py", + "lib/python3.10/idlelib/__main__.py", + "lib/python3.10/idlelib/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/__main__.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/autocomplete.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/autocomplete_w.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/autoexpand.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/browser.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/calltip.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/calltip_w.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/codecontext.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/colorizer.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/config.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/config_key.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/configdialog.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/debugger.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/debugger_r.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/debugobj.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/debugobj_r.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/delegator.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/dynoption.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/editor.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/filelist.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/format.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/grep.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/help.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/help_about.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/history.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/hyperparser.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/idle.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/iomenu.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/macosx.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/mainmenu.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/multicall.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/outwin.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/parenmatch.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/pathbrowser.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/percolator.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/pyparse.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/pyshell.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/query.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/redirector.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/replace.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/rpc.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/run.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/runscript.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/scrolledlist.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/search.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/searchbase.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/searchengine.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/sidebar.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/squeezer.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/stackviewer.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/statusbar.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/textview.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/tooltip.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/tree.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/undo.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/util.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/window.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/zoomheight.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/zzdummy.cpython-310.pyc", + "lib/python3.10/idlelib/autocomplete.py", + "lib/python3.10/idlelib/autocomplete_w.py", + "lib/python3.10/idlelib/autoexpand.py", + "lib/python3.10/idlelib/browser.py", + "lib/python3.10/idlelib/calltip.py", + "lib/python3.10/idlelib/calltip_w.py", + "lib/python3.10/idlelib/codecontext.py", + "lib/python3.10/idlelib/colorizer.py", + "lib/python3.10/idlelib/config-extensions.def", + "lib/python3.10/idlelib/config-highlight.def", + "lib/python3.10/idlelib/config-keys.def", + "lib/python3.10/idlelib/config-main.def", + "lib/python3.10/idlelib/config.py", + "lib/python3.10/idlelib/config_key.py", + "lib/python3.10/idlelib/configdialog.py", + "lib/python3.10/idlelib/debugger.py", + "lib/python3.10/idlelib/debugger_r.py", + "lib/python3.10/idlelib/debugobj.py", + "lib/python3.10/idlelib/debugobj_r.py", + "lib/python3.10/idlelib/delegator.py", + "lib/python3.10/idlelib/dynoption.py", + "lib/python3.10/idlelib/editor.py", + "lib/python3.10/idlelib/extend.txt", + "lib/python3.10/idlelib/filelist.py", + "lib/python3.10/idlelib/format.py", + "lib/python3.10/idlelib/grep.py", + "lib/python3.10/idlelib/help.html", + "lib/python3.10/idlelib/help.py", + "lib/python3.10/idlelib/help_about.py", + "lib/python3.10/idlelib/history.py", + "lib/python3.10/idlelib/hyperparser.py", + "lib/python3.10/idlelib/idle.bat", + "lib/python3.10/idlelib/idle.py", + "lib/python3.10/idlelib/idle.pyw", + "lib/python3.10/idlelib/idle_test/README.txt", + "lib/python3.10/idlelib/idle_test/__init__.py", + "lib/python3.10/idlelib/idle_test/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/htest.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/mock_idle.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/mock_tk.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/template.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_autocomplete.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_autocomplete_w.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_autoexpand.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_browser.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_calltip.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_calltip_w.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_codecontext.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_colorizer.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_config.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_config_key.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_configdialog.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_debugger.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_debugger_r.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_debugobj.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_debugobj_r.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_delegator.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_editmenu.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_editor.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_filelist.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_format.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_grep.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_help.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_help_about.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_history.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_hyperparser.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_iomenu.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_macosx.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_mainmenu.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_multicall.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_outwin.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_parenmatch.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_pathbrowser.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_percolator.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_pyparse.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_pyshell.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_query.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_redirector.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_replace.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_rpc.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_run.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_runscript.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_scrolledlist.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_search.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_searchbase.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_searchengine.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_sidebar.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_squeezer.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_stackviewer.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_statusbar.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_text.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_textview.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_tooltip.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_tree.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_undo.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_util.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_warning.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_window.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_zoomheight.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_zzdummy.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/tkinter_testing_utils.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/example_noext", + "lib/python3.10/idlelib/idle_test/example_stub.pyi", + "lib/python3.10/idlelib/idle_test/htest.py", + "lib/python3.10/idlelib/idle_test/mock_idle.py", + "lib/python3.10/idlelib/idle_test/mock_tk.py", + "lib/python3.10/idlelib/idle_test/template.py", + "lib/python3.10/idlelib/idle_test/test_autocomplete.py", + "lib/python3.10/idlelib/idle_test/test_autocomplete_w.py", + "lib/python3.10/idlelib/idle_test/test_autoexpand.py", + "lib/python3.10/idlelib/idle_test/test_browser.py", + "lib/python3.10/idlelib/idle_test/test_calltip.py", + "lib/python3.10/idlelib/idle_test/test_calltip_w.py", + "lib/python3.10/idlelib/idle_test/test_codecontext.py", + "lib/python3.10/idlelib/idle_test/test_colorizer.py", + "lib/python3.10/idlelib/idle_test/test_config.py", + "lib/python3.10/idlelib/idle_test/test_config_key.py", + "lib/python3.10/idlelib/idle_test/test_configdialog.py", + "lib/python3.10/idlelib/idle_test/test_debugger.py", + "lib/python3.10/idlelib/idle_test/test_debugger_r.py", + "lib/python3.10/idlelib/idle_test/test_debugobj.py", + "lib/python3.10/idlelib/idle_test/test_debugobj_r.py", + "lib/python3.10/idlelib/idle_test/test_delegator.py", + "lib/python3.10/idlelib/idle_test/test_editmenu.py", + "lib/python3.10/idlelib/idle_test/test_editor.py", + "lib/python3.10/idlelib/idle_test/test_filelist.py", + "lib/python3.10/idlelib/idle_test/test_format.py", + "lib/python3.10/idlelib/idle_test/test_grep.py", + "lib/python3.10/idlelib/idle_test/test_help.py", + "lib/python3.10/idlelib/idle_test/test_help_about.py", + "lib/python3.10/idlelib/idle_test/test_history.py", + "lib/python3.10/idlelib/idle_test/test_hyperparser.py", + "lib/python3.10/idlelib/idle_test/test_iomenu.py", + "lib/python3.10/idlelib/idle_test/test_macosx.py", + "lib/python3.10/idlelib/idle_test/test_mainmenu.py", + "lib/python3.10/idlelib/idle_test/test_multicall.py", + "lib/python3.10/idlelib/idle_test/test_outwin.py", + "lib/python3.10/idlelib/idle_test/test_parenmatch.py", + "lib/python3.10/idlelib/idle_test/test_pathbrowser.py", + "lib/python3.10/idlelib/idle_test/test_percolator.py", + "lib/python3.10/idlelib/idle_test/test_pyparse.py", + "lib/python3.10/idlelib/idle_test/test_pyshell.py", + "lib/python3.10/idlelib/idle_test/test_query.py", + "lib/python3.10/idlelib/idle_test/test_redirector.py", + "lib/python3.10/idlelib/idle_test/test_replace.py", + "lib/python3.10/idlelib/idle_test/test_rpc.py", + "lib/python3.10/idlelib/idle_test/test_run.py", + "lib/python3.10/idlelib/idle_test/test_runscript.py", + "lib/python3.10/idlelib/idle_test/test_scrolledlist.py", + "lib/python3.10/idlelib/idle_test/test_search.py", + "lib/python3.10/idlelib/idle_test/test_searchbase.py", + "lib/python3.10/idlelib/idle_test/test_searchengine.py", + "lib/python3.10/idlelib/idle_test/test_sidebar.py", + "lib/python3.10/idlelib/idle_test/test_squeezer.py", + "lib/python3.10/idlelib/idle_test/test_stackviewer.py", + "lib/python3.10/idlelib/idle_test/test_statusbar.py", + "lib/python3.10/idlelib/idle_test/test_text.py", + "lib/python3.10/idlelib/idle_test/test_textview.py", + "lib/python3.10/idlelib/idle_test/test_tooltip.py", + "lib/python3.10/idlelib/idle_test/test_tree.py", + "lib/python3.10/idlelib/idle_test/test_undo.py", + "lib/python3.10/idlelib/idle_test/test_util.py", + "lib/python3.10/idlelib/idle_test/test_warning.py", + "lib/python3.10/idlelib/idle_test/test_window.py", + "lib/python3.10/idlelib/idle_test/test_zoomheight.py", + "lib/python3.10/idlelib/idle_test/test_zzdummy.py", + "lib/python3.10/idlelib/idle_test/tkinter_testing_utils.py", + "lib/python3.10/idlelib/iomenu.py", + "lib/python3.10/idlelib/macosx.py", + "lib/python3.10/idlelib/mainmenu.py", + "lib/python3.10/idlelib/multicall.py", + "lib/python3.10/idlelib/outwin.py", + "lib/python3.10/idlelib/parenmatch.py", + "lib/python3.10/idlelib/pathbrowser.py", + "lib/python3.10/idlelib/percolator.py", + "lib/python3.10/idlelib/pyparse.py", + "lib/python3.10/idlelib/pyshell.py", + "lib/python3.10/idlelib/query.py", + "lib/python3.10/idlelib/redirector.py", + "lib/python3.10/idlelib/replace.py", + "lib/python3.10/idlelib/rpc.py", + "lib/python3.10/idlelib/run.py", + "lib/python3.10/idlelib/runscript.py", + "lib/python3.10/idlelib/scrolledlist.py", + "lib/python3.10/idlelib/search.py", + "lib/python3.10/idlelib/searchbase.py", + "lib/python3.10/idlelib/searchengine.py", + "lib/python3.10/idlelib/sidebar.py", + "lib/python3.10/idlelib/squeezer.py", + "lib/python3.10/idlelib/stackviewer.py", + "lib/python3.10/idlelib/statusbar.py", + "lib/python3.10/idlelib/textview.py", + "lib/python3.10/idlelib/tooltip.py", + "lib/python3.10/idlelib/tree.py", + "lib/python3.10/idlelib/undo.py", + "lib/python3.10/idlelib/util.py", + "lib/python3.10/idlelib/window.py", + "lib/python3.10/idlelib/zoomheight.py", + "lib/python3.10/idlelib/zzdummy.py", + "lib/python3.10/imaplib.py", + "lib/python3.10/imghdr.py", + "lib/python3.10/imp.py", + "lib/python3.10/importlib/__init__.py", + "lib/python3.10/importlib/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/importlib/__pycache__/_abc.cpython-310.pyc", + "lib/python3.10/importlib/__pycache__/_adapters.cpython-310.pyc", + "lib/python3.10/importlib/__pycache__/_bootstrap.cpython-310.pyc", + "lib/python3.10/importlib/__pycache__/_bootstrap_external.cpython-310.pyc", + "lib/python3.10/importlib/__pycache__/_common.cpython-310.pyc", + "lib/python3.10/importlib/__pycache__/abc.cpython-310.pyc", + "lib/python3.10/importlib/__pycache__/machinery.cpython-310.pyc", + "lib/python3.10/importlib/__pycache__/readers.cpython-310.pyc", + "lib/python3.10/importlib/__pycache__/resources.cpython-310.pyc", + "lib/python3.10/importlib/__pycache__/util.cpython-310.pyc", + "lib/python3.10/importlib/_abc.py", + "lib/python3.10/importlib/_adapters.py", + "lib/python3.10/importlib/_bootstrap.py", + "lib/python3.10/importlib/_bootstrap_external.py", + "lib/python3.10/importlib/_common.py", + "lib/python3.10/importlib/abc.py", + "lib/python3.10/importlib/machinery.py", + "lib/python3.10/importlib/metadata/__init__.py", + "lib/python3.10/importlib/metadata/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/importlib/metadata/__pycache__/_adapters.cpython-310.pyc", + "lib/python3.10/importlib/metadata/__pycache__/_collections.cpython-310.pyc", + "lib/python3.10/importlib/metadata/__pycache__/_functools.cpython-310.pyc", + "lib/python3.10/importlib/metadata/__pycache__/_itertools.cpython-310.pyc", + "lib/python3.10/importlib/metadata/__pycache__/_meta.cpython-310.pyc", + "lib/python3.10/importlib/metadata/__pycache__/_text.cpython-310.pyc", + "lib/python3.10/importlib/metadata/_adapters.py", + "lib/python3.10/importlib/metadata/_collections.py", + "lib/python3.10/importlib/metadata/_functools.py", + "lib/python3.10/importlib/metadata/_itertools.py", + "lib/python3.10/importlib/metadata/_meta.py", + "lib/python3.10/importlib/metadata/_text.py", + "lib/python3.10/importlib/readers.py", + "lib/python3.10/importlib/resources.py", + "lib/python3.10/importlib/util.py", + "lib/python3.10/inspect.py", + "lib/python3.10/io.py", + "lib/python3.10/ipaddress.py", + "lib/python3.10/json/__init__.py", + "lib/python3.10/json/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/json/__pycache__/decoder.cpython-310.pyc", + "lib/python3.10/json/__pycache__/encoder.cpython-310.pyc", + "lib/python3.10/json/__pycache__/scanner.cpython-310.pyc", + "lib/python3.10/json/__pycache__/tool.cpython-310.pyc", + "lib/python3.10/json/decoder.py", + "lib/python3.10/json/encoder.py", + "lib/python3.10/json/scanner.py", + "lib/python3.10/json/tool.py", + "lib/python3.10/keyword.py", + "lib/python3.10/lib-dynload/_asyncio.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_bisect.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_blake2.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_bz2.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_codecs_cn.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_codecs_hk.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_codecs_iso2022.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_codecs_jp.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_codecs_kr.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_codecs_tw.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_contextvars.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_crypt.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_csv.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_ctypes.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_ctypes_test.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_curses.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_curses_panel.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_datetime.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_dbm.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_decimal.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_elementtree.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_hashlib.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_heapq.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_json.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_lsprof.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_lzma.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_md5.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_multibytecodec.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_multiprocessing.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_opcode.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_pickle.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_posixshmem.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_posixsubprocess.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_queue.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_random.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_scproxy.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_sha1.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_sha256.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_sha3.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_sha512.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_socket.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_sqlite3.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_ssl.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_statistics.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_struct.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_testbuffer.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_testcapi.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_testclinic.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_testimportmultiple.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_testinternalcapi.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_testmultiphase.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_tkinter.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_uuid.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_xxsubinterpreters.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_xxtestfuzz.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_zoneinfo.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/array.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/audioop.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/binascii.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/cmath.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/fcntl.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/grp.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/math.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/mmap.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/nis.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/pyexpat.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/readline.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/resource.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/select.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/syslog.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/termios.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/unicodedata.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/xxlimited.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/xxlimited_35.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/zlib.cpython-310-darwin.so", + "lib/python3.10/lib2to3/Grammar.txt", + "lib/python3.10/lib2to3/Grammar3.10.14.final.0.pickle", + "lib/python3.10/lib2to3/PatternGrammar.txt", + "lib/python3.10/lib2to3/PatternGrammar3.10.14.final.0.pickle", + "lib/python3.10/lib2to3/__init__.py", + "lib/python3.10/lib2to3/__main__.py", + "lib/python3.10/lib2to3/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/lib2to3/__pycache__/__main__.cpython-310.pyc", + "lib/python3.10/lib2to3/__pycache__/btm_matcher.cpython-310.pyc", + "lib/python3.10/lib2to3/__pycache__/btm_utils.cpython-310.pyc", + "lib/python3.10/lib2to3/__pycache__/fixer_base.cpython-310.pyc", + "lib/python3.10/lib2to3/__pycache__/fixer_util.cpython-310.pyc", + "lib/python3.10/lib2to3/__pycache__/main.cpython-310.pyc", + "lib/python3.10/lib2to3/__pycache__/patcomp.cpython-310.pyc", + "lib/python3.10/lib2to3/__pycache__/pygram.cpython-310.pyc", + "lib/python3.10/lib2to3/__pycache__/pytree.cpython-310.pyc", + "lib/python3.10/lib2to3/__pycache__/refactor.cpython-310.pyc", + "lib/python3.10/lib2to3/btm_matcher.py", + "lib/python3.10/lib2to3/btm_utils.py", + "lib/python3.10/lib2to3/fixer_base.py", + "lib/python3.10/lib2to3/fixer_util.py", + "lib/python3.10/lib2to3/fixes/__init__.py", + "lib/python3.10/lib2to3/fixes/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_apply.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_asserts.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_basestring.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_buffer.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_dict.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_except.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_exec.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_execfile.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_exitfunc.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_filter.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_funcattrs.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_future.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_getcwdu.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_has_key.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_idioms.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_import.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_imports.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_imports2.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_input.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_intern.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_isinstance.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_itertools.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_itertools_imports.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_long.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_map.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_metaclass.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_methodattrs.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_ne.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_next.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_nonzero.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_numliterals.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_operator.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_paren.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_print.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_raise.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_raw_input.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_reduce.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_reload.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_renames.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_repr.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_set_literal.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_standarderror.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_sys_exc.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_throw.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_tuple_params.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_types.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_unicode.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_urllib.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_ws_comma.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_xrange.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_xreadlines.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_zip.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/fix_apply.py", + "lib/python3.10/lib2to3/fixes/fix_asserts.py", + "lib/python3.10/lib2to3/fixes/fix_basestring.py", + "lib/python3.10/lib2to3/fixes/fix_buffer.py", + "lib/python3.10/lib2to3/fixes/fix_dict.py", + "lib/python3.10/lib2to3/fixes/fix_except.py", + "lib/python3.10/lib2to3/fixes/fix_exec.py", + "lib/python3.10/lib2to3/fixes/fix_execfile.py", + "lib/python3.10/lib2to3/fixes/fix_exitfunc.py", + "lib/python3.10/lib2to3/fixes/fix_filter.py", + "lib/python3.10/lib2to3/fixes/fix_funcattrs.py", + "lib/python3.10/lib2to3/fixes/fix_future.py", + "lib/python3.10/lib2to3/fixes/fix_getcwdu.py", + "lib/python3.10/lib2to3/fixes/fix_has_key.py", + "lib/python3.10/lib2to3/fixes/fix_idioms.py", + "lib/python3.10/lib2to3/fixes/fix_import.py", + "lib/python3.10/lib2to3/fixes/fix_imports.py", + "lib/python3.10/lib2to3/fixes/fix_imports2.py", + "lib/python3.10/lib2to3/fixes/fix_input.py", + "lib/python3.10/lib2to3/fixes/fix_intern.py", + "lib/python3.10/lib2to3/fixes/fix_isinstance.py", + "lib/python3.10/lib2to3/fixes/fix_itertools.py", + "lib/python3.10/lib2to3/fixes/fix_itertools_imports.py", + "lib/python3.10/lib2to3/fixes/fix_long.py", + "lib/python3.10/lib2to3/fixes/fix_map.py", + "lib/python3.10/lib2to3/fixes/fix_metaclass.py", + "lib/python3.10/lib2to3/fixes/fix_methodattrs.py", + "lib/python3.10/lib2to3/fixes/fix_ne.py", + "lib/python3.10/lib2to3/fixes/fix_next.py", + "lib/python3.10/lib2to3/fixes/fix_nonzero.py", + "lib/python3.10/lib2to3/fixes/fix_numliterals.py", + "lib/python3.10/lib2to3/fixes/fix_operator.py", + "lib/python3.10/lib2to3/fixes/fix_paren.py", + "lib/python3.10/lib2to3/fixes/fix_print.py", + "lib/python3.10/lib2to3/fixes/fix_raise.py", + "lib/python3.10/lib2to3/fixes/fix_raw_input.py", + "lib/python3.10/lib2to3/fixes/fix_reduce.py", + "lib/python3.10/lib2to3/fixes/fix_reload.py", + "lib/python3.10/lib2to3/fixes/fix_renames.py", + "lib/python3.10/lib2to3/fixes/fix_repr.py", + "lib/python3.10/lib2to3/fixes/fix_set_literal.py", + "lib/python3.10/lib2to3/fixes/fix_standarderror.py", + "lib/python3.10/lib2to3/fixes/fix_sys_exc.py", + "lib/python3.10/lib2to3/fixes/fix_throw.py", + "lib/python3.10/lib2to3/fixes/fix_tuple_params.py", + "lib/python3.10/lib2to3/fixes/fix_types.py", + "lib/python3.10/lib2to3/fixes/fix_unicode.py", + "lib/python3.10/lib2to3/fixes/fix_urllib.py", + "lib/python3.10/lib2to3/fixes/fix_ws_comma.py", + "lib/python3.10/lib2to3/fixes/fix_xrange.py", + "lib/python3.10/lib2to3/fixes/fix_xreadlines.py", + "lib/python3.10/lib2to3/fixes/fix_zip.py", + "lib/python3.10/lib2to3/main.py", + "lib/python3.10/lib2to3/patcomp.py", + "lib/python3.10/lib2to3/pgen2/__init__.py", + "lib/python3.10/lib2to3/pgen2/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/lib2to3/pgen2/__pycache__/conv.cpython-310.pyc", + "lib/python3.10/lib2to3/pgen2/__pycache__/driver.cpython-310.pyc", + "lib/python3.10/lib2to3/pgen2/__pycache__/grammar.cpython-310.pyc", + "lib/python3.10/lib2to3/pgen2/__pycache__/literals.cpython-310.pyc", + "lib/python3.10/lib2to3/pgen2/__pycache__/parse.cpython-310.pyc", + "lib/python3.10/lib2to3/pgen2/__pycache__/pgen.cpython-310.pyc", + "lib/python3.10/lib2to3/pgen2/__pycache__/token.cpython-310.pyc", + "lib/python3.10/lib2to3/pgen2/__pycache__/tokenize.cpython-310.pyc", + "lib/python3.10/lib2to3/pgen2/conv.py", + "lib/python3.10/lib2to3/pgen2/driver.py", + "lib/python3.10/lib2to3/pgen2/grammar.py", + "lib/python3.10/lib2to3/pgen2/literals.py", + "lib/python3.10/lib2to3/pgen2/parse.py", + "lib/python3.10/lib2to3/pgen2/pgen.py", + "lib/python3.10/lib2to3/pgen2/token.py", + "lib/python3.10/lib2to3/pgen2/tokenize.py", + "lib/python3.10/lib2to3/pygram.py", + "lib/python3.10/lib2to3/pytree.py", + "lib/python3.10/lib2to3/refactor.py", + "lib/python3.10/lib2to3/tests/__init__.py", + "lib/python3.10/lib2to3/tests/__main__.py", + "lib/python3.10/lib2to3/tests/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/lib2to3/tests/__pycache__/__main__.cpython-310.pyc", + "lib/python3.10/lib2to3/tests/__pycache__/pytree_idempotency.cpython-310.pyc", + "lib/python3.10/lib2to3/tests/__pycache__/support.cpython-310.pyc", + "lib/python3.10/lib2to3/tests/__pycache__/test_all_fixers.cpython-310.pyc", + "lib/python3.10/lib2to3/tests/__pycache__/test_fixers.cpython-310.pyc", + "lib/python3.10/lib2to3/tests/__pycache__/test_main.cpython-310.pyc", + "lib/python3.10/lib2to3/tests/__pycache__/test_parser.cpython-310.pyc", + "lib/python3.10/lib2to3/tests/__pycache__/test_pytree.cpython-310.pyc", + "lib/python3.10/lib2to3/tests/__pycache__/test_refactor.cpython-310.pyc", + "lib/python3.10/lib2to3/tests/__pycache__/test_util.cpython-310.pyc", + "lib/python3.10/lib2to3/tests/data/README", + "lib/python3.10/lib2to3/tests/data/__pycache__/infinite_recursion.cpython-310.pyc", + "lib/python3.10/lib2to3/tests/data/__pycache__/py3_test_grammar.cpython-310.pyc", + "lib/python3.10/lib2to3/tests/data/bom.py", + "lib/python3.10/lib2to3/tests/data/crlf.py", + "lib/python3.10/lib2to3/tests/data/different_encoding.py", + "lib/python3.10/lib2to3/tests/data/false_encoding.py", + "lib/python3.10/lib2to3/tests/data/fixers/__pycache__/bad_order.cpython-310.pyc", + "lib/python3.10/lib2to3/tests/data/fixers/__pycache__/no_fixer_cls.cpython-310.pyc", + "lib/python3.10/lib2to3/tests/data/fixers/__pycache__/parrot_example.cpython-310.pyc", + "lib/python3.10/lib2to3/tests/data/fixers/bad_order.py", + "lib/python3.10/lib2to3/tests/data/fixers/myfixes/__init__.py", + "lib/python3.10/lib2to3/tests/data/fixers/myfixes/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/lib2to3/tests/data/fixers/myfixes/__pycache__/fix_explicit.cpython-310.pyc", + "lib/python3.10/lib2to3/tests/data/fixers/myfixes/__pycache__/fix_first.cpython-310.pyc", + "lib/python3.10/lib2to3/tests/data/fixers/myfixes/__pycache__/fix_last.cpython-310.pyc", + "lib/python3.10/lib2to3/tests/data/fixers/myfixes/__pycache__/fix_parrot.cpython-310.pyc", + "lib/python3.10/lib2to3/tests/data/fixers/myfixes/__pycache__/fix_preorder.cpython-310.pyc", + "lib/python3.10/lib2to3/tests/data/fixers/myfixes/fix_explicit.py", + "lib/python3.10/lib2to3/tests/data/fixers/myfixes/fix_first.py", + "lib/python3.10/lib2to3/tests/data/fixers/myfixes/fix_last.py", + "lib/python3.10/lib2to3/tests/data/fixers/myfixes/fix_parrot.py", + "lib/python3.10/lib2to3/tests/data/fixers/myfixes/fix_preorder.py", + "lib/python3.10/lib2to3/tests/data/fixers/no_fixer_cls.py", + "lib/python3.10/lib2to3/tests/data/fixers/parrot_example.py", + "lib/python3.10/lib2to3/tests/data/infinite_recursion.py", + "lib/python3.10/lib2to3/tests/data/py2_test_grammar.py", + "lib/python3.10/lib2to3/tests/data/py3_test_grammar.py", + "lib/python3.10/lib2to3/tests/pytree_idempotency.py", + "lib/python3.10/lib2to3/tests/support.py", + "lib/python3.10/lib2to3/tests/test_all_fixers.py", + "lib/python3.10/lib2to3/tests/test_fixers.py", + "lib/python3.10/lib2to3/tests/test_main.py", + "lib/python3.10/lib2to3/tests/test_parser.py", + "lib/python3.10/lib2to3/tests/test_pytree.py", + "lib/python3.10/lib2to3/tests/test_refactor.py", + "lib/python3.10/lib2to3/tests/test_util.py", + "lib/python3.10/linecache.py", + "lib/python3.10/locale.py", + "lib/python3.10/logging/__init__.py", + "lib/python3.10/logging/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/logging/__pycache__/config.cpython-310.pyc", + "lib/python3.10/logging/__pycache__/handlers.cpython-310.pyc", + "lib/python3.10/logging/config.py", + "lib/python3.10/logging/handlers.py", + "lib/python3.10/lzma.py", + "lib/python3.10/mailbox.py", + "lib/python3.10/mailcap.py", + "lib/python3.10/mimetypes.py", + "lib/python3.10/modulefinder.py", + "lib/python3.10/multiprocessing/__init__.py", + "lib/python3.10/multiprocessing/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/multiprocessing/__pycache__/connection.cpython-310.pyc", + "lib/python3.10/multiprocessing/__pycache__/context.cpython-310.pyc", + "lib/python3.10/multiprocessing/__pycache__/forkserver.cpython-310.pyc", + "lib/python3.10/multiprocessing/__pycache__/heap.cpython-310.pyc", + "lib/python3.10/multiprocessing/__pycache__/managers.cpython-310.pyc", + "lib/python3.10/multiprocessing/__pycache__/pool.cpython-310.pyc", + "lib/python3.10/multiprocessing/__pycache__/popen_fork.cpython-310.pyc", + "lib/python3.10/multiprocessing/__pycache__/popen_forkserver.cpython-310.pyc", + "lib/python3.10/multiprocessing/__pycache__/popen_spawn_posix.cpython-310.pyc", + "lib/python3.10/multiprocessing/__pycache__/popen_spawn_win32.cpython-310.pyc", + "lib/python3.10/multiprocessing/__pycache__/process.cpython-310.pyc", + "lib/python3.10/multiprocessing/__pycache__/queues.cpython-310.pyc", + "lib/python3.10/multiprocessing/__pycache__/reduction.cpython-310.pyc", + "lib/python3.10/multiprocessing/__pycache__/resource_sharer.cpython-310.pyc", + "lib/python3.10/multiprocessing/__pycache__/resource_tracker.cpython-310.pyc", + "lib/python3.10/multiprocessing/__pycache__/shared_memory.cpython-310.pyc", + "lib/python3.10/multiprocessing/__pycache__/sharedctypes.cpython-310.pyc", + "lib/python3.10/multiprocessing/__pycache__/spawn.cpython-310.pyc", + "lib/python3.10/multiprocessing/__pycache__/synchronize.cpython-310.pyc", + "lib/python3.10/multiprocessing/__pycache__/util.cpython-310.pyc", + "lib/python3.10/multiprocessing/connection.py", + "lib/python3.10/multiprocessing/context.py", + "lib/python3.10/multiprocessing/dummy/__init__.py", + "lib/python3.10/multiprocessing/dummy/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/multiprocessing/dummy/__pycache__/connection.cpython-310.pyc", + "lib/python3.10/multiprocessing/dummy/connection.py", + "lib/python3.10/multiprocessing/forkserver.py", + "lib/python3.10/multiprocessing/heap.py", + "lib/python3.10/multiprocessing/managers.py", + "lib/python3.10/multiprocessing/pool.py", + "lib/python3.10/multiprocessing/popen_fork.py", + "lib/python3.10/multiprocessing/popen_forkserver.py", + "lib/python3.10/multiprocessing/popen_spawn_posix.py", + "lib/python3.10/multiprocessing/popen_spawn_win32.py", + "lib/python3.10/multiprocessing/process.py", + "lib/python3.10/multiprocessing/queues.py", + "lib/python3.10/multiprocessing/reduction.py", + "lib/python3.10/multiprocessing/resource_sharer.py", + "lib/python3.10/multiprocessing/resource_tracker.py", + "lib/python3.10/multiprocessing/shared_memory.py", + "lib/python3.10/multiprocessing/sharedctypes.py", + "lib/python3.10/multiprocessing/spawn.py", + "lib/python3.10/multiprocessing/synchronize.py", + "lib/python3.10/multiprocessing/util.py", + "lib/python3.10/netrc.py", + "lib/python3.10/nntplib.py", + "lib/python3.10/ntpath.py", + "lib/python3.10/nturl2path.py", + "lib/python3.10/numbers.py", + "lib/python3.10/opcode.py", + "lib/python3.10/operator.py", + "lib/python3.10/optparse.py", + "lib/python3.10/os.py", + "lib/python3.10/pathlib.py", + "lib/python3.10/pdb.py", + "lib/python3.10/pickle.py", + "lib/python3.10/pickletools.py", + "lib/python3.10/pipes.py", + "lib/python3.10/pkgutil.py", + "lib/python3.10/platform.py", + "lib/python3.10/plistlib.py", + "lib/python3.10/poplib.py", + "lib/python3.10/posixpath.py", + "lib/python3.10/pprint.py", + "lib/python3.10/profile.py", + "lib/python3.10/pstats.py", + "lib/python3.10/pty.py", + "lib/python3.10/py_compile.py", + "lib/python3.10/pyclbr.py", + "lib/python3.10/pydoc.py", + "lib/python3.10/pydoc_data/__init__.py", + "lib/python3.10/pydoc_data/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/pydoc_data/__pycache__/topics.cpython-310.pyc", + "lib/python3.10/pydoc_data/_pydoc.css", + "lib/python3.10/pydoc_data/topics.py", + "lib/python3.10/queue.py", + "lib/python3.10/quopri.py", + "lib/python3.10/random.py", + "lib/python3.10/re.py", + "lib/python3.10/reprlib.py", + "lib/python3.10/rlcompleter.py", + "lib/python3.10/runpy.py", + "lib/python3.10/sched.py", + "lib/python3.10/secrets.py", + "lib/python3.10/selectors.py", + "lib/python3.10/shelve.py", + "lib/python3.10/shlex.py", + "lib/python3.10/shutil.py", + "lib/python3.10/signal.py", + "lib/python3.10/site-packages/README.txt", + "lib/python3.10/site.py", + "lib/python3.10/smtpd.py", + "lib/python3.10/smtplib.py", + "lib/python3.10/sndhdr.py", + "lib/python3.10/socket.py", + "lib/python3.10/socketserver.py", + "lib/python3.10/sqlite3/__init__.py", + "lib/python3.10/sqlite3/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/sqlite3/__pycache__/dbapi2.cpython-310.pyc", + "lib/python3.10/sqlite3/__pycache__/dump.cpython-310.pyc", + "lib/python3.10/sqlite3/dbapi2.py", + "lib/python3.10/sqlite3/dump.py", + "lib/python3.10/sre_compile.py", + "lib/python3.10/sre_constants.py", + "lib/python3.10/sre_parse.py", + "lib/python3.10/ssl.py", + "lib/python3.10/stat.py", + "lib/python3.10/statistics.py", + "lib/python3.10/string.py", + "lib/python3.10/stringprep.py", + "lib/python3.10/struct.py", + "lib/python3.10/subprocess.py", + "lib/python3.10/sunau.py", + "lib/python3.10/symtable.py", + "lib/python3.10/sysconfig.py", + "lib/python3.10/tabnanny.py", + "lib/python3.10/tarfile.py", + "lib/python3.10/telnetlib.py", + "lib/python3.10/tempfile.py", + "lib/python3.10/test/__init__.py", + "lib/python3.10/test/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/test/__pycache__/test_script_helper.cpython-310.pyc", + "lib/python3.10/test/__pycache__/test_support.cpython-310.pyc", + "lib/python3.10/test/support/__init__.py", + "lib/python3.10/test/support/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/test/support/__pycache__/bytecode_helper.cpython-310.pyc", + "lib/python3.10/test/support/__pycache__/hashlib_helper.cpython-310.pyc", + "lib/python3.10/test/support/__pycache__/import_helper.cpython-310.pyc", + "lib/python3.10/test/support/__pycache__/interpreters.cpython-310.pyc", + "lib/python3.10/test/support/__pycache__/logging_helper.cpython-310.pyc", + "lib/python3.10/test/support/__pycache__/os_helper.cpython-310.pyc", + "lib/python3.10/test/support/__pycache__/script_helper.cpython-310.pyc", + "lib/python3.10/test/support/__pycache__/socket_helper.cpython-310.pyc", + "lib/python3.10/test/support/__pycache__/testresult.cpython-310.pyc", + "lib/python3.10/test/support/__pycache__/threading_helper.cpython-310.pyc", + "lib/python3.10/test/support/__pycache__/warnings_helper.cpython-310.pyc", + "lib/python3.10/test/support/bytecode_helper.py", + "lib/python3.10/test/support/hashlib_helper.py", + "lib/python3.10/test/support/import_helper.py", + "lib/python3.10/test/support/interpreters.py", + "lib/python3.10/test/support/logging_helper.py", + "lib/python3.10/test/support/os_helper.py", + "lib/python3.10/test/support/script_helper.py", + "lib/python3.10/test/support/socket_helper.py", + "lib/python3.10/test/support/testresult.py", + "lib/python3.10/test/support/threading_helper.py", + "lib/python3.10/test/support/warnings_helper.py", + "lib/python3.10/test/test_script_helper.py", + "lib/python3.10/test/test_support.py", + "lib/python3.10/textwrap.py", + "lib/python3.10/this.py", + "lib/python3.10/threading.py", + "lib/python3.10/timeit.py", + "lib/python3.10/tkinter/__init__.py", + "lib/python3.10/tkinter/__main__.py", + "lib/python3.10/tkinter/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/tkinter/__pycache__/__main__.cpython-310.pyc", + "lib/python3.10/tkinter/__pycache__/colorchooser.cpython-310.pyc", + "lib/python3.10/tkinter/__pycache__/commondialog.cpython-310.pyc", + "lib/python3.10/tkinter/__pycache__/constants.cpython-310.pyc", + "lib/python3.10/tkinter/__pycache__/dialog.cpython-310.pyc", + "lib/python3.10/tkinter/__pycache__/dnd.cpython-310.pyc", + "lib/python3.10/tkinter/__pycache__/filedialog.cpython-310.pyc", + "lib/python3.10/tkinter/__pycache__/font.cpython-310.pyc", + "lib/python3.10/tkinter/__pycache__/messagebox.cpython-310.pyc", + "lib/python3.10/tkinter/__pycache__/scrolledtext.cpython-310.pyc", + "lib/python3.10/tkinter/__pycache__/simpledialog.cpython-310.pyc", + "lib/python3.10/tkinter/__pycache__/tix.cpython-310.pyc", + "lib/python3.10/tkinter/__pycache__/ttk.cpython-310.pyc", + "lib/python3.10/tkinter/colorchooser.py", + "lib/python3.10/tkinter/commondialog.py", + "lib/python3.10/tkinter/constants.py", + "lib/python3.10/tkinter/dialog.py", + "lib/python3.10/tkinter/dnd.py", + "lib/python3.10/tkinter/filedialog.py", + "lib/python3.10/tkinter/font.py", + "lib/python3.10/tkinter/messagebox.py", + "lib/python3.10/tkinter/scrolledtext.py", + "lib/python3.10/tkinter/simpledialog.py", + "lib/python3.10/tkinter/tix.py", + "lib/python3.10/tkinter/ttk.py", + "lib/python3.10/token.py", + "lib/python3.10/tokenize.py", + "lib/python3.10/trace.py", + "lib/python3.10/traceback.py", + "lib/python3.10/tracemalloc.py", + "lib/python3.10/tty.py", + "lib/python3.10/turtle.py", + "lib/python3.10/turtledemo/__init__.py", + "lib/python3.10/turtledemo/__main__.py", + "lib/python3.10/turtledemo/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/turtledemo/__pycache__/__main__.cpython-310.pyc", + "lib/python3.10/turtledemo/__pycache__/bytedesign.cpython-310.pyc", + "lib/python3.10/turtledemo/__pycache__/chaos.cpython-310.pyc", + "lib/python3.10/turtledemo/__pycache__/clock.cpython-310.pyc", + "lib/python3.10/turtledemo/__pycache__/colormixer.cpython-310.pyc", + "lib/python3.10/turtledemo/__pycache__/forest.cpython-310.pyc", + "lib/python3.10/turtledemo/__pycache__/fractalcurves.cpython-310.pyc", + "lib/python3.10/turtledemo/__pycache__/lindenmayer.cpython-310.pyc", + "lib/python3.10/turtledemo/__pycache__/minimal_hanoi.cpython-310.pyc", + "lib/python3.10/turtledemo/__pycache__/nim.cpython-310.pyc", + "lib/python3.10/turtledemo/__pycache__/paint.cpython-310.pyc", + "lib/python3.10/turtledemo/__pycache__/peace.cpython-310.pyc", + "lib/python3.10/turtledemo/__pycache__/penrose.cpython-310.pyc", + "lib/python3.10/turtledemo/__pycache__/planet_and_moon.cpython-310.pyc", + "lib/python3.10/turtledemo/__pycache__/rosette.cpython-310.pyc", + "lib/python3.10/turtledemo/__pycache__/round_dance.cpython-310.pyc", + "lib/python3.10/turtledemo/__pycache__/sorting_animate.cpython-310.pyc", + "lib/python3.10/turtledemo/__pycache__/tree.cpython-310.pyc", + "lib/python3.10/turtledemo/__pycache__/two_canvases.cpython-310.pyc", + "lib/python3.10/turtledemo/__pycache__/yinyang.cpython-310.pyc", + "lib/python3.10/turtledemo/bytedesign.py", + "lib/python3.10/turtledemo/chaos.py", + "lib/python3.10/turtledemo/clock.py", + "lib/python3.10/turtledemo/colormixer.py", + "lib/python3.10/turtledemo/forest.py", + "lib/python3.10/turtledemo/fractalcurves.py", + "lib/python3.10/turtledemo/lindenmayer.py", + "lib/python3.10/turtledemo/minimal_hanoi.py", + "lib/python3.10/turtledemo/nim.py", + "lib/python3.10/turtledemo/paint.py", + "lib/python3.10/turtledemo/peace.py", + "lib/python3.10/turtledemo/penrose.py", + "lib/python3.10/turtledemo/planet_and_moon.py", + "lib/python3.10/turtledemo/rosette.py", + "lib/python3.10/turtledemo/round_dance.py", + "lib/python3.10/turtledemo/sorting_animate.py", + "lib/python3.10/turtledemo/tree.py", + "lib/python3.10/turtledemo/turtle.cfg", + "lib/python3.10/turtledemo/two_canvases.py", + "lib/python3.10/turtledemo/yinyang.py", + "lib/python3.10/types.py", + "lib/python3.10/typing.py", + "lib/python3.10/unittest/__init__.py", + "lib/python3.10/unittest/__main__.py", + "lib/python3.10/unittest/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/unittest/__pycache__/__main__.cpython-310.pyc", + "lib/python3.10/unittest/__pycache__/_log.cpython-310.pyc", + "lib/python3.10/unittest/__pycache__/async_case.cpython-310.pyc", + "lib/python3.10/unittest/__pycache__/case.cpython-310.pyc", + "lib/python3.10/unittest/__pycache__/loader.cpython-310.pyc", + "lib/python3.10/unittest/__pycache__/main.cpython-310.pyc", + "lib/python3.10/unittest/__pycache__/mock.cpython-310.pyc", + "lib/python3.10/unittest/__pycache__/result.cpython-310.pyc", + "lib/python3.10/unittest/__pycache__/runner.cpython-310.pyc", + "lib/python3.10/unittest/__pycache__/signals.cpython-310.pyc", + "lib/python3.10/unittest/__pycache__/suite.cpython-310.pyc", + "lib/python3.10/unittest/__pycache__/util.cpython-310.pyc", + "lib/python3.10/unittest/_log.py", + "lib/python3.10/unittest/async_case.py", + "lib/python3.10/unittest/case.py", + "lib/python3.10/unittest/loader.py", + "lib/python3.10/unittest/main.py", + "lib/python3.10/unittest/mock.py", + "lib/python3.10/unittest/result.py", + "lib/python3.10/unittest/runner.py", + "lib/python3.10/unittest/signals.py", + "lib/python3.10/unittest/suite.py", + "lib/python3.10/unittest/util.py", + "lib/python3.10/urllib/__init__.py", + "lib/python3.10/urllib/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/urllib/__pycache__/error.cpython-310.pyc", + "lib/python3.10/urllib/__pycache__/parse.cpython-310.pyc", + "lib/python3.10/urllib/__pycache__/request.cpython-310.pyc", + "lib/python3.10/urllib/__pycache__/response.cpython-310.pyc", + "lib/python3.10/urllib/__pycache__/robotparser.cpython-310.pyc", + "lib/python3.10/urllib/error.py", + "lib/python3.10/urllib/parse.py", + "lib/python3.10/urllib/request.py", + "lib/python3.10/urllib/response.py", + "lib/python3.10/urllib/robotparser.py", + "lib/python3.10/uu.py", + "lib/python3.10/uuid.py", + "lib/python3.10/venv/__init__.py", + "lib/python3.10/venv/__main__.py", + "lib/python3.10/venv/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/venv/__pycache__/__main__.cpython-310.pyc", + "lib/python3.10/venv/scripts/common/Activate.ps1", + "lib/python3.10/venv/scripts/common/activate", + "lib/python3.10/venv/scripts/posix/activate.csh", + "lib/python3.10/venv/scripts/posix/activate.fish", + "lib/python3.10/warnings.py", + "lib/python3.10/wave.py", + "lib/python3.10/weakref.py", + "lib/python3.10/webbrowser.py", + "lib/python3.10/wsgiref/__init__.py", + "lib/python3.10/wsgiref/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/wsgiref/__pycache__/handlers.cpython-310.pyc", + "lib/python3.10/wsgiref/__pycache__/headers.cpython-310.pyc", + "lib/python3.10/wsgiref/__pycache__/simple_server.cpython-310.pyc", + "lib/python3.10/wsgiref/__pycache__/util.cpython-310.pyc", + "lib/python3.10/wsgiref/__pycache__/validate.cpython-310.pyc", + "lib/python3.10/wsgiref/handlers.py", + "lib/python3.10/wsgiref/headers.py", + "lib/python3.10/wsgiref/simple_server.py", + "lib/python3.10/wsgiref/util.py", + "lib/python3.10/wsgiref/validate.py", + "lib/python3.10/xdrlib.py", + "lib/python3.10/xml/__init__.py", + "lib/python3.10/xml/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/xml/dom/NodeFilter.py", + "lib/python3.10/xml/dom/__init__.py", + "lib/python3.10/xml/dom/__pycache__/NodeFilter.cpython-310.pyc", + "lib/python3.10/xml/dom/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/xml/dom/__pycache__/domreg.cpython-310.pyc", + "lib/python3.10/xml/dom/__pycache__/expatbuilder.cpython-310.pyc", + "lib/python3.10/xml/dom/__pycache__/minicompat.cpython-310.pyc", + "lib/python3.10/xml/dom/__pycache__/minidom.cpython-310.pyc", + "lib/python3.10/xml/dom/__pycache__/pulldom.cpython-310.pyc", + "lib/python3.10/xml/dom/__pycache__/xmlbuilder.cpython-310.pyc", + "lib/python3.10/xml/dom/domreg.py", + "lib/python3.10/xml/dom/expatbuilder.py", + "lib/python3.10/xml/dom/minicompat.py", + "lib/python3.10/xml/dom/minidom.py", + "lib/python3.10/xml/dom/pulldom.py", + "lib/python3.10/xml/dom/xmlbuilder.py", + "lib/python3.10/xml/etree/ElementInclude.py", + "lib/python3.10/xml/etree/ElementPath.py", + "lib/python3.10/xml/etree/ElementTree.py", + "lib/python3.10/xml/etree/__init__.py", + "lib/python3.10/xml/etree/__pycache__/ElementInclude.cpython-310.pyc", + "lib/python3.10/xml/etree/__pycache__/ElementPath.cpython-310.pyc", + "lib/python3.10/xml/etree/__pycache__/ElementTree.cpython-310.pyc", + "lib/python3.10/xml/etree/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/xml/etree/__pycache__/cElementTree.cpython-310.pyc", + "lib/python3.10/xml/etree/cElementTree.py", + "lib/python3.10/xml/parsers/__init__.py", + "lib/python3.10/xml/parsers/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/xml/parsers/__pycache__/expat.cpython-310.pyc", + "lib/python3.10/xml/parsers/expat.py", + "lib/python3.10/xml/sax/__init__.py", + "lib/python3.10/xml/sax/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/xml/sax/__pycache__/_exceptions.cpython-310.pyc", + "lib/python3.10/xml/sax/__pycache__/expatreader.cpython-310.pyc", + "lib/python3.10/xml/sax/__pycache__/handler.cpython-310.pyc", + "lib/python3.10/xml/sax/__pycache__/saxutils.cpython-310.pyc", + "lib/python3.10/xml/sax/__pycache__/xmlreader.cpython-310.pyc", + "lib/python3.10/xml/sax/_exceptions.py", + "lib/python3.10/xml/sax/expatreader.py", + "lib/python3.10/xml/sax/handler.py", + "lib/python3.10/xml/sax/saxutils.py", + "lib/python3.10/xml/sax/xmlreader.py", + "lib/python3.10/xmlrpc/__init__.py", + "lib/python3.10/xmlrpc/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/xmlrpc/__pycache__/client.cpython-310.pyc", + "lib/python3.10/xmlrpc/__pycache__/server.cpython-310.pyc", + "lib/python3.10/xmlrpc/client.py", + "lib/python3.10/xmlrpc/server.py", + "lib/python3.10/zipapp.py", + "lib/python3.10/zipfile.py", + "lib/python3.10/zipimport.py", + "lib/python3.10/zoneinfo/__init__.py", + "lib/python3.10/zoneinfo/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/zoneinfo/__pycache__/_common.cpython-310.pyc", + "lib/python3.10/zoneinfo/__pycache__/_tzpath.cpython-310.pyc", + "lib/python3.10/zoneinfo/__pycache__/_zoneinfo.cpython-310.pyc", + "lib/python3.10/zoneinfo/_common.py", + "lib/python3.10/zoneinfo/_tzpath.py", + "lib/python3.10/zoneinfo/_zoneinfo.py", + "share/man/man1/python3.1", + "share/man/man1/python3.10.1" + ], + "fn": "python-3.10.14-hb885b13_1.conda", + "license": "PSF-2.0", + "link": { + "source": "/Users/donjayamanne/.pyenv/versions/miniconda3-latest/pkgs/python-3.10.14-hb885b13_1", + "type": 1 + }, + "md5": "e588c2babb9f2bbfe336b1fc6239efd2", + "name": "python", + "package_tarball_full_path": "/Users/donjayamanne/.pyenv/versions/miniconda3-latest/pkgs/python-3.10.14-hb885b13_1.conda", + "paths_data": { + "paths": [ + { + "_path": "bin/2to3", + "path_type": "softlink", + "sha256": "63e3bc71edf1069d553dd65b9656a3af72dacc18d3879816c0d7ca56c7a99e5a", + "size_in_bytes": 347 + }, + { + "_path": "bin/2to3-3.10", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_9afkyeq1z4/croot/python-split_1715024112201/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_p", + "sha256": "63e3bc71edf1069d553dd65b9656a3af72dacc18d3879816c0d7ca56c7a99e5a", + "sha256_in_prefix": "07381dde907f3702d27b53f026da059884b24ceabfa7bd6df8295ba186bb2e32", + "size_in_bytes": 347 + }, + { + "_path": "bin/idle3", + "path_type": "softlink", + "sha256": "4c06b6d6230a1bebb604eeb1d53abdc8124ec9780c8ee1a824a36837c31ca764", + "size_in_bytes": 345 + }, + { + "_path": "bin/idle3.10", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_9afkyeq1z4/croot/python-split_1715024112201/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_p", + "sha256": "4c06b6d6230a1bebb604eeb1d53abdc8124ec9780c8ee1a824a36837c31ca764", + "sha256_in_prefix": "0c25c701aaf24084bfdaf6f6963e600ebf93d5a7c3a12972ddf1363e3c326441", + "size_in_bytes": 345 + }, + { + "_path": "bin/pydoc", + "path_type": "softlink", + "sha256": "5be6fb185a727d55053317514cb6e16d7d1f728f1424d3aaedac38f89a51c48f", + "size_in_bytes": 330 + }, + { + "_path": "bin/pydoc3", + "path_type": "softlink", + "sha256": "5be6fb185a727d55053317514cb6e16d7d1f728f1424d3aaedac38f89a51c48f", + "size_in_bytes": 330 + }, + { + "_path": "bin/pydoc3.10", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_9afkyeq1z4/croot/python-split_1715024112201/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_p", + "sha256": "5be6fb185a727d55053317514cb6e16d7d1f728f1424d3aaedac38f89a51c48f", + "sha256_in_prefix": "ce63e8c738443dab28a303b1df78d38adee9c38732f55cd3d83307bfbcf832ce", + "size_in_bytes": 330 + }, + { + "_path": "bin/python", + "path_type": "softlink", + "sha256": "6eff3c533c756370bcc64c57d09e25eefc7b7f5a39049db10a8f31c9e1010f5b", + "size_in_bytes": 3864080 + }, + { + "_path": "bin/python3", + "path_type": "softlink", + "sha256": "6eff3c533c756370bcc64c57d09e25eefc7b7f5a39049db10a8f31c9e1010f5b", + "size_in_bytes": 3864080 + }, + { + "_path": "bin/python3-config", + "path_type": "softlink", + "sha256": "c707b82a8c5cc53054769d40dc72386fd3d7ac3cf1719e5721b85e680eecb6ba", + "size_in_bytes": 2289 + }, + { + "_path": "bin/python3.1", + "path_type": "softlink", + "sha256": "6eff3c533c756370bcc64c57d09e25eefc7b7f5a39049db10a8f31c9e1010f5b", + "size_in_bytes": 3864080 + }, + { + "_path": "bin/python3.10", + "file_mode": "binary", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_9afkyeq1z4/croot/python-split_1715024112201/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_p", + "sha256": "6eff3c533c756370bcc64c57d09e25eefc7b7f5a39049db10a8f31c9e1010f5b", + "sha256_in_prefix": "4b8330e350f6a45c0fdb0cd473b566938db4fd7f9475613bb37d7578eaa21846", + "size_in_bytes": 3864080 + }, + { + "_path": "bin/python3.10-config", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_9afkyeq1z4/croot/python-split_1715024112201/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_p", + "sha256": "c707b82a8c5cc53054769d40dc72386fd3d7ac3cf1719e5721b85e680eecb6ba", + "sha256_in_prefix": "bf233aab74afc434e8cbbe86c64a58e9124b3cd2ed328404db9fd808b9f4155a", + "size_in_bytes": 2289 + }, + { + "_path": "include/python3.10/Python.h", + "path_type": "hardlink", + "sha256": "70b04c40833bdfcdd72b0d3771afe67c74340ff2683b7d26b0dc8e95289263a7", + "sha256_in_prefix": "70b04c40833bdfcdd72b0d3771afe67c74340ff2683b7d26b0dc8e95289263a7", + "size_in_bytes": 3224 + }, + { + "_path": "include/python3.10/abstract.h", + "path_type": "hardlink", + "sha256": "8fa291e5ece081b3cbf643fc451f3fc9620571d98471413fca29aeb38ed8b721", + "sha256_in_prefix": "8fa291e5ece081b3cbf643fc451f3fc9620571d98471413fca29aeb38ed8b721", + "size_in_bytes": 31405 + }, + { + "_path": "include/python3.10/bltinmodule.h", + "path_type": "hardlink", + "sha256": "1b5101b4b85409fd910032713906800bbb83580503036469c2a60ac8e80b8f72", + "sha256_in_prefix": "1b5101b4b85409fd910032713906800bbb83580503036469c2a60ac8e80b8f72", + "size_in_bytes": 264 + }, + { + "_path": "include/python3.10/boolobject.h", + "path_type": "hardlink", + "sha256": "3b042a5d69f1eb92648007a1b988490a7a9177c8ac353aad05d786356a313a9f", + "sha256_in_prefix": "3b042a5d69f1eb92648007a1b988490a7a9177c8ac353aad05d786356a313a9f", + "size_in_bytes": 1224 + }, + { + "_path": "include/python3.10/bytearrayobject.h", + "path_type": "hardlink", + "sha256": "a6f332edc796f35283c9ea75bc59b525c82be52129cea32e3371974de08d6ee1", + "sha256_in_prefix": "a6f332edc796f35283c9ea75bc59b525c82be52129cea32e3371974de08d6ee1", + "size_in_bytes": 1484 + }, + { + "_path": "include/python3.10/bytesobject.h", + "path_type": "hardlink", + "sha256": "bd8631c90c3726af7c24380026abc169f76404e14962221a3b53b194e076b504", + "sha256_in_prefix": "bd8631c90c3726af7c24380026abc169f76404e14962221a3b53b194e076b504", + "size_in_bytes": 2593 + }, + { + "_path": "include/python3.10/cellobject.h", + "path_type": "hardlink", + "sha256": "6a68c1f0d44d668f8080e409d174763cfe75ae11f8c4c667b8e8749a5ae0425d", + "sha256_in_prefix": "6a68c1f0d44d668f8080e409d174763cfe75ae11f8c4c667b8e8749a5ae0425d", + "size_in_bytes": 720 + }, + { + "_path": "include/python3.10/ceval.h", + "path_type": "hardlink", + "sha256": "ea78be9d45a17b75b1dd89b6661300a726dc41bce140d63d03bb4e2b44ae564a", + "sha256_in_prefix": "ea78be9d45a17b75b1dd89b6661300a726dc41bce140d63d03bb4e2b44ae564a", + "size_in_bytes": 5703 + }, + { + "_path": "include/python3.10/classobject.h", + "path_type": "hardlink", + "sha256": "0a644a89790992499ad174d492c8d29778d95966498ee569ad8c6d90da54c054", + "sha256_in_prefix": "0a644a89790992499ad174d492c8d29778d95966498ee569ad8c6d90da54c054", + "size_in_bytes": 1657 + }, + { + "_path": "include/python3.10/code.h", + "path_type": "hardlink", + "sha256": "de21eeb3ae7f1314e296727bd6db61cfe496e177a230ed75071e7af5b02d88b5", + "sha256_in_prefix": "de21eeb3ae7f1314e296727bd6db61cfe496e177a230ed75071e7af5b02d88b5", + "size_in_bytes": 318 + }, + { + "_path": "include/python3.10/codecs.h", + "path_type": "hardlink", + "sha256": "0ca3c6e55e7ff62872b47aeeb7379d784b03ebfc61bbd029b67485fe783baac5", + "sha256_in_prefix": "0ca3c6e55e7ff62872b47aeeb7379d784b03ebfc61bbd029b67485fe783baac5", + "size_in_bytes": 7071 + }, + { + "_path": "include/python3.10/compile.h", + "path_type": "hardlink", + "sha256": "28676e6ff63848c7e812c34bb79cd81dfccbc0a9ffc56d5b1439b304df3771ea", + "sha256_in_prefix": "28676e6ff63848c7e812c34bb79cd81dfccbc0a9ffc56d5b1439b304df3771ea", + "size_in_bytes": 520 + }, + { + "_path": "include/python3.10/complexobject.h", + "path_type": "hardlink", + "sha256": "7c224e629e3d2576ccbf045773863dcbef566f89b78d2a78e61418cae9c282cc", + "sha256_in_prefix": "7c224e629e3d2576ccbf045773863dcbef566f89b78d2a78e61418cae9c282cc", + "size_in_bytes": 1806 + }, + { + "_path": "include/python3.10/context.h", + "path_type": "hardlink", + "sha256": "012ef77a9683a015e68728c4f43014921a04db0626c1dc9fbcc48a87d4e1012f", + "sha256_in_prefix": "012ef77a9683a015e68728c4f43014921a04db0626c1dc9fbcc48a87d4e1012f", + "size_in_bytes": 1962 + }, + { + "_path": "include/python3.10/cpython/abstract.h", + "path_type": "hardlink", + "sha256": "b13d64198e99f84bea5012b9231b775a806c33a58e9e41f8d4ae18c1f75807b4", + "sha256_in_prefix": "b13d64198e99f84bea5012b9231b775a806c33a58e9e41f8d4ae18c1f75807b4", + "size_in_bytes": 14054 + }, + { + "_path": "include/python3.10/cpython/bytearrayobject.h", + "path_type": "hardlink", + "sha256": "6c0ff5534ded2fb01ade071fad06e1561ea3ecb55970c4a79b86fd471fa9bd71", + "sha256_in_prefix": "6c0ff5534ded2fb01ade071fad06e1561ea3ecb55970c4a79b86fd471fa9bd71", + "size_in_bytes": 769 + }, + { + "_path": "include/python3.10/cpython/bytesobject.h", + "path_type": "hardlink", + "sha256": "4d11542b30bc0192c2da85de501abce1efc420792595f8186b6b637f9d640f81", + "sha256_in_prefix": "4d11542b30bc0192c2da85de501abce1efc420792595f8186b6b637f9d640f81", + "size_in_bytes": 4119 + }, + { + "_path": "include/python3.10/cpython/ceval.h", + "path_type": "hardlink", + "sha256": "44ad300f734116a2d7a454f762155f20e3d15e92f4ae7ca58f6f7a43b01a7af2", + "sha256_in_prefix": "44ad300f734116a2d7a454f762155f20e3d15e92f4ae7ca58f6f7a43b01a7af2", + "size_in_bytes": 1468 + }, + { + "_path": "include/python3.10/cpython/code.h", + "path_type": "hardlink", + "sha256": "6a1c95f95b2c6bfc764d4331f65455d2b369176eed6e9a1b9164a3d0a2ccee68", + "sha256_in_prefix": "6a1c95f95b2c6bfc764d4331f65455d2b369176eed6e9a1b9164a3d0a2ccee68", + "size_in_bytes": 7570 + }, + { + "_path": "include/python3.10/cpython/compile.h", + "path_type": "hardlink", + "sha256": "87cc83e0e8b89cb0db751222e8104ce05ae694e90affc82c46a78a1f33b59560", + "sha256_in_prefix": "87cc83e0e8b89cb0db751222e8104ce05ae694e90affc82c46a78a1f33b59560", + "size_in_bytes": 2218 + }, + { + "_path": "include/python3.10/cpython/dictobject.h", + "path_type": "hardlink", + "sha256": "4a518731894c42e68002f9e8684a8f28922a1f5aec691c8b3c26b0559bee46a7", + "sha256_in_prefix": "4a518731894c42e68002f9e8684a8f28922a1f5aec691c8b3c26b0559bee46a7", + "size_in_bytes": 3734 + }, + { + "_path": "include/python3.10/cpython/fileobject.h", + "path_type": "hardlink", + "sha256": "fd6bc941073264fcfd5d4447247f2f2cd160faa67df665ec87259773134270be", + "sha256_in_prefix": "fd6bc941073264fcfd5d4447247f2f2cd160faa67df665ec87259773134270be", + "size_in_bytes": 723 + }, + { + "_path": "include/python3.10/cpython/fileutils.h", + "path_type": "hardlink", + "sha256": "4e7f87aadde1de522a6572ed40e7e43403874499f583320d6d96152e032cf15a", + "sha256_in_prefix": "4e7f87aadde1de522a6572ed40e7e43403874499f583320d6d96152e032cf15a", + "size_in_bytes": 4267 + }, + { + "_path": "include/python3.10/cpython/frameobject.h", + "path_type": "hardlink", + "sha256": "57c0eeeea52ec1239c04b963e1c87d37f83300c17f399f90085d980d9250a0d4", + "sha256_in_prefix": "57c0eeeea52ec1239c04b963e1c87d37f83300c17f399f90085d980d9250a0d4", + "size_in_bytes": 3152 + }, + { + "_path": "include/python3.10/cpython/import.h", + "path_type": "hardlink", + "sha256": "dc0e0f96bdde8dfbc5549cabc219a37268e86f6289e254acc349be220260bc28", + "sha256_in_prefix": "dc0e0f96bdde8dfbc5549cabc219a37268e86f6289e254acc349be220260bc28", + "size_in_bytes": 1630 + }, + { + "_path": "include/python3.10/cpython/initconfig.h", + "path_type": "hardlink", + "sha256": "0f13f74ceb46d3259d8ebdd0be61cfe8d050882fc03fd482b2642a0c81f7cada", + "sha256_in_prefix": "0f13f74ceb46d3259d8ebdd0be61cfe8d050882fc03fd482b2642a0c81f7cada", + "size_in_bytes": 7597 + }, + { + "_path": "include/python3.10/cpython/interpreteridobject.h", + "path_type": "hardlink", + "sha256": "8fc79784d556245d7b7f382063ef3797e3aebd0a6b375a95027dd63a5dfa30b6", + "sha256_in_prefix": "8fc79784d556245d7b7f382063ef3797e3aebd0a6b375a95027dd63a5dfa30b6", + "size_in_bytes": 387 + }, + { + "_path": "include/python3.10/cpython/listobject.h", + "path_type": "hardlink", + "sha256": "54a8c329c95c5ff936284e789c9bdbb8a023d325a4b49290b25f156b4bf4fd5a", + "sha256_in_prefix": "54a8c329c95c5ff936284e789c9bdbb8a023d325a4b49290b25f156b4bf4fd5a", + "size_in_bytes": 1243 + }, + { + "_path": "include/python3.10/cpython/methodobject.h", + "path_type": "hardlink", + "sha256": "d0356e04561a145b08aeb5c457d69443fd43875415844cba57aae3f5ec77c6be", + "sha256_in_prefix": "d0356e04561a145b08aeb5c457d69443fd43875415844cba57aae3f5ec77c6be", + "size_in_bytes": 1399 + }, + { + "_path": "include/python3.10/cpython/object.h", + "path_type": "hardlink", + "sha256": "62dc9ee480a1688a64b46458ba6d5752946a41c8c98c5e91c646f751ab06a59d", + "sha256_in_prefix": "62dc9ee480a1688a64b46458ba6d5752946a41c8c98c5e91c646f751ab06a59d", + "size_in_bytes": 19613 + }, + { + "_path": "include/python3.10/cpython/objimpl.h", + "path_type": "hardlink", + "sha256": "a9cb586f7d01b430c267f54c3c31a3ab0c35682f01409a366a4b1fd15d3844a2", + "sha256_in_prefix": "a9cb586f7d01b430c267f54c3c31a3ab0c35682f01409a366a4b1fd15d3844a2", + "size_in_bytes": 3356 + }, + { + "_path": "include/python3.10/cpython/odictobject.h", + "path_type": "hardlink", + "sha256": "ff2b0d77aea871c1edd6f63209489fe70c7c11d4da9c3e2f6ef6858cdb004a0d", + "sha256_in_prefix": "ff2b0d77aea871c1edd6f63209489fe70c7c11d4da9c3e2f6ef6858cdb004a0d", + "size_in_bytes": 1299 + }, + { + "_path": "include/python3.10/cpython/picklebufobject.h", + "path_type": "hardlink", + "sha256": "da3dd5626150aa4e00a4a0199baa582b4db9b9362412a44f9ac20ca80b0086ca", + "sha256_in_prefix": "da3dd5626150aa4e00a4a0199baa582b4db9b9362412a44f9ac20ca80b0086ca", + "size_in_bytes": 846 + }, + { + "_path": "include/python3.10/cpython/pyctype.h", + "path_type": "hardlink", + "sha256": "10b5ccbc210fd2832e9c34849a3952e8db75f0016add89188358b1da6a8f3dbb", + "sha256_in_prefix": "10b5ccbc210fd2832e9c34849a3952e8db75f0016add89188358b1da6a8f3dbb", + "size_in_bytes": 1387 + }, + { + "_path": "include/python3.10/cpython/pydebug.h", + "path_type": "hardlink", + "sha256": "872f99a8bd4d03d9edf3a2d539a137810749c04ee36da531088d3823f74e8e01", + "sha256_in_prefix": "872f99a8bd4d03d9edf3a2d539a137810749c04ee36da531088d3823f74e8e01", + "size_in_bytes": 1093 + }, + { + "_path": "include/python3.10/cpython/pyerrors.h", + "path_type": "hardlink", + "sha256": "6acd662d252f443195eae92bd034d6e318adc0fcd8cd3c758aed2626c77268a9", + "sha256_in_prefix": "6acd662d252f443195eae92bd034d6e318adc0fcd8cd3c758aed2626c77268a9", + "size_in_bytes": 5476 + }, + { + "_path": "include/python3.10/cpython/pyfpe.h", + "path_type": "hardlink", + "sha256": "ea7bfa7d891a0b5372d8b40a57d1b466b7824296e5c3f8d50b1a7cde084429b7", + "sha256_in_prefix": "ea7bfa7d891a0b5372d8b40a57d1b466b7824296e5c3f8d50b1a7cde084429b7", + "size_in_bytes": 444 + }, + { + "_path": "include/python3.10/cpython/pylifecycle.h", + "path_type": "hardlink", + "sha256": "17f4c4198b21510a89fef782ecefaab8afe8c64812674ccaf4df563fcf31a222", + "sha256_in_prefix": "17f4c4198b21510a89fef782ecefaab8afe8c64812674ccaf4df563fcf31a222", + "size_in_bytes": 2095 + }, + { + "_path": "include/python3.10/cpython/pymem.h", + "path_type": "hardlink", + "sha256": "8a3795a9350b10548e8ad6d37dad69be2abd3870a751e67faa32a19a090608db", + "sha256_in_prefix": "8a3795a9350b10548e8ad6d37dad69be2abd3870a751e67faa32a19a090608db", + "size_in_bytes": 3379 + }, + { + "_path": "include/python3.10/cpython/pystate.h", + "path_type": "hardlink", + "sha256": "87381eb1de1a207514496b1d7c7a0ed477c8dc2f569c22dafe77ba8bca953f9b", + "sha256_in_prefix": "87381eb1de1a207514496b1d7c7a0ed477c8dc2f569c22dafe77ba8bca953f9b", + "size_in_bytes": 11914 + }, + { + "_path": "include/python3.10/cpython/pythonrun.h", + "path_type": "hardlink", + "sha256": "da9ac8ec2ae5ac970ca607a1779c0cb519b2fa67992a70171689191ffa4bfc8c", + "sha256_in_prefix": "da9ac8ec2ae5ac970ca607a1779c0cb519b2fa67992a70171689191ffa4bfc8c", + "size_in_bytes": 4811 + }, + { + "_path": "include/python3.10/cpython/pytime.h", + "path_type": "hardlink", + "sha256": "47b9238d98c2634ade6f9a7d93d3e6be7a3634f783c0b5b1918c24eaa7250d0d", + "sha256_in_prefix": "47b9238d98c2634ade6f9a7d93d3e6be7a3634f783c0b5b1918c24eaa7250d0d", + "size_in_bytes": 9196 + }, + { + "_path": "include/python3.10/cpython/sysmodule.h", + "path_type": "hardlink", + "sha256": "fd31927001b8cc323e82e8d2526d5f022823aabae3885368288e1f59ea471f40", + "sha256_in_prefix": "fd31927001b8cc323e82e8d2526d5f022823aabae3885368288e1f59ea471f40", + "size_in_bytes": 506 + }, + { + "_path": "include/python3.10/cpython/traceback.h", + "path_type": "hardlink", + "sha256": "0e0b89cc4e8733f23d07c3e46e87b53e4accc7c27471ed7f997c93b3b39b84fc", + "sha256_in_prefix": "0e0b89cc4e8733f23d07c3e46e87b53e4accc7c27471ed7f997c93b3b39b84fc", + "size_in_bytes": 404 + }, + { + "_path": "include/python3.10/cpython/tupleobject.h", + "path_type": "hardlink", + "sha256": "cbd0b66e2034cc8d2e5d3acab21bd7339c8e6a4046ea97d6736126ff1a2cf521", + "sha256_in_prefix": "cbd0b66e2034cc8d2e5d3acab21bd7339c8e6a4046ea97d6736126ff1a2cf521", + "size_in_bytes": 975 + }, + { + "_path": "include/python3.10/cpython/unicodeobject.h", + "path_type": "hardlink", + "sha256": "211b6e05e38a995d9bb62de99566607a0d2a36b33657a94776560e0ddc4d6fa9", + "sha256_in_prefix": "211b6e05e38a995d9bb62de99566607a0d2a36b33657a94776560e0ddc4d6fa9", + "size_in_bytes": 44284 + }, + { + "_path": "include/python3.10/datetime.h", + "path_type": "hardlink", + "sha256": "7cd737123510f5ddc334cc2550c832bd1ecc1be73b47e46f4c4a5c3ccb9ac1f5", + "sha256_in_prefix": "7cd737123510f5ddc334cc2550c832bd1ecc1be73b47e46f4c4a5c3ccb9ac1f5", + "size_in_bytes": 9635 + }, + { + "_path": "include/python3.10/descrobject.h", + "path_type": "hardlink", + "sha256": "44b4ebe9baf5b325fb79946f9bad3080c77386359b112f03476f1d1854f7b00f", + "sha256_in_prefix": "44b4ebe9baf5b325fb79946f9bad3080c77386359b112f03476f1d1854f7b00f", + "size_in_bytes": 3002 + }, + { + "_path": "include/python3.10/dictobject.h", + "path_type": "hardlink", + "sha256": "4ce1828fefe39470df01f54f3ab1bca679ccd72c19ebfece6b55368fba96ac2d", + "sha256_in_prefix": "4ce1828fefe39470df01f54f3ab1bca679ccd72c19ebfece6b55368fba96ac2d", + "size_in_bytes": 3853 + }, + { + "_path": "include/python3.10/dynamic_annotations.h", + "path_type": "hardlink", + "sha256": "3e4366f7d082835049730358d277a5ad7a60e16d1601f5622f0a045a37c152ac", + "sha256_in_prefix": "3e4366f7d082835049730358d277a5ad7a60e16d1601f5622f0a045a37c152ac", + "size_in_bytes": 22471 + }, + { + "_path": "include/python3.10/enumobject.h", + "path_type": "hardlink", + "sha256": "2244fe250db9995068fe74dce0e23fd70c12b03fd94751d98b773be8f64896b6", + "sha256_in_prefix": "2244fe250db9995068fe74dce0e23fd70c12b03fd94751d98b773be8f64896b6", + "size_in_bytes": 253 + }, + { + "_path": "include/python3.10/errcode.h", + "path_type": "hardlink", + "sha256": "685786771fcc416cba7f3c51e4d5e42af088b29d28fe6661a4b7ac67db27d9b4", + "sha256_in_prefix": "685786771fcc416cba7f3c51e4d5e42af088b29d28fe6661a4b7ac67db27d9b4", + "size_in_bytes": 1700 + }, + { + "_path": "include/python3.10/eval.h", + "path_type": "hardlink", + "sha256": "8ae7000ff2b0801e8be1af374cdb7aea7fce42517c97dd7eff40861cc707c4ca", + "sha256_in_prefix": "8ae7000ff2b0801e8be1af374cdb7aea7fce42517c97dd7eff40861cc707c4ca", + "size_in_bytes": 831 + }, + { + "_path": "include/python3.10/exports.h", + "path_type": "hardlink", + "sha256": "f9242de8f731846164d4446745dd2a737ccdf83f754099018edc90485b1cd445", + "sha256_in_prefix": "f9242de8f731846164d4446745dd2a737ccdf83f754099018edc90485b1cd445", + "size_in_bytes": 1098 + }, + { + "_path": "include/python3.10/fileobject.h", + "path_type": "hardlink", + "sha256": "4c89937726e6c30d62c361b48567a2de1c0533e7dc8ae8f805d9939842d00a7c", + "sha256_in_prefix": "4c89937726e6c30d62c361b48567a2de1c0533e7dc8ae8f805d9939842d00a7c", + "size_in_bytes": 1571 + }, + { + "_path": "include/python3.10/fileutils.h", + "path_type": "hardlink", + "sha256": "95c65af8238d2dedc03fdfc55bf30db0442db8e7c21e6da270548c03365e0274", + "sha256_in_prefix": "95c65af8238d2dedc03fdfc55bf30db0442db8e7c21e6da270548c03365e0274", + "size_in_bytes": 508 + }, + { + "_path": "include/python3.10/floatobject.h", + "path_type": "hardlink", + "sha256": "20bf507cf87f2b3574f1bd1ffd873e3fc6741cc0891b94fdbcf4237bd34b3f6b", + "sha256_in_prefix": "20bf507cf87f2b3574f1bd1ffd873e3fc6741cc0891b94fdbcf4237bd34b3f6b", + "size_in_bytes": 4360 + }, + { + "_path": "include/python3.10/frameobject.h", + "path_type": "hardlink", + "sha256": "b69efe6636f05e79e50b5a1f46e3ed2602ac5d5eda9fb57a2d58d4cdc99edfb7", + "sha256_in_prefix": "b69efe6636f05e79e50b5a1f46e3ed2602ac5d5eda9fb57a2d58d4cdc99edfb7", + "size_in_bytes": 337 + }, + { + "_path": "include/python3.10/funcobject.h", + "path_type": "hardlink", + "sha256": "f6f08f50fd83a0d2d0d2f7ed4b855990e101813331f9d2a8a2aee2b3e59faab1", + "sha256_in_prefix": "f6f08f50fd83a0d2d0d2f7ed4b855990e101813331f9d2a8a2aee2b3e59faab1", + "size_in_bytes": 4257 + }, + { + "_path": "include/python3.10/genericaliasobject.h", + "path_type": "hardlink", + "sha256": "0e53a0b18c114be68eccea9ffd1dd577e204b1f0ada4d3aedc8e7ee0c80fc7f8", + "sha256_in_prefix": "0e53a0b18c114be68eccea9ffd1dd577e204b1f0ada4d3aedc8e7ee0c80fc7f8", + "size_in_bytes": 334 + }, + { + "_path": "include/python3.10/genobject.h", + "path_type": "hardlink", + "sha256": "078f30dc42929446625c6e8bc995392c58224897377a945060fb2527704576ad", + "sha256_in_prefix": "078f30dc42929446625c6e8bc995392c58224897377a945060fb2527704576ad", + "size_in_bytes": 3347 + }, + { + "_path": "include/python3.10/import.h", + "path_type": "hardlink", + "sha256": "f32a4d416cf558d49d797f8d67d9078917258ed5af1daa734755c8be2c8c76b2", + "sha256_in_prefix": "f32a4d416cf558d49d797f8d67d9078917258ed5af1daa734755c8be2c8c76b2", + "size_in_bytes": 3026 + }, + { + "_path": "include/python3.10/internal/pycore_abstract.h", + "path_type": "hardlink", + "sha256": "ac474dbc0e522a5b59cff25c50f02eb75b08bf60b9056d84bdfd06d7202e9af3", + "sha256_in_prefix": "ac474dbc0e522a5b59cff25c50f02eb75b08bf60b9056d84bdfd06d7202e9af3", + "size_in_bytes": 479 + }, + { + "_path": "include/python3.10/internal/pycore_accu.h", + "path_type": "hardlink", + "sha256": "0af5cf048f515646d68566bd8786e973c45a501f23782d80961e390b116adb2b", + "sha256_in_prefix": "0af5cf048f515646d68566bd8786e973c45a501f23782d80961e390b116adb2b", + "size_in_bytes": 1126 + }, + { + "_path": "include/python3.10/internal/pycore_asdl.h", + "path_type": "hardlink", + "sha256": "09bb323e0a4658ffd5b7ee1f9efec74c4ec18cadce97a76c863df5d1fb2e2559", + "sha256_in_prefix": "09bb323e0a4658ffd5b7ee1f9efec74c4ec18cadce97a76c863df5d1fb2e2559", + "size_in_bytes": 2971 + }, + { + "_path": "include/python3.10/internal/pycore_ast.h", + "path_type": "hardlink", + "sha256": "3dcc46771065bb322c71b3e1332675616c25e11dcd19fd76606b85643671d161", + "sha256_in_prefix": "3dcc46771065bb322c71b3e1332675616c25e11dcd19fd76606b85643671d161", + "size_in_bytes": 28828 + }, + { + "_path": "include/python3.10/internal/pycore_ast_state.h", + "path_type": "hardlink", + "sha256": "54a70b39ad33292983bb2b62817ea1d9b9d2357382b9c6e0f3e74e8842e54c9a", + "sha256_in_prefix": "54a70b39ad33292983bb2b62817ea1d9b9d2357382b9c6e0f3e74e8842e54c9a", + "size_in_bytes": 6457 + }, + { + "_path": "include/python3.10/internal/pycore_atomic.h", + "path_type": "hardlink", + "sha256": "95e7118e799ad3faafc8e58a29b2d1f1a4bb94e1aac3273e042f379f8e12d4e6", + "sha256_in_prefix": "95e7118e799ad3faafc8e58a29b2d1f1a4bb94e1aac3273e042f379f8e12d4e6", + "size_in_bytes": 16979 + }, + { + "_path": "include/python3.10/internal/pycore_atomic_funcs.h", + "path_type": "hardlink", + "sha256": "9d5cfa13ad863a0cc1b0ab06861c1f8cfbdc7d730b9c4603e5777a608263d399", + "sha256_in_prefix": "9d5cfa13ad863a0cc1b0ab06861c1f8cfbdc7d730b9c4603e5777a608263d399", + "size_in_bytes": 2438 + }, + { + "_path": "include/python3.10/internal/pycore_bitutils.h", + "path_type": "hardlink", + "sha256": "89e4de7907d949dc9d48c4a919bfdaaab429e9eb82c8329ede41b198125dbdf3", + "sha256_in_prefix": "89e4de7907d949dc9d48c4a919bfdaaab429e9eb82c8329ede41b198125dbdf3", + "size_in_bytes": 5271 + }, + { + "_path": "include/python3.10/internal/pycore_blocks_output_buffer.h", + "path_type": "hardlink", + "sha256": "03fed5054d0d78e3711e73995e484fefb81495c063a5b9ef555c0395d7fc1ebc", + "sha256_in_prefix": "03fed5054d0d78e3711e73995e484fefb81495c063a5b9ef555c0395d7fc1ebc", + "size_in_bytes": 8688 + }, + { + "_path": "include/python3.10/internal/pycore_bytes_methods.h", + "path_type": "hardlink", + "sha256": "1534326dbf027e9bb472be5ccf8b82fab48f3282cc7f6a61629b801fc80afc00", + "sha256_in_prefix": "1534326dbf027e9bb472be5ccf8b82fab48f3282cc7f6a61629b801fc80afc00", + "size_in_bytes": 3384 + }, + { + "_path": "include/python3.10/internal/pycore_call.h", + "path_type": "hardlink", + "sha256": "99ca19ee267b138ed3412505413d3c252cda8b049c42cc7f6f7395d2b438bae6", + "sha256_in_prefix": "99ca19ee267b138ed3412505413d3c252cda8b049c42cc7f6f7395d2b438bae6", + "size_in_bytes": 870 + }, + { + "_path": "include/python3.10/internal/pycore_ceval.h", + "path_type": "hardlink", + "sha256": "a4a18f5e721f650bcf813bd5930f1ecc14fc801488bb5039c250e101e8951b01", + "sha256_in_prefix": "a4a18f5e721f650bcf813bd5930f1ecc14fc801488bb5039c250e101e8951b01", + "size_in_bytes": 3484 + }, + { + "_path": "include/python3.10/internal/pycore_code.h", + "path_type": "hardlink", + "sha256": "461064e166dd278fd527e0bd6215cd04d28abf9d2ca2c9d23ca098425ff806a1", + "sha256_in_prefix": "461064e166dd278fd527e0bd6215cd04d28abf9d2ca2c9d23ca098425ff806a1", + "size_in_bytes": 696 + }, + { + "_path": "include/python3.10/internal/pycore_compile.h", + "path_type": "hardlink", + "sha256": "21506bc00cb04a89618141c76e31b831c0fafdade423c3e5273b98560e0a6d72", + "sha256_in_prefix": "21506bc00cb04a89618141c76e31b831c0fafdade423c3e5273b98560e0a6d72", + "size_in_bytes": 1045 + }, + { + "_path": "include/python3.10/internal/pycore_condvar.h", + "path_type": "hardlink", + "sha256": "3d37e1739052022a8d120096ffc8521e29a4a930c339a70e315dade3fadd62f5", + "sha256_in_prefix": "3d37e1739052022a8d120096ffc8521e29a4a930c339a70e315dade3fadd62f5", + "size_in_bytes": 2809 + }, + { + "_path": "include/python3.10/internal/pycore_context.h", + "path_type": "hardlink", + "sha256": "d8b138e68e09678167dd9e615f036865da3880d6e423ea087f7b87e69a828cbd", + "sha256_in_prefix": "d8b138e68e09678167dd9e615f036865da3880d6e423ea087f7b87e69a828cbd", + "size_in_bytes": 822 + }, + { + "_path": "include/python3.10/internal/pycore_dtoa.h", + "path_type": "hardlink", + "sha256": "fb94584844dc81a7f8093119cc8119790d31c57c53e7ba462d6c9e47ccde6d86", + "sha256_in_prefix": "fb94584844dc81a7f8093119cc8119790d31c57c53e7ba462d6c9e47ccde6d86", + "size_in_bytes": 646 + }, + { + "_path": "include/python3.10/internal/pycore_fileutils.h", + "path_type": "hardlink", + "sha256": "f52733d98961556de9190dff2c8f5453bcd16cb0113b3b93a25e1bf99e68961f", + "sha256_in_prefix": "f52733d98961556de9190dff2c8f5453bcd16cb0113b3b93a25e1bf99e68961f", + "size_in_bytes": 1704 + }, + { + "_path": "include/python3.10/internal/pycore_format.h", + "path_type": "hardlink", + "sha256": "253cc77e6d11ba20d297813e064650fa965b3653f150bd85f805b94db5f3a98d", + "sha256_in_prefix": "253cc77e6d11ba20d297813e064650fa965b3653f150bd85f805b94db5f3a98d", + "size_in_bytes": 480 + }, + { + "_path": "include/python3.10/internal/pycore_gc.h", + "path_type": "hardlink", + "sha256": "cd380a8a2649d6980a5bd912d3acc3d94eebcba5d1350acae26167e43c60662b", + "sha256_in_prefix": "cd380a8a2649d6980a5bd912d3acc3d94eebcba5d1350acae26167e43c60662b", + "size_in_bytes": 6859 + }, + { + "_path": "include/python3.10/internal/pycore_getopt.h", + "path_type": "hardlink", + "sha256": "e93393067b66b557b0300e05c10ee904d4be54cadfb214c5328a9225ad199452", + "sha256_in_prefix": "e93393067b66b557b0300e05c10ee904d4be54cadfb214c5328a9225ad199452", + "size_in_bytes": 490 + }, + { + "_path": "include/python3.10/internal/pycore_gil.h", + "path_type": "hardlink", + "sha256": "cf455aacd5651e5b43547ebe69bb324eab84238d92665df53c1df32434bd0d9b", + "sha256_in_prefix": "cf455aacd5651e5b43547ebe69bb324eab84238d92665df53c1df32434bd0d9b", + "size_in_bytes": 1565 + }, + { + "_path": "include/python3.10/internal/pycore_hamt.h", + "path_type": "hardlink", + "sha256": "a5650972b76b05a4319421a5122493310f0a63bdcee7a068a0c57f79abdd55f4", + "sha256_in_prefix": "a5650972b76b05a4319421a5122493310f0a63bdcee7a068a0c57f79abdd55f4", + "size_in_bytes": 3697 + }, + { + "_path": "include/python3.10/internal/pycore_hashtable.h", + "path_type": "hardlink", + "sha256": "75e903486d6b6e0468770a6bc3895d8b9423c1b64614e38b29a1d65a1d5bfdf7", + "sha256_in_prefix": "75e903486d6b6e0468770a6bc3895d8b9423c1b64614e38b29a1d65a1d5bfdf7", + "size_in_bytes": 4197 + }, + { + "_path": "include/python3.10/internal/pycore_import.h", + "path_type": "hardlink", + "sha256": "1f84fef1c3137f2b122485cf2a5f7c53eb24795ce26631b63ebd239c239af60b", + "sha256_in_prefix": "1f84fef1c3137f2b122485cf2a5f7c53eb24795ce26631b63ebd239c239af60b", + "size_in_bytes": 346 + }, + { + "_path": "include/python3.10/internal/pycore_initconfig.h", + "path_type": "hardlink", + "sha256": "77f6cfec6d35a23180b0a5794893e49790f171e72d97c6d79c0579e4ea11155f", + "sha256_in_prefix": "77f6cfec6d35a23180b0a5794893e49790f171e72d97c6d79c0579e4ea11155f", + "size_in_bytes": 5625 + }, + { + "_path": "include/python3.10/internal/pycore_interp.h", + "path_type": "hardlink", + "sha256": "fa9edb1e1dea5b0536d132d0379d3ead6f43d5c1be8cf2105dbaad3ba4a67b04", + "sha256_in_prefix": "fa9edb1e1dea5b0536d132d0379d3ead6f43d5c1be8cf2105dbaad3ba4a67b04", + "size_in_bytes": 9289 + }, + { + "_path": "include/python3.10/internal/pycore_list.h", + "path_type": "hardlink", + "sha256": "f9531d6503db771166538ec53c69b265f0fe0a16e8f7ee1a90900d6bcd97e1e2", + "sha256_in_prefix": "f9531d6503db771166538ec53c69b265f0fe0a16e8f7ee1a90900d6bcd97e1e2", + "size_in_bytes": 350 + }, + { + "_path": "include/python3.10/internal/pycore_long.h", + "path_type": "hardlink", + "sha256": "b9d61c7e55ca7529f8e3e8825730acf2c1c9cc33ccfb973c1c440e9215aeb454", + "sha256_in_prefix": "b9d61c7e55ca7529f8e3e8825730acf2c1c9cc33ccfb973c1c440e9215aeb454", + "size_in_bytes": 2589 + }, + { + "_path": "include/python3.10/internal/pycore_moduleobject.h", + "path_type": "hardlink", + "sha256": "bfdc9d60f792c180fddc18e01906c442a89d4642e796db9788960d8639a82205", + "sha256_in_prefix": "bfdc9d60f792c180fddc18e01906c442a89d4642e796db9788960d8639a82205", + "size_in_bytes": 1047 + }, + { + "_path": "include/python3.10/internal/pycore_object.h", + "path_type": "hardlink", + "sha256": "55e7e9ae668c7d38cf6e7dceb4c641106b7af9868bbdcb5dcbc44ec6815fba2a", + "sha256_in_prefix": "55e7e9ae668c7d38cf6e7dceb4c641106b7af9868bbdcb5dcbc44ec6815fba2a", + "size_in_bytes": 5989 + }, + { + "_path": "include/python3.10/internal/pycore_parser.h", + "path_type": "hardlink", + "sha256": "05260556eb3974a843ef4528f0b2d287fe0271260d40a901139fca5840585409", + "sha256_in_prefix": "05260556eb3974a843ef4528f0b2d287fe0271260d40a901139fca5840585409", + "size_in_bytes": 626 + }, + { + "_path": "include/python3.10/internal/pycore_pathconfig.h", + "path_type": "hardlink", + "sha256": "b491e40de0c3c1b7b41890ee523de040a62b7114ae77660417aa8eccfc02203f", + "sha256_in_prefix": "b491e40de0c3c1b7b41890ee523de040a62b7114ae77660417aa8eccfc02203f", + "size_in_bytes": 1981 + }, + { + "_path": "include/python3.10/internal/pycore_pyarena.h", + "path_type": "hardlink", + "sha256": "d4f4e513bae78ff985f51ca48fb7d1a4d57055c59393a1eb661e55e6ec3ba61f", + "sha256_in_prefix": "d4f4e513bae78ff985f51ca48fb7d1a4d57055c59393a1eb661e55e6ec3ba61f", + "size_in_bytes": 2733 + }, + { + "_path": "include/python3.10/internal/pycore_pyerrors.h", + "path_type": "hardlink", + "sha256": "6b499fa85237aad6fd350b42a72ffff0870de23e5b1365113cab495381592df9", + "sha256_in_prefix": "6b499fa85237aad6fd350b42a72ffff0870de23e5b1365113cab495381592df9", + "size_in_bytes": 2314 + }, + { + "_path": "include/python3.10/internal/pycore_pyhash.h", + "path_type": "hardlink", + "sha256": "6e9db9d3e7d7245b10e33598b995fc9b51b3952ce17225830d0248c6fa62dd51", + "sha256_in_prefix": "6e9db9d3e7d7245b10e33598b995fc9b51b3952ce17225830d0248c6fa62dd51", + "size_in_bytes": 206 + }, + { + "_path": "include/python3.10/internal/pycore_pylifecycle.h", + "path_type": "hardlink", + "sha256": "6e0f877bd32fb93ef8826b56974c9e01b54463fb4f3a61c6887e3f94d20b5c74", + "sha256_in_prefix": "6e0f877bd32fb93ef8826b56974c9e01b54463fb4f3a61c6887e3f94d20b5c74", + "size_in_bytes": 4940 + }, + { + "_path": "include/python3.10/internal/pycore_pymem.h", + "path_type": "hardlink", + "sha256": "c5b5b4b8379b8fa6b7b9aaf938afc848d70e424f01eaef8fe0fcd493f806faeb", + "sha256_in_prefix": "c5b5b4b8379b8fa6b7b9aaf938afc848d70e424f01eaef8fe0fcd493f806faeb", + "size_in_bytes": 3211 + }, + { + "_path": "include/python3.10/internal/pycore_pystate.h", + "path_type": "hardlink", + "sha256": "32c1b74638a2809d3fdc1889b927a15d13f71c87e1428023b48f0dc684ef22be", + "sha256_in_prefix": "32c1b74638a2809d3fdc1889b927a15d13f71c87e1428023b48f0dc684ef22be", + "size_in_bytes": 3938 + }, + { + "_path": "include/python3.10/internal/pycore_runtime.h", + "path_type": "hardlink", + "sha256": "142ae39d5b7488ae8abf48036f9817914b5aff43924c70264054a7800d1335bc", + "sha256_in_prefix": "142ae39d5b7488ae8abf48036f9817914b5aff43924c70264054a7800d1335bc", + "size_in_bytes": 4902 + }, + { + "_path": "include/python3.10/internal/pycore_structseq.h", + "path_type": "hardlink", + "sha256": "2199afc79e137be35150f4e06fa2f8d9f42ccbea56bcd68d5f3ecc6a2a14660e", + "sha256_in_prefix": "2199afc79e137be35150f4e06fa2f8d9f42ccbea56bcd68d5f3ecc6a2a14660e", + "size_in_bytes": 386 + }, + { + "_path": "include/python3.10/internal/pycore_symtable.h", + "path_type": "hardlink", + "sha256": "514c300c5ce732bb68f7207e502a2726d470d4b7d5265aef0bcb23f69dda5b06", + "sha256_in_prefix": "514c300c5ce732bb68f7207e502a2726d470d4b7d5265aef0bcb23f69dda5b06", + "size_in_bytes": 5578 + }, + { + "_path": "include/python3.10/internal/pycore_sysmodule.h", + "path_type": "hardlink", + "sha256": "091730828d6b60293756f9ed5f700bb77e7f2419f6b05c9fc0f2e02708617fb5", + "sha256_in_prefix": "091730828d6b60293756f9ed5f700bb77e7f2419f6b05c9fc0f2e02708617fb5", + "size_in_bytes": 548 + }, + { + "_path": "include/python3.10/internal/pycore_traceback.h", + "path_type": "hardlink", + "sha256": "d5c76579b88470869ee5b6bf338c5dabb3f7cae8741fcf3f5c0e1e05eefd9e2a", + "sha256_in_prefix": "d5c76579b88470869ee5b6bf338c5dabb3f7cae8741fcf3f5c0e1e05eefd9e2a", + "size_in_bytes": 2970 + }, + { + "_path": "include/python3.10/internal/pycore_tuple.h", + "path_type": "hardlink", + "sha256": "7f44d17d0d9500284c7167c9455e597f3c5b7d712ba27ce8eb696d82fd5d8acd", + "sha256_in_prefix": "7f44d17d0d9500284c7167c9455e597f3c5b7d712ba27ce8eb696d82fd5d8acd", + "size_in_bytes": 425 + }, + { + "_path": "include/python3.10/internal/pycore_ucnhash.h", + "path_type": "hardlink", + "sha256": "6d9077e875703e5db7daf293a6c7ea3d43d1ee84dec137a950f17a26e9348eb5", + "sha256_in_prefix": "6d9077e875703e5db7daf293a6c7ea3d43d1ee84dec137a950f17a26e9348eb5", + "size_in_bytes": 898 + }, + { + "_path": "include/python3.10/internal/pycore_unionobject.h", + "path_type": "hardlink", + "sha256": "8ec5586a3ffac58c3006d227ae4e9868a5e8afd5cdbebcb84b26570ca0097dd6", + "sha256_in_prefix": "8ec5586a3ffac58c3006d227ae4e9868a5e8afd5cdbebcb84b26570ca0097dd6", + "size_in_bytes": 629 + }, + { + "_path": "include/python3.10/internal/pycore_warnings.h", + "path_type": "hardlink", + "sha256": "bb97717b23047f5788708aef722b3c8f761a8ff191a5147681dac18ef6604595", + "sha256_in_prefix": "bb97717b23047f5788708aef722b3c8f761a8ff191a5147681dac18ef6604595", + "size_in_bytes": 633 + }, + { + "_path": "include/python3.10/interpreteridobject.h", + "path_type": "hardlink", + "sha256": "62d060794f7488f365402db81ded3d588b6d7759eb0de9194329fd01a9374cf6", + "sha256_in_prefix": "62d060794f7488f365402db81ded3d588b6d7759eb0de9194329fd01a9374cf6", + "size_in_bytes": 334 + }, + { + "_path": "include/python3.10/intrcheck.h", + "path_type": "hardlink", + "sha256": "696fe17618c579a8cbaad9b86175f60d43ea0b9e8aaaa1d65ad256d53dc163c1", + "sha256_in_prefix": "696fe17618c579a8cbaad9b86175f60d43ea0b9e8aaaa1d65ad256d53dc163c1", + "size_in_bytes": 772 + }, + { + "_path": "include/python3.10/iterobject.h", + "path_type": "hardlink", + "sha256": "fab74e0f2a2cd185f846ade3247b1e348b9ed5b72f875cec7ff6f90e8f167dc3", + "sha256_in_prefix": "fab74e0f2a2cd185f846ade3247b1e348b9ed5b72f875cec7ff6f90e8f167dc3", + "size_in_bytes": 593 + }, + { + "_path": "include/python3.10/listobject.h", + "path_type": "hardlink", + "sha256": "fea25ac3a5d8f0b8678cd77eba73cf9c3797490a24c1e6585bf255982ab48c23", + "sha256_in_prefix": "fea25ac3a5d8f0b8678cd77eba73cf9c3797490a24c1e6585bf255982ab48c23", + "size_in_bytes": 1781 + }, + { + "_path": "include/python3.10/longintrepr.h", + "path_type": "hardlink", + "sha256": "28dddc9f2d5db3e383d1e921a7731bdff683ec394b8fd334f6cba14241d5d244", + "sha256_in_prefix": "28dddc9f2d5db3e383d1e921a7731bdff683ec394b8fd334f6cba14241d5d244", + "size_in_bytes": 3799 + }, + { + "_path": "include/python3.10/longobject.h", + "path_type": "hardlink", + "sha256": "7159278389a2a2bc9d27dd8def44800c6fbf966582d112021c19d5c4278b03aa", + "sha256_in_prefix": "7159278389a2a2bc9d27dd8def44800c6fbf966582d112021c19d5c4278b03aa", + "size_in_bytes": 8606 + }, + { + "_path": "include/python3.10/marshal.h", + "path_type": "hardlink", + "sha256": "06ba6a68154f85951794529465a07e07444fb852440059a398c98344004a27f5", + "sha256_in_prefix": "06ba6a68154f85951794529465a07e07444fb852440059a398c98344004a27f5", + "size_in_bytes": 803 + }, + { + "_path": "include/python3.10/memoryobject.h", + "path_type": "hardlink", + "sha256": "5a89491cd879fd90ba20525c710c74e278d2432da789ce6c608ee4c65920cd48", + "sha256_in_prefix": "5a89491cd879fd90ba20525c710c74e278d2432da789ce6c608ee4c65920cd48", + "size_in_bytes": 2764 + }, + { + "_path": "include/python3.10/methodobject.h", + "path_type": "hardlink", + "sha256": "f4b74f9970a1077df25b79349cae90ce26499736a7cae9612fe32615e3852c6f", + "sha256_in_prefix": "f4b74f9970a1077df25b79349cae90ce26499736a7cae9612fe32615e3852c6f", + "size_in_bytes": 4147 + }, + { + "_path": "include/python3.10/modsupport.h", + "path_type": "hardlink", + "sha256": "718c034912af87f742a587863f1cf384a3c6bc69a7d80288b324acc4cdfea901", + "sha256_in_prefix": "718c034912af87f742a587863f1cf384a3c6bc69a7d80288b324acc4cdfea901", + "size_in_bytes": 10333 + }, + { + "_path": "include/python3.10/moduleobject.h", + "path_type": "hardlink", + "sha256": "1c53bd662099c015242581a1c1c96784455a6f5be0e673f569a7734a9841a62e", + "sha256_in_prefix": "1c53bd662099c015242581a1c1c96784455a6f5be0e673f569a7734a9841a62e", + "size_in_bytes": 2458 + }, + { + "_path": "include/python3.10/namespaceobject.h", + "path_type": "hardlink", + "sha256": "d282d6d0c6493f56921c039bfa23fd38bc4a643ebb9ace07108d9b170900fbc8", + "sha256_in_prefix": "d282d6d0c6493f56921c039bfa23fd38bc4a643ebb9ace07108d9b170900fbc8", + "size_in_bytes": 349 + }, + { + "_path": "include/python3.10/object.h", + "path_type": "hardlink", + "sha256": "ccf9ce9261d28fbbbbcb5c365e10e467c3a9df0bdf408f9449d713389c71e0ab", + "sha256_in_prefix": "ccf9ce9261d28fbbbbcb5c365e10e467c3a9df0bdf408f9449d713389c71e0ab", + "size_in_bytes": 28344 + }, + { + "_path": "include/python3.10/objimpl.h", + "path_type": "hardlink", + "sha256": "235f2853c721bfa952a98452961ca1ad5200da10b2d76b026a27e45fb11593c2", + "sha256_in_prefix": "235f2853c721bfa952a98452961ca1ad5200da10b2d76b026a27e45fb11593c2", + "size_in_bytes": 8445 + }, + { + "_path": "include/python3.10/opcode.h", + "path_type": "hardlink", + "sha256": "831a78176f1e285a4f37bd11253ba7e28870956d8fc5df32d281f2dff88c5e07", + "sha256_in_prefix": "831a78176f1e285a4f37bd11253ba7e28870956d8fc5df32d281f2dff88c5e07", + "size_in_bytes": 5509 + }, + { + "_path": "include/python3.10/osdefs.h", + "path_type": "hardlink", + "sha256": "8372e9c507949a88ed3cad5fd0a830190d60a1655e9a3f59ef4d0832c06a041c", + "sha256_in_prefix": "8372e9c507949a88ed3cad5fd0a830190d60a1655e9a3f59ef4d0832c06a041c", + "size_in_bytes": 737 + }, + { + "_path": "include/python3.10/osmodule.h", + "path_type": "hardlink", + "sha256": "c013935b48f48ca8ce249a4d482c55e3fb6f1cfe786c5a32a57969bb74a779d9", + "sha256_in_prefix": "c013935b48f48ca8ce249a4d482c55e3fb6f1cfe786c5a32a57969bb74a779d9", + "size_in_bytes": 291 + }, + { + "_path": "include/python3.10/patchlevel.h", + "path_type": "hardlink", + "sha256": "59744a5030593533e3217dfea25dc08c23d130a5224ff6465ec33901e798decb", + "sha256_in_prefix": "59744a5030593533e3217dfea25dc08c23d130a5224ff6465ec33901e798decb", + "size_in_bytes": 1301 + }, + { + "_path": "include/python3.10/py_curses.h", + "path_type": "hardlink", + "sha256": "18498ae03ed5fb81815a98e1dde888c9e0ea1c38fead6c7b3698d2583538c7f6", + "sha256_in_prefix": "18498ae03ed5fb81815a98e1dde888c9e0ea1c38fead6c7b3698d2583538c7f6", + "size_in_bytes": 2474 + }, + { + "_path": "include/python3.10/pycapsule.h", + "path_type": "hardlink", + "sha256": "8fed74eb81e83720caae346011dd6deedb147fd462bf94e679eac5065dfa92aa", + "sha256_in_prefix": "8fed74eb81e83720caae346011dd6deedb147fd462bf94e679eac5065dfa92aa", + "size_in_bytes": 1725 + }, + { + "_path": "include/python3.10/pyconfig.h", + "path_type": "hardlink", + "sha256": "e135595826a0dfaef729fb12c47e9defd4eb78307b75e96703dfc19df1127fff", + "sha256_in_prefix": "e135595826a0dfaef729fb12c47e9defd4eb78307b75e96703dfc19df1127fff", + "size_in_bytes": 48898 + }, + { + "_path": "include/python3.10/pydtrace.h", + "path_type": "hardlink", + "sha256": "d342948372e46cb0124ba1311ce5ba9941837ac8a137a76b5a532bca03c696e8", + "sha256_in_prefix": "d342948372e46cb0124ba1311ce5ba9941837ac8a137a76b5a532bca03c696e8", + "size_in_bytes": 2413 + }, + { + "_path": "include/python3.10/pyerrors.h", + "path_type": "hardlink", + "sha256": "2ae64c563e6b020ef70dc29ad78dab7a32b6074ca5d324d60befc92b092730d5", + "sha256_in_prefix": "2ae64c563e6b020ef70dc29ad78dab7a32b6074ca5d324d60befc92b092730d5", + "size_in_bytes": 12426 + }, + { + "_path": "include/python3.10/pyexpat.h", + "path_type": "hardlink", + "sha256": "24eb6f486b4eec69bcd84ec6cc17833040095aabba7a0c4ebe491bb5de02879e", + "sha256_in_prefix": "24eb6f486b4eec69bcd84ec6cc17833040095aabba7a0c4ebe491bb5de02879e", + "size_in_bytes": 2572 + }, + { + "_path": "include/python3.10/pyframe.h", + "path_type": "hardlink", + "sha256": "92fa396239229cd523e37349f9ae6e8d990061698c5d7e0770a473ce15b39304", + "sha256_in_prefix": "92fa396239229cd523e37349f9ae6e8d990061698c5d7e0770a473ce15b39304", + "size_in_bytes": 466 + }, + { + "_path": "include/python3.10/pyhash.h", + "path_type": "hardlink", + "sha256": "f6746833402decba260d9d83f98111a0088de3f00bd44ee205b89140027f62e3", + "sha256_in_prefix": "f6746833402decba260d9d83f98111a0088de3f00bd44ee205b89140027f62e3", + "size_in_bytes": 4223 + }, + { + "_path": "include/python3.10/pylifecycle.h", + "path_type": "hardlink", + "sha256": "0b3b1923447d6e1224e88994fe00b63ee50786d253832bdeea3323db985fa99b", + "sha256_in_prefix": "0b3b1923447d6e1224e88994fe00b63ee50786d253832bdeea3323db985fa99b", + "size_in_bytes": 2080 + }, + { + "_path": "include/python3.10/pymacconfig.h", + "path_type": "hardlink", + "sha256": "06a284cd2ccccbac21c5aa2ce5ea1d05d04a4b5e5038e5d55c7fab260ab30e2c", + "sha256_in_prefix": "06a284cd2ccccbac21c5aa2ce5ea1d05d04a4b5e5038e5d55c7fab260ab30e2c", + "size_in_bytes": 2989 + }, + { + "_path": "include/python3.10/pymacro.h", + "path_type": "hardlink", + "sha256": "4bed498f025583031bf71f5fde5cb589e3af0744e73143b6b074845fff51f7ef", + "sha256_in_prefix": "4bed498f025583031bf71f5fde5cb589e3af0744e73143b6b074845fff51f7ef", + "size_in_bytes": 4920 + }, + { + "_path": "include/python3.10/pymath.h", + "path_type": "hardlink", + "sha256": "3942d5ed97fccb693d4b342ffe3dbf1ceb01927a4566fb54f3b748fb92e348aa", + "sha256_in_prefix": "3942d5ed97fccb693d4b342ffe3dbf1ceb01927a4566fb54f3b748fb92e348aa", + "size_in_bytes": 8313 + }, + { + "_path": "include/python3.10/pymem.h", + "path_type": "hardlink", + "sha256": "3e256cc189d68c3fc0a70496e22cf3cd9b34be925b157240699f9e397c9cbd3a", + "sha256_in_prefix": "3e256cc189d68c3fc0a70496e22cf3cd9b34be925b157240699f9e397c9cbd3a", + "size_in_bytes": 3891 + }, + { + "_path": "include/python3.10/pyport.h", + "path_type": "hardlink", + "sha256": "7f8668d75ea83e4cbb3c187383bc032abb99a585eed5f67791a418b9c7065377", + "sha256_in_prefix": "7f8668d75ea83e4cbb3c187383bc032abb99a585eed5f67791a418b9c7065377", + "size_in_bytes": 31684 + }, + { + "_path": "include/python3.10/pystate.h", + "path_type": "hardlink", + "sha256": "69aafe4b49dbcb969d56ad795aac8b97f4ed48ea233675d83e0ba93423254197", + "sha256_in_prefix": "69aafe4b49dbcb969d56ad795aac8b97f4ed48ea233675d83e0ba93423254197", + "size_in_bytes": 5250 + }, + { + "_path": "include/python3.10/pystrcmp.h", + "path_type": "hardlink", + "sha256": "f401d8338fb6ecf5f12768ee95cd09c262f880b2ee522ca344b890dbdcde4c88", + "sha256_in_prefix": "f401d8338fb6ecf5f12768ee95cd09c262f880b2ee522ca344b890dbdcde4c88", + "size_in_bytes": 436 + }, + { + "_path": "include/python3.10/pystrhex.h", + "path_type": "hardlink", + "sha256": "2242f90a9a2bf13a32f0016bb056869193df04230ace468b469b18008f56a0f9", + "sha256_in_prefix": "2242f90a9a2bf13a32f0016bb056869193df04230ace468b469b18008f56a0f9", + "size_in_bytes": 849 + }, + { + "_path": "include/python3.10/pystrtod.h", + "path_type": "hardlink", + "sha256": "df98a492044f55cf016c008fef3181d77d13f1828b84625b5cb1f460e5f5ed2f", + "sha256_in_prefix": "df98a492044f55cf016c008fef3181d77d13f1828b84625b5cb1f460e5f5ed2f", + "size_in_bytes": 1483 + }, + { + "_path": "include/python3.10/pythonrun.h", + "path_type": "hardlink", + "sha256": "0a4dbe8791dae43facabc29e8b298d95bd0d1da615d6ccf3158b5ab033f08fb4", + "sha256_in_prefix": "0a4dbe8791dae43facabc29e8b298d95bd0d1da615d6ccf3158b5ab033f08fb4", + "size_in_bytes": 1110 + }, + { + "_path": "include/python3.10/pythread.h", + "path_type": "hardlink", + "sha256": "f578d2d30051b9474f36916909308665d51d3e9653f62774a628e659b969f8d4", + "sha256_in_prefix": "f578d2d30051b9474f36916909308665d51d3e9653f62774a628e659b969f8d4", + "size_in_bytes": 5938 + }, + { + "_path": "include/python3.10/rangeobject.h", + "path_type": "hardlink", + "sha256": "eb9bbb31cf628ffa8c4452aa7d136941b3e93e43e04d44b51c68ba0b16d56381", + "sha256_in_prefix": "eb9bbb31cf628ffa8c4452aa7d136941b3e93e43e04d44b51c68ba0b16d56381", + "size_in_bytes": 628 + }, + { + "_path": "include/python3.10/setobject.h", + "path_type": "hardlink", + "sha256": "822f34d6214a838f9d15ffeb47b4bbae4b0726cb9aa28b1a92ab321175c26161", + "sha256_in_prefix": "822f34d6214a838f9d15ffeb47b4bbae4b0726cb9aa28b1a92ab321175c26161", + "size_in_bytes": 3381 + }, + { + "_path": "include/python3.10/sliceobject.h", + "path_type": "hardlink", + "sha256": "3215a02de59673a950b8941a0224474cf0bcb62f617d9afc402f1e17713f9c28", + "sha256_in_prefix": "3215a02de59673a950b8941a0224474cf0bcb62f617d9afc402f1e17713f9c28", + "size_in_bytes": 2516 + }, + { + "_path": "include/python3.10/structmember.h", + "path_type": "hardlink", + "sha256": "8a7666cbc440aefb0520615dd50a776c34b987bd6781dd4c2d40950ceb603950", + "sha256_in_prefix": "8a7666cbc440aefb0520615dd50a776c34b987bd6781dd4c2d40950ceb603950", + "size_in_bytes": 2074 + }, + { + "_path": "include/python3.10/structseq.h", + "path_type": "hardlink", + "sha256": "d08c84466646660599c2f6d03af90be06ee8f9f81380a891d9e2a8c8e27e4308", + "sha256_in_prefix": "d08c84466646660599c2f6d03af90be06ee8f9f81380a891d9e2a8c8e27e4308", + "size_in_bytes": 1390 + }, + { + "_path": "include/python3.10/sysmodule.h", + "path_type": "hardlink", + "sha256": "2c1c21db5c8704de23d1580250a30243ca3a924f14f11e4b54376a3fffd8d76f", + "sha256_in_prefix": "2c1c21db5c8704de23d1580250a30243ca3a924f14f11e4b54376a3fffd8d76f", + "size_in_bytes": 1242 + }, + { + "_path": "include/python3.10/token.h", + "path_type": "hardlink", + "sha256": "754b9f53780c030f72b1d0ac10f13b89d0da1ad955c07c4eb3bcbc3406347b02", + "sha256_in_prefix": "754b9f53780c030f72b1d0ac10f13b89d0da1ad955c07c4eb3bcbc3406347b02", + "size_in_bytes": 2669 + }, + { + "_path": "include/python3.10/traceback.h", + "path_type": "hardlink", + "sha256": "c6db281d9686cf1b6895f7574a05291263b81aaa3f35cd0ca9a2e3219a669b45", + "sha256_in_prefix": "c6db281d9686cf1b6895f7574a05291263b81aaa3f35cd0ca9a2e3219a669b45", + "size_in_bytes": 584 + }, + { + "_path": "include/python3.10/tracemalloc.h", + "path_type": "hardlink", + "sha256": "0e5e535fbb5e66400b4dcb3d404ff532971ae964b4a11ac4abb6d73991ad24fe", + "sha256_in_prefix": "0e5e535fbb5e66400b4dcb3d404ff532971ae964b4a11ac4abb6d73991ad24fe", + "size_in_bytes": 1114 + }, + { + "_path": "include/python3.10/tupleobject.h", + "path_type": "hardlink", + "sha256": "a0659adc9bdffd1980fca036b3b9eabc1a99540435b6e857f071711054ebb3ed", + "sha256_in_prefix": "a0659adc9bdffd1980fca036b3b9eabc1a99540435b6e857f071711054ebb3ed", + "size_in_bytes": 1614 + }, + { + "_path": "include/python3.10/typeslots.h", + "path_type": "hardlink", + "sha256": "a6387e3e14881e86e1b71433a76db9d0ed8ab3a67be3fafc79edbcc44dcc77e1", + "sha256_in_prefix": "a6387e3e14881e86e1b71433a76db9d0ed8ab3a67be3fafc79edbcc44dcc77e1", + "size_in_bytes": 2460 + }, + { + "_path": "include/python3.10/unicodeobject.h", + "path_type": "hardlink", + "sha256": "99a0694450678191c1105c5bfdd53caafd7a9bf96af0c894fac0b725194972e7", + "sha256_in_prefix": "99a0694450678191c1105c5bfdd53caafd7a9bf96af0c894fac0b725194972e7", + "size_in_bytes": 36148 + }, + { + "_path": "include/python3.10/warnings.h", + "path_type": "hardlink", + "sha256": "d07c5b3d4b5f3b0c651e1d4244cfe7494e312792ece3568a5134dd8169b61eb2", + "sha256_in_prefix": "d07c5b3d4b5f3b0c651e1d4244cfe7494e312792ece3568a5134dd8169b61eb2", + "size_in_bytes": 1776 + }, + { + "_path": "include/python3.10/weakrefobject.h", + "path_type": "hardlink", + "sha256": "d64920779d0bdf9b1620eb19afa837d0d74df2e076819b90aa95a3aa0a35c009", + "sha256_in_prefix": "d64920779d0bdf9b1620eb19afa837d0d74df2e076819b90aa95a3aa0a35c009", + "size_in_bytes": 2863 + }, + { + "_path": "lib/libpython3.10.dylib", + "file_mode": "binary", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_9afkyeq1z4/croot/python-split_1715024112201/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_p", + "sha256": "7b1f9570c42214c0e6e8635e8c63baa3595a775426eac7f124cff5335bd6cb40", + "sha256_in_prefix": "abb207b8c7d590a3ed8e104de52d6b7966dbc39fabe725a28c1bc11e61a21e58", + "size_in_bytes": 3864464 + }, + { + "_path": "lib/pkgconfig/python-3.10-embed.pc", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_9afkyeq1z4/croot/python-split_1715024112201/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_p", + "sha256": "680dfe09aa7c661be98e9efa4a887f980e6c5bb4d7e61f78fbb4ea270c9b09fa", + "sha256_in_prefix": "42b27adc731ee221dd2bc09d66470c6b61cf5a633f9a5bde68a27fcb35dd3ea7", + "size_in_bytes": 559 + }, + { + "_path": "lib/pkgconfig/python-3.10.pc", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_9afkyeq1z4/croot/python-split_1715024112201/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_p", + "sha256": "a5d91d009752e565bdf4af589608872508e12f763dd67665d3a0c49df8216c21", + "sha256_in_prefix": "a45dec0733455234729d7a8d0b17d5715cb8c9758f1b214ef4e1b1e9fff23580", + "size_in_bytes": 532 + }, + { + "_path": "lib/pkgconfig/python3-embed.pc", + "path_type": "softlink", + "sha256": "680dfe09aa7c661be98e9efa4a887f980e6c5bb4d7e61f78fbb4ea270c9b09fa", + "size_in_bytes": 559 + }, + { + "_path": "lib/pkgconfig/python3.pc", + "path_type": "softlink", + "sha256": "a5d91d009752e565bdf4af589608872508e12f763dd67665d3a0c49df8216c21", + "size_in_bytes": 532 + }, + { + "_path": "lib/python3.1", + "path_type": "softlink", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size_in_bytes": 0 + }, + { + "_path": "lib/python3.10/LICENSE.txt", + "path_type": "hardlink", + "sha256": "3b2f81fe21d181c499c59a256c8e1968455d6689d269aa85373bfb6af41da3bf", + "sha256_in_prefix": "3b2f81fe21d181c499c59a256c8e1968455d6689d269aa85373bfb6af41da3bf", + "size_in_bytes": 13936 + }, + { + "_path": "lib/python3.10/__future__.py", + "path_type": "hardlink", + "sha256": "7923cdce02f46d719df43663dcf5f5bf21e28ac5397c950ec7dc4e357881b33f", + "sha256_in_prefix": "7923cdce02f46d719df43663dcf5f5bf21e28ac5397c950ec7dc4e357881b33f", + "size_in_bytes": 5155 + }, + { + "_path": "lib/python3.10/__phello__.foo.py", + "path_type": "hardlink", + "sha256": "586d9bf9b42fadd32feb1fba80613bcbfb4180dbcd6f03af678b5a6deb9d6a7b", + "sha256_in_prefix": "586d9bf9b42fadd32feb1fba80613bcbfb4180dbcd6f03af678b5a6deb9d6a7b", + "size_in_bytes": 64 + }, + { + "_path": "lib/python3.10/__pycache__/__future__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "b4400240cb61bac95f1b30edddb9019299bcb7cdebc786645e7e393f3d044622", + "sha256_in_prefix": "b4400240cb61bac95f1b30edddb9019299bcb7cdebc786645e7e393f3d044622", + "size_in_bytes": 4385 + }, + { + "_path": "lib/python3.10/__pycache__/__phello__.foo.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "0d92003811f61096c30da9e786b25f6b7f7db272f2bc5b4ecc5b2aa26ce2d90e", + "sha256_in_prefix": "0d92003811f61096c30da9e786b25f6b7f7db272f2bc5b4ecc5b2aa26ce2d90e", + "size_in_bytes": 384 + }, + { + "_path": "lib/python3.10/__pycache__/_aix_support.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "74d84993a86c57fdccb1ff7b23b678b22668003f5861475d23a576f6f9c751ac", + "sha256_in_prefix": "74d84993a86c57fdccb1ff7b23b678b22668003f5861475d23a576f6f9c751ac", + "size_in_bytes": 3133 + }, + { + "_path": "lib/python3.10/__pycache__/_bootsubprocess.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "40afad151efd5325420b68e419e9bc7ca00860072d669d1b371a48244301f05a", + "sha256_in_prefix": "40afad151efd5325420b68e419e9bc7ca00860072d669d1b371a48244301f05a", + "size_in_bytes": 2548 + }, + { + "_path": "lib/python3.10/__pycache__/_collections_abc.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "3705adeeb0ddb5592775a9f427879a1eda2a77f2e2b15ab1aa56e0ef6f1ad39f", + "sha256_in_prefix": "3705adeeb0ddb5592775a9f427879a1eda2a77f2e2b15ab1aa56e0ef6f1ad39f", + "size_in_bytes": 33179 + }, + { + "_path": "lib/python3.10/__pycache__/_compat_pickle.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "448003ce38a928842f989516b480fa63fd7c1caa00c2e2155a4e20cf1c33882d", + "sha256_in_prefix": "448003ce38a928842f989516b480fa63fd7c1caa00c2e2155a4e20cf1c33882d", + "size_in_bytes": 6126 + }, + { + "_path": "lib/python3.10/__pycache__/_compression.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "efbfbc1a43f7219c5f211b24672bd2aeaa032a98721977c52adc5db4d38d94f8", + "sha256_in_prefix": "efbfbc1a43f7219c5f211b24672bd2aeaa032a98721977c52adc5db4d38d94f8", + "size_in_bytes": 4766 + }, + { + "_path": "lib/python3.10/__pycache__/_markupbase.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "4287cce456ca1be6e0cee9396233113517742a9d4f6f6cbfc03133e11a192c64", + "sha256_in_prefix": "4287cce456ca1be6e0cee9396233113517742a9d4f6f6cbfc03133e11a192c64", + "size_in_bytes": 7826 + }, + { + "_path": "lib/python3.10/__pycache__/_osx_support.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "403ea0eae3d1140d78ad6098ec8c1c4b46ed4a2ba929e36196fb5e1d08822072", + "sha256_in_prefix": "403ea0eae3d1140d78ad6098ec8c1c4b46ed4a2ba929e36196fb5e1d08822072", + "size_in_bytes": 11789 + }, + { + "_path": "lib/python3.10/__pycache__/_py_abc.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "ca109749193930066f511803fbeba6b784ae3e217d886f10da830e2aefc1ea33", + "sha256_in_prefix": "ca109749193930066f511803fbeba6b784ae3e217d886f10da830e2aefc1ea33", + "size_in_bytes": 4937 + }, + { + "_path": "lib/python3.10/__pycache__/_pydecimal.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c408bb10ac1eb72fb56f5a6a5280f816766c3d771c6019a55903f958230efe9a", + "sha256_in_prefix": "c408bb10ac1eb72fb56f5a6a5280f816766c3d771c6019a55903f958230efe9a", + "size_in_bytes": 157990 + }, + { + "_path": "lib/python3.10/__pycache__/_pyio.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "ff30382a92156104f756a2e02aacd68b40e22050eb0d9f09256a7c906a65b824", + "sha256_in_prefix": "ff30382a92156104f756a2e02aacd68b40e22050eb0d9f09256a7c906a65b824", + "size_in_bytes": 73649 + }, + { + "_path": "lib/python3.10/__pycache__/_sitebuiltins.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "5a1c5e7fd72c254268da36c9c6b8511967e77d139d9a684af7c17429617bb92e", + "sha256_in_prefix": "5a1c5e7fd72c254268da36c9c6b8511967e77d139d9a684af7c17429617bb92e", + "size_in_bytes": 3801 + }, + { + "_path": "lib/python3.10/__pycache__/_strptime.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "f9b89b256738b6103b7f6ccf083b0151062becd023fbf40054087c5201eef1eb", + "sha256_in_prefix": "f9b89b256738b6103b7f6ccf083b0151062becd023fbf40054087c5201eef1eb", + "size_in_bytes": 16199 + }, + { + "_path": "lib/python3.10/__pycache__/_sysconfigdata__darwin_darwin.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "eb806727aa1a98280b614d68278ba12e73ecc9bf781664108799a6ae12bfe882", + "sha256_in_prefix": "eb806727aa1a98280b614d68278ba12e73ecc9bf781664108799a6ae12bfe882", + "size_in_bytes": 57477 + }, + { + "_path": "lib/python3.10/__pycache__/_sysconfigdata_arm64_apple_darwin20_0_0.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "d6d51c552a9c2a1a2e21e72cb87818d42c8cfc3a070a936eec0791bb2ad9b1c4", + "sha256_in_prefix": "d6d51c552a9c2a1a2e21e72cb87818d42c8cfc3a070a936eec0791bb2ad9b1c4", + "size_in_bytes": 58720 + }, + { + "_path": "lib/python3.10/__pycache__/_threading_local.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "956a29319dfce726dbbda799bdf596fa7c3ddc455279aebc05c9d3f3226b475c", + "sha256_in_prefix": "956a29319dfce726dbbda799bdf596fa7c3ddc455279aebc05c9d3f3226b475c", + "size_in_bytes": 6793 + }, + { + "_path": "lib/python3.10/__pycache__/_weakrefset.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "89a206d3765095441f4f87b4e0de6363811e9c849e58fbc9fdb7b4253f6b5a18", + "sha256_in_prefix": "89a206d3765095441f4f87b4e0de6363811e9c849e58fbc9fdb7b4253f6b5a18", + "size_in_bytes": 7862 + }, + { + "_path": "lib/python3.10/__pycache__/abc.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "a52553d510dfc14f194ce4f05b1a074245caac9ee764c90ba1170c4d7703e084", + "sha256_in_prefix": "a52553d510dfc14f194ce4f05b1a074245caac9ee764c90ba1170c4d7703e084", + "size_in_bytes": 7005 + }, + { + "_path": "lib/python3.10/__pycache__/aifc.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "96fa531f6eaf2c655060de9de0b5a526b1926187b6725a7b5e1b3785bf793651", + "sha256_in_prefix": "96fa531f6eaf2c655060de9de0b5a526b1926187b6725a7b5e1b3785bf793651", + "size_in_bytes": 24939 + }, + { + "_path": "lib/python3.10/__pycache__/antigravity.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c15ba793e79f1c88709ff4ccf712d044c07d69ad754e5f4389ab52d996293d3d", + "sha256_in_prefix": "c15ba793e79f1c88709ff4ccf712d044c07d69ad754e5f4389ab52d996293d3d", + "size_in_bytes": 1076 + }, + { + "_path": "lib/python3.10/__pycache__/argparse.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "653261b6cefdd6b591630d7d73121050a3f4836b6be9472d7ba3592db591f91b", + "sha256_in_prefix": "653261b6cefdd6b591630d7d73121050a3f4836b6be9472d7ba3592db591f91b", + "size_in_bytes": 63480 + }, + { + "_path": "lib/python3.10/__pycache__/ast.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "4fdba66a5b5d6056c4f44735830a9c95e7263f715755e51878e08d57cc49573d", + "sha256_in_prefix": "4fdba66a5b5d6056c4f44735830a9c95e7263f715755e51878e08d57cc49573d", + "size_in_bytes": 55993 + }, + { + "_path": "lib/python3.10/__pycache__/asynchat.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "77bc80a0e9730883ff9deebe553a9bd04b90f996897fe2d6742ae9c5b2884f94", + "sha256_in_prefix": "77bc80a0e9730883ff9deebe553a9bd04b90f996897fe2d6742ae9c5b2884f94", + "size_in_bytes": 7279 + }, + { + "_path": "lib/python3.10/__pycache__/asyncore.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "20e719657d8f7fe419cf078ec820e7ee97926cb65144027e7372c3b9d7d00a00", + "sha256_in_prefix": "20e719657d8f7fe419cf078ec820e7ee97926cb65144027e7372c3b9d7d00a00", + "size_in_bytes": 16256 + }, + { + "_path": "lib/python3.10/__pycache__/base64.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "e65e4002d78cf7808e39529a69743bbc1fac426ce553099cab0c340586a9e146", + "sha256_in_prefix": "e65e4002d78cf7808e39529a69743bbc1fac426ce553099cab0c340586a9e146", + "size_in_bytes": 17416 + }, + { + "_path": "lib/python3.10/__pycache__/bdb.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "cff013ddad99a2161fca0ab9b3dffb383646f30508cb3025099a731887ec717b", + "sha256_in_prefix": "cff013ddad99a2161fca0ab9b3dffb383646f30508cb3025099a731887ec717b", + "size_in_bytes": 26086 + }, + { + "_path": "lib/python3.10/__pycache__/binhex.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "58d9d124d04814f5c2228496c5875b922084a5ae67b48891543f608297009f5e", + "sha256_in_prefix": "58d9d124d04814f5c2228496c5875b922084a5ae67b48891543f608297009f5e", + "size_in_bytes": 13124 + }, + { + "_path": "lib/python3.10/__pycache__/bisect.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "2fe405c57a646ff82872f60c542976b44cf80e8b82966f8d534481805d55aab7", + "sha256_in_prefix": "2fe405c57a646ff82872f60c542976b44cf80e8b82966f8d534481805d55aab7", + "size_in_bytes": 2583 + }, + { + "_path": "lib/python3.10/__pycache__/bz2.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "388c6983c5e23e30281cfa4b6087116ce943bfce46f51de2e06c4f2832e4da1e", + "sha256_in_prefix": "388c6983c5e23e30281cfa4b6087116ce943bfce46f51de2e06c4f2832e4da1e", + "size_in_bytes": 10865 + }, + { + "_path": "lib/python3.10/__pycache__/cProfile.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "6f4832fb40c8422631d84ee0b1984bb746cc3386d9f6d55bc8fa1a87c04941cc", + "sha256_in_prefix": "6f4832fb40c8422631d84ee0b1984bb746cc3386d9f6d55bc8fa1a87c04941cc", + "size_in_bytes": 5367 + }, + { + "_path": "lib/python3.10/__pycache__/calendar.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "41ab7e6289302ea49fe02bb5de66f2fcb4d603c896ec57f29923ac1878189e09", + "sha256_in_prefix": "41ab7e6289302ea49fe02bb5de66f2fcb4d603c896ec57f29923ac1878189e09", + "size_in_bytes": 26557 + }, + { + "_path": "lib/python3.10/__pycache__/cgi.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "21508b6a55607103314bf8c2a1e299f5e9a5418e1a8ee02c29ab35a540b7f84b", + "sha256_in_prefix": "21508b6a55607103314bf8c2a1e299f5e9a5418e1a8ee02c29ab35a540b7f84b", + "size_in_bytes": 26977 + }, + { + "_path": "lib/python3.10/__pycache__/cgitb.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "eb42ebda3782db9101ee60737b1eb8f876cac86bfd549740ca73d76c84428df0", + "sha256_in_prefix": "eb42ebda3782db9101ee60737b1eb8f876cac86bfd549740ca73d76c84428df0", + "size_in_bytes": 10252 + }, + { + "_path": "lib/python3.10/__pycache__/chunk.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "9526ed36ad8fdf2a461a0f3a8b87cf2d4ba9faf6598c1d5c23f947da328019d3", + "sha256_in_prefix": "9526ed36ad8fdf2a461a0f3a8b87cf2d4ba9faf6598c1d5c23f947da328019d3", + "size_in_bytes": 5114 + }, + { + "_path": "lib/python3.10/__pycache__/cmd.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "d9697c409d32169e1b487b83dc88dde0afcd41094971f5cdce19b89b4b4ee0d7", + "sha256_in_prefix": "d9697c409d32169e1b487b83dc88dde0afcd41094971f5cdce19b89b4b4ee0d7", + "size_in_bytes": 12961 + }, + { + "_path": "lib/python3.10/__pycache__/code.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "01f3f998ba446add1e80175913158d579b25bc768dccaa890436bfe14d018b0e", + "sha256_in_prefix": "01f3f998ba446add1e80175913158d579b25bc768dccaa890436bfe14d018b0e", + "size_in_bytes": 10211 + }, + { + "_path": "lib/python3.10/__pycache__/codecs.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "f6dd0eb1aed702c9bda5ce714f805b2f48d69784792239f924bf75946b777987", + "sha256_in_prefix": "f6dd0eb1aed702c9bda5ce714f805b2f48d69784792239f924bf75946b777987", + "size_in_bytes": 33473 + }, + { + "_path": "lib/python3.10/__pycache__/codeop.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "56e25f650344efd7be63464e769bb16710c4bf29f97f52160e308ea8fe026838", + "sha256_in_prefix": "56e25f650344efd7be63464e769bb16710c4bf29f97f52160e308ea8fe026838", + "size_in_bytes": 5849 + }, + { + "_path": "lib/python3.10/__pycache__/colorsys.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "8e9f1200e7755d7cb4e158268162de0790390fb217d946420878f9237d4d8ab7", + "sha256_in_prefix": "8e9f1200e7755d7cb4e158268162de0790390fb217d946420878f9237d4d8ab7", + "size_in_bytes": 3519 + }, + { + "_path": "lib/python3.10/__pycache__/compileall.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "6869c23c55badfdbd9b3f6d96034af82fe2f92eba5733f6d046e926d22b97d81", + "sha256_in_prefix": "6869c23c55badfdbd9b3f6d96034af82fe2f92eba5733f6d046e926d22b97d81", + "size_in_bytes": 12987 + }, + { + "_path": "lib/python3.10/__pycache__/configparser.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "83afca07c67a5f77d96a0ef151a4430b30523506204e9e8b45f6cf828ec5eeef", + "sha256_in_prefix": "83afca07c67a5f77d96a0ef151a4430b30523506204e9e8b45f6cf828ec5eeef", + "size_in_bytes": 45712 + }, + { + "_path": "lib/python3.10/__pycache__/contextlib.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "6b8bf7767070ae3c2c7b9d22bbc1120e1b8e544b01e72918f0afb446f7df9969", + "sha256_in_prefix": "6b8bf7767070ae3c2c7b9d22bbc1120e1b8e544b01e72918f0afb446f7df9969", + "size_in_bytes": 21149 + }, + { + "_path": "lib/python3.10/__pycache__/contextvars.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c2f57f37f3d9a12abfd7834f8db67e815624798366a4ceea2317e43a9d532221", + "sha256_in_prefix": "c2f57f37f3d9a12abfd7834f8db67e815624798366a4ceea2317e43a9d532221", + "size_in_bytes": 500 + }, + { + "_path": "lib/python3.10/__pycache__/copy.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "64decfc2d25d7ef0fb208694d90a76bca7b8cb05d7b628ae53e243c6b3bd581f", + "sha256_in_prefix": "64decfc2d25d7ef0fb208694d90a76bca7b8cb05d7b628ae53e243c6b3bd581f", + "size_in_bytes": 7250 + }, + { + "_path": "lib/python3.10/__pycache__/copyreg.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "61570021bcf4d6d70d7b6d204bb5187bc0b19b23d0a0ea81473e2af213c579d9", + "sha256_in_prefix": "61570021bcf4d6d70d7b6d204bb5187bc0b19b23d0a0ea81473e2af213c579d9", + "size_in_bytes": 4937 + }, + { + "_path": "lib/python3.10/__pycache__/crypt.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "585d7215b895f8a93acfec84b6164730df9a7ccfd68ee06de213fe0f73e39069", + "sha256_in_prefix": "585d7215b895f8a93acfec84b6164730df9a7ccfd68ee06de213fe0f73e39069", + "size_in_bytes": 3804 + }, + { + "_path": "lib/python3.10/__pycache__/csv.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "678bbcd238f510ce76e46def71ca4a13bee377445b0939cd4ef3d1715cf73e45", + "sha256_in_prefix": "678bbcd238f510ce76e46def71ca4a13bee377445b0939cd4ef3d1715cf73e45", + "size_in_bytes": 12052 + }, + { + "_path": "lib/python3.10/__pycache__/dataclasses.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "8492229bfdc0d841d19df272212952d3927b262a0cf2854e310512d59d9933b5", + "sha256_in_prefix": "8492229bfdc0d841d19df272212952d3927b262a0cf2854e310512d59d9933b5", + "size_in_bytes": 26832 + }, + { + "_path": "lib/python3.10/__pycache__/datetime.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "da688f0a3da65dd52aca379f681b813dbefbafaae69fc2f3c506c6ad35c2bf4d", + "sha256_in_prefix": "da688f0a3da65dd52aca379f681b813dbefbafaae69fc2f3c506c6ad35c2bf4d", + "size_in_bytes": 56528 + }, + { + "_path": "lib/python3.10/__pycache__/decimal.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "37745d1f434455d6bf8aa25c329a79914c3026a4fecec9a87ae784d3d6ac1523", + "sha256_in_prefix": "37745d1f434455d6bf8aa25c329a79914c3026a4fecec9a87ae784d3d6ac1523", + "size_in_bytes": 616 + }, + { + "_path": "lib/python3.10/__pycache__/difflib.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "40cb5d1019f34a0d8df8ef816a4df5ab5fcb28eb1a20f28361184e205d9ce0e6", + "sha256_in_prefix": "40cb5d1019f34a0d8df8ef816a4df5ab5fcb28eb1a20f28361184e205d9ce0e6", + "size_in_bytes": 58900 + }, + { + "_path": "lib/python3.10/__pycache__/dis.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "fbf9be612e9a1bd2f7121f4d4e5a1de5c27fef1c3eeb1da0a34bbb8b0d9db221", + "sha256_in_prefix": "fbf9be612e9a1bd2f7121f4d4e5a1de5c27fef1c3eeb1da0a34bbb8b0d9db221", + "size_in_bytes": 15910 + }, + { + "_path": "lib/python3.10/__pycache__/doctest.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c5feb35e4844e56346949e78c9f83a990c18e5efac0369c3962ff0af322550d0", + "sha256_in_prefix": "c5feb35e4844e56346949e78c9f83a990c18e5efac0369c3962ff0af322550d0", + "size_in_bytes": 76429 + }, + { + "_path": "lib/python3.10/__pycache__/enum.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "da66a5b03db5a124e7e37f33c164f928df4cce80d24c49a368b36f95f6fe6656", + "sha256_in_prefix": "da66a5b03db5a124e7e37f33c164f928df4cce80d24c49a368b36f95f6fe6656", + "size_in_bytes": 26317 + }, + { + "_path": "lib/python3.10/__pycache__/filecmp.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "f83ba44cc7adbbfee80d5fde25d175c458c6dab351df114ab394a98ce72ffb83", + "sha256_in_prefix": "f83ba44cc7adbbfee80d5fde25d175c458c6dab351df114ab394a98ce72ffb83", + "size_in_bytes": 9003 + }, + { + "_path": "lib/python3.10/__pycache__/fileinput.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "141d4e9264495c8bc48e0541e60224b0c781285929a32d8ed9bcfeacad5c5ed5", + "sha256_in_prefix": "141d4e9264495c8bc48e0541e60224b0c781285929a32d8ed9bcfeacad5c5ed5", + "size_in_bytes": 14326 + }, + { + "_path": "lib/python3.10/__pycache__/fnmatch.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "7fbf805d920be71ed49a34c098bacfc8cafb66ce03fc46ea9542ee964382be19", + "sha256_in_prefix": "7fbf805d920be71ed49a34c098bacfc8cafb66ce03fc46ea9542ee964382be19", + "size_in_bytes": 4498 + }, + { + "_path": "lib/python3.10/__pycache__/fractions.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "f3931e2ed31a74e52b1e7a8e2e028b3241156629e02b89d43e1e4ef5c1ffba11", + "sha256_in_prefix": "f3931e2ed31a74e52b1e7a8e2e028b3241156629e02b89d43e1e4ef5c1ffba11", + "size_in_bytes": 18854 + }, + { + "_path": "lib/python3.10/__pycache__/ftplib.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "7456d488070584f8e84e732edbbc97b975bfe386f974ee30c557cf4f0574a697", + "sha256_in_prefix": "7456d488070584f8e84e732edbbc97b975bfe386f974ee30c557cf4f0574a697", + "size_in_bytes": 29231 + }, + { + "_path": "lib/python3.10/__pycache__/functools.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c7fedc57d8e94cb481559418e42f30fa40665ff9644e30f089e0c2cc84a4bb0e", + "sha256_in_prefix": "c7fedc57d8e94cb481559418e42f30fa40665ff9644e30f089e0c2cc84a4bb0e", + "size_in_bytes": 28589 + }, + { + "_path": "lib/python3.10/__pycache__/genericpath.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "017725066fe80b38f6bdd8f3021db04a43a09e6b9f7517d4678c244ce7d00400", + "sha256_in_prefix": "017725066fe80b38f6bdd8f3021db04a43a09e6b9f7517d4678c244ce7d00400", + "size_in_bytes": 4161 + }, + { + "_path": "lib/python3.10/__pycache__/getopt.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "7c422760fb84531ddf234c61505d759ba75b2a2eb1ada137c74f89d47d07262f", + "sha256_in_prefix": "7c422760fb84531ddf234c61505d759ba75b2a2eb1ada137c74f89d47d07262f", + "size_in_bytes": 6593 + }, + { + "_path": "lib/python3.10/__pycache__/getpass.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "262fb20a9e63d82eb3db3aa101e3d61b4bbda9c8794508ebfc9a185933c33015", + "sha256_in_prefix": "262fb20a9e63d82eb3db3aa101e3d61b4bbda9c8794508ebfc9a185933c33015", + "size_in_bytes": 4464 + }, + { + "_path": "lib/python3.10/__pycache__/gettext.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "148373ca4225f840b889936102e105bda112526d8062e50c83a06d239b2d5130", + "sha256_in_prefix": "148373ca4225f840b889936102e105bda112526d8062e50c83a06d239b2d5130", + "size_in_bytes": 18364 + }, + { + "_path": "lib/python3.10/__pycache__/glob.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "dd205a5b8563456be3fb60b0e5198394a184a576260bf601f38b6b68abe38280", + "sha256_in_prefix": "dd205a5b8563456be3fb60b0e5198394a184a576260bf601f38b6b68abe38280", + "size_in_bytes": 6106 + }, + { + "_path": "lib/python3.10/__pycache__/graphlib.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "32645c5b773034100ce7693745a2a92439ce668796d1ac34c5b3bc8650623e20", + "sha256_in_prefix": "32645c5b773034100ce7693745a2a92439ce668796d1ac34c5b3bc8650623e20", + "size_in_bytes": 7870 + }, + { + "_path": "lib/python3.10/__pycache__/gzip.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "d0e07fd01a69fb3254902660a5df1ed4d6320d3917f607f5129ddf12881e5aab", + "sha256_in_prefix": "d0e07fd01a69fb3254902660a5df1ed4d6320d3917f607f5129ddf12881e5aab", + "size_in_bytes": 18800 + }, + { + "_path": "lib/python3.10/__pycache__/hashlib.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "e85264b58f48e05e3556aa2411d76d73e4ffaf8285a8e6c02c542ed3057d5e35", + "sha256_in_prefix": "e85264b58f48e05e3556aa2411d76d73e4ffaf8285a8e6c02c542ed3057d5e35", + "size_in_bytes": 7099 + }, + { + "_path": "lib/python3.10/__pycache__/heapq.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "e4a33cabee62636677a09b92b8e2311b850408d714aafc39a9c272f141a2c291", + "sha256_in_prefix": "e4a33cabee62636677a09b92b8e2311b850408d714aafc39a9c272f141a2c291", + "size_in_bytes": 14119 + }, + { + "_path": "lib/python3.10/__pycache__/hmac.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "b9b4d10afe14c33ea7fdc4ce50802eed2e95547e08fe8eef772a44971289e42c", + "sha256_in_prefix": "b9b4d10afe14c33ea7fdc4ce50802eed2e95547e08fe8eef772a44971289e42c", + "size_in_bytes": 7227 + }, + { + "_path": "lib/python3.10/__pycache__/imaplib.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "0317f26c00af5e25492c45762ed0cc6547258d53a9515b41485c11cbb7be72bb", + "sha256_in_prefix": "0317f26c00af5e25492c45762ed0cc6547258d53a9515b41485c11cbb7be72bb", + "size_in_bytes": 42566 + }, + { + "_path": "lib/python3.10/__pycache__/imghdr.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "838a47f3449dc0bf6f3c8beffee125fbe018ddb6bfc5868623bc61ee8ac130f7", + "sha256_in_prefix": "838a47f3449dc0bf6f3c8beffee125fbe018ddb6bfc5868623bc61ee8ac130f7", + "size_in_bytes": 4159 + }, + { + "_path": "lib/python3.10/__pycache__/imp.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "b46c580a561c2c58b8a094f5627e2f00f89f9e10e0f6a10c79766bb307d4dfc3", + "sha256_in_prefix": "b46c580a561c2c58b8a094f5627e2f00f89f9e10e0f6a10c79766bb307d4dfc3", + "size_in_bytes": 10040 + }, + { + "_path": "lib/python3.10/__pycache__/inspect.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "65f2cfd81a6e279e3240a05a5e0754ac2e61660d39d439b3d81ee4306b387cea", + "sha256_in_prefix": "65f2cfd81a6e279e3240a05a5e0754ac2e61660d39d439b3d81ee4306b387cea", + "size_in_bytes": 85407 + }, + { + "_path": "lib/python3.10/__pycache__/io.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "97de3de8e511637f4fe9307214190f10d0e9362b8e0a90b7c3aee8adbc1e0188", + "sha256_in_prefix": "97de3de8e511637f4fe9307214190f10d0e9362b8e0a90b7c3aee8adbc1e0188", + "size_in_bytes": 3917 + }, + { + "_path": "lib/python3.10/__pycache__/ipaddress.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "3bdd8557eda0056c4c9d2f074aec1d665150389e3be4ec4c2b1dee276ecad5fa", + "sha256_in_prefix": "3bdd8557eda0056c4c9d2f074aec1d665150389e3be4ec4c2b1dee276ecad5fa", + "size_in_bytes": 61705 + }, + { + "_path": "lib/python3.10/__pycache__/keyword.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "6bb53d8d8f40997214e7aa1adbb1ef3982149b1e7278b26a877c66519f010c9a", + "sha256_in_prefix": "6bb53d8d8f40997214e7aa1adbb1ef3982149b1e7278b26a877c66519f010c9a", + "size_in_bytes": 1181 + }, + { + "_path": "lib/python3.10/__pycache__/linecache.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "3a8b060a5ef79be319694b8aa84f683048bd3e6134b75bd4ecc72cc9b0d52cc7", + "sha256_in_prefix": "3a8b060a5ef79be319694b8aa84f683048bd3e6134b75bd4ecc72cc9b0d52cc7", + "size_in_bytes": 4396 + }, + { + "_path": "lib/python3.10/__pycache__/locale.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "e2eb02d08c094d29c2eeb0f2b4f39d151512d920032f122beec1c335e45f552d", + "sha256_in_prefix": "e2eb02d08c094d29c2eeb0f2b4f39d151512d920032f122beec1c335e45f552d", + "size_in_bytes": 46419 + }, + { + "_path": "lib/python3.10/__pycache__/lzma.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "ef0fb42b275c937c15ca5bbc9e348ea11d68241edd750f877c3a98e8867ceaf7", + "sha256_in_prefix": "ef0fb42b275c937c15ca5bbc9e348ea11d68241edd750f877c3a98e8867ceaf7", + "size_in_bytes": 12095 + }, + { + "_path": "lib/python3.10/__pycache__/mailbox.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "26ee985ff97911fac27a3753c3f7f53e1b8f51a75cebca586ed58bd763a7d4f0", + "sha256_in_prefix": "26ee985ff97911fac27a3753c3f7f53e1b8f51a75cebca586ed58bd763a7d4f0", + "size_in_bytes": 60345 + }, + { + "_path": "lib/python3.10/__pycache__/mailcap.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "eb78b7326bab97d8404c7ca04a37dc0b395a750f99fe568ea7c7f870fd31a289", + "sha256_in_prefix": "eb78b7326bab97d8404c7ca04a37dc0b395a750f99fe568ea7c7f870fd31a289", + "size_in_bytes": 7315 + }, + { + "_path": "lib/python3.10/__pycache__/mimetypes.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "41aa6242d996d005a37cc99cc9f66371cbf717a0c55adabd59a79a0e7100f291", + "sha256_in_prefix": "41aa6242d996d005a37cc99cc9f66371cbf717a0c55adabd59a79a0e7100f291", + "size_in_bytes": 17873 + }, + { + "_path": "lib/python3.10/__pycache__/modulefinder.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "329c08f04075d30537ee703668778b759bfb90a865a31c27ed1c60b73df01aec", + "sha256_in_prefix": "329c08f04075d30537ee703668778b759bfb90a865a31c27ed1c60b73df01aec", + "size_in_bytes": 16420 + }, + { + "_path": "lib/python3.10/__pycache__/netrc.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "9d1c97a947c74d169ced52ecaaec755bc97f7ddffe884cea69b459dae11ef768", + "sha256_in_prefix": "9d1c97a947c74d169ced52ecaaec755bc97f7ddffe884cea69b459dae11ef768", + "size_in_bytes": 4187 + }, + { + "_path": "lib/python3.10/__pycache__/nntplib.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "12b86f6b84eb639725c05ea07b23c8c333befff47b36d91a2f4164b39976e880", + "sha256_in_prefix": "12b86f6b84eb639725c05ea07b23c8c333befff47b36d91a2f4164b39976e880", + "size_in_bytes": 31618 + }, + { + "_path": "lib/python3.10/__pycache__/ntpath.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "afb3d2071aa6e66e3ad57d0ae6f3ed72f5204f1e8a48c870b25ae617d5f26dc6", + "sha256_in_prefix": "afb3d2071aa6e66e3ad57d0ae6f3ed72f5204f1e8a48c870b25ae617d5f26dc6", + "size_in_bytes": 15557 + }, + { + "_path": "lib/python3.10/__pycache__/nturl2path.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "4553299c008527b278c6267b2fdb24abca4e83c737c12d2f41fda199be56830a", + "sha256_in_prefix": "4553299c008527b278c6267b2fdb24abca4e83c737c12d2f41fda199be56830a", + "size_in_bytes": 2001 + }, + { + "_path": "lib/python3.10/__pycache__/numbers.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "7b8f9165e3fe1fe5eb792ed562bf9ae91cde73c678b5183fe01ac6a8ee9c96a2", + "sha256_in_prefix": "7b8f9165e3fe1fe5eb792ed562bf9ae91cde73c678b5183fe01ac6a8ee9c96a2", + "size_in_bytes": 12120 + }, + { + "_path": "lib/python3.10/__pycache__/opcode.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "7e3f11d2639a0ca368994591f750f0dda1c40bf61e50f98926a8bcf0d5f92781", + "sha256_in_prefix": "7e3f11d2639a0ca368994591f750f0dda1c40bf61e50f98926a8bcf0d5f92781", + "size_in_bytes": 5701 + }, + { + "_path": "lib/python3.10/__pycache__/operator.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "e33d469c1ef19afb226be604d443c0632c0cfdf371b0b2be1ca88201eb7d05ba", + "sha256_in_prefix": "e33d469c1ef19afb226be604d443c0632c0cfdf371b0b2be1ca88201eb7d05ba", + "size_in_bytes": 13762 + }, + { + "_path": "lib/python3.10/__pycache__/optparse.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "12e45c066b939489305438da8cdb99d089ad5976eb9509c3ee44abd68558da1d", + "sha256_in_prefix": "12e45c066b939489305438da8cdb99d089ad5976eb9509c3ee44abd68558da1d", + "size_in_bytes": 48008 + }, + { + "_path": "lib/python3.10/__pycache__/os.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "ee8c8334085a36a276a2a7588d37325b22096657763c38d77a65d87a16167fe6", + "sha256_in_prefix": "ee8c8334085a36a276a2a7588d37325b22096657763c38d77a65d87a16167fe6", + "size_in_bytes": 31853 + }, + { + "_path": "lib/python3.10/__pycache__/pathlib.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "8b3907a9e51f8960d8ed9f90a80313cfb77d06879ca49a337ef5b3a425c34c89", + "sha256_in_prefix": "8b3907a9e51f8960d8ed9f90a80313cfb77d06879ca49a337ef5b3a425c34c89", + "size_in_bytes": 42306 + }, + { + "_path": "lib/python3.10/__pycache__/pdb.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "76ab63e94834951bb52b48ac2f697d97e32b8906bf1e5d8a398b46fe251558c7", + "sha256_in_prefix": "76ab63e94834951bb52b48ac2f697d97e32b8906bf1e5d8a398b46fe251558c7", + "size_in_bytes": 47435 + }, + { + "_path": "lib/python3.10/__pycache__/pickle.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "332a98837f8ef0e0462ca05369fc595d5ddfdb9ef8329f23b8a2e8c2e1571276", + "sha256_in_prefix": "332a98837f8ef0e0462ca05369fc595d5ddfdb9ef8329f23b8a2e8c2e1571276", + "size_in_bytes": 47136 + }, + { + "_path": "lib/python3.10/__pycache__/pickletools.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "e5e32ef4cf4b58be1ec348b20bb215426d509feae0ccdd12879adba6454959a3", + "sha256_in_prefix": "e5e32ef4cf4b58be1ec348b20bb215426d509feae0ccdd12879adba6454959a3", + "size_in_bytes": 68014 + }, + { + "_path": "lib/python3.10/__pycache__/pipes.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "7db85cd541010725873b10dd5d2ce937f644318240666747b97cadf802a2e42e", + "sha256_in_prefix": "7db85cd541010725873b10dd5d2ce937f644318240666747b97cadf802a2e42e", + "size_in_bytes": 8023 + }, + { + "_path": "lib/python3.10/__pycache__/pkgutil.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "2b86671ff03bd2e9057fbd5163be4ba97608ea2aa23b2a78040aa548bc8f794d", + "sha256_in_prefix": "2b86671ff03bd2e9057fbd5163be4ba97608ea2aa23b2a78040aa548bc8f794d", + "size_in_bytes": 18615 + }, + { + "_path": "lib/python3.10/__pycache__/platform.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "f0e3ae39791484fb075953aecf85613b5a5cee114a497bad349f3fe5b199edd4", + "sha256_in_prefix": "f0e3ae39791484fb075953aecf85613b5a5cee114a497bad349f3fe5b199edd4", + "size_in_bytes": 27749 + }, + { + "_path": "lib/python3.10/__pycache__/plistlib.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "e23305830d8f895b514a0c9c1a0c818385052d561d3735a792296e7c053909d6", + "sha256_in_prefix": "e23305830d8f895b514a0c9c1a0c818385052d561d3735a792296e7c053909d6", + "size_in_bytes": 23810 + }, + { + "_path": "lib/python3.10/__pycache__/poplib.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "79f55fdcc7e417f3b095aa72c5abcce72e3e05a14dafc27314ddffa9833c21f4", + "sha256_in_prefix": "79f55fdcc7e417f3b095aa72c5abcce72e3e05a14dafc27314ddffa9833c21f4", + "size_in_bytes": 13827 + }, + { + "_path": "lib/python3.10/__pycache__/posixpath.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "af5ad547cebb7e6d7a555aac88f073dfcee2e2793987ae19a220d6bfc4ac1549", + "sha256_in_prefix": "af5ad547cebb7e6d7a555aac88f073dfcee2e2793987ae19a220d6bfc4ac1549", + "size_in_bytes": 10784 + }, + { + "_path": "lib/python3.10/__pycache__/pprint.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "480b453266bfc47328f5c59673975d0cc684bbcd18130ff79e195700fb13ffab", + "sha256_in_prefix": "480b453266bfc47328f5c59673975d0cc684bbcd18130ff79e195700fb13ffab", + "size_in_bytes": 18129 + }, + { + "_path": "lib/python3.10/__pycache__/profile.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "b5d6a24048a288c977fb7760bef5a75c081599ccc1ee4d74e5ffe3652d9ec7e1", + "sha256_in_prefix": "b5d6a24048a288c977fb7760bef5a75c081599ccc1ee4d74e5ffe3652d9ec7e1", + "size_in_bytes": 14645 + }, + { + "_path": "lib/python3.10/__pycache__/pstats.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "74a105a817909e809dc4f03f6f5455a51b2abbcdf2eddefcae4f52712756cbff", + "sha256_in_prefix": "74a105a817909e809dc4f03f6f5455a51b2abbcdf2eddefcae4f52712756cbff", + "size_in_bytes": 23616 + }, + { + "_path": "lib/python3.10/__pycache__/pty.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "7764d7bf1369e06195f94464b10bf1841f872b0a3b658a4bfc3e61c04d1a62db", + "sha256_in_prefix": "7764d7bf1369e06195f94464b10bf1841f872b0a3b658a4bfc3e61c04d1a62db", + "size_in_bytes": 4397 + }, + { + "_path": "lib/python3.10/__pycache__/py_compile.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "8c51520e06892c5c9c8643b2ae596f44a87e8e00f90878ffba38fae8d6715f01", + "sha256_in_prefix": "8c51520e06892c5c9c8643b2ae596f44a87e8e00f90878ffba38fae8d6715f01", + "size_in_bytes": 7571 + }, + { + "_path": "lib/python3.10/__pycache__/pyclbr.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "eea28e22a5cb5e2f72f8d0502a38ac8603bb39d143706b56304c0f0a66f05d4e", + "sha256_in_prefix": "eea28e22a5cb5e2f72f8d0502a38ac8603bb39d143706b56304c0f0a66f05d4e", + "size_in_bytes": 10029 + }, + { + "_path": "lib/python3.10/__pycache__/pydoc.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "853cefb6de255c4375b360519b9d21cc9f3c7c1b7d1077bb912fef01ec95d728", + "sha256_in_prefix": "853cefb6de255c4375b360519b9d21cc9f3c7c1b7d1077bb912fef01ec95d728", + "size_in_bytes": 85634 + }, + { + "_path": "lib/python3.10/__pycache__/queue.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "3f977a43029a4742801bc954076cc5740834ece129dd704a5adff6157e9159d8", + "sha256_in_prefix": "3f977a43029a4742801bc954076cc5740834ece129dd704a5adff6157e9159d8", + "size_in_bytes": 11046 + }, + { + "_path": "lib/python3.10/__pycache__/quopri.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "ad041b7a6d53f7320fa5d3493ba76084a324e6801a7dcf6d3b401f708ca9e74c", + "sha256_in_prefix": "ad041b7a6d53f7320fa5d3493ba76084a324e6801a7dcf6d3b401f708ca9e74c", + "size_in_bytes": 6048 + }, + { + "_path": "lib/python3.10/__pycache__/random.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "7f799e9a6a4efef1df5aa0bdf3cf0baff9821cd86b89122e84a0dbc73bce221f", + "sha256_in_prefix": "7f799e9a6a4efef1df5aa0bdf3cf0baff9821cd86b89122e84a0dbc73bce221f", + "size_in_bytes": 23002 + }, + { + "_path": "lib/python3.10/__pycache__/re.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "de6f6b6b8e587a60ceef34f7e232eeb60d4fba1b41852b278d62a55b709e7f3a", + "sha256_in_prefix": "de6f6b6b8e587a60ceef34f7e232eeb60d4fba1b41852b278d62a55b709e7f3a", + "size_in_bytes": 14481 + }, + { + "_path": "lib/python3.10/__pycache__/reprlib.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "05634e96492039fb43041a3bcc3ce453027ac674e874430d93e49a7188495332", + "sha256_in_prefix": "05634e96492039fb43041a3bcc3ce453027ac674e874430d93e49a7188495332", + "size_in_bytes": 5504 + }, + { + "_path": "lib/python3.10/__pycache__/rlcompleter.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "9a12abe6afa01bfb5ff1dff5c65596e82c9e0b9696a4bed623c5b0ad30f35fbd", + "sha256_in_prefix": "9a12abe6afa01bfb5ff1dff5c65596e82c9e0b9696a4bed623c5b0ad30f35fbd", + "size_in_bytes": 6208 + }, + { + "_path": "lib/python3.10/__pycache__/runpy.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "2f7f23f41bd3053299446cd47182c63d0d37d4e571d71fd27cf3168bdb4278d8", + "sha256_in_prefix": "2f7f23f41bd3053299446cd47182c63d0d37d4e571d71fd27cf3168bdb4278d8", + "size_in_bytes": 9665 + }, + { + "_path": "lib/python3.10/__pycache__/sched.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "8b87370133b11f0cecd85162b9eff6acf12eff0d92c76e9b60aaeae7479067dd", + "sha256_in_prefix": "8b87370133b11f0cecd85162b9eff6acf12eff0d92c76e9b60aaeae7479067dd", + "size_in_bytes": 6369 + }, + { + "_path": "lib/python3.10/__pycache__/secrets.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "e54f26116de28db76fac51d9fe2ad7db94b740c8f30cdd1de1a795d854a52f37", + "sha256_in_prefix": "e54f26116de28db76fac51d9fe2ad7db94b740c8f30cdd1de1a795d854a52f37", + "size_in_bytes": 2429 + }, + { + "_path": "lib/python3.10/__pycache__/selectors.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "466b56ea319722116fd2daed9a9356698cee4b614c8a357f51833c2642247e11", + "sha256_in_prefix": "466b56ea319722116fd2daed9a9356698cee4b614c8a357f51833c2642247e11", + "size_in_bytes": 17359 + }, + { + "_path": "lib/python3.10/__pycache__/shelve.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "fb0c9f0543143667d2864540755a44d9a4f85e58f3bee6534b6b325f159f32c9", + "sha256_in_prefix": "fb0c9f0543143667d2864540755a44d9a4f85e58f3bee6534b6b325f159f32c9", + "size_in_bytes": 9746 + }, + { + "_path": "lib/python3.10/__pycache__/shlex.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c12946081162ca3a5bac322701d059d441bd7ef7c291ce0daab57ecf61117a68", + "sha256_in_prefix": "c12946081162ca3a5bac322701d059d441bd7ef7c291ce0daab57ecf61117a68", + "size_in_bytes": 8036 + }, + { + "_path": "lib/python3.10/__pycache__/shutil.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "7a5fa7157229da3fd94f4d39c5086c13dcbaf842b4a7bf4baf7376d4b151b05e", + "sha256_in_prefix": "7a5fa7157229da3fd94f4d39c5086c13dcbaf842b4a7bf4baf7376d4b151b05e", + "size_in_bytes": 38790 + }, + { + "_path": "lib/python3.10/__pycache__/signal.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "9269615b7bfaedb29c59c989bcdbea06bfbc4b24bd5b799d4e58c1093f455f60", + "sha256_in_prefix": "9269615b7bfaedb29c59c989bcdbea06bfbc4b24bd5b799d4e58c1093f455f60", + "size_in_bytes": 3189 + }, + { + "_path": "lib/python3.10/__pycache__/site.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "cd0d6790f041a3b661e66f00676431f93e857dd49580ee5d01e36bb04e4a6e08", + "sha256_in_prefix": "cd0d6790f041a3b661e66f00676431f93e857dd49580ee5d01e36bb04e4a6e08", + "size_in_bytes": 17902 + }, + { + "_path": "lib/python3.10/__pycache__/smtpd.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "7399c09f937bb69c75f57b3aba64d15009498ac4d21fc9a35bd2668ae65cf390", + "sha256_in_prefix": "7399c09f937bb69c75f57b3aba64d15009498ac4d21fc9a35bd2668ae65cf390", + "size_in_bytes": 26401 + }, + { + "_path": "lib/python3.10/__pycache__/smtplib.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "38efe1268c57a7bd00e721cd87aac916d7391a352b99292ebf0baf797e47b283", + "sha256_in_prefix": "38efe1268c57a7bd00e721cd87aac916d7391a352b99292ebf0baf797e47b283", + "size_in_bytes": 36020 + }, + { + "_path": "lib/python3.10/__pycache__/sndhdr.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "36d3d17304b43a2bd66bf4e0fdabb997fa500ae2778053fcf38df49a24f22f8d", + "sha256_in_prefix": "36d3d17304b43a2bd66bf4e0fdabb997fa500ae2778053fcf38df49a24f22f8d", + "size_in_bytes": 7216 + }, + { + "_path": "lib/python3.10/__pycache__/socket.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "73631c65590777b0e07f303619b090eeacf6c47b758ddaacd194f9544323627a", + "sha256_in_prefix": "73631c65590777b0e07f303619b090eeacf6c47b758ddaacd194f9544323627a", + "size_in_bytes": 29217 + }, + { + "_path": "lib/python3.10/__pycache__/socketserver.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "9896c3117ef237e5ae913794cba70879599eb075c31477f24940a1101fdfa6df", + "sha256_in_prefix": "9896c3117ef237e5ae913794cba70879599eb075c31477f24940a1101fdfa6df", + "size_in_bytes": 25601 + }, + { + "_path": "lib/python3.10/__pycache__/sre_compile.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "5ff24ece8dfe2ec6cdd2aa3ef738ba3a22da25e73d88adc6df983f8f6ddb8c7f", + "sha256_in_prefix": "5ff24ece8dfe2ec6cdd2aa3ef738ba3a22da25e73d88adc6df983f8f6ddb8c7f", + "size_in_bytes": 15448 + }, + { + "_path": "lib/python3.10/__pycache__/sre_constants.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "7458a0443a5c3528e72bb5234e08a559bd093369823a60c8702e26f25b942e12", + "sha256_in_prefix": "7458a0443a5c3528e72bb5234e08a559bd093369823a60c8702e26f25b942e12", + "size_in_bytes": 6611 + }, + { + "_path": "lib/python3.10/__pycache__/sre_parse.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "cdf0130c3260d61c4ae02cebb348a2a7124311f5a0a905b5316dbd21b9ea96d7", + "sha256_in_prefix": "cdf0130c3260d61c4ae02cebb348a2a7124311f5a0a905b5316dbd21b9ea96d7", + "size_in_bytes": 22009 + }, + { + "_path": "lib/python3.10/__pycache__/ssl.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "90ee6432f019288a23f4decb84a718114cb98b4f7344be67e83cf45303fa08a0", + "sha256_in_prefix": "90ee6432f019288a23f4decb84a718114cb98b4f7344be67e83cf45303fa08a0", + "size_in_bytes": 45535 + }, + { + "_path": "lib/python3.10/__pycache__/stat.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "1976574aa065b1ac292f8d713d37f02e97c4342696464e5e71e98b1b2026f265", + "sha256_in_prefix": "1976574aa065b1ac292f8d713d37f02e97c4342696464e5e71e98b1b2026f265", + "size_in_bytes": 4527 + }, + { + "_path": "lib/python3.10/__pycache__/statistics.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "564529e2d5c9bf9af57231465c03bf4cd1eaa04f144c77814ea641d64d6065c9", + "sha256_in_prefix": "564529e2d5c9bf9af57231465c03bf4cd1eaa04f144c77814ea641d64d6065c9", + "size_in_bytes": 37305 + }, + { + "_path": "lib/python3.10/__pycache__/string.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "2db1d247799b8173ca3a75a928c5e41e4dbe1b76b1e2730e99b7d827f5c635d2", + "sha256_in_prefix": "2db1d247799b8173ca3a75a928c5e41e4dbe1b76b1e2730e99b7d827f5c635d2", + "size_in_bytes": 7356 + }, + { + "_path": "lib/python3.10/__pycache__/stringprep.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "23d1f3f79af1f13e97129248afb3514b5519157b33838d0799b0f56467aa9104", + "sha256_in_prefix": "23d1f3f79af1f13e97129248afb3514b5519157b33838d0799b0f56467aa9104", + "size_in_bytes": 17329 + }, + { + "_path": "lib/python3.10/__pycache__/struct.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "3688a1f0af065700ea01e94a97465309550daa3567e50027a508a48161f5b198", + "sha256_in_prefix": "3688a1f0af065700ea01e94a97465309550daa3567e50027a508a48161f5b198", + "size_in_bytes": 561 + }, + { + "_path": "lib/python3.10/__pycache__/subprocess.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "ee4dfd25ca82d435506dbd280ff00788ac18f714ba4ac01dd48eac68c448b084", + "sha256_in_prefix": "ee4dfd25ca82d435506dbd280ff00788ac18f714ba4ac01dd48eac68c448b084", + "size_in_bytes": 44995 + }, + { + "_path": "lib/python3.10/__pycache__/sunau.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "930531ad687c85cf8044ce5a2e07e1ac79845496da8c0da9cc76d5f08a5d9ccf", + "sha256_in_prefix": "930531ad687c85cf8044ce5a2e07e1ac79845496da8c0da9cc76d5f08a5d9ccf", + "size_in_bytes": 16736 + }, + { + "_path": "lib/python3.10/__pycache__/symtable.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "879e5a33e2280a19bafcc09fe58c528daec95b04693c768e89c3bb9064805362", + "sha256_in_prefix": "879e5a33e2280a19bafcc09fe58c528daec95b04693c768e89c3bb9064805362", + "size_in_bytes": 13089 + }, + { + "_path": "lib/python3.10/__pycache__/sysconfig.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "937aa0ab417e860a11b07ad3037d8ebea4a2fd186c91107dd82b41ea04853d06", + "sha256_in_prefix": "937aa0ab417e860a11b07ad3037d8ebea4a2fd186c91107dd82b41ea04853d06", + "size_in_bytes": 17767 + }, + { + "_path": "lib/python3.10/__pycache__/tabnanny.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "bd7c8620d89ea31ac448b09163aeb174ab57115a7ed2b1c19637ebf5cb908345", + "sha256_in_prefix": "bd7c8620d89ea31ac448b09163aeb174ab57115a7ed2b1c19637ebf5cb908345", + "size_in_bytes": 7204 + }, + { + "_path": "lib/python3.10/__pycache__/tarfile.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "22565e029d33406c53a4557e7ad6706f75427fb61e5aaf9cefb4f182fe6b0ca0", + "sha256_in_prefix": "22565e029d33406c53a4557e7ad6706f75427fb61e5aaf9cefb4f182fe6b0ca0", + "size_in_bytes": 70607 + }, + { + "_path": "lib/python3.10/__pycache__/telnetlib.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c65f7a03d11380870ce335d60339f7781f3f8b5f2426f3f7af8d477120fdc3c6", + "sha256_in_prefix": "c65f7a03d11380870ce335d60339f7781f3f8b5f2426f3f7af8d477120fdc3c6", + "size_in_bytes": 18760 + }, + { + "_path": "lib/python3.10/__pycache__/tempfile.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "71810ee6e0f42968750c7f2819c3ccc4928aab9f5cc243ff20449dc225c0352f", + "sha256_in_prefix": "71810ee6e0f42968750c7f2819c3ccc4928aab9f5cc243ff20449dc225c0352f", + "size_in_bytes": 24567 + }, + { + "_path": "lib/python3.10/__pycache__/textwrap.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "a60bd591aab34db92c21e066e0d04c11758d76f73471425d70d928bf3d7a899a", + "sha256_in_prefix": "a60bd591aab34db92c21e066e0d04c11758d76f73471425d70d928bf3d7a899a", + "size_in_bytes": 14066 + }, + { + "_path": "lib/python3.10/__pycache__/this.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "186ae09446db64aad0268cba0c6b7314b24b4b28d9695fb53b87918fe5a3f106", + "sha256_in_prefix": "186ae09446db64aad0268cba0c6b7314b24b4b28d9695fb53b87918fe5a3f106", + "size_in_bytes": 1518 + }, + { + "_path": "lib/python3.10/__pycache__/threading.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "4cb74848eba1f5f0b508d775b25437a7bbcbe0aeb9850305880f25e8fa7ad4a0", + "sha256_in_prefix": "4cb74848eba1f5f0b508d775b25437a7bbcbe0aeb9850305880f25e8fa7ad4a0", + "size_in_bytes": 45223 + }, + { + "_path": "lib/python3.10/__pycache__/timeit.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "348e2518d965ad9b0c841aecfd311424aa458519f4eb768693366a5baa0dd118", + "sha256_in_prefix": "348e2518d965ad9b0c841aecfd311424aa458519f4eb768693366a5baa0dd118", + "size_in_bytes": 12023 + }, + { + "_path": "lib/python3.10/__pycache__/token.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "556f792ef1326a52dd4f87c19a58057c66c5bef16d34173377de61636f570b0d", + "sha256_in_prefix": "556f792ef1326a52dd4f87c19a58057c66c5bef16d34173377de61636f570b0d", + "size_in_bytes": 2992 + }, + { + "_path": "lib/python3.10/__pycache__/tokenize.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "1f8741f734bed8e44c0d6933a54e4722242de32470de8bcd83340a35ac0ad352", + "sha256_in_prefix": "1f8741f734bed8e44c0d6933a54e4722242de32470de8bcd83340a35ac0ad352", + "size_in_bytes": 17448 + }, + { + "_path": "lib/python3.10/__pycache__/trace.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "10c5591c3e75634587f9265a5a014cf2e141475b9ea4391b981ee0bbc5124b57", + "sha256_in_prefix": "10c5591c3e75634587f9265a5a014cf2e141475b9ea4391b981ee0bbc5124b57", + "size_in_bytes": 20124 + }, + { + "_path": "lib/python3.10/__pycache__/traceback.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "31d0b30ac4c29ef2f2d2dd5bafacf21c4d34c1e4bea8b8dc31c5f3180bd6d79f", + "sha256_in_prefix": "31d0b30ac4c29ef2f2d2dd5bafacf21c4d34c1e4bea8b8dc31c5f3180bd6d79f", + "size_in_bytes": 21966 + }, + { + "_path": "lib/python3.10/__pycache__/tracemalloc.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "e65a53d0f3a39940d639591cc6a0e5a9a87f5a2a78ce56894214fc281328cda3", + "sha256_in_prefix": "e65a53d0f3a39940d639591cc6a0e5a9a87f5a2a78ce56894214fc281328cda3", + "size_in_bytes": 17779 + }, + { + "_path": "lib/python3.10/__pycache__/tty.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "4c00d776ed42339b847c45e5eaccd510355c3d8e0cdf001aefbcd2f1fffe0386", + "sha256_in_prefix": "4c00d776ed42339b847c45e5eaccd510355c3d8e0cdf001aefbcd2f1fffe0386", + "size_in_bytes": 1333 + }, + { + "_path": "lib/python3.10/__pycache__/turtle.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c119e518158b121dd5df9b364a2145a3df571cbc1fef5f2cb9239b554906c8b4", + "sha256_in_prefix": "c119e518158b121dd5df9b364a2145a3df571cbc1fef5f2cb9239b554906c8b4", + "size_in_bytes": 129111 + }, + { + "_path": "lib/python3.10/__pycache__/types.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "2ff80802d1c1453ac9c8033bc96e74bf4f350d285c30d4b6ea66aaab3ef0acf1", + "sha256_in_prefix": "2ff80802d1c1453ac9c8033bc96e74bf4f350d285c30d4b6ea66aaab3ef0acf1", + "size_in_bytes": 9779 + }, + { + "_path": "lib/python3.10/__pycache__/typing.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "1a09ec028e150b35e8b06fb50262a4f59b20ac3f87663d42e425665e789fe5f1", + "sha256_in_prefix": "1a09ec028e150b35e8b06fb50262a4f59b20ac3f87663d42e425665e789fe5f1", + "size_in_bytes": 85531 + }, + { + "_path": "lib/python3.10/__pycache__/uu.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "5f4d6534c252e38259be605486ec87073c87d41c54dead227f1ad03d5301f600", + "sha256_in_prefix": "5f4d6534c252e38259be605486ec87073c87d41c54dead227f1ad03d5301f600", + "size_in_bytes": 4121 + }, + { + "_path": "lib/python3.10/__pycache__/uuid.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "bd49bf96527b25593232faa59fb504b5b834a9fb879c29299f29d908df2737bc", + "sha256_in_prefix": "bd49bf96527b25593232faa59fb504b5b834a9fb879c29299f29d908df2737bc", + "size_in_bytes": 22752 + }, + { + "_path": "lib/python3.10/__pycache__/warnings.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "1a8aa179d694195741780fcdc616932b7f5d75ddc9242d1929815a2fbd7cd616", + "sha256_in_prefix": "1a8aa179d694195741780fcdc616932b7f5d75ddc9242d1929815a2fbd7cd616", + "size_in_bytes": 13900 + }, + { + "_path": "lib/python3.10/__pycache__/wave.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "f7520ce2f972e65426ab67eef413334d6c13eaf323468172547aec6053929726", + "sha256_in_prefix": "f7520ce2f972e65426ab67eef413334d6c13eaf323468172547aec6053929726", + "size_in_bytes": 17848 + }, + { + "_path": "lib/python3.10/__pycache__/weakref.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "50aa992f0c9441147f76dbfb92233623c175f0931b86eb6ff51ac68e898c517d", + "sha256_in_prefix": "50aa992f0c9441147f76dbfb92233623c175f0931b86eb6ff51ac68e898c517d", + "size_in_bytes": 20597 + }, + { + "_path": "lib/python3.10/__pycache__/webbrowser.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "ca40167c6382225a6116dc352a57d7c3a75be9ff6ec557dc362dbdd594cf236a", + "sha256_in_prefix": "ca40167c6382225a6116dc352a57d7c3a75be9ff6ec557dc362dbdd594cf236a", + "size_in_bytes": 17254 + }, + { + "_path": "lib/python3.10/__pycache__/xdrlib.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "754402e4d3e1ac5c54f112562d9796e18db17f2ff92c6b4f6ffb7c0eccc12455", + "sha256_in_prefix": "754402e4d3e1ac5c54f112562d9796e18db17f2ff92c6b4f6ffb7c0eccc12455", + "size_in_bytes": 8134 + }, + { + "_path": "lib/python3.10/__pycache__/zipapp.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "fdf3b5ea4eec59e1026596e984b42621ce0f56c2fea6a09713982bd31d1b7335", + "sha256_in_prefix": "fdf3b5ea4eec59e1026596e984b42621ce0f56c2fea6a09713982bd31d1b7335", + "size_in_bytes": 6267 + }, + { + "_path": "lib/python3.10/__pycache__/zipfile.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "3c8e5b920291055f1b015372d9c430977f6680f48186aa7a4480dfc34afa374e", + "sha256_in_prefix": "3c8e5b920291055f1b015372d9c430977f6680f48186aa7a4480dfc34afa374e", + "size_in_bytes": 61658 + }, + { + "_path": "lib/python3.10/__pycache__/zipimport.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c9b6b37a1c99d3c3dd80218cdbb8c1bd7075a463da4041e9103eca7cdb9e49a1", + "sha256_in_prefix": "c9b6b37a1c99d3c3dd80218cdbb8c1bd7075a463da4041e9103eca7cdb9e49a1", + "size_in_bytes": 17287 + }, + { + "_path": "lib/python3.10/_aix_support.py", + "path_type": "hardlink", + "sha256": "d46a626c4160dcfde1f8e83f10f014524f0c1faf793432e5f322cd97a403a010", + "sha256_in_prefix": "d46a626c4160dcfde1f8e83f10f014524f0c1faf793432e5f322cd97a403a010", + "size_in_bytes": 3270 + }, + { + "_path": "lib/python3.10/_bootsubprocess.py", + "path_type": "hardlink", + "sha256": "dd8afc4a86131491a4f05078b307aae5eef19d6a26e7d9ffbfe2ebabbd6b5b6a", + "sha256_in_prefix": "dd8afc4a86131491a4f05078b307aae5eef19d6a26e7d9ffbfe2ebabbd6b5b6a", + "size_in_bytes": 2675 + }, + { + "_path": "lib/python3.10/_collections_abc.py", + "path_type": "hardlink", + "sha256": "48560945f0f48a364ceff93de6e4cd2e2779b5effce505e70258506be4c67dba", + "sha256_in_prefix": "48560945f0f48a364ceff93de6e4cd2e2779b5effce505e70258506be4c67dba", + "size_in_bytes": 32284 + }, + { + "_path": "lib/python3.10/_compat_pickle.py", + "path_type": "hardlink", + "sha256": "71248216fb1cc2b9a0a1faa305daa8c680d9c637141cb2db283e407684209cab", + "sha256_in_prefix": "71248216fb1cc2b9a0a1faa305daa8c680d9c637141cb2db283e407684209cab", + "size_in_bytes": 8749 + }, + { + "_path": "lib/python3.10/_compression.py", + "path_type": "hardlink", + "sha256": "3ad5d60627477a60939ee44fc1bb3a05dbe8fb52f0f75039b8f5d8f1a278b981", + "sha256_in_prefix": "3ad5d60627477a60939ee44fc1bb3a05dbe8fb52f0f75039b8f5d8f1a278b981", + "size_in_bytes": 5681 + }, + { + "_path": "lib/python3.10/_markupbase.py", + "path_type": "hardlink", + "sha256": "cb14dd6f2e2439eb70b806cd49d19911363d424c2b6b9f4b73c9c08022d47030", + "sha256_in_prefix": "cb14dd6f2e2439eb70b806cd49d19911363d424c2b6b9f4b73c9c08022d47030", + "size_in_bytes": 14653 + }, + { + "_path": "lib/python3.10/_osx_support.py", + "path_type": "hardlink", + "sha256": "6a99e8c9ff67c891a3c4c19e449fe2ee7b9d8e4b71f8741c3ce4469ce315dd95", + "sha256_in_prefix": "6a99e8c9ff67c891a3c4c19e449fe2ee7b9d8e4b71f8741c3ce4469ce315dd95", + "size_in_bytes": 21787 + }, + { + "_path": "lib/python3.10/_py_abc.py", + "path_type": "hardlink", + "sha256": "f9c6fe3dd9b51bd7d93f867356e9d362600c924febfd903ee1c6e298860dca92", + "sha256_in_prefix": "f9c6fe3dd9b51bd7d93f867356e9d362600c924febfd903ee1c6e298860dca92", + "size_in_bytes": 6189 + }, + { + "_path": "lib/python3.10/_pydecimal.py", + "path_type": "hardlink", + "sha256": "8b8d83314c282428810d5111dc76fad3b4f773ab535f425c1cd951483f735c50", + "sha256_in_prefix": "8b8d83314c282428810d5111dc76fad3b4f773ab535f425c1cd951483f735c50", + "size_in_bytes": 228676 + }, + { + "_path": "lib/python3.10/_pyio.py", + "path_type": "hardlink", + "sha256": "6c059e6f9800fc08bd0998251c66c16066c9bd3e0413424f252e16e5b48d3dee", + "sha256_in_prefix": "6c059e6f9800fc08bd0998251c66c16066c9bd3e0413424f252e16e5b48d3dee", + "size_in_bytes": 94467 + }, + { + "_path": "lib/python3.10/_sitebuiltins.py", + "path_type": "hardlink", + "sha256": "b9388bc1d6d12ed6be12da420ab1feca40f99c0e33ec315d92b1e01cb69b25bc", + "sha256_in_prefix": "b9388bc1d6d12ed6be12da420ab1feca40f99c0e33ec315d92b1e01cb69b25bc", + "size_in_bytes": 3128 + }, + { + "_path": "lib/python3.10/_strptime.py", + "path_type": "hardlink", + "sha256": "065e6597af214f795d16c018fdfe60ec93ab1d2703bdb159e0576173a19a72f8", + "sha256_in_prefix": "065e6597af214f795d16c018fdfe60ec93ab1d2703bdb159e0576173a19a72f8", + "size_in_bytes": 25277 + }, + { + "_path": "lib/python3.10/_sysconfigdata__darwin_darwin.py", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_9afkyeq1z4/croot/python-split_1715024112201/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_p", + "sha256": "e6d60c63eb8c01b4fde7d61f5e9245ac32662db7b499b1a7c96053dfaeff3297", + "sha256_in_prefix": "4bcdc88d749f3550ce70c4331043e0c43e4aeb47272324c079d1f186c1a1b3ba", + "size_in_bytes": 57548 + }, + { + "_path": "lib/python3.10/_sysconfigdata__darwin_darwin.py.orig", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_9afkyeq1z4/croot/python-split_1715024112201/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_p", + "sha256": "b7856badf58d94dffc6bf0f8a4abb7dabea7e25cc0742b5be5f597e5713670c3", + "sha256_in_prefix": "dd629c56ec211ee7c5082535a812cf13bd1f61e6a2787f74593d549781c6e47d", + "size_in_bytes": 66674 + }, + { + "_path": "lib/python3.10/_sysconfigdata_arm64_apple_darwin20_0_0.py", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_9afkyeq1z4/croot/python-split_1715024112201/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_p", + "sha256": "f271a2d611a7f9de1e0085415618a611469dffa8f754368f1f955f4f5d59b3f2", + "sha256_in_prefix": "24b06995ef1dc0c5c1929b6d436241857f9c79a75af15a850076b67e42c1f931", + "size_in_bytes": 59223 + }, + { + "_path": "lib/python3.10/_threading_local.py", + "path_type": "hardlink", + "sha256": "e1bf3dae66d0bfa63c8bb8a1d10c611203c35c636f7f5191fd56105788ef29cb", + "sha256_in_prefix": "e1bf3dae66d0bfa63c8bb8a1d10c611203c35c636f7f5191fd56105788ef29cb", + "size_in_bytes": 7220 + }, + { + "_path": "lib/python3.10/_weakrefset.py", + "path_type": "hardlink", + "sha256": "49fb432325ef836f89caa60e50b152eb6f32b700ed71fedcd4d56815723f77ba", + "sha256_in_prefix": "49fb432325ef836f89caa60e50b152eb6f32b700ed71fedcd4d56815723f77ba", + "size_in_bytes": 5923 + }, + { + "_path": "lib/python3.10/abc.py", + "path_type": "hardlink", + "sha256": "c702f783a7e81f9c37a1d22095c05360b11916d144d2730ff735c36f879523c5", + "sha256_in_prefix": "c702f783a7e81f9c37a1d22095c05360b11916d144d2730ff735c36f879523c5", + "size_in_bytes": 6522 + }, + { + "_path": "lib/python3.10/aifc.py", + "path_type": "hardlink", + "sha256": "bb1a32c21c6ce68e9858cd5ec983643afa586a4f6d613210e49ea7346ba02833", + "sha256_in_prefix": "bb1a32c21c6ce68e9858cd5ec983643afa586a4f6d613210e49ea7346ba02833", + "size_in_bytes": 32605 + }, + { + "_path": "lib/python3.10/antigravity.py", + "path_type": "hardlink", + "sha256": "8a5ee63e1b79ba2733e7ff4290b6eefea60e7f3a1ccb6bb519535aaf92b44967", + "sha256_in_prefix": "8a5ee63e1b79ba2733e7ff4290b6eefea60e7f3a1ccb6bb519535aaf92b44967", + "size_in_bytes": 500 + }, + { + "_path": "lib/python3.10/argparse.py", + "path_type": "hardlink", + "sha256": "a238b700513237e10d26056e42c5b4e42d4961ea70e15ebeef4c61c76615f004", + "sha256_in_prefix": "a238b700513237e10d26056e42c5b4e42d4961ea70e15ebeef4c61c76615f004", + "size_in_bytes": 98543 + }, + { + "_path": "lib/python3.10/ast.py", + "path_type": "hardlink", + "sha256": "2bacf018a141dd55b5ab20e4e2cc39ca7390b26f06948f8a8cb6edbedc292829", + "sha256_in_prefix": "2bacf018a141dd55b5ab20e4e2cc39ca7390b26f06948f8a8cb6edbedc292829", + "size_in_bytes": 59900 + }, + { + "_path": "lib/python3.10/asynchat.py", + "path_type": "hardlink", + "sha256": "375c501c0dc3138c5f75fa80ce624c8f1a5bfd388c7855c3b03982751faf30e5", + "sha256_in_prefix": "375c501c0dc3138c5f75fa80ce624c8f1a5bfd388c7855c3b03982751faf30e5", + "size_in_bytes": 11520 + }, + { + "_path": "lib/python3.10/asyncio/__init__.py", + "path_type": "hardlink", + "sha256": "3930c26c8274f38a7f5bf6cc323f313b8ed922a8c0fc1fb50aab4beccca25d02", + "sha256_in_prefix": "3930c26c8274f38a7f5bf6cc323f313b8ed922a8c0fc1fb50aab4beccca25d02", + "size_in_bytes": 1108 + }, + { + "_path": "lib/python3.10/asyncio/__main__.py", + "path_type": "hardlink", + "sha256": "eb22d0fa0c480025270feb1e7f962510666287fe2ccaeb7f309d32637507d061", + "sha256_in_prefix": "eb22d0fa0c480025270feb1e7f962510666287fe2ccaeb7f309d32637507d061", + "size_in_bytes": 3343 + }, + { + "_path": "lib/python3.10/asyncio/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c50fd6ca76b312bb7d5fa6e961302e625075e9f02758245e9a2076419312be1c", + "sha256_in_prefix": "c50fd6ca76b312bb7d5fa6e961302e625075e9f02758245e9a2076419312be1c", + "size_in_bytes": 998 + }, + { + "_path": "lib/python3.10/asyncio/__pycache__/__main__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c49dd7d96c2a2a86ae1dda3c2f49c19173c64b60f380d4c0fe7889893c4ad21c", + "sha256_in_prefix": "c49dd7d96c2a2a86ae1dda3c2f49c19173c64b60f380d4c0fe7889893c4ad21c", + "size_in_bytes": 3166 + }, + { + "_path": "lib/python3.10/asyncio/__pycache__/base_events.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "107e0a1924a2a20765415ecdd6f95485f250a8b446d65bd8dc4edb3f762869fe", + "sha256_in_prefix": "107e0a1924a2a20765415ecdd6f95485f250a8b446d65bd8dc4edb3f762869fe", + "size_in_bytes": 52106 + }, + { + "_path": "lib/python3.10/asyncio/__pycache__/base_futures.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "773f23a3f46e15b3fa2a6bda6945de6244864cf610428e7a6e249e85c17420eb", + "sha256_in_prefix": "773f23a3f46e15b3fa2a6bda6945de6244864cf610428e7a6e249e85c17420eb", + "size_in_bytes": 2165 + }, + { + "_path": "lib/python3.10/asyncio/__pycache__/base_subprocess.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "200ccaf2461bb48f0c0d7dbb6959e21dd457ef87eb830a43dc772ab906857137", + "sha256_in_prefix": "200ccaf2461bb48f0c0d7dbb6959e21dd457ef87eb830a43dc772ab906857137", + "size_in_bytes": 9640 + }, + { + "_path": "lib/python3.10/asyncio/__pycache__/base_tasks.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "88b198a64c78e2e2eac9912b087ed6e3186fdb643b6d260180f83f7299bfdfc0", + "sha256_in_prefix": "88b198a64c78e2e2eac9912b087ed6e3186fdb643b6d260180f83f7299bfdfc0", + "size_in_bytes": 2235 + }, + { + "_path": "lib/python3.10/asyncio/__pycache__/constants.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "7f25f4ac10ea7c0a2ddb0f63b46d2838177b4f3abdf6ed3dc4da794489e852b3", + "sha256_in_prefix": "7f25f4ac10ea7c0a2ddb0f63b46d2838177b4f3abdf6ed3dc4da794489e852b3", + "size_in_bytes": 840 + }, + { + "_path": "lib/python3.10/asyncio/__pycache__/coroutines.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "22747090a427fc5e389510308d66c16521d84101ef54055540a94398197b335d", + "sha256_in_prefix": "22747090a427fc5e389510308d66c16521d84101ef54055540a94398197b335d", + "size_in_bytes": 6875 + }, + { + "_path": "lib/python3.10/asyncio/__pycache__/events.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "6150778bbf8d133c1370537e4f5a16eac066c6f533e8c3322c01e8bb4df60157", + "sha256_in_prefix": "6150778bbf8d133c1370537e4f5a16eac066c6f533e8c3322c01e8bb4df60157", + "size_in_bytes": 28560 + }, + { + "_path": "lib/python3.10/asyncio/__pycache__/exceptions.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "408b845a92a10abba02e4dbd7dd5f7f67a8cc44d66eb2086b0cd34e0fd965c08", + "sha256_in_prefix": "408b845a92a10abba02e4dbd7dd5f7f67a8cc44d66eb2086b0cd34e0fd965c08", + "size_in_bytes": 2722 + }, + { + "_path": "lib/python3.10/asyncio/__pycache__/format_helpers.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "742b31f71b8f9e780d228d0d99e708b7424ca3f2f025240fc3dffdf40adc72b1", + "sha256_in_prefix": "742b31f71b8f9e780d228d0d99e708b7424ca3f2f025240fc3dffdf40adc72b1", + "size_in_bytes": 2593 + }, + { + "_path": "lib/python3.10/asyncio/__pycache__/futures.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "487922582f9a2511359bef27edf9d58eb92672b9381f57ab990e022e5893d778", + "sha256_in_prefix": "487922582f9a2511359bef27edf9d58eb92672b9381f57ab990e022e5893d778", + "size_in_bytes": 12141 + }, + { + "_path": "lib/python3.10/asyncio/__pycache__/locks.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "02758800fd9fac72ff67b913bc8ae8e14e795d5578851d2755575f21bc72e669", + "sha256_in_prefix": "02758800fd9fac72ff67b913bc8ae8e14e795d5578851d2755575f21bc72e669", + "size_in_bytes": 14427 + }, + { + "_path": "lib/python3.10/asyncio/__pycache__/log.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "555c7d91172b204424dea6a5c06016ce09db370e6851245b5de88e239f9d0c67", + "sha256_in_prefix": "555c7d91172b204424dea6a5c06016ce09db370e6851245b5de88e239f9d0c67", + "size_in_bytes": 483 + }, + { + "_path": "lib/python3.10/asyncio/__pycache__/mixins.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "0caf4cb884242dd4f5f5108a7a7d23899e9b094957337899005ec5d762e20328", + "sha256_in_prefix": "0caf4cb884242dd4f5f5108a7a7d23899e9b094957337899005ec5d762e20328", + "size_in_bytes": 1331 + }, + { + "_path": "lib/python3.10/asyncio/__pycache__/proactor_events.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "28200218ef05692e6b7d6adb50578f2563bc4ae37841f81ef904eed51bebb198", + "sha256_in_prefix": "28200218ef05692e6b7d6adb50578f2563bc4ae37841f81ef904eed51bebb198", + "size_in_bytes": 24952 + }, + { + "_path": "lib/python3.10/asyncio/__pycache__/protocols.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "9910d32f4131be86845b0e899a0bae115a67be62b17818f24564eff9e6d5bf5e", + "sha256_in_prefix": "9910d32f4131be86845b0e899a0bae115a67be62b17818f24564eff9e6d5bf5e", + "size_in_bytes": 8552 + }, + { + "_path": "lib/python3.10/asyncio/__pycache__/queues.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "eb5024cf7181427dc4b3661c191aeff1df3a52269f8dea0c89e18f31e2aae00a", + "sha256_in_prefix": "eb5024cf7181427dc4b3661c191aeff1df3a52269f8dea0c89e18f31e2aae00a", + "size_in_bytes": 8295 + }, + { + "_path": "lib/python3.10/asyncio/__pycache__/runners.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "2ad8b783b39fc485bb6da55175a7cfc8124801b0a1e5f94d84a3c7dbcca24c4f", + "sha256_in_prefix": "2ad8b783b39fc485bb6da55175a7cfc8124801b0a1e5f94d84a3c7dbcca24c4f", + "size_in_bytes": 2346 + }, + { + "_path": "lib/python3.10/asyncio/__pycache__/selector_events.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "bda68f3f9da026d31e7a7a3fde3b6ec53887500e9638f5a06c2dc4287f7f6c3a", + "sha256_in_prefix": "bda68f3f9da026d31e7a7a3fde3b6ec53887500e9638f5a06c2dc4287f7f6c3a", + "size_in_bytes": 29832 + }, + { + "_path": "lib/python3.10/asyncio/__pycache__/sslproto.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "217b114b4ee62c01a5155e2b2a56dca065cdb127fc8e9b952ea8ef373f8acf3f", + "sha256_in_prefix": "217b114b4ee62c01a5155e2b2a56dca065cdb127fc8e9b952ea8ef373f8acf3f", + "size_in_bytes": 21949 + }, + { + "_path": "lib/python3.10/asyncio/__pycache__/staggered.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "028d579920950564efc1030b0718fc23c88680dc30c0e01da1d015283f621169", + "sha256_in_prefix": "028d579920950564efc1030b0718fc23c88680dc30c0e01da1d015283f621169", + "size_in_bytes": 4437 + }, + { + "_path": "lib/python3.10/asyncio/__pycache__/streams.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "96f11f2fca9ec097d0092d5e68894a68d076f4df6f342b6fabfbfbdc9e656ffd", + "sha256_in_prefix": "96f11f2fca9ec097d0092d5e68894a68d076f4df6f342b6fabfbfbdc9e656ffd", + "size_in_bytes": 20637 + }, + { + "_path": "lib/python3.10/asyncio/__pycache__/subprocess.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "291c7851b3ca2a1cdf71860f4966f727d3bdee269d428dcc4c3a758fb36761d9", + "sha256_in_prefix": "291c7851b3ca2a1cdf71860f4966f727d3bdee269d428dcc4c3a758fb36761d9", + "size_in_bytes": 7316 + }, + { + "_path": "lib/python3.10/asyncio/__pycache__/tasks.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "ad32f1f9d7fe895c5e5ca97791ba33078f9961c0c18f3fdd4c3490a762bb1933", + "sha256_in_prefix": "ad32f1f9d7fe895c5e5ca97791ba33078f9961c0c18f3fdd4c3490a762bb1933", + "size_in_bytes": 24227 + }, + { + "_path": "lib/python3.10/asyncio/__pycache__/threads.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "97c4d7237aae8e0d7a6e31d81fcf10f58e87d5b7cc391083c1b85a2001510643", + "sha256_in_prefix": "97c4d7237aae8e0d7a6e31d81fcf10f58e87d5b7cc391083c1b85a2001510643", + "size_in_bytes": 1239 + }, + { + "_path": "lib/python3.10/asyncio/__pycache__/transports.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "6e06ffb819a318472508584eadd5049d8dcb46f35aeb02df665c5398a3cb1fd0", + "sha256_in_prefix": "6e06ffb819a318472508584eadd5049d8dcb46f35aeb02df665c5398a3cb1fd0", + "size_in_bytes": 12586 + }, + { + "_path": "lib/python3.10/asyncio/__pycache__/trsock.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "e4fe086286a84cb1a62cf798eb303cc2ff472efaa417d9dccaa4312e14866946", + "sha256_in_prefix": "e4fe086286a84cb1a62cf798eb303cc2ff472efaa417d9dccaa4312e14866946", + "size_in_bytes": 8096 + }, + { + "_path": "lib/python3.10/asyncio/__pycache__/unix_events.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "6698b97c82d84f083d89655bd19dffd01c9939f791c77218955c26fc3b24511e", + "sha256_in_prefix": "6698b97c82d84f083d89655bd19dffd01c9939f791c77218955c26fc3b24511e", + "size_in_bytes": 41686 + }, + { + "_path": "lib/python3.10/asyncio/__pycache__/windows_events.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "91ab16177ca8a6cca36e8c5f98cbe4ebd1b0731e51e0e15693a2051d0a9703df", + "sha256_in_prefix": "91ab16177ca8a6cca36e8c5f98cbe4ebd1b0731e51e0e15693a2051d0a9703df", + "size_in_bytes": 24401 + }, + { + "_path": "lib/python3.10/asyncio/__pycache__/windows_utils.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "70c3a25e8a8b9e7a6b2da431f921232ffc79807eeaafc7d21c77db081b8c7a3a", + "sha256_in_prefix": "70c3a25e8a8b9e7a6b2da431f921232ffc79807eeaafc7d21c77db081b8c7a3a", + "size_in_bytes": 4750 + }, + { + "_path": "lib/python3.10/asyncio/base_events.py", + "path_type": "hardlink", + "sha256": "c6eae278db516bb7330204f7117ba4f80f200879c53d04a5e1e9c1131413c4f7", + "sha256_in_prefix": "c6eae278db516bb7330204f7117ba4f80f200879c53d04a5e1e9c1131413c4f7", + "size_in_bytes": 74341 + }, + { + "_path": "lib/python3.10/asyncio/base_futures.py", + "path_type": "hardlink", + "sha256": "6305968656c74facd06240e0a5352a8cb6db569c1c91f4908277d2723bae411d", + "sha256_in_prefix": "6305968656c74facd06240e0a5352a8cb6db569c1c91f4908277d2723bae411d", + "size_in_bytes": 2574 + }, + { + "_path": "lib/python3.10/asyncio/base_subprocess.py", + "path_type": "hardlink", + "sha256": "877cd264f49b3fbeaf0de6d7f0369e007a5e02f601d7ab72f3117a056aaa3cea", + "sha256_in_prefix": "877cd264f49b3fbeaf0de6d7f0369e007a5e02f601d7ab72f3117a056aaa3cea", + "size_in_bytes": 8843 + }, + { + "_path": "lib/python3.10/asyncio/base_tasks.py", + "path_type": "hardlink", + "sha256": "fb8c4508749d9ff286eeea60a9cc179b21480467f93d3b440ddc5caf908ec3bd", + "sha256_in_prefix": "fb8c4508749d9ff286eeea60a9cc179b21480467f93d3b440ddc5caf908ec3bd", + "size_in_bytes": 2467 + }, + { + "_path": "lib/python3.10/asyncio/constants.py", + "path_type": "hardlink", + "sha256": "e3bb7404a839c2ba512def9ef8ce206ff4ae3499eeec840c3d08d633d5e72d5d", + "sha256_in_prefix": "e3bb7404a839c2ba512def9ef8ce206ff4ae3499eeec840c3d08d633d5e72d5d", + "size_in_bytes": 888 + }, + { + "_path": "lib/python3.10/asyncio/coroutines.py", + "path_type": "hardlink", + "sha256": "55132b9bd716b607d231f97098d5c74484b4317f97877d7fcc9256ee56e0e154", + "sha256_in_prefix": "55132b9bd716b607d231f97098d5c74484b4317f97877d7fcc9256ee56e0e154", + "size_in_bytes": 8797 + }, + { + "_path": "lib/python3.10/asyncio/events.py", + "path_type": "hardlink", + "sha256": "29b89287c42d78cc8ef426e791cc36e5ecdf172bd04b3ceb77889f2e37661dc7", + "sha256_in_prefix": "29b89287c42d78cc8ef426e791cc36e5ecdf172bd04b3ceb77889f2e37661dc7", + "size_in_bytes": 27346 + }, + { + "_path": "lib/python3.10/asyncio/exceptions.py", + "path_type": "hardlink", + "sha256": "026283dbf8f6ab28f1aede20d07f13ec60653293e7da495eac2fd13aa3f6e289", + "sha256_in_prefix": "026283dbf8f6ab28f1aede20d07f13ec60653293e7da495eac2fd13aa3f6e289", + "size_in_bytes": 1633 + }, + { + "_path": "lib/python3.10/asyncio/format_helpers.py", + "path_type": "hardlink", + "sha256": "6377b672b3f4ba8b6f0f7a5f0ea00cde24c8cddc0ca764e3329f302763477f59", + "sha256_in_prefix": "6377b672b3f4ba8b6f0f7a5f0ea00cde24c8cddc0ca764e3329f302763477f59", + "size_in_bytes": 2404 + }, + { + "_path": "lib/python3.10/asyncio/futures.py", + "path_type": "hardlink", + "sha256": "5bc3d79ef36d9253beb8fb636acbbba061cd6b1c6a82a3100b9a31d4321ea097", + "sha256_in_prefix": "5bc3d79ef36d9253beb8fb636acbbba061cd6b1c6a82a3100b9a31d4321ea097", + "size_in_bytes": 14187 + }, + { + "_path": "lib/python3.10/asyncio/locks.py", + "path_type": "hardlink", + "sha256": "46a3a6a634d65900a1bc1567fa778146e5cb37a0d1b208bc0f29ee6b5703a0f1", + "sha256_in_prefix": "46a3a6a634d65900a1bc1567fa778146e5cb37a0d1b208bc0f29ee6b5703a0f1", + "size_in_bytes": 14122 + }, + { + "_path": "lib/python3.10/asyncio/log.py", + "path_type": "hardlink", + "sha256": "80e4cc3ded4b138baba486519e7444801a23d6ac35f229d336a407a96af7e8d2", + "sha256_in_prefix": "80e4cc3ded4b138baba486519e7444801a23d6ac35f229d336a407a96af7e8d2", + "size_in_bytes": 124 + }, + { + "_path": "lib/python3.10/asyncio/mixins.py", + "path_type": "hardlink", + "sha256": "830ed2ee56d90258cb29d0042b321e8076f7fac34c66b5f265f93aceb7159d25", + "sha256_in_prefix": "830ed2ee56d90258cb29d0042b321e8076f7fac34c66b5f265f93aceb7159d25", + "size_in_bytes": 803 + }, + { + "_path": "lib/python3.10/asyncio/proactor_events.py", + "path_type": "hardlink", + "sha256": "0ff50f71c24339339319c82d987b13541b625a1d6357ff3aea04d817857a7bbf", + "sha256_in_prefix": "0ff50f71c24339339319c82d987b13541b625a1d6357ff3aea04d817857a7bbf", + "size_in_bytes": 32541 + }, + { + "_path": "lib/python3.10/asyncio/protocols.py", + "path_type": "hardlink", + "sha256": "1d1b49988c338b4ef06e30f9e92d9db2e00080c341f0a3f573bb8312deb8aff6", + "sha256_in_prefix": "1d1b49988c338b4ef06e30f9e92d9db2e00080c341f0a3f573bb8312deb8aff6", + "size_in_bytes": 6957 + }, + { + "_path": "lib/python3.10/asyncio/queues.py", + "path_type": "hardlink", + "sha256": "b8f53efbc9fe57d4fb7df0bcc95f17c1eb63b1917f4fb7cd7906f382e3ed1ca3", + "sha256_in_prefix": "b8f53efbc9fe57d4fb7df0bcc95f17c1eb63b1917f4fb7cd7906f382e3ed1ca3", + "size_in_bytes": 8034 + }, + { + "_path": "lib/python3.10/asyncio/runners.py", + "path_type": "hardlink", + "sha256": "ab0247599989c8c8ff0e083eebb54e63312c32a207f28a47f5f22390a89364db", + "sha256_in_prefix": "ab0247599989c8c8ff0e083eebb54e63312c32a207f28a47f5f22390a89364db", + "size_in_bytes": 2104 + }, + { + "_path": "lib/python3.10/asyncio/selector_events.py", + "path_type": "hardlink", + "sha256": "964874b8b676dffadc934e131977d68b5d3df5372f5d8e476117dc8ae8a3a078", + "sha256_in_prefix": "964874b8b676dffadc934e131977d68b5d3df5372f5d8e476117dc8ae8a3a078", + "size_in_bytes": 39700 + }, + { + "_path": "lib/python3.10/asyncio/sslproto.py", + "path_type": "hardlink", + "sha256": "8da7cf9187e6e99cfc4331fb273673a2a7968c4323680add7b3c3e3e669cddde", + "sha256_in_prefix": "8da7cf9187e6e99cfc4331fb273673a2a7968c4323680add7b3c3e3e669cddde", + "size_in_bytes": 27459 + }, + { + "_path": "lib/python3.10/asyncio/staggered.py", + "path_type": "hardlink", + "sha256": "ff289bdc20a50ad9620393479d785bc653e71c2e3298f53ab27907cd136498e9", + "sha256_in_prefix": "ff289bdc20a50ad9620393479d785bc653e71c2e3298f53ab27907cd136498e9", + "size_in_bytes": 5992 + }, + { + "_path": "lib/python3.10/asyncio/streams.py", + "path_type": "hardlink", + "sha256": "48139784fe1e262ebea7ff72effd32c228f031399a12e0fbe27c0e770bc598e2", + "sha256_in_prefix": "48139784fe1e262ebea7ff72effd32c228f031399a12e0fbe27c0e770bc598e2", + "size_in_bytes": 25749 + }, + { + "_path": "lib/python3.10/asyncio/subprocess.py", + "path_type": "hardlink", + "sha256": "bfe0359e5fcf7a41554c47c94479014fb8873debac5d7f39869e17f82266e555", + "sha256_in_prefix": "bfe0359e5fcf7a41554c47c94479014fb8873debac5d7f39869e17f82266e555", + "size_in_bytes": 7405 + }, + { + "_path": "lib/python3.10/asyncio/tasks.py", + "path_type": "hardlink", + "sha256": "b3bccb5346d370059d20191cfec96e15bb07442c3aae9ce9c717190a8d8920c7", + "sha256_in_prefix": "b3bccb5346d370059d20191cfec96e15bb07442c3aae9ce9c717190a8d8920c7", + "size_in_bytes": 32458 + }, + { + "_path": "lib/python3.10/asyncio/threads.py", + "path_type": "hardlink", + "sha256": "39d37295383641565f0c08bd992e2f661dc8051eb17e890b834fce96bde0910e", + "sha256_in_prefix": "39d37295383641565f0c08bd992e2f661dc8051eb17e890b834fce96bde0910e", + "size_in_bytes": 790 + }, + { + "_path": "lib/python3.10/asyncio/transports.py", + "path_type": "hardlink", + "sha256": "986703cea28769307f7cdffc58a09ef78ea292e74d3b8d4f926e4452558998ce", + "sha256_in_prefix": "986703cea28769307f7cdffc58a09ef78ea292e74d3b8d4f926e4452558998ce", + "size_in_bytes": 10724 + }, + { + "_path": "lib/python3.10/asyncio/trsock.py", + "path_type": "hardlink", + "sha256": "435acc190d018d9421baa224d25b8d893967af5c5737a1e42f1bbf614c8e2bf3", + "sha256_in_prefix": "435acc190d018d9421baa224d25b8d893967af5c5737a1e42f1bbf614c8e2bf3", + "size_in_bytes": 5876 + }, + { + "_path": "lib/python3.10/asyncio/unix_events.py", + "path_type": "hardlink", + "sha256": "5db9c0ef744faa38c3429261473a3c894ba2108ac85b1f6d8a15317abfacb23e", + "sha256_in_prefix": "5db9c0ef744faa38c3429261473a3c894ba2108ac85b1f6d8a15317abfacb23e", + "size_in_bytes": 51624 + }, + { + "_path": "lib/python3.10/asyncio/windows_events.py", + "path_type": "hardlink", + "sha256": "95e80fb8245aa6de6435a70fdb7b8dd1f3189ce16d746addd0037e055384ced4", + "sha256_in_prefix": "95e80fb8245aa6de6435a70fdb7b8dd1f3189ce16d746addd0037e055384ced4", + "size_in_bytes": 33394 + }, + { + "_path": "lib/python3.10/asyncio/windows_utils.py", + "path_type": "hardlink", + "sha256": "e6fcffefa2521666bc2aed0f5caf8e862c1c1014ad12d2ab5fbce09c2df9c6f0", + "sha256_in_prefix": "e6fcffefa2521666bc2aed0f5caf8e862c1c1014ad12d2ab5fbce09c2df9c6f0", + "size_in_bytes": 5060 + }, + { + "_path": "lib/python3.10/asyncore.py", + "path_type": "hardlink", + "sha256": "a16d3244eb6d29870811bf9bf28227f005200e1498405f0adfac972f55220110", + "sha256_in_prefix": "a16d3244eb6d29870811bf9bf28227f005200e1498405f0adfac972f55220110", + "size_in_bytes": 20268 + }, + { + "_path": "lib/python3.10/base64.py", + "path_type": "hardlink", + "sha256": "108aaee81d7b9d1ceeb5d64d299ad8b9f78b6358c14a34d29ea11389f676cc91", + "sha256_in_prefix": "108aaee81d7b9d1ceeb5d64d299ad8b9f78b6358c14a34d29ea11389f676cc91", + "size_in_bytes": 20847 + }, + { + "_path": "lib/python3.10/bdb.py", + "path_type": "hardlink", + "sha256": "fe2841e182a4bc8561278102bdbd73c99c8345b4a8d2b2540af6a95f0b7f7734", + "sha256_in_prefix": "fe2841e182a4bc8561278102bdbd73c99c8345b4a8d2b2540af6a95f0b7f7734", + "size_in_bytes": 32396 + }, + { + "_path": "lib/python3.10/binhex.py", + "path_type": "hardlink", + "sha256": "347151ad93436cac32265eb255b07c75ddb89055ee8aca2c59eebff9df5d5d73", + "sha256_in_prefix": "347151ad93436cac32265eb255b07c75ddb89055ee8aca2c59eebff9df5d5d73", + "size_in_bytes": 14784 + }, + { + "_path": "lib/python3.10/bisect.py", + "path_type": "hardlink", + "sha256": "e5b2ff166f48a06e70ae831d8c9b47283fcd0c254306eee12d3dae9c55e11526", + "sha256_in_prefix": "e5b2ff166f48a06e70ae831d8c9b47283fcd0c254306eee12d3dae9c55e11526", + "size_in_bytes": 3135 + }, + { + "_path": "lib/python3.10/bz2.py", + "path_type": "hardlink", + "sha256": "76ab3252924e71e859d7d90e8d3db13b6554975cfcac0fdadced4de7f8779330", + "sha256_in_prefix": "76ab3252924e71e859d7d90e8d3db13b6554975cfcac0fdadced4de7f8779330", + "size_in_bytes": 11847 + }, + { + "_path": "lib/python3.10/cProfile.py", + "path_type": "hardlink", + "sha256": "60421977dca84f29b6c3be7229b39c5ec1ebbc724852b947ca779be8f84e7a4f", + "sha256_in_prefix": "60421977dca84f29b6c3be7229b39c5ec1ebbc724852b947ca779be8f84e7a4f", + "size_in_bytes": 6347 + }, + { + "_path": "lib/python3.10/calendar.py", + "path_type": "hardlink", + "sha256": "69bce110ecb19bf03d90fceddeb4f6704091c6f615ed6e8870fce5116ea2130e", + "sha256_in_prefix": "69bce110ecb19bf03d90fceddeb4f6704091c6f615ed6e8870fce5116ea2130e", + "size_in_bytes": 24575 + }, + { + "_path": "lib/python3.10/cgi.py", + "path_type": "hardlink", + "sha256": "ecd78445816fcd84c3c6fbcbb42f171a76cbad74c685a2ab241ca5c49ec5c297", + "sha256_in_prefix": "ecd78445816fcd84c3c6fbcbb42f171a76cbad74c685a2ab241ca5c49ec5c297", + "size_in_bytes": 34099 + }, + { + "_path": "lib/python3.10/cgitb.py", + "path_type": "hardlink", + "sha256": "8fbd49c0c9fad05e5036258e3749516f4e0c8a61cf7c9720574f5e20cb94beab", + "sha256_in_prefix": "8fbd49c0c9fad05e5036258e3749516f4e0c8a61cf7c9720574f5e20cb94beab", + "size_in_bytes": 12096 + }, + { + "_path": "lib/python3.10/chunk.py", + "path_type": "hardlink", + "sha256": "34a5d2cde2e00a03acd84768ccd352ebdc3ac008a8f41ab1caee698e4a474ca0", + "sha256_in_prefix": "34a5d2cde2e00a03acd84768ccd352ebdc3ac008a8f41ab1caee698e4a474ca0", + "size_in_bytes": 5435 + }, + { + "_path": "lib/python3.10/cmd.py", + "path_type": "hardlink", + "sha256": "1b18b978b7f2e2a587aa77f0bc7a6130718c4b680dd19cc749eb2ee7eb8b9590", + "sha256_in_prefix": "1b18b978b7f2e2a587aa77f0bc7a6130718c4b680dd19cc749eb2ee7eb8b9590", + "size_in_bytes": 14860 + }, + { + "_path": "lib/python3.10/code.py", + "path_type": "hardlink", + "sha256": "266841655656d5b2370e80addcdb959f5173142d5e3778b489e734802447c5e8", + "sha256_in_prefix": "266841655656d5b2370e80addcdb959f5173142d5e3778b489e734802447c5e8", + "size_in_bytes": 10622 + }, + { + "_path": "lib/python3.10/codecs.py", + "path_type": "hardlink", + "sha256": "166ffd0f0fe40631bb7adef898ebfe59c7fb9efeb25f635b0fd50b68e9353b6a", + "sha256_in_prefix": "166ffd0f0fe40631bb7adef898ebfe59c7fb9efeb25f635b0fd50b68e9353b6a", + "size_in_bytes": 36714 + }, + { + "_path": "lib/python3.10/codeop.py", + "path_type": "hardlink", + "sha256": "32799ec2d30e2792f8ddbd4b33ac83d5d410142c71199078c2036c6503ef29d2", + "sha256_in_prefix": "32799ec2d30e2792f8ddbd4b33ac83d5d410142c71199078c2036c6503ef29d2", + "size_in_bytes": 5609 + }, + { + "_path": "lib/python3.10/collections/__init__.py", + "path_type": "hardlink", + "sha256": "5d7b9d899fb1407a614cb2ade46b6d2400ba797634e9fed7d770fc4b7e372760", + "sha256_in_prefix": "5d7b9d899fb1407a614cb2ade46b6d2400ba797634e9fed7d770fc4b7e372760", + "size_in_bytes": 51398 + }, + { + "_path": "lib/python3.10/collections/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c91339a01dc68d45c09a82dc8d04b9387770b34b0b8a7b8592fbcaa2128c4b5f", + "sha256_in_prefix": "c91339a01dc68d45c09a82dc8d04b9387770b34b0b8a7b8592fbcaa2128c4b5f", + "size_in_bytes": 48707 + }, + { + "_path": "lib/python3.10/collections/__pycache__/abc.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "005d8c614fd5d98dc1941e080f9b7befaaa4d34ddce54b649db33848ea0ff1b7", + "sha256_in_prefix": "005d8c614fd5d98dc1941e080f9b7befaaa4d34ddce54b649db33848ea0ff1b7", + "size_in_bytes": 233 + }, + { + "_path": "lib/python3.10/collections/abc.py", + "path_type": "hardlink", + "sha256": "9cb4208f99128a0489b6c8e6c61637617dd7d4250c59e065491957eda084dd10", + "sha256_in_prefix": "9cb4208f99128a0489b6c8e6c61637617dd7d4250c59e065491957eda084dd10", + "size_in_bytes": 119 + }, + { + "_path": "lib/python3.10/colorsys.py", + "path_type": "hardlink", + "sha256": "ab78926242b393e09aeb37854f11cce2160cafce02ef713e4aac341abed9b040", + "sha256_in_prefix": "ab78926242b393e09aeb37854f11cce2160cafce02ef713e4aac341abed9b040", + "size_in_bytes": 4017 + }, + { + "_path": "lib/python3.10/compileall.py", + "path_type": "hardlink", + "sha256": "6ab668e2660cc54aafa2621751302da637f27c2484bf4783e559e68dbb0e05e5", + "sha256_in_prefix": "6ab668e2660cc54aafa2621751302da637f27c2484bf4783e559e68dbb0e05e5", + "size_in_bytes": 20252 + }, + { + "_path": "lib/python3.10/concurrent/__init__.py", + "path_type": "hardlink", + "sha256": "87ad5c8954dd56fbbca04517bf87477ff4dce575170c7dd1281d7ef1f4214ac8", + "sha256_in_prefix": "87ad5c8954dd56fbbca04517bf87477ff4dce575170c7dd1281d7ef1f4214ac8", + "size_in_bytes": 38 + }, + { + "_path": "lib/python3.10/concurrent/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "6f0e54471503635b75e1358ea6f79a28324d893d15acb2809e883500f8cd3064", + "sha256_in_prefix": "6f0e54471503635b75e1358ea6f79a28324d893d15acb2809e883500f8cd3064", + "size_in_bytes": 389 + }, + { + "_path": "lib/python3.10/concurrent/futures/__init__.py", + "path_type": "hardlink", + "sha256": "ff1f05fa12bc54681fa90da6197d7b2aaa09545e92b2a407769412b99b8966f9", + "sha256_in_prefix": "ff1f05fa12bc54681fa90da6197d7b2aaa09545e92b2a407769412b99b8966f9", + "size_in_bytes": 1554 + }, + { + "_path": "lib/python3.10/concurrent/futures/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c8cabba8d5be8f720bbc3bf69a3c4a61c6cfc889a9ebe3bf780fc56cdd40c1bc", + "sha256_in_prefix": "c8cabba8d5be8f720bbc3bf69a3c4a61c6cfc889a9ebe3bf780fc56cdd40c1bc", + "size_in_bytes": 1361 + }, + { + "_path": "lib/python3.10/concurrent/futures/__pycache__/_base.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "0bee2bd0cdfa306a6d54e7d227da0fafd4a98ed0cbdd859c80744958548a2484", + "sha256_in_prefix": "0bee2bd0cdfa306a6d54e7d227da0fafd4a98ed0cbdd859c80744958548a2484", + "size_in_bytes": 22487 + }, + { + "_path": "lib/python3.10/concurrent/futures/__pycache__/process.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "6e23026b7d5c8e78e26fd5feb66fc0399be47c06de6534239f1cd7556aad8ccf", + "sha256_in_prefix": "6e23026b7d5c8e78e26fd5feb66fc0399be47c06de6534239f1cd7556aad8ccf", + "size_in_bytes": 22011 + }, + { + "_path": "lib/python3.10/concurrent/futures/__pycache__/thread.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "d8c7f4edb878ec2060ba520318b465a049068837edb814c1bcc0a7fafe1178e8", + "sha256_in_prefix": "d8c7f4edb878ec2060ba520318b465a049068837edb814c1bcc0a7fafe1178e8", + "size_in_bytes": 6219 + }, + { + "_path": "lib/python3.10/concurrent/futures/_base.py", + "path_type": "hardlink", + "sha256": "6fc621cca6d246a19d3474f0e8b33cf24aecd0d89c649e92e2786709b9e24408", + "sha256_in_prefix": "6fc621cca6d246a19d3474f0e8b33cf24aecd0d89c649e92e2786709b9e24408", + "size_in_bytes": 22848 + }, + { + "_path": "lib/python3.10/concurrent/futures/process.py", + "path_type": "hardlink", + "sha256": "b02bb0c6158a31bc2e7ffc8fb6d049f4af64d6830b8b0c5aefc56e308cf53676", + "sha256_in_prefix": "b02bb0c6158a31bc2e7ffc8fb6d049f4af64d6830b8b0c5aefc56e308cf53676", + "size_in_bytes": 31995 + }, + { + "_path": "lib/python3.10/concurrent/futures/thread.py", + "path_type": "hardlink", + "sha256": "b06f8899881193efc72cfc3ebf2836dce4e668b3856ad35f4016616d643a519e", + "sha256_in_prefix": "b06f8899881193efc72cfc3ebf2836dce4e668b3856ad35f4016616d643a519e", + "size_in_bytes": 8771 + }, + { + "_path": "lib/python3.10/config-3.10-darwin/Makefile", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_9afkyeq1z4/croot/python-split_1715024112201/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_p", + "sha256": "519fc7d7e5bf92f06c8676ceb3c4f1f42cc96ca2d4b65aab2052c7d9aedf1ff5", + "sha256_in_prefix": "066a2492b8f464bb57e0d0e8b547faa49f138714f8c72fc8988d448a3ee3a519", + "size_in_bytes": 92204 + }, + { + "_path": "lib/python3.10/config-3.10-darwin/Setup", + "path_type": "hardlink", + "sha256": "4e919ed7f7fc274d9ea400fe0f56ff0e2942635bf1d878034db9d12b342425f0", + "sha256_in_prefix": "4e919ed7f7fc274d9ea400fe0f56ff0e2942635bf1d878034db9d12b342425f0", + "size_in_bytes": 15518 + }, + { + "_path": "lib/python3.10/config-3.10-darwin/Setup.local", + "path_type": "hardlink", + "sha256": "d29e734b34f3f8cb4a8c2b9305b6e7f378214ecd13928f2671db2c7ee0f7b378", + "sha256_in_prefix": "d29e734b34f3f8cb4a8c2b9305b6e7f378214ecd13928f2671db2c7ee0f7b378", + "size_in_bytes": 41 + }, + { + "_path": "lib/python3.10/config-3.10-darwin/__pycache__/python-config.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "9eee063ca3b38c7066d1585e752104a57ef0667669e8ea1489acf96331bcdf5f", + "sha256_in_prefix": "9eee063ca3b38c7066d1585e752104a57ef0667669e8ea1489acf96331bcdf5f", + "size_in_bytes": 2130 + }, + { + "_path": "lib/python3.10/config-3.10-darwin/config.c", + "path_type": "hardlink", + "sha256": "a33b17b491bd8d9817c74beae5bd4e64ce6df754e161ff2813c83e661baa734a", + "sha256_in_prefix": "a33b17b491bd8d9817c74beae5bd4e64ce6df754e161ff2813c83e661baa734a", + "size_in_bytes": 3389 + }, + { + "_path": "lib/python3.10/config-3.10-darwin/config.c.in", + "path_type": "hardlink", + "sha256": "7a31cbf2498d03219c431cb13a22eb868c4fc0f5f45f369fc3acb317edd5e1c1", + "sha256_in_prefix": "7a31cbf2498d03219c431cb13a22eb868c4fc0f5f45f369fc3acb317edd5e1c1", + "size_in_bytes": 1623 + }, + { + "_path": "lib/python3.10/config-3.10-darwin/install-sh", + "path_type": "hardlink", + "sha256": "618b9afe95659e12966f090232b2e713946f1c162915c8385dfff71f34eacd58", + "sha256_in_prefix": "618b9afe95659e12966f090232b2e713946f1c162915c8385dfff71f34eacd58", + "size_in_bytes": 15368 + }, + { + "_path": "lib/python3.10/config-3.10-darwin/makesetup", + "path_type": "hardlink", + "sha256": "b4db4d0be1ba1bcd82ccd9d9b5ed41281d2a9f7b7245d3e5459537a117c05fd4", + "sha256_in_prefix": "b4db4d0be1ba1bcd82ccd9d9b5ed41281d2a9f7b7245d3e5459537a117c05fd4", + "size_in_bytes": 7855 + }, + { + "_path": "lib/python3.10/config-3.10-darwin/python-config.py", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_9afkyeq1z4/croot/python-split_1715024112201/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_p", + "sha256": "c707b82a8c5cc53054769d40dc72386fd3d7ac3cf1719e5721b85e680eecb6ba", + "sha256_in_prefix": "bf233aab74afc434e8cbbe86c64a58e9124b3cd2ed328404db9fd808b9f4155a", + "size_in_bytes": 2289 + }, + { + "_path": "lib/python3.10/config-3.10-darwin/python.o", + "path_type": "hardlink", + "sha256": "eb79c860cdeba773902b5fd0ad42712bd47147a3be1a056a8d1371b8d3941c4c", + "sha256_in_prefix": "eb79c860cdeba773902b5fd0ad42712bd47147a3be1a056a8d1371b8d3941c4c", + "size_in_bytes": 3808 + }, + { + "_path": "lib/python3.10/configparser.py", + "path_type": "hardlink", + "sha256": "df56496e25906c42f7599e7237b1c8e33eb6e9a9a5590cad55e2907492bba88a", + "sha256_in_prefix": "df56496e25906c42f7599e7237b1c8e33eb6e9a9a5590cad55e2907492bba88a", + "size_in_bytes": 54612 + }, + { + "_path": "lib/python3.10/contextlib.py", + "path_type": "hardlink", + "sha256": "2e17d45cf3da698c9752c58a668c8a03d0ce2280fdffd6e352794a38a94d9f07", + "sha256_in_prefix": "2e17d45cf3da698c9752c58a668c8a03d0ce2280fdffd6e352794a38a94d9f07", + "size_in_bytes": 25882 + }, + { + "_path": "lib/python3.10/contextvars.py", + "path_type": "hardlink", + "sha256": "5ed260be8d1f4fe92261b7810b4bb1e8539c42093d7493f677d076e1a87f459a", + "sha256_in_prefix": "5ed260be8d1f4fe92261b7810b4bb1e8539c42093d7493f677d076e1a87f459a", + "size_in_bytes": 129 + }, + { + "_path": "lib/python3.10/copy.py", + "path_type": "hardlink", + "sha256": "27dcfc53a4b9d4fbc3d90c74e549eb6eca9301524d6d2fbff9a6589cf51b6fd5", + "sha256_in_prefix": "27dcfc53a4b9d4fbc3d90c74e549eb6eca9301524d6d2fbff9a6589cf51b6fd5", + "size_in_bytes": 8681 + }, + { + "_path": "lib/python3.10/copyreg.py", + "path_type": "hardlink", + "sha256": "65cc0a30e07e9768ff97c78391985459a237083dce0c9086abfb879dc517420b", + "sha256_in_prefix": "65cc0a30e07e9768ff97c78391985459a237083dce0c9086abfb879dc517420b", + "size_in_bytes": 7426 + }, + { + "_path": "lib/python3.10/crypt.py", + "path_type": "hardlink", + "sha256": "5905d010f274b8935e12e7536fe25ec44877e04ad7633ffe21db855718ada8d5", + "sha256_in_prefix": "5905d010f274b8935e12e7536fe25ec44877e04ad7633ffe21db855718ada8d5", + "size_in_bytes": 3848 + }, + { + "_path": "lib/python3.10/csv.py", + "path_type": "hardlink", + "sha256": "6c68a5186e3b85e6e267a7ef96479327a45ae2b40bf5e9f2017e4b2282b3f5b1", + "sha256_in_prefix": "6c68a5186e3b85e6e267a7ef96479327a45ae2b40bf5e9f2017e4b2282b3f5b1", + "size_in_bytes": 16030 + }, + { + "_path": "lib/python3.10/ctypes/__init__.py", + "path_type": "hardlink", + "sha256": "9b99fa34cb2c454490337a62a9d91f5828c1a4f1ac22d94d94fffea34a2d612e", + "sha256_in_prefix": "9b99fa34cb2c454490337a62a9d91f5828c1a4f1ac22d94d94fffea34a2d612e", + "size_in_bytes": 17988 + }, + { + "_path": "lib/python3.10/ctypes/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "fb5bc3570132c634bf175f5c3d3ac899e4d22f97e991e00b6754ae3807801070", + "sha256_in_prefix": "fb5bc3570132c634bf175f5c3d3ac899e4d22f97e991e00b6754ae3807801070", + "size_in_bytes": 16136 + }, + { + "_path": "lib/python3.10/ctypes/__pycache__/_aix.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "1ef00e5239f3abe2259e548fc9286aa1f8abbb6d6e5289b998af3a4f76553d0c", + "sha256_in_prefix": "1ef00e5239f3abe2259e548fc9286aa1f8abbb6d6e5289b998af3a4f76553d0c", + "size_in_bytes": 10124 + }, + { + "_path": "lib/python3.10/ctypes/__pycache__/_endian.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "2efc0b0a7e4ff6eae4a44981d0ede3c5d0d25f305f1c03abac9aed9c1495cd14", + "sha256_in_prefix": "2efc0b0a7e4ff6eae4a44981d0ede3c5d0d25f305f1c03abac9aed9c1495cd14", + "size_in_bytes": 2155 + }, + { + "_path": "lib/python3.10/ctypes/__pycache__/util.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "04b1da955952e522b1cbb606193193398f08f895d1683a3eddb18b8464c40c75", + "sha256_in_prefix": "04b1da955952e522b1cbb606193193398f08f895d1683a3eddb18b8464c40c75", + "size_in_bytes": 8973 + }, + { + "_path": "lib/python3.10/ctypes/__pycache__/wintypes.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "233a2cd6f2882fa7359e34f45e428cb87b74b2c4cae3670cbbc91204d30924f9", + "sha256_in_prefix": "233a2cd6f2882fa7359e34f45e428cb87b74b2c4cae3670cbbc91204d30924f9", + "size_in_bytes": 5112 + }, + { + "_path": "lib/python3.10/ctypes/_aix.py", + "path_type": "hardlink", + "sha256": "3aaaa326d9c45e115d87e9e52874b1acd766cb4c578cecad667177d50849034c", + "sha256_in_prefix": "3aaaa326d9c45e115d87e9e52874b1acd766cb4c578cecad667177d50849034c", + "size_in_bytes": 12575 + }, + { + "_path": "lib/python3.10/ctypes/_endian.py", + "path_type": "hardlink", + "sha256": "4c9944875236d4227e8fd80ca0439417870ef387a532403393da91bf7ff67e16", + "sha256_in_prefix": "4c9944875236d4227e8fd80ca0439417870ef387a532403393da91bf7ff67e16", + "size_in_bytes": 2000 + }, + { + "_path": "lib/python3.10/ctypes/macholib/README.ctypes", + "path_type": "hardlink", + "sha256": "dc29d1da83b6a0a09a41647e4111eee878ed079c2d6b54a98fd6d8b88dd581f2", + "sha256_in_prefix": "dc29d1da83b6a0a09a41647e4111eee878ed079c2d6b54a98fd6d8b88dd581f2", + "size_in_bytes": 296 + }, + { + "_path": "lib/python3.10/ctypes/macholib/__init__.py", + "path_type": "hardlink", + "sha256": "1e77c01eec8f167ed10b754f153c0c743c8e5196ae9c81dffc08f129ab56dbfd", + "sha256_in_prefix": "1e77c01eec8f167ed10b754f153c0c743c8e5196ae9c81dffc08f129ab56dbfd", + "size_in_bytes": 154 + }, + { + "_path": "lib/python3.10/ctypes/macholib/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "361a9a71511781187498d4fed371f90aa3e7de30bb5ff394510f80038da3c9d1", + "sha256_in_prefix": "361a9a71511781187498d4fed371f90aa3e7de30bb5ff394510f80038da3c9d1", + "size_in_bytes": 556 + }, + { + "_path": "lib/python3.10/ctypes/macholib/__pycache__/dyld.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "1e713afb833efce544ef5fa682594c693424aff08817ec550f343169b8eb9a64", + "sha256_in_prefix": "1e713afb833efce544ef5fa682594c693424aff08817ec550f343169b8eb9a64", + "size_in_bytes": 4946 + }, + { + "_path": "lib/python3.10/ctypes/macholib/__pycache__/dylib.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "0c5d12fd48d2ce660a68902552fc6e2986048342ad01c4ce15b0736bd9a8223c", + "sha256_in_prefix": "0c5d12fd48d2ce660a68902552fc6e2986048342ad01c4ce15b0736bd9a8223c", + "size_in_bytes": 2163 + }, + { + "_path": "lib/python3.10/ctypes/macholib/__pycache__/framework.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "867c297f7ccb9265f964af093ff52c5b9826bf0d06e82ef19f462599caa9eac6", + "sha256_in_prefix": "867c297f7ccb9265f964af093ff52c5b9826bf0d06e82ef19f462599caa9eac6", + "size_in_bytes": 2443 + }, + { + "_path": "lib/python3.10/ctypes/macholib/dyld.py", + "path_type": "hardlink", + "sha256": "d0c8d4fd2b41360c513f49aa0bbfe2dfb79b7543bb78534aeeea9abfd18c57b7", + "sha256_in_prefix": "d0c8d4fd2b41360c513f49aa0bbfe2dfb79b7543bb78534aeeea9abfd18c57b7", + "size_in_bytes": 5415 + }, + { + "_path": "lib/python3.10/ctypes/macholib/dylib.py", + "path_type": "hardlink", + "sha256": "17de9f3d36c6ccbd97ed4ca15a908ad06663a84aa5d485714b202db7fe8e171a", + "sha256_in_prefix": "17de9f3d36c6ccbd97ed4ca15a908ad06663a84aa5d485714b202db7fe8e171a", + "size_in_bytes": 1828 + }, + { + "_path": "lib/python3.10/ctypes/macholib/fetch_macholib", + "path_type": "hardlink", + "sha256": "a9f6faacdb1aa00ac2f68043cd445171de9639a732b861bd5e64090a2865ab23", + "sha256_in_prefix": "a9f6faacdb1aa00ac2f68043cd445171de9639a732b861bd5e64090a2865ab23", + "size_in_bytes": 84 + }, + { + "_path": "lib/python3.10/ctypes/macholib/fetch_macholib.bat", + "path_type": "hardlink", + "sha256": "7497fbdbb98afca4ac455e3a057c59bcdebaf1280e25c94741dc301f05cb53e5", + "sha256_in_prefix": "7497fbdbb98afca4ac455e3a057c59bcdebaf1280e25c94741dc301f05cb53e5", + "size_in_bytes": 75 + }, + { + "_path": "lib/python3.10/ctypes/macholib/framework.py", + "path_type": "hardlink", + "sha256": "bf15187b7ea40c0255f14095e1091c13953c2efd98d96b409debc67669defc56", + "sha256_in_prefix": "bf15187b7ea40c0255f14095e1091c13953c2efd98d96b409debc67669defc56", + "size_in_bytes": 2201 + }, + { + "_path": "lib/python3.10/ctypes/util.py", + "path_type": "hardlink", + "sha256": "2c256f4c754f9e085b3a86d22a307ceb8ec455a1d351b88fca517e6ffbfa13f6", + "sha256_in_prefix": "2c256f4c754f9e085b3a86d22a307ceb8ec455a1d351b88fca517e6ffbfa13f6", + "size_in_bytes": 14856 + }, + { + "_path": "lib/python3.10/ctypes/wintypes.py", + "path_type": "hardlink", + "sha256": "c8f29e6cb1b05223e423391242f671381546130acae1fd7baafb65ba849f2a00", + "sha256_in_prefix": "c8f29e6cb1b05223e423391242f671381546130acae1fd7baafb65ba849f2a00", + "size_in_bytes": 5628 + }, + { + "_path": "lib/python3.10/curses/__init__.py", + "path_type": "hardlink", + "sha256": "d8730e360dd00ec046bdd85cae41fe83c907c6ae3716a964158fce8f31ab28b0", + "sha256_in_prefix": "d8730e360dd00ec046bdd85cae41fe83c907c6ae3716a964158fce8f31ab28b0", + "size_in_bytes": 3369 + }, + { + "_path": "lib/python3.10/curses/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "8f27cc2cae6d0e52b8fb9a8037187cbe4bdce2a739c043b7bc0ba548e69fe9eb", + "sha256_in_prefix": "8f27cc2cae6d0e52b8fb9a8037187cbe4bdce2a739c043b7bc0ba548e69fe9eb", + "size_in_bytes": 2103 + }, + { + "_path": "lib/python3.10/curses/__pycache__/ascii.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "6dc378240369b0424ddc01c0cfb8bcc3330d0202b9fe8dd7ead8ea52e50a103f", + "sha256_in_prefix": "6dc378240369b0424ddc01c0cfb8bcc3330d0202b9fe8dd7ead8ea52e50a103f", + "size_in_bytes": 3864 + }, + { + "_path": "lib/python3.10/curses/__pycache__/has_key.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "3894717809e7c7a16e54f39425c278c9f9e35155df0ea76d5d64dd759a1d302b", + "sha256_in_prefix": "3894717809e7c7a16e54f39425c278c9f9e35155df0ea76d5d64dd759a1d302b", + "size_in_bytes": 4905 + }, + { + "_path": "lib/python3.10/curses/__pycache__/panel.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "34471d16d56a0dedeed733ea6d5e451e986ab496159b52e99d5ceef453bfc7e6", + "sha256_in_prefix": "34471d16d56a0dedeed733ea6d5e451e986ab496159b52e99d5ceef453bfc7e6", + "size_in_bytes": 480 + }, + { + "_path": "lib/python3.10/curses/__pycache__/textpad.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "2de2bb28f4d2d6e610d3c1b226e9102fd689b25991a1c6812d152b35365e6ddc", + "sha256_in_prefix": "2de2bb28f4d2d6e610d3c1b226e9102fd689b25991a1c6812d152b35365e6ddc", + "size_in_bytes": 6243 + }, + { + "_path": "lib/python3.10/curses/ascii.py", + "path_type": "hardlink", + "sha256": "cf0137c2143c5e5bea2ccd25bfc61f3a274c5d8fdab3bc4c2c7329412ce7b656", + "sha256_in_prefix": "cf0137c2143c5e5bea2ccd25bfc61f3a274c5d8fdab3bc4c2c7329412ce7b656", + "size_in_bytes": 2547 + }, + { + "_path": "lib/python3.10/curses/has_key.py", + "path_type": "hardlink", + "sha256": "15a052812d9ae80124bb25b3f5b9ffae38e2b03073774e163abf3d773140cfb3", + "sha256_in_prefix": "15a052812d9ae80124bb25b3f5b9ffae38e2b03073774e163abf3d773140cfb3", + "size_in_bytes": 5634 + }, + { + "_path": "lib/python3.10/curses/panel.py", + "path_type": "hardlink", + "sha256": "13ef404a30da1825a612ca3e453db88c305d45deef4441c4c9e2ef7ee0ef50c7", + "sha256_in_prefix": "13ef404a30da1825a612ca3e453db88c305d45deef4441c4c9e2ef7ee0ef50c7", + "size_in_bytes": 87 + }, + { + "_path": "lib/python3.10/curses/textpad.py", + "path_type": "hardlink", + "sha256": "bbc4634b3396bb6aa89f186206b9e236047e443ffd727116f45b537f4dce0759", + "sha256_in_prefix": "bbc4634b3396bb6aa89f186206b9e236047e443ffd727116f45b537f4dce0759", + "size_in_bytes": 7657 + }, + { + "_path": "lib/python3.10/dataclasses.py", + "path_type": "hardlink", + "sha256": "fa2e3728d8184954479c6fcd17015a5e0c176850f18f119f5c548fca49019441", + "sha256_in_prefix": "fa2e3728d8184954479c6fcd17015a5e0c176850f18f119f5c548fca49019441", + "size_in_bytes": 56390 + }, + { + "_path": "lib/python3.10/datetime.py", + "path_type": "hardlink", + "sha256": "92cdb4ad1ed394924cf3b7eaa601541e38aef1df98b3841f5eca733b2c5097b8", + "sha256_in_prefix": "92cdb4ad1ed394924cf3b7eaa601541e38aef1df98b3841f5eca733b2c5097b8", + "size_in_bytes": 88086 + }, + { + "_path": "lib/python3.10/dbm/__init__.py", + "path_type": "hardlink", + "sha256": "930cdedcd5887bdf70477c541d73b54797c232d90dce149ab5b135331f04ec16", + "sha256_in_prefix": "930cdedcd5887bdf70477c541d73b54797c232d90dce149ab5b135331f04ec16", + "size_in_bytes": 5839 + }, + { + "_path": "lib/python3.10/dbm/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "a75a5e4d20fdad661ea5401d63a0706dbc2f6cf79e7ae5c45545076cdf45e773", + "sha256_in_prefix": "a75a5e4d20fdad661ea5401d63a0706dbc2f6cf79e7ae5c45545076cdf45e773", + "size_in_bytes": 4235 + }, + { + "_path": "lib/python3.10/dbm/__pycache__/dumb.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "9b80ec6267bd76fbb06a06d62567c3f5241fd076b47cd5ee1aed17280921c9ba", + "sha256_in_prefix": "9b80ec6267bd76fbb06a06d62567c3f5241fd076b47cd5ee1aed17280921c9ba", + "size_in_bytes": 8104 + }, + { + "_path": "lib/python3.10/dbm/__pycache__/gnu.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "ebffc1c4b03b444286f2e5350269299329c257e3dcb4f49abf368681261c5a39", + "sha256_in_prefix": "ebffc1c4b03b444286f2e5350269299329c257e3dcb4f49abf368681261c5a39", + "size_in_bytes": 460 + }, + { + "_path": "lib/python3.10/dbm/__pycache__/ndbm.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "051a71d7b598af84c691d4f0da22a8f5bb615ceedd9bcebaba8b4b4eab0ddef3", + "sha256_in_prefix": "051a71d7b598af84c691d4f0da22a8f5bb615ceedd9bcebaba8b4b4eab0ddef3", + "size_in_bytes": 459 + }, + { + "_path": "lib/python3.10/dbm/dumb.py", + "path_type": "hardlink", + "sha256": "eec69824f4a1cfa02e23766eecc48339b09c5a08b0099063d3f0311c252e9700", + "sha256_in_prefix": "eec69824f4a1cfa02e23766eecc48339b09c5a08b0099063d3f0311c252e9700", + "size_in_bytes": 11536 + }, + { + "_path": "lib/python3.10/dbm/gnu.py", + "path_type": "hardlink", + "sha256": "36cd4904f50e00c4df4ad9d450b3970e150957425f47c00cf979ba73eff49778", + "sha256_in_prefix": "36cd4904f50e00c4df4ad9d450b3970e150957425f47c00cf979ba73eff49778", + "size_in_bytes": 72 + }, + { + "_path": "lib/python3.10/dbm/ndbm.py", + "path_type": "hardlink", + "sha256": "1bcc2d9b2fad1901f3421a174eeecb5b8ccc6763283b87bbe0705b404c71904b", + "sha256_in_prefix": "1bcc2d9b2fad1901f3421a174eeecb5b8ccc6763283b87bbe0705b404c71904b", + "size_in_bytes": 70 + }, + { + "_path": "lib/python3.10/decimal.py", + "path_type": "hardlink", + "sha256": "000c00bad31d126b054c6ec7f3e02b27c0f9a4d579f987d3c4f879cee1bacb81", + "sha256_in_prefix": "000c00bad31d126b054c6ec7f3e02b27c0f9a4d579f987d3c4f879cee1bacb81", + "size_in_bytes": 320 + }, + { + "_path": "lib/python3.10/difflib.py", + "path_type": "hardlink", + "sha256": "0c6afc23568d55b3e9ac914f9c5361e3033e778aa5b58d3cc82835fc5c638679", + "sha256_in_prefix": "0c6afc23568d55b3e9ac914f9c5361e3033e778aa5b58d3cc82835fc5c638679", + "size_in_bytes": 83308 + }, + { + "_path": "lib/python3.10/dis.py", + "path_type": "hardlink", + "sha256": "67075458fb59ec9e0d6206440df6b2f31944fcb4c480b9f6fe202094bc455d1d", + "sha256_in_prefix": "67075458fb59ec9e0d6206440df6b2f31944fcb4c480b9f6fe202094bc455d1d", + "size_in_bytes": 20020 + }, + { + "_path": "lib/python3.10/distutils/README", + "path_type": "hardlink", + "sha256": "8d19071886238eda514e96a7ab1c17d6d8c26ae628c4ddbc8ecc5329fd9d8000", + "sha256_in_prefix": "8d19071886238eda514e96a7ab1c17d6d8c26ae628c4ddbc8ecc5329fd9d8000", + "size_in_bytes": 244 + }, + { + "_path": "lib/python3.10/distutils/__init__.py", + "path_type": "hardlink", + "sha256": "50c33f1d73f224a50a07f64e29a5e71b86b105a2e61873e7f47dc28a6baa7680", + "sha256_in_prefix": "50c33f1d73f224a50a07f64e29a5e71b86b105a2e61873e7f47dc28a6baa7680", + "size_in_bytes": 541 + }, + { + "_path": "lib/python3.10/distutils/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "78081e735ece7a0ed014e84634d7fae140b6467a1fa4ee05512eb5dfae87d15a", + "sha256_in_prefix": "78081e735ece7a0ed014e84634d7fae140b6467a1fa4ee05512eb5dfae87d15a", + "size_in_bytes": 875 + }, + { + "_path": "lib/python3.10/distutils/__pycache__/_msvccompiler.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "dc9cfd7fb7c535279c089713035d5cfe7bc54769eaef3cf2fc5cad1a22f63545", + "sha256_in_prefix": "dc9cfd7fb7c535279c089713035d5cfe7bc54769eaef3cf2fc5cad1a22f63545", + "size_in_bytes": 13198 + }, + { + "_path": "lib/python3.10/distutils/__pycache__/archive_util.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "b842a109cccb4b315bd49e93db83d77b227e8ba3e877d60a0f9f764aa0f8e860", + "sha256_in_prefix": "b842a109cccb4b315bd49e93db83d77b227e8ba3e877d60a0f9f764aa0f8e860", + "size_in_bytes": 6762 + }, + { + "_path": "lib/python3.10/distutils/__pycache__/bcppcompiler.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "00731c7662c1bbfd65dd1a14e354a22885c98cf73417d202e01f93113fa0d0cc", + "sha256_in_prefix": "00731c7662c1bbfd65dd1a14e354a22885c98cf73417d202e01f93113fa0d0cc", + "size_in_bytes": 6749 + }, + { + "_path": "lib/python3.10/distutils/__pycache__/ccompiler.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "e3fd619a0f07286308f36e84a8b6ab6680dd471d5299ff348104f7ee3b829486", + "sha256_in_prefix": "e3fd619a0f07286308f36e84a8b6ab6680dd471d5299ff348104f7ee3b829486", + "size_in_bytes": 33039 + }, + { + "_path": "lib/python3.10/distutils/__pycache__/cmd.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "5cb1cc89b3a2ee171eefca71b0e8c70dbc62960c5fc9b10ededa58b80d9f4b01", + "sha256_in_prefix": "5cb1cc89b3a2ee171eefca71b0e8c70dbc62960c5fc9b10ededa58b80d9f4b01", + "size_in_bytes": 14149 + }, + { + "_path": "lib/python3.10/distutils/__pycache__/config.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c0ec082d60c3cd488850245ec6207c4a229aa434fbf2938ee811f2e167482e5c", + "sha256_in_prefix": "c0ec082d60c3cd488850245ec6207c4a229aa434fbf2938ee811f2e167482e5c", + "size_in_bytes": 3788 + }, + { + "_path": "lib/python3.10/distutils/__pycache__/core.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "755a9b635c7edca2e4f8b8ef433c1bf1b35ed4e8adb0421912b64d2a2598cfad", + "sha256_in_prefix": "755a9b635c7edca2e4f8b8ef433c1bf1b35ed4e8adb0421912b64d2a2598cfad", + "size_in_bytes": 6857 + }, + { + "_path": "lib/python3.10/distutils/__pycache__/cygwinccompiler.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "23b0cca35695adf473b923ca2f67df4389e842242bcd0afdad5e96ff66d1b7bd", + "sha256_in_prefix": "23b0cca35695adf473b923ca2f67df4389e842242bcd0afdad5e96ff66d1b7bd", + "size_in_bytes": 8752 + }, + { + "_path": "lib/python3.10/distutils/__pycache__/debug.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "a66c62448e6375b80478ba0de20d8954ea55979df862549a4b2dca371d738201", + "sha256_in_prefix": "a66c62448e6375b80478ba0de20d8954ea55979df862549a4b2dca371d738201", + "size_in_bytes": 451 + }, + { + "_path": "lib/python3.10/distutils/__pycache__/dep_util.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "a134fa99a024a7fbe7681c01bdbf57d9602090c98988abeb6437dcd2e97a6547", + "sha256_in_prefix": "a134fa99a024a7fbe7681c01bdbf57d9602090c98988abeb6437dcd2e97a6547", + "size_in_bytes": 2972 + }, + { + "_path": "lib/python3.10/distutils/__pycache__/dir_util.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "a096f0220d121863dd13801048f1dcf9378f7a2cc43e595f3c32c5e7c5848265", + "sha256_in_prefix": "a096f0220d121863dd13801048f1dcf9378f7a2cc43e595f3c32c5e7c5848265", + "size_in_bytes": 5824 + }, + { + "_path": "lib/python3.10/distutils/__pycache__/dist.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "ab8b0c1af8ca4b65257917c4356c0f5588bc2798fe989d0640dcc91cc22ad7ca", + "sha256_in_prefix": "ab8b0c1af8ca4b65257917c4356c0f5588bc2798fe989d0640dcc91cc22ad7ca", + "size_in_bytes": 34204 + }, + { + "_path": "lib/python3.10/distutils/__pycache__/errors.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "6416a7bad79de74a93ce577e29b1c35fa01c89d6e39f867d6699bc1c929e47f2", + "sha256_in_prefix": "6416a7bad79de74a93ce577e29b1c35fa01c89d6e39f867d6699bc1c929e47f2", + "size_in_bytes": 5193 + }, + { + "_path": "lib/python3.10/distutils/__pycache__/extension.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "104263a1686869c9d6e948f380ee891e199a06c5cd625514eda3a8454de27b83", + "sha256_in_prefix": "104263a1686869c9d6e948f380ee891e199a06c5cd625514eda3a8454de27b83", + "size_in_bytes": 7228 + }, + { + "_path": "lib/python3.10/distutils/__pycache__/fancy_getopt.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "4f6238092f1209dd1e1def93cf659d1ffa38382fb447d57fb57b3b91b76e4e8d", + "sha256_in_prefix": "4f6238092f1209dd1e1def93cf659d1ffa38382fb447d57fb57b3b91b76e4e8d", + "size_in_bytes": 10831 + }, + { + "_path": "lib/python3.10/distutils/__pycache__/file_util.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "228914526ec211b9c0e6c4104ace7a859794fbbfd68cee3f2eef6822add7f039", + "sha256_in_prefix": "228914526ec211b9c0e6c4104ace7a859794fbbfd68cee3f2eef6822add7f039", + "size_in_bytes": 6177 + }, + { + "_path": "lib/python3.10/distutils/__pycache__/filelist.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "50ceac85ba57c2ff825719a5826679122fa1521e5a04c0f5459f834c7f9796ad", + "sha256_in_prefix": "50ceac85ba57c2ff825719a5826679122fa1521e5a04c0f5459f834c7f9796ad", + "size_in_bytes": 10081 + }, + { + "_path": "lib/python3.10/distutils/__pycache__/log.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "975274e9ece0f0d0fd7dfa5cee9df2dddd3dba40d344f4a3dec9519c4d7c61f3", + "sha256_in_prefix": "975274e9ece0f0d0fd7dfa5cee9df2dddd3dba40d344f4a3dec9519c4d7c61f3", + "size_in_bytes": 2508 + }, + { + "_path": "lib/python3.10/distutils/__pycache__/msvc9compiler.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "2608e5037f7a9e28f4cab2229d49e36051f059939b433e2a31fbe89a53c6ffdd", + "sha256_in_prefix": "2608e5037f7a9e28f4cab2229d49e36051f059939b433e2a31fbe89a53c6ffdd", + "size_in_bytes": 17763 + }, + { + "_path": "lib/python3.10/distutils/__pycache__/msvccompiler.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "d1745b220d2a78e32fce06fd6c4d4b5b4800d44130a5fed6aae4bccc162435fb", + "sha256_in_prefix": "d1745b220d2a78e32fce06fd6c4d4b5b4800d44130a5fed6aae4bccc162435fb", + "size_in_bytes": 14982 + }, + { + "_path": "lib/python3.10/distutils/__pycache__/spawn.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "b0bf66e3259ee923c1e05d28a0e2065d4b4c529224dd289e1af243194df10bc1", + "sha256_in_prefix": "b0bf66e3259ee923c1e05d28a0e2065d4b4c529224dd289e1af243194df10bc1", + "size_in_bytes": 3668 + }, + { + "_path": "lib/python3.10/distutils/__pycache__/sysconfig.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "cb83c63aa8b3c78ebadb08030a69694c6a9d84435fbd86b5c371ef7b6ba62fd5", + "sha256_in_prefix": "cb83c63aa8b3c78ebadb08030a69694c6a9d84435fbd86b5c371ef7b6ba62fd5", + "size_in_bytes": 7322 + }, + { + "_path": "lib/python3.10/distutils/__pycache__/text_file.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "ae831c74025813e2eda218a19becae0a46a6870f239e2d3bdda64bfbf20d46c5", + "sha256_in_prefix": "ae831c74025813e2eda218a19becae0a46a6870f239e2d3bdda64bfbf20d46c5", + "size_in_bytes": 8670 + }, + { + "_path": "lib/python3.10/distutils/__pycache__/unixccompiler.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "d65206fdc7aec173e8ccebb1b7ed1032ceac3081555a015f5ed90d656829d842", + "sha256_in_prefix": "d65206fdc7aec173e8ccebb1b7ed1032ceac3081555a015f5ed90d656829d842", + "size_in_bytes": 7070 + }, + { + "_path": "lib/python3.10/distutils/__pycache__/util.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "d27f5ce699de319deac40f2ff5482daf1ac2d99f29d9e9b7113a0cb43bc1b7b0", + "sha256_in_prefix": "d27f5ce699de319deac40f2ff5482daf1ac2d99f29d9e9b7113a0cb43bc1b7b0", + "size_in_bytes": 15890 + }, + { + "_path": "lib/python3.10/distutils/__pycache__/version.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "f29e6373d9e1746421279bb4b7fa389988bb134f47f4a0352628f022f7541e72", + "sha256_in_prefix": "f29e6373d9e1746421279bb4b7fa389988bb134f47f4a0352628f022f7541e72", + "size_in_bytes": 7560 + }, + { + "_path": "lib/python3.10/distutils/__pycache__/versionpredicate.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "d388e2dd942fea3f0e504399fe0e541676b572527784c2d2b1d8f9cab57905ff", + "sha256_in_prefix": "d388e2dd942fea3f0e504399fe0e541676b572527784c2d2b1d8f9cab57905ff", + "size_in_bytes": 5388 + }, + { + "_path": "lib/python3.10/distutils/_msvccompiler.py", + "path_type": "hardlink", + "sha256": "21c14c94e6015f56b8c28abd8c8f628f33efbdb808a4a26b0deeb31f2d4ca17a", + "sha256_in_prefix": "21c14c94e6015f56b8c28abd8c8f628f33efbdb808a4a26b0deeb31f2d4ca17a", + "size_in_bytes": 20404 + }, + { + "_path": "lib/python3.10/distutils/archive_util.py", + "path_type": "hardlink", + "sha256": "a96fae886c187b14ef2b97be8927a5ff7d43b21c7e0aa4da9cd3caeac9f07fdf", + "sha256_in_prefix": "a96fae886c187b14ef2b97be8927a5ff7d43b21c7e0aa4da9cd3caeac9f07fdf", + "size_in_bytes": 8572 + }, + { + "_path": "lib/python3.10/distutils/bcppcompiler.py", + "path_type": "hardlink", + "sha256": "3890d5a425265fa1fcbffee5575ce27d5d5f731f760abd9d862521ebdf3d5092", + "sha256_in_prefix": "3890d5a425265fa1fcbffee5575ce27d5d5f731f760abd9d862521ebdf3d5092", + "size_in_bytes": 14894 + }, + { + "_path": "lib/python3.10/distutils/ccompiler.py", + "path_type": "hardlink", + "sha256": "194146bc2645bafe0d34d90d6837958779de804b21178b3e1a3da651bbbccffb", + "sha256_in_prefix": "194146bc2645bafe0d34d90d6837958779de804b21178b3e1a3da651bbbccffb", + "size_in_bytes": 47418 + }, + { + "_path": "lib/python3.10/distutils/cmd.py", + "path_type": "hardlink", + "sha256": "79ca3a2c0194b686cbb8f69fba19a02a09304512ff598f0a27861e0c21e9725b", + "sha256_in_prefix": "79ca3a2c0194b686cbb8f69fba19a02a09304512ff598f0a27861e0c21e9725b", + "size_in_bytes": 18079 + }, + { + "_path": "lib/python3.10/distutils/command/__init__.py", + "path_type": "hardlink", + "sha256": "f0bcde9801fad1d064fee42c8ccbe36eb121cba7b6e4415c40c3ec144217ee37", + "sha256_in_prefix": "f0bcde9801fad1d064fee42c8ccbe36eb121cba7b6e4415c40c3ec144217ee37", + "size_in_bytes": 771 + }, + { + "_path": "lib/python3.10/distutils/command/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "10b25e5e1bd542eb4ecc8e024e5aca5a94e9fbc7a14a593364846f32d2951b2c", + "sha256_in_prefix": "10b25e5e1bd542eb4ecc8e024e5aca5a94e9fbc7a14a593364846f32d2951b2c", + "size_in_bytes": 456 + }, + { + "_path": "lib/python3.10/distutils/command/__pycache__/bdist.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "fb7b429c74113dbba6ec305783195139cac7f96c4958cb1ad3c95ebce5820d01", + "sha256_in_prefix": "fb7b429c74113dbba6ec305783195139cac7f96c4958cb1ad3c95ebce5820d01", + "size_in_bytes": 3804 + }, + { + "_path": "lib/python3.10/distutils/command/__pycache__/bdist_dumb.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "7be8b4f25ceb0860ebe1f26badcc9cf30dc6fc6ce23fcd5b6c88c5312eabe32c", + "sha256_in_prefix": "7be8b4f25ceb0860ebe1f26badcc9cf30dc6fc6ce23fcd5b6c88c5312eabe32c", + "size_in_bytes": 3584 + }, + { + "_path": "lib/python3.10/distutils/command/__pycache__/bdist_msi.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "547d13fa3a865e57dea68f9ca7605ba0e3a38fa4674ed26fdd58415816278fb5", + "sha256_in_prefix": "547d13fa3a865e57dea68f9ca7605ba0e3a38fa4674ed26fdd58415816278fb5", + "size_in_bytes": 19919 + }, + { + "_path": "lib/python3.10/distutils/command/__pycache__/bdist_rpm.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "ac617772f23fbdb3443958c48c607d5c375d77e275fbc5392a83e57311a2b6b3", + "sha256_in_prefix": "ac617772f23fbdb3443958c48c607d5c375d77e275fbc5392a83e57311a2b6b3", + "size_in_bytes": 12487 + }, + { + "_path": "lib/python3.10/distutils/command/__pycache__/build.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "2a46c498ed15d60d1686184f27bc8144456bea06c2a2a5f32ac9a2c92071ca19", + "sha256_in_prefix": "2a46c498ed15d60d1686184f27bc8144456bea06c2a2a5f32ac9a2c92071ca19", + "size_in_bytes": 4098 + }, + { + "_path": "lib/python3.10/distutils/command/__pycache__/build_clib.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "2f9fa67bd251f3dee4482aef0a15d56963b00da7d9612cf243b26f0e1bc86377", + "sha256_in_prefix": "2f9fa67bd251f3dee4482aef0a15d56963b00da7d9612cf243b26f0e1bc86377", + "size_in_bytes": 5069 + }, + { + "_path": "lib/python3.10/distutils/command/__pycache__/build_ext.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "72f4160dbcad7c47a0f5fdd2abd61edd288100b322b6ded0b41766420b5ff493", + "sha256_in_prefix": "72f4160dbcad7c47a0f5fdd2abd61edd288100b322b6ded0b41766420b5ff493", + "size_in_bytes": 16447 + }, + { + "_path": "lib/python3.10/distutils/command/__pycache__/build_py.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "a7029857b60fcccbda350d63a8d0705d5af8c001aecdaec3858e70b19995e5fc", + "sha256_in_prefix": "a7029857b60fcccbda350d63a8d0705d5af8c001aecdaec3858e70b19995e5fc", + "size_in_bytes": 10728 + }, + { + "_path": "lib/python3.10/distutils/command/__pycache__/build_scripts.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "2759e5382d4ed80c14a6a804bea554e2bf94b1bd0f58ad8e6469cd1815936ccb", + "sha256_in_prefix": "2759e5382d4ed80c14a6a804bea554e2bf94b1bd0f58ad8e6469cd1815936ccb", + "size_in_bytes": 4583 + }, + { + "_path": "lib/python3.10/distutils/command/__pycache__/check.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "07d4dfdfe92b872f221f1a10dc7ca086ba0e3470d0fb56ba78824151e59157f9", + "sha256_in_prefix": "07d4dfdfe92b872f221f1a10dc7ca086ba0e3470d0fb56ba78824151e59157f9", + "size_in_bytes": 5207 + }, + { + "_path": "lib/python3.10/distutils/command/__pycache__/clean.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "f9d91d8666c6c44048d30ac6ab92cc62e47e1b33d0c07a36ea0fc4aa78dc7624", + "sha256_in_prefix": "f9d91d8666c6c44048d30ac6ab92cc62e47e1b33d0c07a36ea0fc4aa78dc7624", + "size_in_bytes": 2347 + }, + { + "_path": "lib/python3.10/distutils/command/__pycache__/config.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "beb9a927ceff8878ecec302b83da887dc2288918cec3743ebf6124fa728f7fb3", + "sha256_in_prefix": "beb9a927ceff8878ecec302b83da887dc2288918cec3743ebf6124fa728f7fb3", + "size_in_bytes": 10529 + }, + { + "_path": "lib/python3.10/distutils/command/__pycache__/install.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "d756dcd486c53b9434edcd223df80fc25ca6bcb865760cf4f3355816d101dc77", + "sha256_in_prefix": "d756dcd486c53b9434edcd223df80fc25ca6bcb865760cf4f3355816d101dc77", + "size_in_bytes": 14064 + }, + { + "_path": "lib/python3.10/distutils/command/__pycache__/install_data.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "81656cfac75c9261f82ceb3ab6f3d27f4838839e579e6b3b63fd18e96f1960f9", + "sha256_in_prefix": "81656cfac75c9261f82ceb3ab6f3d27f4838839e579e6b3b63fd18e96f1960f9", + "size_in_bytes": 2546 + }, + { + "_path": "lib/python3.10/distutils/command/__pycache__/install_egg_info.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "b40a8d73dc439806754c419a24bd70e4a19313cce74b285ced2acac7f17e05b0", + "sha256_in_prefix": "b40a8d73dc439806754c419a24bd70e4a19313cce74b285ced2acac7f17e05b0", + "size_in_bytes": 3287 + }, + { + "_path": "lib/python3.10/distutils/command/__pycache__/install_headers.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "beff819b95120aa837d71a7e47a03dc9f17bb4f8dee10d59de7ac2cc2f66269b", + "sha256_in_prefix": "beff819b95120aa837d71a7e47a03dc9f17bb4f8dee10d59de7ac2cc2f66269b", + "size_in_bytes": 1969 + }, + { + "_path": "lib/python3.10/distutils/command/__pycache__/install_lib.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "7b9a3abc80ce16a528c53a4a56b1eccf11db187b65bd5f0f9bdc747cae975561", + "sha256_in_prefix": "7b9a3abc80ce16a528c53a4a56b1eccf11db187b65bd5f0f9bdc747cae975561", + "size_in_bytes": 5371 + }, + { + "_path": "lib/python3.10/distutils/command/__pycache__/install_scripts.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "90b1513898786c2320fae478dbf1b5c7509ca4b14c2f6ef1ea03f851773a6d34", + "sha256_in_prefix": "90b1513898786c2320fae478dbf1b5c7509ca4b14c2f6ef1ea03f851773a6d34", + "size_in_bytes": 2398 + }, + { + "_path": "lib/python3.10/distutils/command/__pycache__/register.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "0ac09691ec79999bd489e80bdb9c974712107183ac51e06df97a4314c19d2f1a", + "sha256_in_prefix": "0ac09691ec79999bd489e80bdb9c974712107183ac51e06df97a4314c19d2f1a", + "size_in_bytes": 8882 + }, + { + "_path": "lib/python3.10/distutils/command/__pycache__/sdist.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "b81453bd424a6e682d9c0c0ec2dd0f0b13e8d30376c86faa2ae07753bdbed242", + "sha256_in_prefix": "b81453bd424a6e682d9c0c0ec2dd0f0b13e8d30376c86faa2ae07753bdbed242", + "size_in_bytes": 14698 + }, + { + "_path": "lib/python3.10/distutils/command/__pycache__/upload.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "d261a24782f2b679129db667a3f758c0aa1e4f2dc6db7a57496b4cf7cc8fb1c8", + "sha256_in_prefix": "d261a24782f2b679129db667a3f758c0aa1e4f2dc6db7a57496b4cf7cc8fb1c8", + "size_in_bytes": 5341 + }, + { + "_path": "lib/python3.10/distutils/command/bdist.py", + "path_type": "hardlink", + "sha256": "b8fa0cb381931c6d51e13da553a7d91a3e9841324d9ba4496862f2fdac990459", + "sha256_in_prefix": "b8fa0cb381931c6d51e13da553a7d91a3e9841324d9ba4496862f2fdac990459", + "size_in_bytes": 5433 + }, + { + "_path": "lib/python3.10/distutils/command/bdist_dumb.py", + "path_type": "hardlink", + "sha256": "053babf63708a69c8fecf89abe37ec93b623125aafc5e60eda7a54c8f3ce7a47", + "sha256_in_prefix": "053babf63708a69c8fecf89abe37ec93b623125aafc5e60eda7a54c8f3ce7a47", + "size_in_bytes": 4913 + }, + { + "_path": "lib/python3.10/distutils/command/bdist_msi.py", + "path_type": "hardlink", + "sha256": "f9a6c1fdcbaead2f17ea343b2645d5fae6e6fa5b6bbd84aa92d715a013caa968", + "sha256_in_prefix": "f9a6c1fdcbaead2f17ea343b2645d5fae6e6fa5b6bbd84aa92d715a013caa968", + "size_in_bytes": 35519 + }, + { + "_path": "lib/python3.10/distutils/command/bdist_rpm.py", + "path_type": "hardlink", + "sha256": "8233b0db61a10d26dcab46ddab6e5c4dbfa7e875969b46d284b41a77f9a42789", + "sha256_in_prefix": "8233b0db61a10d26dcab46ddab6e5c4dbfa7e875969b46d284b41a77f9a42789", + "size_in_bytes": 21537 + }, + { + "_path": "lib/python3.10/distutils/command/build.py", + "path_type": "hardlink", + "sha256": "d753724765005336a5ae44d9da98740401c55850b68ed4ac37b808685f8d0b4f", + "sha256_in_prefix": "d753724765005336a5ae44d9da98740401c55850b68ed4ac37b808685f8d0b4f", + "size_in_bytes": 5767 + }, + { + "_path": "lib/python3.10/distutils/command/build_clib.py", + "path_type": "hardlink", + "sha256": "6e05531e1dbc78b400d86930ebc6a602977f8fba90057e0c4c8fb34ef00afc9e", + "sha256_in_prefix": "6e05531e1dbc78b400d86930ebc6a602977f8fba90057e0c4c8fb34ef00afc9e", + "size_in_bytes": 8022 + }, + { + "_path": "lib/python3.10/distutils/command/build_ext.py", + "path_type": "hardlink", + "sha256": "30c24f0b11e57fdae05248b39f82a3abdbd878011fc72a9fabc5ec4c4f84a563", + "sha256_in_prefix": "30c24f0b11e57fdae05248b39f82a3abdbd878011fc72a9fabc5ec4c4f84a563", + "size_in_bytes": 31635 + }, + { + "_path": "lib/python3.10/distutils/command/build_py.py", + "path_type": "hardlink", + "sha256": "4bf365c3885913c3e7220a97e4e14c766b7e19298e84f410e1fda3af5b819e85", + "sha256_in_prefix": "4bf365c3885913c3e7220a97e4e14c766b7e19298e84f410e1fda3af5b819e85", + "size_in_bytes": 17190 + }, + { + "_path": "lib/python3.10/distutils/command/build_scripts.py", + "path_type": "hardlink", + "sha256": "68ac9c2493f1dcb7d9d5cbd981225ac670f62e7bd1339589fbcc64a5d81c2ec2", + "sha256_in_prefix": "68ac9c2493f1dcb7d9d5cbd981225ac670f62e7bd1339589fbcc64a5d81c2ec2", + "size_in_bytes": 6232 + }, + { + "_path": "lib/python3.10/distutils/command/check.py", + "path_type": "hardlink", + "sha256": "9927e429a3a9e968e41ae0bd5fa5ce2d691dfc1aa5e84b532b8089a8d3e87c0f", + "sha256_in_prefix": "9927e429a3a9e968e41ae0bd5fa5ce2d691dfc1aa5e84b532b8089a8d3e87c0f", + "size_in_bytes": 5636 + }, + { + "_path": "lib/python3.10/distutils/command/clean.py", + "path_type": "hardlink", + "sha256": "d930ade3baeee2165933445f55f5188f96dba6272918b3f8421c398c1b6fa7d9", + "sha256_in_prefix": "d930ade3baeee2165933445f55f5188f96dba6272918b3f8421c398c1b6fa7d9", + "size_in_bytes": 2776 + }, + { + "_path": "lib/python3.10/distutils/command/command_template", + "path_type": "hardlink", + "sha256": "7c1c707cd6ad3872515cf3fc9d8dd1a3f7cc08e3eb71813ed427499b256a8751", + "sha256_in_prefix": "7c1c707cd6ad3872515cf3fc9d8dd1a3f7cc08e3eb71813ed427499b256a8751", + "size_in_bytes": 633 + }, + { + "_path": "lib/python3.10/distutils/command/config.py", + "path_type": "hardlink", + "sha256": "d9a4e3c30dcfc23301f3e6626c27b83fb07ea86d61335827feb257632c51cfa7", + "sha256_in_prefix": "d9a4e3c30dcfc23301f3e6626c27b83fb07ea86d61335827feb257632c51cfa7", + "size_in_bytes": 13117 + }, + { + "_path": "lib/python3.10/distutils/command/install.py", + "path_type": "hardlink", + "sha256": "32b5cd24c6aafcdd73a2835e99f3bdf8c4f53d04de0011b3cb04f786ae60b994", + "sha256_in_prefix": "32b5cd24c6aafcdd73a2835e99f3bdf8c4f53d04de0011b3cb04f786ae60b994", + "size_in_bytes": 28242 + }, + { + "_path": "lib/python3.10/distutils/command/install_data.py", + "path_type": "hardlink", + "sha256": "62118e0308778093ea17b7a6e57034ae6a51e36cf56cb87cd28a049730f252f9", + "sha256_in_prefix": "62118e0308778093ea17b7a6e57034ae6a51e36cf56cb87cd28a049730f252f9", + "size_in_bytes": 2822 + }, + { + "_path": "lib/python3.10/distutils/command/install_egg_info.py", + "path_type": "hardlink", + "sha256": "d245b496254c79a7648d7d197117cca6d2857a7d3b1b0ea0cb0d551d3e4a2307", + "sha256_in_prefix": "d245b496254c79a7648d7d197117cca6d2857a7d3b1b0ea0cb0d551d3e4a2307", + "size_in_bytes": 2603 + }, + { + "_path": "lib/python3.10/distutils/command/install_headers.py", + "path_type": "hardlink", + "sha256": "5d0ea27646c80dfaf59635c23b39ee55432f385a47067e9c2b45b3f6020cd9be", + "sha256_in_prefix": "5d0ea27646c80dfaf59635c23b39ee55432f385a47067e9c2b45b3f6020cd9be", + "size_in_bytes": 1298 + }, + { + "_path": "lib/python3.10/distutils/command/install_lib.py", + "path_type": "hardlink", + "sha256": "f40a1f47e30ef6502d8f0c2eba40a9b5ea4e68910a3195b65478b2479854ec70", + "sha256_in_prefix": "f40a1f47e30ef6502d8f0c2eba40a9b5ea4e68910a3195b65478b2479854ec70", + "size_in_bytes": 8397 + }, + { + "_path": "lib/python3.10/distutils/command/install_scripts.py", + "path_type": "hardlink", + "sha256": "fc22d4790c06251718da48a4edaccf327e4876d0c2ae359d52f675921946e9c9", + "sha256_in_prefix": "fc22d4790c06251718da48a4edaccf327e4876d0c2ae359d52f675921946e9c9", + "size_in_bytes": 2017 + }, + { + "_path": "lib/python3.10/distutils/command/register.py", + "path_type": "hardlink", + "sha256": "da36aaf7debcaedda9b91543071d476cd897bf6eee3a4f22744ff894f7ffdd53", + "sha256_in_prefix": "da36aaf7debcaedda9b91543071d476cd897bf6eee3a4f22744ff894f7ffdd53", + "size_in_bytes": 11712 + }, + { + "_path": "lib/python3.10/distutils/command/sdist.py", + "path_type": "hardlink", + "sha256": "aa8b498c03b3ca1263ab6fa80c89a3345aceb5a4a778414325307eb04935c275", + "sha256_in_prefix": "aa8b498c03b3ca1263ab6fa80c89a3345aceb5a4a778414325307eb04935c275", + "size_in_bytes": 19005 + }, + { + "_path": "lib/python3.10/distutils/command/upload.py", + "path_type": "hardlink", + "sha256": "ed9475fb90f3ef73d98f8f1f40b8637de2767c9c4fca95975b0a2c55164e5b8c", + "sha256_in_prefix": "ed9475fb90f3ef73d98f8f1f40b8637de2767c9c4fca95975b0a2c55164e5b8c", + "size_in_bytes": 7621 + }, + { + "_path": "lib/python3.10/distutils/config.py", + "path_type": "hardlink", + "sha256": "76d1e06e5c7d2617f2acac75f89ec9971c3f7fbb3c65b3c54228b65163136696", + "sha256_in_prefix": "76d1e06e5c7d2617f2acac75f89ec9971c3f7fbb3c65b3c54228b65163136696", + "size_in_bytes": 4827 + }, + { + "_path": "lib/python3.10/distutils/core.py", + "path_type": "hardlink", + "sha256": "8db74e92938ad3dc62fb9eaf861c2f9f77d87612dbe4324ef2adcad5f9d0cf44", + "sha256_in_prefix": "8db74e92938ad3dc62fb9eaf861c2f9f77d87612dbe4324ef2adcad5f9d0cf44", + "size_in_bytes": 8876 + }, + { + "_path": "lib/python3.10/distutils/cygwinccompiler.py", + "path_type": "hardlink", + "sha256": "b75a16168b3210efd52a6b79b47f386da4ea3d86644caaa929a31a1bc25d1f0c", + "sha256_in_prefix": "b75a16168b3210efd52a6b79b47f386da4ea3d86644caaa929a31a1bc25d1f0c", + "size_in_bytes": 16480 + }, + { + "_path": "lib/python3.10/distutils/debug.py", + "path_type": "hardlink", + "sha256": "37a32b4c0a8aea5f52564ead5b0791d74f0f33c3a5eea3657f257e9c770b86c6", + "sha256_in_prefix": "37a32b4c0a8aea5f52564ead5b0791d74f0f33c3a5eea3657f257e9c770b86c6", + "size_in_bytes": 139 + }, + { + "_path": "lib/python3.10/distutils/dep_util.py", + "path_type": "hardlink", + "sha256": "1ae47d230fe3cd9464c9e989e475fcac1ff0446c642017019b5aa1e78afbce19", + "sha256_in_prefix": "1ae47d230fe3cd9464c9e989e475fcac1ff0446c642017019b5aa1e78afbce19", + "size_in_bytes": 3491 + }, + { + "_path": "lib/python3.10/distutils/dir_util.py", + "path_type": "hardlink", + "sha256": "5308413944dc57ae464f071ee123ee4d747c67cab72d811c9adb6a7066f46d8a", + "sha256_in_prefix": "5308413944dc57ae464f071ee123ee4d747c67cab72d811c9adb6a7066f46d8a", + "size_in_bytes": 7778 + }, + { + "_path": "lib/python3.10/distutils/dist.py", + "path_type": "hardlink", + "sha256": "1e797f81633e34c7993030ac4047b0cd43e49739d40dd03ef262d5c7dd7b17d2", + "sha256_in_prefix": "1e797f81633e34c7993030ac4047b0cd43e49739d40dd03ef262d5c7dd7b17d2", + "size_in_bytes": 50385 + }, + { + "_path": "lib/python3.10/distutils/errors.py", + "path_type": "hardlink", + "sha256": "62bead29919dcc1a0d8b9def06d8aad1427ffd7d390a6c5275026a3966b0e926", + "sha256_in_prefix": "62bead29919dcc1a0d8b9def06d8aad1427ffd7d390a6c5275026a3966b0e926", + "size_in_bytes": 3577 + }, + { + "_path": "lib/python3.10/distutils/extension.py", + "path_type": "hardlink", + "sha256": "cfb99f8b891f9e933544d4b0d25a59569e71bbd79320d61ba64e953e6a6f5a58", + "sha256_in_prefix": "cfb99f8b891f9e933544d4b0d25a59569e71bbd79320d61ba64e953e6a6f5a58", + "size_in_bytes": 10529 + }, + { + "_path": "lib/python3.10/distutils/fancy_getopt.py", + "path_type": "hardlink", + "sha256": "38fc69d82c478b5629fddd43f09c56e147aaf5f0bbd6d7a040569a7e1e7c1865", + "sha256_in_prefix": "38fc69d82c478b5629fddd43f09c56e147aaf5f0bbd6d7a040569a7e1e7c1865", + "size_in_bytes": 17784 + }, + { + "_path": "lib/python3.10/distutils/file_util.py", + "path_type": "hardlink", + "sha256": "d2152a7c8b4dff1d83562851d0c1dd03828231508e3bc568072685a7f6ba3038", + "sha256_in_prefix": "d2152a7c8b4dff1d83562851d0c1dd03828231508e3bc568072685a7f6ba3038", + "size_in_bytes": 8148 + }, + { + "_path": "lib/python3.10/distutils/filelist.py", + "path_type": "hardlink", + "sha256": "f1b471873a7616c6a81d3ed3b8a0f842372e87f07d3b0ff14edfe1b5926f3764", + "sha256_in_prefix": "f1b471873a7616c6a81d3ed3b8a0f842372e87f07d3b0ff14edfe1b5926f3764", + "size_in_bytes": 12832 + }, + { + "_path": "lib/python3.10/distutils/log.py", + "path_type": "hardlink", + "sha256": "8560667540b62bddbb41c56fdd110c5b71cc3dc97171c3d09e0c4b4ae517425d", + "sha256_in_prefix": "8560667540b62bddbb41c56fdd110c5b71cc3dc97171c3d09e0c4b4ae517425d", + "size_in_bytes": 1969 + }, + { + "_path": "lib/python3.10/distutils/msvc9compiler.py", + "path_type": "hardlink", + "sha256": "33d3edc009158d1bf1353165440929e8403935776c16bfaa775f97466f8a8ac3", + "sha256_in_prefix": "33d3edc009158d1bf1353165440929e8403935776c16bfaa775f97466f8a8ac3", + "size_in_bytes": 30453 + }, + { + "_path": "lib/python3.10/distutils/msvccompiler.py", + "path_type": "hardlink", + "sha256": "658b27520202e2d653d969096d39135325520807369c533d0d5288b887cf054d", + "sha256_in_prefix": "658b27520202e2d653d969096d39135325520807369c533d0d5288b887cf054d", + "size_in_bytes": 23540 + }, + { + "_path": "lib/python3.10/distutils/spawn.py", + "path_type": "hardlink", + "sha256": "87336cdb85c2f6ecf2c67cd8a43903bf2cf884c218b1661dcc63a52ad96343e7", + "sha256_in_prefix": "87336cdb85c2f6ecf2c67cd8a43903bf2cf884c218b1661dcc63a52ad96343e7", + "size_in_bytes": 4660 + }, + { + "_path": "lib/python3.10/distutils/sysconfig.py", + "path_type": "hardlink", + "sha256": "d256473d977d81f47eaf2f639672f70ca155635a13ef0ea156b0a94d94fc9a49", + "sha256_in_prefix": "d256473d977d81f47eaf2f639672f70ca155635a13ef0ea156b0a94d94fc9a49", + "size_in_bytes": 12631 + }, + { + "_path": "lib/python3.10/distutils/tests/Setup.sample", + "path_type": "hardlink", + "sha256": "ff839230cf999711c05b9ee030a7e843376aa51190971fd597643508cea7dc74", + "sha256_in_prefix": "ff839230cf999711c05b9ee030a7e843376aa51190971fd597643508cea7dc74", + "size_in_bytes": 2249 + }, + { + "_path": "lib/python3.10/distutils/tests/__init__.py", + "path_type": "hardlink", + "sha256": "07af8a5bf78195cef635a75fa3433feb88e8e33565eefeb66d330ac02260fd45", + "sha256_in_prefix": "07af8a5bf78195cef635a75fa3433feb88e8e33565eefeb66d330ac02260fd45", + "size_in_bytes": 1384 + }, + { + "_path": "lib/python3.10/distutils/tests/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "cf719d176699396df733fdad686e825e5f63af9da147f1e9573cddb2571e1146", + "sha256_in_prefix": "cf719d176699396df733fdad686e825e5f63af9da147f1e9573cddb2571e1146", + "size_in_bytes": 1652 + }, + { + "_path": "lib/python3.10/distutils/tests/__pycache__/support.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "ddf254ab6bb81160a20d7fe08ae6ae6edb914145e855ef36abdc6650e6198ee6", + "sha256_in_prefix": "ddf254ab6bb81160a20d7fe08ae6ae6edb914145e855ef36abdc6650e6198ee6", + "size_in_bytes": 7727 + }, + { + "_path": "lib/python3.10/distutils/tests/__pycache__/test_archive_util.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "1595fad4bbc8d924900fdac67de5da92e85733cded1ea409b6e8948f7dc15420", + "sha256_in_prefix": "1595fad4bbc8d924900fdac67de5da92e85733cded1ea409b6e8948f7dc15420", + "size_in_bytes": 11852 + }, + { + "_path": "lib/python3.10/distutils/tests/__pycache__/test_bdist.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "1880061caf9d88101712704433a15c0ba68b047d723c62ea102817a62c09ceb9", + "sha256_in_prefix": "1880061caf9d88101712704433a15c0ba68b047d723c62ea102817a62c09ceb9", + "size_in_bytes": 2038 + }, + { + "_path": "lib/python3.10/distutils/tests/__pycache__/test_bdist_dumb.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "a33a38b193c09f63972c480f0f12554eb7ee93c893afc17dd73c77fbd7947cf3", + "sha256_in_prefix": "a33a38b193c09f63972c480f0f12554eb7ee93c893afc17dd73c77fbd7947cf3", + "size_in_bytes": 3119 + }, + { + "_path": "lib/python3.10/distutils/tests/__pycache__/test_bdist_msi.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "d7a7f8c809a91b4bdc69e1523d2b3ca209be50b101700135d60b75dc1a800a6d", + "sha256_in_prefix": "d7a7f8c809a91b4bdc69e1523d2b3ca209be50b101700135d60b75dc1a800a6d", + "size_in_bytes": 1493 + }, + { + "_path": "lib/python3.10/distutils/tests/__pycache__/test_bdist_rpm.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "357cfe54d84fb283e05c774c1468e889d33db5e3645071bb18e7231ebe0b834d", + "sha256_in_prefix": "357cfe54d84fb283e05c774c1468e889d33db5e3645071bb18e7231ebe0b834d", + "size_in_bytes": 3883 + }, + { + "_path": "lib/python3.10/distutils/tests/__pycache__/test_build.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "57774a904908fc0c828e0e95409a7bc9d4a4396e0090dfb668640d96af77725b", + "sha256_in_prefix": "57774a904908fc0c828e0e95409a7bc9d4a4396e0090dfb668640d96af77725b", + "size_in_bytes": 1903 + }, + { + "_path": "lib/python3.10/distutils/tests/__pycache__/test_build_clib.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c833d713317f92e98d23e4dbdf0ffc66ffa502a72ecf790b574f03ca2103e917", + "sha256_in_prefix": "c833d713317f92e98d23e4dbdf0ffc66ffa502a72ecf790b574f03ca2103e917", + "size_in_bytes": 4428 + }, + { + "_path": "lib/python3.10/distutils/tests/__pycache__/test_build_ext.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "ab657617b1e212361ec1fbb19572b87d1bd6d0f24869b9766665c08dc2463c94", + "sha256_in_prefix": "ab657617b1e212361ec1fbb19572b87d1bd6d0f24869b9766665c08dc2463c94", + "size_in_bytes": 13995 + }, + { + "_path": "lib/python3.10/distutils/tests/__pycache__/test_build_py.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "d07a6b54562000d2eecd01878841e7b745ea4e326e8e186ece7c3742052ecb6c", + "sha256_in_prefix": "d07a6b54562000d2eecd01878841e7b745ea4e326e8e186ece7c3742052ecb6c", + "size_in_bytes": 5283 + }, + { + "_path": "lib/python3.10/distutils/tests/__pycache__/test_build_scripts.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "2dbb66e5713d431a0cc169228a6d0ddd53a45fed5856190c64344d677e8dd25b", + "sha256_in_prefix": "2dbb66e5713d431a0cc169228a6d0ddd53a45fed5856190c64344d677e8dd25b", + "size_in_bytes": 3726 + }, + { + "_path": "lib/python3.10/distutils/tests/__pycache__/test_check.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "162b5fa962be0aad7cc8246bb51e9b07ed1d89d51120580b2c17971256c2475e", + "sha256_in_prefix": "162b5fa962be0aad7cc8246bb51e9b07ed1d89d51120580b2c17971256c2475e", + "size_in_bytes": 4452 + }, + { + "_path": "lib/python3.10/distutils/tests/__pycache__/test_clean.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "9ab2d7af81564381a810c0a8fecb2ba7d1596e3f8c0f54eed18edfed2429a08d", + "sha256_in_prefix": "9ab2d7af81564381a810c0a8fecb2ba7d1596e3f8c0f54eed18edfed2429a08d", + "size_in_bytes": 1586 + }, + { + "_path": "lib/python3.10/distutils/tests/__pycache__/test_cmd.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "87e930df455682003ded46941d637d9b459e9ee726f0d8f164767a29bbe6f760", + "sha256_in_prefix": "87e930df455682003ded46941d637d9b459e9ee726f0d8f164767a29bbe6f760", + "size_in_bytes": 4576 + }, + { + "_path": "lib/python3.10/distutils/tests/__pycache__/test_config.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "8bca21b9e13eaacbf2c2c1a60bfa51ad961c626cc524aee99f39aa0cf7e78c99", + "sha256_in_prefix": "8bca21b9e13eaacbf2c2c1a60bfa51ad961c626cc524aee99f39aa0cf7e78c99", + "size_in_bytes": 4372 + }, + { + "_path": "lib/python3.10/distutils/tests/__pycache__/test_config_cmd.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "967dded47363bd52c80b44c15a0a60579b8d546960dc8ebaa354eb9b4504314a", + "sha256_in_prefix": "967dded47363bd52c80b44c15a0a60579b8d546960dc8ebaa354eb9b4504314a", + "size_in_bytes": 3849 + }, + { + "_path": "lib/python3.10/distutils/tests/__pycache__/test_core.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "9f3e50deba21a36fcb8e6718a278afe58135993719325b2f3c68d6dd6ec2884a", + "sha256_in_prefix": "9f3e50deba21a36fcb8e6718a278afe58135993719325b2f3c68d6dd6ec2884a", + "size_in_bytes": 4473 + }, + { + "_path": "lib/python3.10/distutils/tests/__pycache__/test_cygwinccompiler.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "aa230e4f394194019c10697d46b4214c73677b5060c7529e7a7b09e0fa58a397", + "sha256_in_prefix": "aa230e4f394194019c10697d46b4214c73677b5060c7529e7a7b09e0fa58a397", + "size_in_bytes": 4741 + }, + { + "_path": "lib/python3.10/distutils/tests/__pycache__/test_dep_util.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "5b7062d687e3624bf5e01e2f5b223102ab227f8caec494cd07a9734489a34b52", + "sha256_in_prefix": "5b7062d687e3624bf5e01e2f5b223102ab227f8caec494cd07a9734489a34b52", + "size_in_bytes": 2550 + }, + { + "_path": "lib/python3.10/distutils/tests/__pycache__/test_dir_util.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "cd06b2e2bd3aa27de8de9e6199a3387489e681e63934190d547934ab6cbd7b03", + "sha256_in_prefix": "cd06b2e2bd3aa27de8de9e6199a3387489e681e63934190d547934ab6cbd7b03", + "size_in_bytes": 5174 + }, + { + "_path": "lib/python3.10/distutils/tests/__pycache__/test_dist.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "db4b0b262d2591d9eb30f7911b8bf21abd850e43438958fe040427aa7786e1ad", + "sha256_in_prefix": "db4b0b262d2591d9eb30f7911b8bf21abd850e43438958fe040427aa7786e1ad", + "size_in_bytes": 16026 + }, + { + "_path": "lib/python3.10/distutils/tests/__pycache__/test_extension.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "ac61f202cfa70bf9b62eeabf31ac4529a534a6d5394d422644e030c221ca2041", + "sha256_in_prefix": "ac61f202cfa70bf9b62eeabf31ac4529a534a6d5394d422644e030c221ca2041", + "size_in_bytes": 2727 + }, + { + "_path": "lib/python3.10/distutils/tests/__pycache__/test_file_util.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "59717b4288932f5801a7cdce2bb987c7c7567d6e274fd879d9e7dee8b96f03c5", + "sha256_in_prefix": "59717b4288932f5801a7cdce2bb987c7c7567d6e274fd879d9e7dee8b96f03c5", + "size_in_bytes": 4934 + }, + { + "_path": "lib/python3.10/distutils/tests/__pycache__/test_filelist.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "f80f6c9561bcc354e08571cdce5641ec5383b5ff11ae5776120b6a5cf5a9e46c", + "sha256_in_prefix": "f80f6c9561bcc354e08571cdce5641ec5383b5ff11ae5776120b6a5cf5a9e46c", + "size_in_bytes": 8683 + }, + { + "_path": "lib/python3.10/distutils/tests/__pycache__/test_install.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "bb9db112386da6fa93362e7fc1a9f7d9d159cc65ea4f40731fcd1d51e949ee2f", + "sha256_in_prefix": "bb9db112386da6fa93362e7fc1a9f7d9d159cc65ea4f40731fcd1d51e949ee2f", + "size_in_bytes": 7892 + }, + { + "_path": "lib/python3.10/distutils/tests/__pycache__/test_install_data.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "d1147df7293d2f5073fa3e3aae95066c3be1dff73558137dce640c55060185da", + "sha256_in_prefix": "d1147df7293d2f5073fa3e3aae95066c3be1dff73558137dce640c55060185da", + "size_in_bytes": 2209 + }, + { + "_path": "lib/python3.10/distutils/tests/__pycache__/test_install_headers.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "35599d1afacab51bd8710d2a6d9989cd7cb3adcb6cf75af430c33e27d832c022", + "sha256_in_prefix": "35599d1afacab51bd8710d2a6d9989cd7cb3adcb6cf75af430c33e27d832c022", + "size_in_bytes": 1640 + }, + { + "_path": "lib/python3.10/distutils/tests/__pycache__/test_install_lib.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "d39e45d243fd756f145cbd7b5ea03ad2e0be093deb2295b80d79a49eaf9d2577", + "sha256_in_prefix": "d39e45d243fd756f145cbd7b5ea03ad2e0be093deb2295b80d79a49eaf9d2577", + "size_in_bytes": 3569 + }, + { + "_path": "lib/python3.10/distutils/tests/__pycache__/test_install_scripts.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "8663a0c1b853f73c9355e77f81db04eb416a6d1eff26c727157df565dcda54f9", + "sha256_in_prefix": "8663a0c1b853f73c9355e77f81db04eb416a6d1eff26c727157df565dcda54f9", + "size_in_bytes": 2710 + }, + { + "_path": "lib/python3.10/distutils/tests/__pycache__/test_log.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "3bcf71b651d1904f6cd90ccfc1aed3fc67a291733d10994eee6f8d829065061d", + "sha256_in_prefix": "3bcf71b651d1904f6cd90ccfc1aed3fc67a291733d10994eee6f8d829065061d", + "size_in_bytes": 1914 + }, + { + "_path": "lib/python3.10/distutils/tests/__pycache__/test_msvc9compiler.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "8270a6edba52e98ec2b83be70ce7487860ff15524f891a9d6afc5aa74e177a38", + "sha256_in_prefix": "8270a6edba52e98ec2b83be70ce7487860ff15524f891a9d6afc5aa74e177a38", + "size_in_bytes": 5927 + }, + { + "_path": "lib/python3.10/distutils/tests/__pycache__/test_msvccompiler.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "a701a71398ac0d2aef9ff1136431811864888b75be20ba76805c168c9e6961c2", + "sha256_in_prefix": "a701a71398ac0d2aef9ff1136431811864888b75be20ba76805c168c9e6961c2", + "size_in_bytes": 2552 + }, + { + "_path": "lib/python3.10/distutils/tests/__pycache__/test_register.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "67aef4bf00a422b56beb5ef36462295c3cea9b3d3d9ef048cf3daacd32163eeb", + "sha256_in_prefix": "67aef4bf00a422b56beb5ef36462295c3cea9b3d3d9ef048cf3daacd32163eeb", + "size_in_bytes": 8440 + }, + { + "_path": "lib/python3.10/distutils/tests/__pycache__/test_sdist.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "a8ad8f6185d0987f9443ef1e775675262b6f3b9f2fa10da600be22457a5820b0", + "sha256_in_prefix": "a8ad8f6185d0987f9443ef1e775675262b6f3b9f2fa10da600be22457a5820b0", + "size_in_bytes": 12764 + }, + { + "_path": "lib/python3.10/distutils/tests/__pycache__/test_spawn.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "1e264821a8be72979b4736d57d32dd7365195fd12dfb18aff86b9988e9723d58", + "sha256_in_prefix": "1e264821a8be72979b4736d57d32dd7365195fd12dfb18aff86b9988e9723d58", + "size_in_bytes": 3907 + }, + { + "_path": "lib/python3.10/distutils/tests/__pycache__/test_sysconfig.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "3a99e2279a5012ea2e2eb08fc9219d0559b748f9795541cdc137d71750a04920", + "sha256_in_prefix": "3a99e2279a5012ea2e2eb08fc9219d0559b748f9795541cdc137d71750a04920", + "size_in_bytes": 9103 + }, + { + "_path": "lib/python3.10/distutils/tests/__pycache__/test_text_file.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "98e32dc5fc12e8e2b0f00ce7b7b745aceb50a4900f5ba4eb509b2afb5c6c81d8", + "sha256_in_prefix": "98e32dc5fc12e8e2b0f00ce7b7b745aceb50a4900f5ba4eb509b2afb5c6c81d8", + "size_in_bytes": 2651 + }, + { + "_path": "lib/python3.10/distutils/tests/__pycache__/test_unixccompiler.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "348f8da1fe4ef52bc53b4010ba7ceda1ffbcd427f49905c71a31c79b08650038", + "sha256_in_prefix": "348f8da1fe4ef52bc53b4010ba7ceda1ffbcd427f49905c71a31c79b08650038", + "size_in_bytes": 4748 + }, + { + "_path": "lib/python3.10/distutils/tests/__pycache__/test_upload.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "d3d3cfe30827c198d948351b98c5776d2c2a7e02e39826987c974d1d3343226c", + "sha256_in_prefix": "d3d3cfe30827c198d948351b98c5776d2c2a7e02e39826987c974d1d3343226c", + "size_in_bytes": 7099 + }, + { + "_path": "lib/python3.10/distutils/tests/__pycache__/test_util.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "a03dcd9ec81680a61f70d084742e488256fbe9f54b7d3c1efff2a536422b4c14", + "sha256_in_prefix": "a03dcd9ec81680a61f70d084742e488256fbe9f54b7d3c1efff2a536422b4c14", + "size_in_bytes": 9305 + }, + { + "_path": "lib/python3.10/distutils/tests/__pycache__/test_version.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "d9fd4f8635e16137e9118d50bbad3418b2a21d51610cc57a1a3b67ef4ade99ad", + "sha256_in_prefix": "d9fd4f8635e16137e9118d50bbad3418b2a21d51610cc57a1a3b67ef4ade99ad", + "size_in_bytes": 2702 + }, + { + "_path": "lib/python3.10/distutils/tests/__pycache__/test_versionpredicate.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "ca952fcbad2f0e03e733628734a9bd02556fdcbbc4660b4e9cd69f7ee8bf7658", + "sha256_in_prefix": "ca952fcbad2f0e03e733628734a9bd02556fdcbbc4660b4e9cd69f7ee8bf7658", + "size_in_bytes": 788 + }, + { + "_path": "lib/python3.10/distutils/tests/includetest.rst", + "path_type": "hardlink", + "sha256": "1a766ccac6850b0424118733e2b086803921e0829f98ad0719be671a5da4263c", + "sha256_in_prefix": "1a766ccac6850b0424118733e2b086803921e0829f98ad0719be671a5da4263c", + "size_in_bytes": 25 + }, + { + "_path": "lib/python3.10/distutils/tests/support.py", + "path_type": "hardlink", + "sha256": "f7649fe69f9eae66781747a72550c3743a197608ca6b37d5607930570a804384", + "sha256_in_prefix": "f7649fe69f9eae66781747a72550c3743a197608ca6b37d5607930570a804384", + "size_in_bytes": 6490 + }, + { + "_path": "lib/python3.10/distutils/tests/test_archive_util.py", + "path_type": "hardlink", + "sha256": "83bf2ee3296935e9a7cc528e903c5bd4632501f5a659453da9576f95b5ee133a", + "sha256_in_prefix": "83bf2ee3296935e9a7cc528e903c5bd4632501f5a659453da9576f95b5ee133a", + "size_in_bytes": 14375 + }, + { + "_path": "lib/python3.10/distutils/tests/test_bdist.py", + "path_type": "hardlink", + "sha256": "48ceba7378dd0d0ed0e3983d120c4fbc3793a35d8bf47cb32f13f18f61a1f854", + "sha256_in_prefix": "48ceba7378dd0d0ed0e3983d120c4fbc3793a35d8bf47cb32f13f18f61a1f854", + "size_in_bytes": 1764 + }, + { + "_path": "lib/python3.10/distutils/tests/test_bdist_dumb.py", + "path_type": "hardlink", + "sha256": "fbe9884e5e1a28ff1d01c087bae2aff7fce7f80884f16b7e3941945e977f3ec2", + "sha256_in_prefix": "fbe9884e5e1a28ff1d01c087bae2aff7fce7f80884f16b7e3941945e977f3ec2", + "size_in_bytes": 2905 + }, + { + "_path": "lib/python3.10/distutils/tests/test_bdist_msi.py", + "path_type": "hardlink", + "sha256": "85385f211bc84e188d73acec80e5023db03cccd4dea606c02c2d52ee2d42f55f", + "sha256_in_prefix": "85385f211bc84e188d73acec80e5023db03cccd4dea606c02c2d52ee2d42f55f", + "size_in_bytes": 843 + }, + { + "_path": "lib/python3.10/distutils/tests/test_bdist_rpm.py", + "path_type": "hardlink", + "sha256": "e40ec9e60ee10385af078bf41b8a2fa126fc4f0919547e0a68f0b1aa2517f046", + "sha256_in_prefix": "e40ec9e60ee10385af078bf41b8a2fa126fc4f0919547e0a68f0b1aa2517f046", + "size_in_bytes": 5012 + }, + { + "_path": "lib/python3.10/distutils/tests/test_build.py", + "path_type": "hardlink", + "sha256": "c21e2ce5937429a9aeb92686b192e4751eb28399dd7af44bf524b5706c2237e8", + "sha256_in_prefix": "c21e2ce5937429a9aeb92686b192e4751eb28399dd7af44bf524b5706c2237e8", + "size_in_bytes": 1965 + }, + { + "_path": "lib/python3.10/distutils/tests/test_build_clib.py", + "path_type": "hardlink", + "sha256": "c13bcc9b849ba70fa7e49baffc922fb2ad03671cbd989e28217220a65fc5bad1", + "sha256_in_prefix": "c13bcc9b849ba70fa7e49baffc922fb2ad03671cbd989e28217220a65fc5bad1", + "size_in_bytes": 4913 + }, + { + "_path": "lib/python3.10/distutils/tests/test_build_ext.py", + "path_type": "hardlink", + "sha256": "e79ebbde7cb44634761b906c45315cf054c360184844bb7274dfeb010088c9a8", + "sha256_in_prefix": "e79ebbde7cb44634761b906c45315cf054c360184844bb7274dfeb010088c9a8", + "size_in_bytes": 20829 + }, + { + "_path": "lib/python3.10/distutils/tests/test_build_py.py", + "path_type": "hardlink", + "sha256": "1eeea30b412c1f9375c86965528f0fcea92cb59a9f6f7f827ad639f6d50d5432", + "sha256_in_prefix": "1eeea30b412c1f9375c86965528f0fcea92cb59a9f6f7f827ad639f6d50d5432", + "size_in_bytes": 6335 + }, + { + "_path": "lib/python3.10/distutils/tests/test_build_scripts.py", + "path_type": "hardlink", + "sha256": "046407fe31a1b3416acbd34df0c4622c7f7e6fecf9859bcebd4214b6b62c505f", + "sha256_in_prefix": "046407fe31a1b3416acbd34df0c4622c7f7e6fecf9859bcebd4214b6b62c505f", + "size_in_bytes": 3593 + }, + { + "_path": "lib/python3.10/distutils/tests/test_check.py", + "path_type": "hardlink", + "sha256": "03950ad7681549157802d8c38005c59ed3c5df5d9f328636701bf24c9953984f", + "sha256_in_prefix": "03950ad7681549157802d8c38005c59ed3c5df5d9f328636701bf24c9953984f", + "size_in_bytes": 5711 + }, + { + "_path": "lib/python3.10/distutils/tests/test_clean.py", + "path_type": "hardlink", + "sha256": "af860768e940633cd0dda9bdb10d3faa9f018e4e94bcb29975cbfa8fcb7fe424", + "sha256_in_prefix": "af860768e940633cd0dda9bdb10d3faa9f018e4e94bcb29975cbfa8fcb7fe424", + "size_in_bytes": 1441 + }, + { + "_path": "lib/python3.10/distutils/tests/test_cmd.py", + "path_type": "hardlink", + "sha256": "f0e86363c03e17fcf28d44938d2d064d3de8419705acfa6f6f7a286a66e4b7ba", + "sha256_in_prefix": "f0e86363c03e17fcf28d44938d2d064d3de8419705acfa6f6f7a286a66e4b7ba", + "size_in_bytes": 3835 + }, + { + "_path": "lib/python3.10/distutils/tests/test_config.py", + "path_type": "hardlink", + "sha256": "1c0e82ceed789b3bd1c1de73d40a79c623b8698f07aad0299921bb4ab9f758ea", + "sha256_in_prefix": "1c0e82ceed789b3bd1c1de73d40a79c623b8698f07aad0299921bb4ab9f758ea", + "size_in_bytes": 3892 + }, + { + "_path": "lib/python3.10/distutils/tests/test_config_cmd.py", + "path_type": "hardlink", + "sha256": "792a8948fd5d79a77bad54d65b92f4a8bbfa2d54211ecb93a8884066f56427e8", + "sha256_in_prefix": "792a8948fd5d79a77bad54d65b92f4a8bbfa2d54211ecb93a8884066f56427e8", + "size_in_bytes": 3199 + }, + { + "_path": "lib/python3.10/distutils/tests/test_core.py", + "path_type": "hardlink", + "sha256": "f05ece1f6896864213519c9ebd6dcc3b68afe35769aff55de9d5c1a37e354908", + "sha256_in_prefix": "f05ece1f6896864213519c9ebd6dcc3b68afe35769aff55de9d5c1a37e354908", + "size_in_bytes": 4080 + }, + { + "_path": "lib/python3.10/distutils/tests/test_cygwinccompiler.py", + "path_type": "hardlink", + "sha256": "ab94a3e3cc02359e455af7fed69ab8dc2266bf58a3b10d4153ace9a776b28fb6", + "sha256_in_prefix": "ab94a3e3cc02359e455af7fed69ab8dc2266bf58a3b10d4153ace9a776b28fb6", + "size_in_bytes": 5636 + }, + { + "_path": "lib/python3.10/distutils/tests/test_dep_util.py", + "path_type": "hardlink", + "sha256": "6dc13cad79303d04b81a83a9d556775a442e1369d45121a0e0ab8f13242328c1", + "sha256_in_prefix": "6dc13cad79303d04b81a83a9d556775a442e1369d45121a0e0ab8f13242328c1", + "size_in_bytes": 2820 + }, + { + "_path": "lib/python3.10/distutils/tests/test_dir_util.py", + "path_type": "hardlink", + "sha256": "44a92518311e69ba5e32529650673c6ac61b300b97800f8cd5423b429ca2abf1", + "sha256_in_prefix": "44a92518311e69ba5e32529650673c6ac61b300b97800f8cd5423b429ca2abf1", + "size_in_bytes": 4654 + }, + { + "_path": "lib/python3.10/distutils/tests/test_dist.py", + "path_type": "hardlink", + "sha256": "71ea4a132597be2891b931d7f1ccb5ff7811aa6353bc13bd9490df7ef18feabc", + "sha256_in_prefix": "71ea4a132597be2891b931d7f1ccb5ff7811aa6353bc13bd9490df7ef18feabc", + "size_in_bytes": 19114 + }, + { + "_path": "lib/python3.10/distutils/tests/test_extension.py", + "path_type": "hardlink", + "sha256": "01eed22047545deacb1b4448b55589a9941df362a28570dd225606776d47c225", + "sha256_in_prefix": "01eed22047545deacb1b4448b55589a9941df362a28570dd225606776d47c225", + "size_in_bytes": 2808 + }, + { + "_path": "lib/python3.10/distutils/tests/test_file_util.py", + "path_type": "hardlink", + "sha256": "43f8091f014358761d806c4f7a69347afec116f37093c0a01991a9d58cf59b5d", + "sha256_in_prefix": "43f8091f014358761d806c4f7a69347afec116f37093c0a01991a9d58cf59b5d", + "size_in_bytes": 4448 + }, + { + "_path": "lib/python3.10/distutils/tests/test_filelist.py", + "path_type": "hardlink", + "sha256": "a15e902307d415403251a223f52fb90345030025b133231188b2bfa1b1ca725b", + "sha256_in_prefix": "a15e902307d415403251a223f52fb90345030025b133231188b2bfa1b1ca725b", + "size_in_bytes": 11469 + }, + { + "_path": "lib/python3.10/distutils/tests/test_install.py", + "path_type": "hardlink", + "sha256": "2e45219abaa569087b5f0a0c0c930ec92538672c79e4034e368f324ddef02110", + "sha256_in_prefix": "2e45219abaa569087b5f0a0c0c930ec92538672c79e4034e368f324ddef02110", + "size_in_bytes": 8984 + }, + { + "_path": "lib/python3.10/distutils/tests/test_install_data.py", + "path_type": "hardlink", + "sha256": "e0a29d16cffd3997def9179353eb6ae020644c2e59a5d4dc5ec1583da51eab7e", + "sha256_in_prefix": "e0a29d16cffd3997def9179353eb6ae020644c2e59a5d4dc5ec1583da51eab7e", + "size_in_bytes": 2577 + }, + { + "_path": "lib/python3.10/distutils/tests/test_install_headers.py", + "path_type": "hardlink", + "sha256": "abbddc109ef35ed9aca855ca57629ff38f775f7a972da5771df9654e0bcdf8aa", + "sha256_in_prefix": "abbddc109ef35ed9aca855ca57629ff38f775f7a972da5771df9654e0bcdf8aa", + "size_in_bytes": 1238 + }, + { + "_path": "lib/python3.10/distutils/tests/test_install_lib.py", + "path_type": "hardlink", + "sha256": "b7bb725739e88f1529897190c26c969689735852da29b39f1fa962a7875dd531", + "sha256_in_prefix": "b7bb725739e88f1529897190c26c969689735852da29b39f1fa962a7875dd531", + "size_in_bytes": 3974 + }, + { + "_path": "lib/python3.10/distutils/tests/test_install_scripts.py", + "path_type": "hardlink", + "sha256": "0a7e1d6f6befd7aa20f4acc0b9154f3206565a2ea5c81b71ad7b255d2b9195f8", + "sha256_in_prefix": "0a7e1d6f6befd7aa20f4acc0b9154f3206565a2ea5c81b71ad7b255d2b9195f8", + "size_in_bytes": 2625 + }, + { + "_path": "lib/python3.10/distutils/tests/test_log.py", + "path_type": "hardlink", + "sha256": "e79dada8f4e68c15b1ceb61f1f35354106972a6e3f29b69f351d701ad1ff3690", + "sha256_in_prefix": "e79dada8f4e68c15b1ceb61f1f35354106972a6e3f29b69f351d701ad1ff3690", + "size_in_bytes": 1864 + }, + { + "_path": "lib/python3.10/distutils/tests/test_msvc9compiler.py", + "path_type": "hardlink", + "sha256": "284acd052027b622bc696be5fd2068fb149cb82a10e6dd15537175604c1a212e", + "sha256_in_prefix": "284acd052027b622bc696be5fd2068fb149cb82a10e6dd15537175604c1a212e", + "size_in_bytes": 6038 + }, + { + "_path": "lib/python3.10/distutils/tests/test_msvccompiler.py", + "path_type": "hardlink", + "sha256": "0d1dde41db44732b7bb09f00ecb0359d6c9434ddbe3065ea0ee3a93a9035543b", + "sha256_in_prefix": "0d1dde41db44732b7bb09f00ecb0359d6c9434ddbe3065ea0ee3a93a9035543b", + "size_in_bytes": 2845 + }, + { + "_path": "lib/python3.10/distutils/tests/test_register.py", + "path_type": "hardlink", + "sha256": "0250ba18275c1b7b4d54a7e5e5b2353d0408b938baae10783661d24123dc31d0", + "sha256_in_prefix": "0250ba18275c1b7b4d54a7e5e5b2353d0408b938baae10783661d24123dc31d0", + "size_in_bytes": 9805 + }, + { + "_path": "lib/python3.10/distutils/tests/test_sdist.py", + "path_type": "hardlink", + "sha256": "7b14aa02788e3ec8f3f68aa73120bdfdb9771aba3c4f0db6af2482707322fcb5", + "sha256_in_prefix": "7b14aa02788e3ec8f3f68aa73120bdfdb9771aba3c4f0db6af2482707322fcb5", + "size_in_bytes": 17087 + }, + { + "_path": "lib/python3.10/distutils/tests/test_spawn.py", + "path_type": "hardlink", + "sha256": "94ac8098d4663d41cbfb8893d3af3b633c06bb40dfe898a0f76a96bf10bcafe7", + "sha256_in_prefix": "94ac8098d4663d41cbfb8893d3af3b633c06bb40dfe898a0f76a96bf10bcafe7", + "size_in_bytes": 5430 + }, + { + "_path": "lib/python3.10/distutils/tests/test_sysconfig.py", + "path_type": "hardlink", + "sha256": "a5398489113f8b7a878b6bcccccba5a1a8bbea3857a285c3c3d3ffde8903e0b2", + "sha256_in_prefix": "a5398489113f8b7a878b6bcccccba5a1a8bbea3857a285c3c3d3ffde8903e0b2", + "size_in_bytes": 11120 + }, + { + "_path": "lib/python3.10/distutils/tests/test_text_file.py", + "path_type": "hardlink", + "sha256": "dbf3f1b388f55a2ac4c13336f2814fdc862ad52e88a93c7eca7cb3e68d2d8d9a", + "sha256_in_prefix": "dbf3f1b388f55a2ac4c13336f2814fdc862ad52e88a93c7eca7cb3e68d2d8d9a", + "size_in_bytes": 3436 + }, + { + "_path": "lib/python3.10/distutils/tests/test_unixccompiler.py", + "path_type": "hardlink", + "sha256": "afdec9265cc15f2dd52e11128ff9ea6fc75a47c39d3d079ef9953c0a14108eae", + "sha256_in_prefix": "afdec9265cc15f2dd52e11128ff9ea6fc75a47c39d3d079ef9953c0a14108eae", + "size_in_bytes": 4829 + }, + { + "_path": "lib/python3.10/distutils/tests/test_upload.py", + "path_type": "hardlink", + "sha256": "5acabcbf6ad46d7c6cd0a3ab45796872944e8ddf21fa89c0cca6f1ecbb1cc733", + "sha256_in_prefix": "5acabcbf6ad46d7c6cd0a3ab45796872944e8ddf21fa89c0cca6f1ecbb1cc733", + "size_in_bytes": 7137 + }, + { + "_path": "lib/python3.10/distutils/tests/test_util.py", + "path_type": "hardlink", + "sha256": "9a795b1ede038ac9c2ab16e1f852c17bd5c00e29d22c0c9e2d02ce8224fb74f9", + "sha256_in_prefix": "9a795b1ede038ac9c2ab16e1f852c17bd5c00e29d22c0c9e2d02ce8224fb74f9", + "size_in_bytes": 11611 + }, + { + "_path": "lib/python3.10/distutils/tests/test_version.py", + "path_type": "hardlink", + "sha256": "9fad90df09845d5dd4b654f375c929f5532e2e243f77ab102aaeabf39a71e7e5", + "sha256_in_prefix": "9fad90df09845d5dd4b654f375c929f5532e2e243f77ab102aaeabf39a71e7e5", + "size_in_bytes": 3450 + }, + { + "_path": "lib/python3.10/distutils/tests/test_versionpredicate.py", + "path_type": "hardlink", + "sha256": "690003c23752f77c7ea1108cd51dd7e9b0ca7021ad925aa982bae5bcd2f988b0", + "sha256_in_prefix": "690003c23752f77c7ea1108cd51dd7e9b0ca7021ad925aa982bae5bcd2f988b0", + "size_in_bytes": 280 + }, + { + "_path": "lib/python3.10/distutils/tests/xxmodule.c", + "path_type": "hardlink", + "sha256": "0a3bcc0446de7d7092d3b36b4b908c2aa7278c91188d399faa6e511df87daee8", + "sha256_in_prefix": "0a3bcc0446de7d7092d3b36b4b908c2aa7278c91188d399faa6e511df87daee8", + "size_in_bytes": 12862 + }, + { + "_path": "lib/python3.10/distutils/text_file.py", + "path_type": "hardlink", + "sha256": "3ecb8025e59d289a0b495ffa37a229079fb43daf382b32d4b9c24c1516b3c372", + "sha256_in_prefix": "3ecb8025e59d289a0b495ffa37a229079fb43daf382b32d4b9c24c1516b3c372", + "size_in_bytes": 12483 + }, + { + "_path": "lib/python3.10/distutils/unixccompiler.py", + "path_type": "hardlink", + "sha256": "d712f8538752bbc8cf7c76e30b3e69c0a409d94fbf004732f6f6ea5c24f26780", + "sha256_in_prefix": "d712f8538752bbc8cf7c76e30b3e69c0a409d94fbf004732f6f6ea5c24f26780", + "size_in_bytes": 14855 + }, + { + "_path": "lib/python3.10/distutils/util.py", + "path_type": "hardlink", + "sha256": "5a759d80dc2bebdda1bc4461ddc9a335c378e3a25e4da20218cdce07686824ae", + "sha256_in_prefix": "5a759d80dc2bebdda1bc4461ddc9a335c378e3a25e4da20218cdce07686824ae", + "size_in_bytes": 21032 + }, + { + "_path": "lib/python3.10/distutils/version.py", + "path_type": "hardlink", + "sha256": "f0da203fa34f3d0a69dc450c65c4fd73310789af9e86a3e8f2ca68fdeec08145", + "sha256_in_prefix": "f0da203fa34f3d0a69dc450c65c4fd73310789af9e86a3e8f2ca68fdeec08145", + "size_in_bytes": 12514 + }, + { + "_path": "lib/python3.10/distutils/versionpredicate.py", + "path_type": "hardlink", + "sha256": "671a4403e4d0bfcf2651673a85eb543b8a92a80dac6bb8a98d9dd010ae5ebc39", + "sha256_in_prefix": "671a4403e4d0bfcf2651673a85eb543b8a92a80dac6bb8a98d9dd010ae5ebc39", + "size_in_bytes": 5133 + }, + { + "_path": "lib/python3.10/doctest.py", + "path_type": "hardlink", + "sha256": "e6cb29d6207195f566d69aea56c2c2036c311b8188b89ee3e9264116a60b82e1", + "sha256_in_prefix": "e6cb29d6207195f566d69aea56c2c2036c311b8188b89ee3e9264116a60b82e1", + "size_in_bytes": 105143 + }, + { + "_path": "lib/python3.10/email/__init__.py", + "path_type": "hardlink", + "sha256": "14eeb17ae40c6cc19b48a9bd5e2a0340ee3dd86a8d64bd1d5c4df8fcfa726c8a", + "sha256_in_prefix": "14eeb17ae40c6cc19b48a9bd5e2a0340ee3dd86a8d64bd1d5c4df8fcfa726c8a", + "size_in_bytes": 1766 + }, + { + "_path": "lib/python3.10/email/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "d96c88b809756384b1299a1bfc52a7ce7cd6712c4261cb9b335b056b74f9ad4e", + "sha256_in_prefix": "d96c88b809756384b1299a1bfc52a7ce7cd6712c4261cb9b335b056b74f9ad4e", + "size_in_bytes": 1814 + }, + { + "_path": "lib/python3.10/email/__pycache__/_encoded_words.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "9c3634b01d72d0db5cab6a0c928eb5f8e15126718d768679c36a0055201c2070", + "sha256_in_prefix": "9c3634b01d72d0db5cab6a0c928eb5f8e15126718d768679c36a0055201c2070", + "size_in_bytes": 5994 + }, + { + "_path": "lib/python3.10/email/__pycache__/_header_value_parser.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "48fe91697cb36586ba0fdb8b65fab59d3fff94d5e0771a9ae6de661d5c9fdb6d", + "sha256_in_prefix": "48fe91697cb36586ba0fdb8b65fab59d3fff94d5e0771a9ae6de661d5c9fdb6d", + "size_in_bytes": 78049 + }, + { + "_path": "lib/python3.10/email/__pycache__/_parseaddr.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "71ffe0ea0421cdc7d6e992be3edf59a6254e7cac36a32a955d931597c28910bb", + "sha256_in_prefix": "71ffe0ea0421cdc7d6e992be3edf59a6254e7cac36a32a955d931597c28910bb", + "size_in_bytes": 12766 + }, + { + "_path": "lib/python3.10/email/__pycache__/_policybase.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "b34fb92f9e766beb2a83718a701dbb4389f1eb7d2807502657390ffb194a4bc0", + "sha256_in_prefix": "b34fb92f9e766beb2a83718a701dbb4389f1eb7d2807502657390ffb194a4bc0", + "size_in_bytes": 15036 + }, + { + "_path": "lib/python3.10/email/__pycache__/base64mime.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "179c7013edadf9d44451f9eceed7c1585d206e0dfa06e6283a5a32dc55032298", + "sha256_in_prefix": "179c7013edadf9d44451f9eceed7c1585d206e0dfa06e6283a5a32dc55032298", + "size_in_bytes": 3494 + }, + { + "_path": "lib/python3.10/email/__pycache__/charset.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c5129bb2184682c17e63da022643dfd0ecd4219b7cf292070e936e050b8340d8", + "sha256_in_prefix": "c5129bb2184682c17e63da022643dfd0ecd4219b7cf292070e936e050b8340d8", + "size_in_bytes": 11829 + }, + { + "_path": "lib/python3.10/email/__pycache__/contentmanager.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "53e4704110f0791440fa403cc3cfa5287dcf5f4eced99340c4c949ae77e780e7", + "sha256_in_prefix": "53e4704110f0791440fa403cc3cfa5287dcf5f4eced99340c4c949ae77e780e7", + "size_in_bytes": 7643 + }, + { + "_path": "lib/python3.10/email/__pycache__/encoders.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "4d47e49f24ca18a31a64615e7fa81f3bfab75ced5bf74775a5d60a180edbbabc", + "sha256_in_prefix": "4d47e49f24ca18a31a64615e7fa81f3bfab75ced5bf74775a5d60a180edbbabc", + "size_in_bytes": 1881 + }, + { + "_path": "lib/python3.10/email/__pycache__/errors.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "1e15917bbb070ebb3aab99c418982b42b03156bb49c850fc0f9b39db21dfd344", + "sha256_in_prefix": "1e15917bbb070ebb3aab99c418982b42b03156bb49c850fc0f9b39db21dfd344", + "size_in_bytes": 5956 + }, + { + "_path": "lib/python3.10/email/__pycache__/feedparser.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c9b3a3cc2561072c988a595108623035a7aca12d1160d4bcfefff639e4bd4300", + "sha256_in_prefix": "c9b3a3cc2561072c988a595108623035a7aca12d1160d4bcfefff639e4bd4300", + "size_in_bytes": 10832 + }, + { + "_path": "lib/python3.10/email/__pycache__/generator.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "e56cc2363b7bc48bcda9791529adc23c687ffd3e9dee42de38ba2976839dc97f", + "sha256_in_prefix": "e56cc2363b7bc48bcda9791529adc23c687ffd3e9dee42de38ba2976839dc97f", + "size_in_bytes": 12855 + }, + { + "_path": "lib/python3.10/email/__pycache__/header.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "da6b85822bc5cd8d502fc6e382959f4427e492dad89eeb5ffbbee6937bf545ff", + "sha256_in_prefix": "da6b85822bc5cd8d502fc6e382959f4427e492dad89eeb5ffbbee6937bf545ff", + "size_in_bytes": 16716 + }, + { + "_path": "lib/python3.10/email/__pycache__/headerregistry.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "1c9cc79997b7753d6dc0538b07c5cb1d91661b7f9ad23b31ccb0f4070f6e38bc", + "sha256_in_prefix": "1c9cc79997b7753d6dc0538b07c5cb1d91661b7f9ad23b31ccb0f4070f6e38bc", + "size_in_bytes": 22159 + }, + { + "_path": "lib/python3.10/email/__pycache__/iterators.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "9c4c45eb0b3585c8e7eb40d695d86489fb50536d3d7102f5b0467bb1939d5db7", + "sha256_in_prefix": "9c4c45eb0b3585c8e7eb40d695d86489fb50536d3d7102f5b0467bb1939d5db7", + "size_in_bytes": 2222 + }, + { + "_path": "lib/python3.10/email/__pycache__/message.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c07e625a935251ec3ad1549206db5e0a8509650961789219b69d05b84fb2d20b", + "sha256_in_prefix": "c07e625a935251ec3ad1549206db5e0a8509650961789219b69d05b84fb2d20b", + "size_in_bytes": 38058 + }, + { + "_path": "lib/python3.10/email/__pycache__/parser.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "0fa7eb30940ba95080fe64a992a681c16e2d0a50e264c877e31266634d4238b2", + "sha256_in_prefix": "0fa7eb30940ba95080fe64a992a681c16e2d0a50e264c877e31266634d4238b2", + "size_in_bytes": 5927 + }, + { + "_path": "lib/python3.10/email/__pycache__/policy.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c06eca141280f578addde40dd75094b69356d574e913b50e3d5b60a39c36004d", + "sha256_in_prefix": "c06eca141280f578addde40dd75094b69356d574e913b50e3d5b60a39c36004d", + "size_in_bytes": 9907 + }, + { + "_path": "lib/python3.10/email/__pycache__/quoprimime.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c5c44b096807d45b8a2aecdc8602c7e79482bdba4ac901e4b082fa15077196c4", + "sha256_in_prefix": "c5c44b096807d45b8a2aecdc8602c7e79482bdba4ac901e4b082fa15077196c4", + "size_in_bytes": 7877 + }, + { + "_path": "lib/python3.10/email/__pycache__/utils.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "46bed577933fc8d2e4963c1775e988c2f10a8891fd72b52165e8d858365e7fdc", + "sha256_in_prefix": "46bed577933fc8d2e4963c1775e988c2f10a8891fd72b52165e8d858365e7fdc", + "size_in_bytes": 9940 + }, + { + "_path": "lib/python3.10/email/_encoded_words.py", + "path_type": "hardlink", + "sha256": "4178321600c0a19ca04cfe8542ce44487f339d15d89a473b58cea63c0b230217", + "sha256_in_prefix": "4178321600c0a19ca04cfe8542ce44487f339d15d89a473b58cea63c0b230217", + "size_in_bytes": 8541 + }, + { + "_path": "lib/python3.10/email/_header_value_parser.py", + "path_type": "hardlink", + "sha256": "f4fe84dcd279f58ef04a9763cde87947fc6358a112ef2953f40b04b5a9058c9c", + "sha256_in_prefix": "f4fe84dcd279f58ef04a9763cde87947fc6358a112ef2953f40b04b5a9058c9c", + "size_in_bytes": 106982 + }, + { + "_path": "lib/python3.10/email/_parseaddr.py", + "path_type": "hardlink", + "sha256": "4308932872acbf4a674312a45a49b870e48026e3dfedc878ee2f512ddf2f30ba", + "sha256_in_prefix": "4308932872acbf4a674312a45a49b870e48026e3dfedc878ee2f512ddf2f30ba", + "size_in_bytes": 17821 + }, + { + "_path": "lib/python3.10/email/_policybase.py", + "path_type": "hardlink", + "sha256": "967a41672b54f3443eac096968ad189d75c77be7eb42611b4d81d12a41605be9", + "sha256_in_prefix": "967a41672b54f3443eac096968ad189d75c77be7eb42611b4d81d12a41605be9", + "size_in_bytes": 15073 + }, + { + "_path": "lib/python3.10/email/architecture.rst", + "path_type": "hardlink", + "sha256": "f2b2ba7497fd02d13abcfc2a98099283a94b09e8b4f2c1c822ecacde3bec3eae", + "sha256_in_prefix": "f2b2ba7497fd02d13abcfc2a98099283a94b09e8b4f2c1c822ecacde3bec3eae", + "size_in_bytes": 9561 + }, + { + "_path": "lib/python3.10/email/base64mime.py", + "path_type": "hardlink", + "sha256": "508aa55b77f042a8da60ce79ed66715818049d5061677be6d02fe89269d8a3dd", + "sha256_in_prefix": "508aa55b77f042a8da60ce79ed66715818049d5061677be6d02fe89269d8a3dd", + "size_in_bytes": 3559 + }, + { + "_path": "lib/python3.10/email/charset.py", + "path_type": "hardlink", + "sha256": "115cc9aad570643b91897a19c71f7a27028bc11b4ee4374e11a32643c1b12d25", + "sha256_in_prefix": "115cc9aad570643b91897a19c71f7a27028bc11b4ee4374e11a32643c1b12d25", + "size_in_bytes": 17128 + }, + { + "_path": "lib/python3.10/email/contentmanager.py", + "path_type": "hardlink", + "sha256": "2b3adab3d945d156bf8a22762590278bbf177d95545e5fc3c1d6c73b5d041ddf", + "sha256_in_prefix": "2b3adab3d945d156bf8a22762590278bbf177d95545e5fc3c1d6c73b5d041ddf", + "size_in_bytes": 10555 + }, + { + "_path": "lib/python3.10/email/encoders.py", + "path_type": "hardlink", + "sha256": "1e05b3ee30c62c605077e7770b5b3249f5060d968b0fee8d5cf9cad9450b89cd", + "sha256_in_prefix": "1e05b3ee30c62c605077e7770b5b3249f5060d968b0fee8d5cf9cad9450b89cd", + "size_in_bytes": 1786 + }, + { + "_path": "lib/python3.10/email/errors.py", + "path_type": "hardlink", + "sha256": "33fc889cbff57bb78c913bb6c24c5d52bd02f3cba0f4b1cb2913340294a6ec1a", + "sha256_in_prefix": "33fc889cbff57bb78c913bb6c24c5d52bd02f3cba0f4b1cb2913340294a6ec1a", + "size_in_bytes": 3735 + }, + { + "_path": "lib/python3.10/email/feedparser.py", + "path_type": "hardlink", + "sha256": "6f8faf3d77fbdc2096f8bbedfd58c3d58e7937a11f0d652b43a2b842a5597625", + "sha256_in_prefix": "6f8faf3d77fbdc2096f8bbedfd58c3d58e7937a11f0d652b43a2b842a5597625", + "size_in_bytes": 22780 + }, + { + "_path": "lib/python3.10/email/generator.py", + "path_type": "hardlink", + "sha256": "696404ca67a6d917a6801221cd6f5c9f0f88eaf3a3d0c7bae426ba573ab34d5e", + "sha256_in_prefix": "696404ca67a6d917a6801221cd6f5c9f0f88eaf3a3d0c7bae426ba573ab34d5e", + "size_in_bytes": 20196 + }, + { + "_path": "lib/python3.10/email/header.py", + "path_type": "hardlink", + "sha256": "99921e2aa7ae5ae1433a0e3f92c732026677417c39923996c11931589ff8a361", + "sha256_in_prefix": "99921e2aa7ae5ae1433a0e3f92c732026677417c39923996c11931589ff8a361", + "size_in_bytes": 24102 + }, + { + "_path": "lib/python3.10/email/headerregistry.py", + "path_type": "hardlink", + "sha256": "c6732dcb9473c45c8999c318d6281e549e842174bd9da13f39d9bfd45324d283", + "sha256_in_prefix": "c6732dcb9473c45c8999c318d6281e549e842174bd9da13f39d9bfd45324d283", + "size_in_bytes": 20813 + }, + { + "_path": "lib/python3.10/email/iterators.py", + "path_type": "hardlink", + "sha256": "7ebca15c9f5889b9551727303666a7bd80c5e4ebdf6bc7ec4d0c46938a1378e1", + "sha256_in_prefix": "7ebca15c9f5889b9551727303666a7bd80c5e4ebdf6bc7ec4d0c46938a1378e1", + "size_in_bytes": 2135 + }, + { + "_path": "lib/python3.10/email/message.py", + "path_type": "hardlink", + "sha256": "1b125a3f94289c3ff62f4dee59bcc46ded67aa4f759d3dbc035d84ce92d85d1e", + "sha256_in_prefix": "1b125a3f94289c3ff62f4dee59bcc46ded67aa4f759d3dbc035d84ce92d85d1e", + "size_in_bytes": 47060 + }, + { + "_path": "lib/python3.10/email/mime/__init__.py", + "path_type": "hardlink", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size_in_bytes": 0 + }, + { + "_path": "lib/python3.10/email/mime/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "4262672278c29465df589e8576e13ec3c2c0be6f99ca98aed673a372b2ae4129", + "sha256_in_prefix": "4262672278c29465df589e8576e13ec3c2c0be6f99ca98aed673a372b2ae4129", + "size_in_bytes": 389 + }, + { + "_path": "lib/python3.10/email/mime/__pycache__/application.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "b3d72bd96a897c9c642a96f29cf2c973c0c4aede07f279a86833e57aebe6db8e", + "sha256_in_prefix": "b3d72bd96a897c9c642a96f29cf2c973c0c4aede07f279a86833e57aebe6db8e", + "size_in_bytes": 1718 + }, + { + "_path": "lib/python3.10/email/mime/__pycache__/audio.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "cb3f53c6beb588d98633c502d4e3a9942dfb1a64c08adf35a49c4c7d14d3cec4", + "sha256_in_prefix": "cb3f53c6beb588d98633c502d4e3a9942dfb1a64c08adf35a49c4c7d14d3cec4", + "size_in_bytes": 2885 + }, + { + "_path": "lib/python3.10/email/mime/__pycache__/base.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "40afd4523b13e99b916dfd663e73da2e97a0fac12f99bdf0ebd0b82da56619c0", + "sha256_in_prefix": "40afd4523b13e99b916dfd663e73da2e97a0fac12f99bdf0ebd0b82da56619c0", + "size_in_bytes": 1304 + }, + { + "_path": "lib/python3.10/email/mime/__pycache__/image.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "f847ed79360b698743c0a9a628448961cf60d76d44acf78708a2477ef93aff2c", + "sha256_in_prefix": "f847ed79360b698743c0a9a628448961cf60d76d44acf78708a2477ef93aff2c", + "size_in_bytes": 2162 + }, + { + "_path": "lib/python3.10/email/mime/__pycache__/message.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "4859d12e5edfcbddeb858b93f4f60e503f4ce08e8b2394c06e6e21545f018100", + "sha256_in_prefix": "4859d12e5edfcbddeb858b93f4f60e503f4ce08e8b2394c06e6e21545f018100", + "size_in_bytes": 1541 + }, + { + "_path": "lib/python3.10/email/mime/__pycache__/multipart.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "759118ca75976cda6a054ba910ab5eae4a1bafe7c6b2d598a4bb999e4dad188e", + "sha256_in_prefix": "759118ca75976cda6a054ba910ab5eae4a1bafe7c6b2d598a4bb999e4dad188e", + "size_in_bytes": 1767 + }, + { + "_path": "lib/python3.10/email/mime/__pycache__/nonmultipart.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "956e1cee596fe50409ca1c0147f1c9391e099c7aaba1511e41d754e0952f3015", + "sha256_in_prefix": "956e1cee596fe50409ca1c0147f1c9391e099c7aaba1511e41d754e0952f3015", + "size_in_bytes": 1019 + }, + { + "_path": "lib/python3.10/email/mime/__pycache__/text.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "eed1d756a181ce7141f57c26904359784d410ee04842a16783a5d74df8c841e7", + "sha256_in_prefix": "eed1d756a181ce7141f57c26904359784d410ee04842a16783a5d74df8c841e7", + "size_in_bytes": 1570 + }, + { + "_path": "lib/python3.10/email/mime/application.py", + "path_type": "hardlink", + "sha256": "b82a944ccba03e7e7eec46232e50ffe4ce2c32f4b0e26662e6bde30d533584ae", + "sha256_in_prefix": "b82a944ccba03e7e7eec46232e50ffe4ce2c32f4b0e26662e6bde30d533584ae", + "size_in_bytes": 1321 + }, + { + "_path": "lib/python3.10/email/mime/audio.py", + "path_type": "hardlink", + "sha256": "5c1566e6fbf12bb963489ee71df43b60cba8a2bed640a0387d9b3e27fc521e85", + "sha256_in_prefix": "5c1566e6fbf12bb963489ee71df43b60cba8a2bed640a0387d9b3e27fc521e85", + "size_in_bytes": 2739 + }, + { + "_path": "lib/python3.10/email/mime/base.py", + "path_type": "hardlink", + "sha256": "8e1014770d0d5e9fe6207ae0919b572033e4acc75e961ea0a3f760547716e3ee", + "sha256_in_prefix": "8e1014770d0d5e9fe6207ae0919b572033e4acc75e961ea0a3f760547716e3ee", + "size_in_bytes": 916 + }, + { + "_path": "lib/python3.10/email/mime/image.py", + "path_type": "hardlink", + "sha256": "9346e718eac589fc711bd1549a216466850eb1ed7e05cce0ecc73d280c368e6e", + "sha256_in_prefix": "9346e718eac589fc711bd1549a216466850eb1ed7e05cce0ecc73d280c368e6e", + "size_in_bytes": 1828 + }, + { + "_path": "lib/python3.10/email/mime/message.py", + "path_type": "hardlink", + "sha256": "0553e0365eb7e58ba8dcd5f4d416af8ab331b5d6d920b6fb16481ed172fa7d79", + "sha256_in_prefix": "0553e0365eb7e58ba8dcd5f4d416af8ab331b5d6d920b6fb16481ed172fa7d79", + "size_in_bytes": 1317 + }, + { + "_path": "lib/python3.10/email/mime/multipart.py", + "path_type": "hardlink", + "sha256": "53730a1a7807d8af12b88665d8f474f48bf39ed1ef4c47433267a44ef54b0ba7", + "sha256_in_prefix": "53730a1a7807d8af12b88665d8f474f48bf39ed1ef4c47433267a44ef54b0ba7", + "size_in_bytes": 1621 + }, + { + "_path": "lib/python3.10/email/mime/nonmultipart.py", + "path_type": "hardlink", + "sha256": "1f6fdedb5ba3e0a698bf33d77e329fc4cf2ab4305474b6ae23c1bc0f99daaf7a", + "sha256_in_prefix": "1f6fdedb5ba3e0a698bf33d77e329fc4cf2ab4305474b6ae23c1bc0f99daaf7a", + "size_in_bytes": 691 + }, + { + "_path": "lib/python3.10/email/mime/text.py", + "path_type": "hardlink", + "sha256": "aa903b8248020e9211e88f2c3a5e3a05f6969b6aab2b6f01ea1ddff776b870de", + "sha256_in_prefix": "aa903b8248020e9211e88f2c3a5e3a05f6969b6aab2b6f01ea1ddff776b870de", + "size_in_bytes": 1437 + }, + { + "_path": "lib/python3.10/email/parser.py", + "path_type": "hardlink", + "sha256": "eab481ca55902fae679fa2f794c8a81f913723d5029a79d9eb806d4b0c6b6b49", + "sha256_in_prefix": "eab481ca55902fae679fa2f794c8a81f913723d5029a79d9eb806d4b0c6b6b49", + "size_in_bytes": 5041 + }, + { + "_path": "lib/python3.10/email/policy.py", + "path_type": "hardlink", + "sha256": "ca1b94f27db711094e9ba3ec4419313c3e660d1016f4bf01d467e5a174bb6302", + "sha256_in_prefix": "ca1b94f27db711094e9ba3ec4419313c3e660d1016f4bf01d467e5a174bb6302", + "size_in_bytes": 10383 + }, + { + "_path": "lib/python3.10/email/quoprimime.py", + "path_type": "hardlink", + "sha256": "3b892900fd55b57d3be22f7bc9696feb905545adb81d37f4b77166753473a4b4", + "sha256_in_prefix": "3b892900fd55b57d3be22f7bc9696feb905545adb81d37f4b77166753473a4b4", + "size_in_bytes": 9858 + }, + { + "_path": "lib/python3.10/email/utils.py", + "path_type": "hardlink", + "sha256": "151a5736d6be70f9e397f3578c8d59a95d92e6490482d21287f6a5506d332fe8", + "sha256_in_prefix": "151a5736d6be70f9e397f3578c8d59a95d92e6490482d21287f6a5506d332fe8", + "size_in_bytes": 13422 + }, + { + "_path": "lib/python3.10/encodings/__init__.py", + "path_type": "hardlink", + "sha256": "05f07fc2a0fbd9a9cc92aa7567df84f343ebbb17fc676432e108e127d81913df", + "sha256_in_prefix": "05f07fc2a0fbd9a9cc92aa7567df84f343ebbb17fc676432e108e127d81913df", + "size_in_bytes": 5620 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "44ebff2b329edca585e553e9093df4e796430b3f351ecde019320f9a4579f93d", + "sha256_in_prefix": "44ebff2b329edca585e553e9093df4e796430b3f351ecde019320f9a4579f93d", + "size_in_bytes": 4129 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/aliases.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "39237892b7f84aacde50bbb1e08931a43d00f30129a201c02b355e3ea718a1e1", + "sha256_in_prefix": "39237892b7f84aacde50bbb1e08931a43d00f30129a201c02b355e3ea718a1e1", + "size_in_bytes": 11175 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/ascii.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "9789383f7a1a8a6bf4d9a54bc965f625cbea67e5e9d193ebf256c0808c5e1705", + "sha256_in_prefix": "9789383f7a1a8a6bf4d9a54bc965f625cbea67e5e9d193ebf256c0808c5e1705", + "size_in_bytes": 2066 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/base64_codec.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "d427b4aa532d9daea96a880273a4d66a84ecbdb8ddf9c4890adb83b83dbd7824", + "sha256_in_prefix": "d427b4aa532d9daea96a880273a4d66a84ecbdb8ddf9c4890adb83b83dbd7824", + "size_in_bytes": 2501 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/big5.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "11970f0e431436a6fa553642dd38b6b1850eb9b5910d8c507935c9858a578b6a", + "sha256_in_prefix": "11970f0e431436a6fa553642dd38b6b1850eb9b5910d8c507935c9858a578b6a", + "size_in_bytes": 1620 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/big5hkscs.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "3932bd845ee66311f5fabfc8b0143753e2a5b87c251bedfb65ea4daadee8a627", + "sha256_in_prefix": "3932bd845ee66311f5fabfc8b0143753e2a5b87c251bedfb65ea4daadee8a627", + "size_in_bytes": 1630 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/bz2_codec.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "856964b3ecf4f5e9a3a8692fc280332919a6e629d623e75e52c2967369a7417b", + "sha256_in_prefix": "856964b3ecf4f5e9a3a8692fc280332919a6e629d623e75e52c2967369a7417b", + "size_in_bytes": 3340 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/charmap.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "e67e588a78c94b40ab42dab009f729276c5de082f389d98ad9ddd0d399da4c58", + "sha256_in_prefix": "e67e588a78c94b40ab42dab009f729276c5de082f389d98ad9ddd0d399da4c58", + "size_in_bytes": 2714 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/cp037.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "85dd1139f008633c3a62e0a8fde45d19e5021299d064f64986bc0edf3d01e6b2", + "sha256_in_prefix": "85dd1139f008633c3a62e0a8fde45d19e5021299d064f64986bc0edf3d01e6b2", + "size_in_bytes": 2604 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/cp1006.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "7f684e3d0f114df7cb79a0f047ebf1f2a430af3b9fffdacf55b93a9d30c7fa12", + "sha256_in_prefix": "7f684e3d0f114df7cb79a0f047ebf1f2a430af3b9fffdacf55b93a9d30c7fa12", + "size_in_bytes": 2680 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/cp1026.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "0b4708876397296fb06caae80e7c77582e4555e95ae9956bffb20cab680c034c", + "sha256_in_prefix": "0b4708876397296fb06caae80e7c77582e4555e95ae9956bffb20cab680c034c", + "size_in_bytes": 2608 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/cp1125.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "eee00712821e6ba9828d11690ccadc3f9fd88ceb77fcd643a467331766ba4230", + "sha256_in_prefix": "eee00712821e6ba9828d11690ccadc3f9fd88ceb77fcd643a467331766ba4230", + "size_in_bytes": 9545 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/cp1140.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "65fdfe7c0416b4f7c88e4ba791085643f304b475e12f633a87dadf6033ee0b8b", + "sha256_in_prefix": "65fdfe7c0416b4f7c88e4ba791085643f304b475e12f633a87dadf6033ee0b8b", + "size_in_bytes": 2594 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/cp1250.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "ea5a69aa2399ea5ee85f88c83ef47eb56a569bc5fcb9b766e757935506cde7ea", + "sha256_in_prefix": "ea5a69aa2399ea5ee85f88c83ef47eb56a569bc5fcb9b766e757935506cde7ea", + "size_in_bytes": 2631 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/cp1251.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "03a843b0e54e07c0c2d05b3fdcea0a939fda179b8cb3162b7b189903bd7bde5c", + "sha256_in_prefix": "03a843b0e54e07c0c2d05b3fdcea0a939fda179b8cb3162b7b189903bd7bde5c", + "size_in_bytes": 2628 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/cp1252.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "eba53eb031aeb03b9f9d3d0ae110d466a9c93e8235201252f8b804250b5e700a", + "sha256_in_prefix": "eba53eb031aeb03b9f9d3d0ae110d466a9c93e8235201252f8b804250b5e700a", + "size_in_bytes": 2631 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/cp1253.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "ceae90acd6505c874de2c57e434cbdff5323c1890bb49ef6a4bd76ad4180bb27", + "sha256_in_prefix": "ceae90acd6505c874de2c57e434cbdff5323c1890bb49ef6a4bd76ad4180bb27", + "size_in_bytes": 2644 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/cp1254.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "bd775e7c07bc1b5e31556bb36b47b30be4b1669c97af345bc74b12ad59598b56", + "sha256_in_prefix": "bd775e7c07bc1b5e31556bb36b47b30be4b1669c97af345bc74b12ad59598b56", + "size_in_bytes": 2633 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/cp1255.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "f23e3d82ef1a3bf38b2d62097dcc2685ed8dea1eee3ce218d0fa02fde7c4fbf1", + "sha256_in_prefix": "f23e3d82ef1a3bf38b2d62097dcc2685ed8dea1eee3ce218d0fa02fde7c4fbf1", + "size_in_bytes": 2652 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/cp1256.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "a04054368aa259ef991d29cf73b3d99d38be513b5fb56c78905ed63577dfe753", + "sha256_in_prefix": "a04054368aa259ef991d29cf73b3d99d38be513b5fb56c78905ed63577dfe753", + "size_in_bytes": 2630 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/cp1257.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "367aed5ba60979754a0850b41dcc184da34c2158b26849a1ade8e14353682bdf", + "sha256_in_prefix": "367aed5ba60979754a0850b41dcc184da34c2158b26849a1ade8e14353682bdf", + "size_in_bytes": 2638 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/cp1258.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "8641e0243abb93ab5808c43615b1eae3a510ea7f7c2fb42700c8b05f7cb74768", + "sha256_in_prefix": "8641e0243abb93ab5808c43615b1eae3a510ea7f7c2fb42700c8b05f7cb74768", + "size_in_bytes": 2636 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/cp273.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "bb11a7200fce6a13a6d1ee3cc7fb79c814c200cdb3e5627981a885a144f8e2ae", + "sha256_in_prefix": "bb11a7200fce6a13a6d1ee3cc7fb79c814c200cdb3e5627981a885a144f8e2ae", + "size_in_bytes": 2590 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/cp424.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "98188f963e0403a359a6cacaf878c1354b173c5aac137c70f8122a696b0e56b2", + "sha256_in_prefix": "98188f963e0403a359a6cacaf878c1354b173c5aac137c70f8122a696b0e56b2", + "size_in_bytes": 2375 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/cp437.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "696f079e6fcfde7b23b217c12fc0ab7aa19b7f157b8c91493e4b6dcaa286ec32", + "sha256_in_prefix": "696f079e6fcfde7b23b217c12fc0ab7aa19b7f157b8c91493e4b6dcaa286ec32", + "size_in_bytes": 9178 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/cp500.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "f43dbe392cc114c089cfce5f174b3bbf19f87d7489f9a0e145019f0fe0139109", + "sha256_in_prefix": "f43dbe392cc114c089cfce5f174b3bbf19f87d7489f9a0e145019f0fe0139109", + "size_in_bytes": 2604 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/cp720.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "0442fda704669d6b3bb34a5bc5fe787d8af1020423fe3512164c23f7d88a1c90", + "sha256_in_prefix": "0442fda704669d6b3bb34a5bc5fe787d8af1020423fe3512164c23f7d88a1c90", + "size_in_bytes": 2701 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/cp737.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "b14cd5fac5ac626d5d93bdc349c31948cd4274d7c6608975713d87db22076979", + "sha256_in_prefix": "b14cd5fac5ac626d5d93bdc349c31948cd4274d7c6608975713d87db22076979", + "size_in_bytes": 9580 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/cp775.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "a3343c5938a7b0cbf3d448d35900f4d178867b309467aa11f168fb46b9b4c2eb", + "sha256_in_prefix": "a3343c5938a7b0cbf3d448d35900f4d178867b309467aa11f168fb46b9b4c2eb", + "size_in_bytes": 9218 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/cp850.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "a0c685ff9ea76c2d43f93c4bcf9e373c47aae5f84eeccd8c7f53edd01523a418", + "sha256_in_prefix": "a0c685ff9ea76c2d43f93c4bcf9e373c47aae5f84eeccd8c7f53edd01523a418", + "size_in_bytes": 8759 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/cp852.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "6f2fafe3a109ac40ce0d2698e66c185a45459bd176c1596beb0182671cd7a403", + "sha256_in_prefix": "6f2fafe3a109ac40ce0d2698e66c185a45459bd176c1596beb0182671cd7a403", + "size_in_bytes": 9234 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/cp855.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "649c427996c6e16cfa8f81dbe70d765928a4d10bdafaa9955ac82459a9beec25", + "sha256_in_prefix": "649c427996c6e16cfa8f81dbe70d765928a4d10bdafaa9955ac82459a9beec25", + "size_in_bytes": 9547 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/cp856.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "7fe48f8054080de23252810db2093052a6d5a48f850734f44d082da8e6491c7f", + "sha256_in_prefix": "7fe48f8054080de23252810db2093052a6d5a48f850734f44d082da8e6491c7f", + "size_in_bytes": 2666 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/cp857.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "1f2a296ebbab6301fb3fc8150fff46757ea0ba2407c47de7f5fd3c5ad85936ba", + "sha256_in_prefix": "1f2a296ebbab6301fb3fc8150fff46757ea0ba2407c47de7f5fd3c5ad85936ba", + "size_in_bytes": 8658 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/cp858.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "8298561a4f40299532ad832f875f88708891d565fe63ce8be09de98f41d3695d", + "sha256_in_prefix": "8298561a4f40299532ad832f875f88708891d565fe63ce8be09de98f41d3695d", + "size_in_bytes": 8729 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/cp860.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "efc45700dcecb70065c4e6302a1409541c19061071ec413e620406b803a13cec", + "sha256_in_prefix": "efc45700dcecb70065c4e6302a1409541c19061071ec413e620406b803a13cec", + "size_in_bytes": 9149 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/cp861.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "f6687a187e755fb7c15957445a9a70870a860d8402cfa08713b8a963bce11c26", + "sha256_in_prefix": "f6687a187e755fb7c15957445a9a70870a860d8402cfa08713b8a963bce11c26", + "size_in_bytes": 9174 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/cp862.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "0b42c8bb7048d68d88f4f7503d3cbce25b3c74906c9dfd7047bb12edf4eb6170", + "sha256_in_prefix": "0b42c8bb7048d68d88f4f7503d3cbce25b3c74906c9dfd7047bb12edf4eb6170", + "size_in_bytes": 9407 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/cp863.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "7068f22a9f1c83cdcfb2bba099ae1be5fdb82b1bd89c854eea867389b8a39c81", + "sha256_in_prefix": "7068f22a9f1c83cdcfb2bba099ae1be5fdb82b1bd89c854eea867389b8a39c81", + "size_in_bytes": 9170 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/cp864.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "19fa66c93ed988eb475ec48cb2d73db8808f0b29ca9d1e3901a5ab7960771917", + "sha256_in_prefix": "19fa66c93ed988eb475ec48cb2d73db8808f0b29ca9d1e3901a5ab7960771917", + "size_in_bytes": 9317 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/cp865.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "0bd10f50c2f896994379c0d64a955314e7ba0323f1e9e20612befd64d44a2693", + "sha256_in_prefix": "0bd10f50c2f896994379c0d64a955314e7ba0323f1e9e20612befd64d44a2693", + "size_in_bytes": 9174 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/cp866.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "6ff95b6774a539d65401bbec080d5943b2f6d66fd064a455f3badfcc084bc0e0", + "sha256_in_prefix": "6ff95b6774a539d65401bbec080d5943b2f6d66fd064a455f3badfcc084bc0e0", + "size_in_bytes": 9587 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/cp869.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "8e9668fad0f07b4c1055c2ec1def67f0de002c086986f8cba55d40eea07d0c9b", + "sha256_in_prefix": "8e9668fad0f07b4c1055c2ec1def67f0de002c086986f8cba55d40eea07d0c9b", + "size_in_bytes": 9222 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/cp874.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c1b1ca3f2faac23a7c7e53f0ad54dede6c3ee70f387b6b516da9b9734bd50d8e", + "sha256_in_prefix": "c1b1ca3f2faac23a7c7e53f0ad54dede6c3ee70f387b6b516da9b9734bd50d8e", + "size_in_bytes": 2473 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/cp875.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "85124f68e894a82c10e1887137125ff489111f2afd5f6478b39f8534cf72be26", + "sha256_in_prefix": "85124f68e894a82c10e1887137125ff489111f2afd5f6478b39f8534cf72be26", + "size_in_bytes": 2601 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/cp932.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "6bcdaabadf1e126c8506bc24bad4239d4cca704cc8642091d4059b2bfec29297", + "sha256_in_prefix": "6bcdaabadf1e126c8506bc24bad4239d4cca704cc8642091d4059b2bfec29297", + "size_in_bytes": 1622 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/cp949.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "415e4e3074b3a884305fd38cfab6892bd2c209626135ea9c7f2c966667cd8b5c", + "sha256_in_prefix": "415e4e3074b3a884305fd38cfab6892bd2c209626135ea9c7f2c966667cd8b5c", + "size_in_bytes": 1622 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/cp950.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c09edd5c1b4d65dd56352337b53650bc2e5b6b61c539317f7caa1c011673410b", + "sha256_in_prefix": "c09edd5c1b4d65dd56352337b53650bc2e5b6b61c539317f7caa1c011673410b", + "size_in_bytes": 1622 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/euc_jis_2004.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "f1989b4dba7639455bd401adc4f44dd8206f5a22f503282acc1613646c0f22ef", + "sha256_in_prefix": "f1989b4dba7639455bd401adc4f44dd8206f5a22f503282acc1613646c0f22ef", + "size_in_bytes": 1636 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/euc_jisx0213.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "29800b3557a7bd99bb16eaea428fb71fedd275f59d8c6cc0ca24a716d2ac0eb8", + "sha256_in_prefix": "29800b3557a7bd99bb16eaea428fb71fedd275f59d8c6cc0ca24a716d2ac0eb8", + "size_in_bytes": 1636 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/euc_jp.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "07e8984898f50aaf8824845ea5869b7eba80ca34ff87034eabecba5d0f49acc7", + "sha256_in_prefix": "07e8984898f50aaf8824845ea5869b7eba80ca34ff87034eabecba5d0f49acc7", + "size_in_bytes": 1624 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/euc_kr.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "88a370fdda7fdc203eb8f36ca5420884121cdf54ff9ed62a02ab85918d0781cc", + "sha256_in_prefix": "88a370fdda7fdc203eb8f36ca5420884121cdf54ff9ed62a02ab85918d0781cc", + "size_in_bytes": 1624 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/gb18030.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "e437534e5d15d69755e0f2e4df60c997a7a620bfb0891294157793ccccc347a4", + "sha256_in_prefix": "e437534e5d15d69755e0f2e4df60c997a7a620bfb0891294157793ccccc347a4", + "size_in_bytes": 1626 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/gb2312.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "aad9b564a771366adadde69b31faba6d9f8f5b1d95a9a3bba013e8a3fdba2770", + "sha256_in_prefix": "aad9b564a771366adadde69b31faba6d9f8f5b1d95a9a3bba013e8a3fdba2770", + "size_in_bytes": 1624 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/gbk.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "449efe3da61b96376b50c6a27b1daad18f32bffcbc432cc968d3281b808f0362", + "sha256_in_prefix": "449efe3da61b96376b50c6a27b1daad18f32bffcbc432cc968d3281b808f0362", + "size_in_bytes": 1618 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/hex_codec.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "4a2802006401637cf5bd15696f7cfb35d60ce5a9d8665778dbee1f2a9ab8d307", + "sha256_in_prefix": "4a2802006401637cf5bd15696f7cfb35d60ce5a9d8665778dbee1f2a9ab8d307", + "size_in_bytes": 2488 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/hp_roman8.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "a368d2a3661f6a2b52de6ce6959b100465dd9f56ecc73acfc3a7b643193acdc5", + "sha256_in_prefix": "a368d2a3661f6a2b52de6ce6959b100465dd9f56ecc73acfc3a7b643193acdc5", + "size_in_bytes": 2805 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/hz.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "4f49593b6b7cff2fb5ec9b07d68b99ff9f0b9bb246a81d5bcba7a2739abd3678", + "sha256_in_prefix": "4f49593b6b7cff2fb5ec9b07d68b99ff9f0b9bb246a81d5bcba7a2739abd3678", + "size_in_bytes": 1616 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/idna.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "a6649d58fea99d8b06fe5c07e415684e46b3ad1658cd740feaf0b0b758c23f25", + "sha256_in_prefix": "a6649d58fea99d8b06fe5c07e415684e46b3ad1658cd740feaf0b0b758c23f25", + "size_in_bytes": 5853 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/iso2022_jp.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "398e4fefe3f1aff3ff316ab4a0ddefe0fa4660c91afb504dc1b5cb9696307474", + "sha256_in_prefix": "398e4fefe3f1aff3ff316ab4a0ddefe0fa4660c91afb504dc1b5cb9696307474", + "size_in_bytes": 1637 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/iso2022_jp_1.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "e671736b5d9a5249cedaee7038996431d8291e48cb38b8501afc21d132939e44", + "sha256_in_prefix": "e671736b5d9a5249cedaee7038996431d8291e48cb38b8501afc21d132939e44", + "size_in_bytes": 1641 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/iso2022_jp_2.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "5fb826cafb01116b61577aa1484dcd92ca5cd7c21f639b057a0cb8245c05e2c8", + "sha256_in_prefix": "5fb826cafb01116b61577aa1484dcd92ca5cd7c21f639b057a0cb8245c05e2c8", + "size_in_bytes": 1641 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/iso2022_jp_2004.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "a02fd1d0ea23cd76db0002b41a2dc00191dbe14ab1e09bac245adec55e1463bf", + "sha256_in_prefix": "a02fd1d0ea23cd76db0002b41a2dc00191dbe14ab1e09bac245adec55e1463bf", + "size_in_bytes": 1647 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/iso2022_jp_3.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "411734f00c018ba30468e7a9499a4160c4fb2853fe469cef46e9daabbb443045", + "sha256_in_prefix": "411734f00c018ba30468e7a9499a4160c4fb2853fe469cef46e9daabbb443045", + "size_in_bytes": 1641 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/iso2022_jp_ext.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "3708ac0a5dbd2506a25ddeb9c8a6b1d0bde78ba073e39d5d8798f50f17edef0b", + "sha256_in_prefix": "3708ac0a5dbd2506a25ddeb9c8a6b1d0bde78ba073e39d5d8798f50f17edef0b", + "size_in_bytes": 1645 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/iso2022_kr.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "649c7bb387ff5afdc41276ab69c6dc08d9429ba6169c3c78324676f7baf4dabb", + "sha256_in_prefix": "649c7bb387ff5afdc41276ab69c6dc08d9429ba6169c3c78324676f7baf4dabb", + "size_in_bytes": 1637 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/iso8859_1.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "aa9274cbac4ff16a8ff0b39e76c4dae1ff5792c48fcc51a7d697df58ae9dc08e", + "sha256_in_prefix": "aa9274cbac4ff16a8ff0b39e76c4dae1ff5792c48fcc51a7d697df58ae9dc08e", + "size_in_bytes": 2603 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/iso8859_10.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "fdd0c8d0c93b0cdfce96b571930320a0fdf421d98fec0563d8bbdd4fd99ce2ad", + "sha256_in_prefix": "fdd0c8d0c93b0cdfce96b571930320a0fdf421d98fec0563d8bbdd4fd99ce2ad", + "size_in_bytes": 2608 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/iso8859_11.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "3fdbc2b61dab3b9583147a7c75b8701babc64dd59e02e78e8100de201e34a0e8", + "sha256_in_prefix": "3fdbc2b61dab3b9583147a7c75b8701babc64dd59e02e78e8100de201e34a0e8", + "size_in_bytes": 2443 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/iso8859_13.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "a19752eafb2eaa6409ee424377afc786f0c1af494d7e64f62e7edd991a39a659", + "sha256_in_prefix": "a19752eafb2eaa6409ee424377afc786f0c1af494d7e64f62e7edd991a39a659", + "size_in_bytes": 2611 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/iso8859_14.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "8eff13271dea3425c20d5ff4b854065b8a8fc84ac646252a4312d8bdf4d353bb", + "sha256_in_prefix": "8eff13271dea3425c20d5ff4b854065b8a8fc84ac646252a4312d8bdf4d353bb", + "size_in_bytes": 2370 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/iso8859_15.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "a85b1cd0400337b192f79c151b490fe9e693cdafe570c4e61cd5703df049aa09", + "sha256_in_prefix": "a85b1cd0400337b192f79c151b490fe9e693cdafe570c4e61cd5703df049aa09", + "size_in_bytes": 2608 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/iso8859_16.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "dad9fc91c80cfaac9f23d30d85513cb76284b340f0e4e6d9160132270d5c6dbf", + "sha256_in_prefix": "dad9fc91c80cfaac9f23d30d85513cb76284b340f0e4e6d9160132270d5c6dbf", + "size_in_bytes": 2610 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/iso8859_2.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "fbafed16dac54624c729d17b2d2b62e90b5fac1f3a20c826ddeb6a3d94e13186", + "sha256_in_prefix": "fbafed16dac54624c729d17b2d2b62e90b5fac1f3a20c826ddeb6a3d94e13186", + "size_in_bytes": 2603 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/iso8859_3.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "8de7f818836c003393601b68093b6d0ef1fc5ca472851a648b243a6076e562e8", + "sha256_in_prefix": "8de7f818836c003393601b68093b6d0ef1fc5ca472851a648b243a6076e562e8", + "size_in_bytes": 2610 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/iso8859_4.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "aa309f0cfdf8079849d60514ca5d88d68db5d7627a1805f85fb8dd5e72452b38", + "sha256_in_prefix": "aa309f0cfdf8079849d60514ca5d88d68db5d7627a1805f85fb8dd5e72452b38", + "size_in_bytes": 2603 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/iso8859_5.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "2afb9fc97c126f5def7d9a906ebc41800c83572f9703896886ca52fa342dee32", + "sha256_in_prefix": "2afb9fc97c126f5def7d9a906ebc41800c83572f9703896886ca52fa342dee32", + "size_in_bytes": 2604 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/iso8859_6.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "a554b59bbab0919fd994673db6a343c7c85d9cf81ec7b7fd6ce406467889d997", + "sha256_in_prefix": "a554b59bbab0919fd994673db6a343c7c85d9cf81ec7b7fd6ce406467889d997", + "size_in_bytes": 2389 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/iso8859_7.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "b5f345b6b23291b2529350160aee275556bdb33f6824ea2e68d26f3fcfc9d834", + "sha256_in_prefix": "b5f345b6b23291b2529350160aee275556bdb33f6824ea2e68d26f3fcfc9d834", + "size_in_bytes": 2611 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/iso8859_8.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "a15037e4e7deb5ed8e4998f682bd9b734292f94fa37d40849a4bc1b378b3e7bb", + "sha256_in_prefix": "a15037e4e7deb5ed8e4998f682bd9b734292f94fa37d40849a4bc1b378b3e7bb", + "size_in_bytes": 2642 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/iso8859_9.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "67a2123d0dfc3d04192b9bf1a5adc6f0950b53e462d88cea9a976e42b3a82c68", + "sha256_in_prefix": "67a2123d0dfc3d04192b9bf1a5adc6f0950b53e462d88cea9a976e42b3a82c68", + "size_in_bytes": 2603 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/johab.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "770627660c2134652aa6aec64bcfc9bd59cbeeba45116a0bee95439e8ccee6c1", + "sha256_in_prefix": "770627660c2134652aa6aec64bcfc9bd59cbeeba45116a0bee95439e8ccee6c1", + "size_in_bytes": 1622 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/koi8_r.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "b5c33523e5f229bf3052c0f5cfd65e7d388008358a5de277099a896064ca03aa", + "sha256_in_prefix": "b5c33523e5f229bf3052c0f5cfd65e7d388008358a5de277099a896064ca03aa", + "size_in_bytes": 2655 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/koi8_t.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "72b4d45b4121809bc62db21af1e6c07b4f852641be6a052558145057de6ee5f0", + "sha256_in_prefix": "72b4d45b4121809bc62db21af1e6c07b4f852641be6a052558145057de6ee5f0", + "size_in_bytes": 2566 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/koi8_u.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "250de0622506619b103e95e93fbbdb3832fc31d5cd96c908556e30c7a45afb74", + "sha256_in_prefix": "250de0622506619b103e95e93fbbdb3832fc31d5cd96c908556e30c7a45afb74", + "size_in_bytes": 2641 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/kz1048.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "91d04b669035195cf7f7ac078c98807948923447f1a423d54f305aacbe8aa641", + "sha256_in_prefix": "91d04b669035195cf7f7ac078c98807948923447f1a423d54f305aacbe8aa641", + "size_in_bytes": 2618 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/latin_1.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "82960a45d19bca668b2a059322d0fa6ff2da071ef36e8b347e597e92320e8839", + "sha256_in_prefix": "82960a45d19bca668b2a059322d0fa6ff2da071ef36e8b347e597e92320e8839", + "size_in_bytes": 2078 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/mac_arabic.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "d0368142c72309a39d58542ea4da95cbc483d484f0d2c210c8b0a22d23a44a82", + "sha256_in_prefix": "d0368142c72309a39d58542ea4da95cbc483d484f0d2c210c8b0a22d23a44a82", + "size_in_bytes": 9064 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/mac_croatian.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c94226fa3bd25e2e358043b2eaba6440f6727c21e9c4f3b00daa96eb89a8cca9", + "sha256_in_prefix": "c94226fa3bd25e2e358043b2eaba6440f6727c21e9c4f3b00daa96eb89a8cca9", + "size_in_bytes": 2650 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/mac_cyrillic.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "38c5e0f4b69ddaaddeef584bd92d29529d8b696b3ce27dbb431bb0822db3297d", + "sha256_in_prefix": "38c5e0f4b69ddaaddeef584bd92d29529d8b696b3ce27dbb431bb0822db3297d", + "size_in_bytes": 2640 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/mac_farsi.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "3e3bbf65d5a7ac56f75eb01c0155b247a2145ec76a4ab81fd9d36a8b8ed16de9", + "sha256_in_prefix": "3e3bbf65d5a7ac56f75eb01c0155b247a2145ec76a4ab81fd9d36a8b8ed16de9", + "size_in_bytes": 2584 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/mac_greek.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "b84a3336b147f3a22be627b674e6d18bb035bb3c799d8214b69655c4e9e39ec3", + "sha256_in_prefix": "b84a3336b147f3a22be627b674e6d18bb035bb3c799d8214b69655c4e9e39ec3", + "size_in_bytes": 2624 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/mac_iceland.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "5c4c04b4b92ac383e7c0c6360c2bd37a5909a964fe3e9595e0163f26a0367764", + "sha256_in_prefix": "5c4c04b4b92ac383e7c0c6360c2bd37a5909a964fe3e9595e0163f26a0367764", + "size_in_bytes": 2643 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/mac_latin2.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "7dd625a7e5762109a1735bf570807a6dc704c40675c4e91e8cadbfeb866f1714", + "sha256_in_prefix": "7dd625a7e5762109a1735bf570807a6dc704c40675c4e91e8cadbfeb866f1714", + "size_in_bytes": 2784 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/mac_roman.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "bfb2aa785f43bdea50edc5a9c87d962630eb24aa2e30d5f4eddec6f64ba46fac", + "sha256_in_prefix": "bfb2aa785f43bdea50edc5a9c87d962630eb24aa2e30d5f4eddec6f64ba46fac", + "size_in_bytes": 2641 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/mac_romanian.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "9bd51c26824322b69e3a81ed101709daff973aeb9517d60d9dcdf0086048cad2", + "sha256_in_prefix": "9bd51c26824322b69e3a81ed101709daff973aeb9517d60d9dcdf0086048cad2", + "size_in_bytes": 2651 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/mac_turkish.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "f490a68db5254e2034d24c782fc2d1856e13bf943b986059d2ff50593e7cd949", + "sha256_in_prefix": "f490a68db5254e2034d24c782fc2d1856e13bf943b986059d2ff50593e7cd949", + "size_in_bytes": 2385 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/mbcs.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "bb6edb6ab6f3f365c3d04f5580e4a1f41ae041655ba0cfd3bcfe3f9023abfbf5", + "sha256_in_prefix": "bb6edb6ab6f3f365c3d04f5580e4a1f41ae041655ba0cfd3bcfe3f9023abfbf5", + "size_in_bytes": 1936 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/oem.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c3c973cf13432176802d65c6b8fd1dc67a38e60b0634d7723cc535c44d530d97", + "sha256_in_prefix": "c3c973cf13432176802d65c6b8fd1dc67a38e60b0634d7723cc535c44d530d97", + "size_in_bytes": 1749 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/palmos.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "16918797f259b272180c9c512e50f9681d4cb54c9c6a94d20f578153047d1fbd", + "sha256_in_prefix": "16918797f259b272180c9c512e50f9681d4cb54c9c6a94d20f578153047d1fbd", + "size_in_bytes": 2631 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/ptcp154.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c9fc0fa81df5424a2646f14070d09c3e094c080afe6b6ea3ab2fa05759f89421", + "sha256_in_prefix": "c9fc0fa81df5424a2646f14070d09c3e094c080afe6b6ea3ab2fa05759f89421", + "size_in_bytes": 2725 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/punycode.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "d913ad9200eb306803ee99afcf00c4d161bd7fd74f221d1d8d7b2cd2e6c38890", + "sha256_in_prefix": "d913ad9200eb306803ee99afcf00c4d161bd7fd74f221d1d8d7b2cd2e6c38890", + "size_in_bytes": 6559 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/quopri_codec.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "a2fa14114fc51fe5bb7ca0290e2da8670b09b85a85fb42e7acd065803136492a", + "sha256_in_prefix": "a2fa14114fc51fe5bb7ca0290e2da8670b09b85a85fb42e7acd065803136492a", + "size_in_bytes": 2571 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/raw_unicode_escape.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "a5e453d4074b891c0805fec335115915203e2a60b587b0f495ff4af494d0faab", + "sha256_in_prefix": "a5e453d4074b891c0805fec335115915203e2a60b587b0f495ff4af494d0faab", + "size_in_bytes": 2212 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/rot_13.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c243427f4aa2bd5b8fbb810bd7f3eaa3c56e029b47ea7b1b2124763635c586ed", + "sha256_in_prefix": "c243427f4aa2bd5b8fbb810bd7f3eaa3c56e029b47ea7b1b2124763635c586ed", + "size_in_bytes": 3245 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/shift_jis.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "d06fa5da2bbc1a03da638ce3e38c2c13f07dac50c3838909644c5b022215825b", + "sha256_in_prefix": "d06fa5da2bbc1a03da638ce3e38c2c13f07dac50c3838909644c5b022215825b", + "size_in_bytes": 1630 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/shift_jis_2004.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c377d5bb4767d761f776b234931d3d7bd8cdc136fd8f546851bcfad9f063534a", + "sha256_in_prefix": "c377d5bb4767d761f776b234931d3d7bd8cdc136fd8f546851bcfad9f063534a", + "size_in_bytes": 1381 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/shift_jisx0213.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "61b39dfb695ffd349e4509d50147f96f734f59a8934790d0c2242fc7e8ea76a1", + "sha256_in_prefix": "61b39dfb695ffd349e4509d50147f96f734f59a8934790d0c2242fc7e8ea76a1", + "size_in_bytes": 1381 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/tis_620.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "6d0f8aa18bb7edafb2c24aae3e4d4442922f55d3fc9f2eaa51f9761d50e4d072", + "sha256_in_prefix": "6d0f8aa18bb7edafb2c24aae3e4d4442922f55d3fc9f2eaa51f9761d50e4d072", + "size_in_bytes": 2693 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/undefined.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "b1a8ac117fcbbbf742e6ae817201734fd1cf0b2eaa601f31a250f73d39b8c713", + "sha256_in_prefix": "b1a8ac117fcbbbf742e6ae817201734fd1cf0b2eaa601f31a250f73d39b8c713", + "size_in_bytes": 2269 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/unicode_escape.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "b7926ba86c4261dd4f2cd18137a15e9debdc04fa0cd2e01b4ce28f89f136acbb", + "sha256_in_prefix": "b7926ba86c4261dd4f2cd18137a15e9debdc04fa0cd2e01b4ce28f89f136acbb", + "size_in_bytes": 2192 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/utf_16.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "2ecc3a89b933c81504ff3a94f6616b2ddc88e315136760e4b49bad637f48cd16", + "sha256_in_prefix": "2ecc3a89b933c81504ff3a94f6616b2ddc88e315136760e4b49bad637f48cd16", + "size_in_bytes": 5098 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/utf_16_be.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "ca9c3a136da48e2166adacc2d4b61e43e5bd404da83efd0d27d7f465708b1726", + "sha256_in_prefix": "ca9c3a136da48e2166adacc2d4b61e43e5bd404da83efd0d27d7f465708b1726", + "size_in_bytes": 1871 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/utf_16_le.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "7f5f6e18eb213fdbd0689889f7d2c4503b1298a67b47d00ffbc65f84c18a642c", + "sha256_in_prefix": "7f5f6e18eb213fdbd0689889f7d2c4503b1298a67b47d00ffbc65f84c18a642c", + "size_in_bytes": 1871 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/utf_32.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "9d6aa48388c3ee9a0b0f0eac65718fabb6b7714e031f0dead8645cc104c0f558", + "sha256_in_prefix": "9d6aa48388c3ee9a0b0f0eac65718fabb6b7714e031f0dead8645cc104c0f558", + "size_in_bytes": 4991 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/utf_32_be.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "a04c8c5eaf1ad08b4e0e42e53609de257b3904cdb6b632166315ef179f05d8d7", + "sha256_in_prefix": "a04c8c5eaf1ad08b4e0e42e53609de257b3904cdb6b632166315ef179f05d8d7", + "size_in_bytes": 1764 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/utf_32_le.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "ca6d63a6e05745d36fa1ffa2746aa0b0cd36ce66cec03de51dc9dfddc1ffc97f", + "sha256_in_prefix": "ca6d63a6e05745d36fa1ffa2746aa0b0cd36ce66cec03de51dc9dfddc1ffc97f", + "size_in_bytes": 1764 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/utf_7.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "1927f5d5600ac5852c9ec3890dc6ee727433bc810986572ccdd2b484ac89b483", + "sha256_in_prefix": "1927f5d5600ac5852c9ec3890dc6ee727433bc810986572ccdd2b484ac89b483", + "size_in_bytes": 1792 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/utf_8.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "545c1e5b3381cbbfa07f97cb1016bd12812edbc3452be75866c6f672373a562d", + "sha256_in_prefix": "545c1e5b3381cbbfa07f97cb1016bd12812edbc3452be75866c6f672373a562d", + "size_in_bytes": 1851 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/utf_8_sig.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "40f9100325ca2bf28bbc0568738fb9481c1ff6b0d542b7e1e271b6375f07c7aa", + "sha256_in_prefix": "40f9100325ca2bf28bbc0568738fb9481c1ff6b0d542b7e1e271b6375f07c7aa", + "size_in_bytes": 4648 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/uu_codec.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "023468dd04207acf35186502354210fcc7b22dcf0c1699d0033518a30f7afade", + "sha256_in_prefix": "023468dd04207acf35186502354210fcc7b22dcf0c1699d0033518a30f7afade", + "size_in_bytes": 3440 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/zlib_codec.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "9583eaa05864365fe955f87da7de1fac7d1d8e10860f41cc54e92b101064ec74", + "sha256_in_prefix": "9583eaa05864365fe955f87da7de1fac7d1d8e10860f41cc54e92b101064ec74", + "size_in_bytes": 2842 + }, + { + "_path": "lib/python3.10/encodings/aliases.py", + "path_type": "hardlink", + "sha256": "6fdcc49ba23a0203ae6cf28e608f8e6297d7c4d77d52e651db3cb49b9564c6d2", + "sha256_in_prefix": "6fdcc49ba23a0203ae6cf28e608f8e6297d7c4d77d52e651db3cb49b9564c6d2", + "size_in_bytes": 15677 + }, + { + "_path": "lib/python3.10/encodings/ascii.py", + "path_type": "hardlink", + "sha256": "578aa1173f7cc60dad2895071287fe6182bd14787b3fbf47a6c7983dfe3675e3", + "sha256_in_prefix": "578aa1173f7cc60dad2895071287fe6182bd14787b3fbf47a6c7983dfe3675e3", + "size_in_bytes": 1248 + }, + { + "_path": "lib/python3.10/encodings/base64_codec.py", + "path_type": "hardlink", + "sha256": "cf9ac7a464f541492486241d1b4bf33e37b45c6499275cc4d69c5a8e564e5976", + "sha256_in_prefix": "cf9ac7a464f541492486241d1b4bf33e37b45c6499275cc4d69c5a8e564e5976", + "size_in_bytes": 1533 + }, + { + "_path": "lib/python3.10/encodings/big5.py", + "path_type": "hardlink", + "sha256": "98fac6f86a20dd05da197e2058176ebfd47edee7074c3248f5f48fe0fb672d7c", + "sha256_in_prefix": "98fac6f86a20dd05da197e2058176ebfd47edee7074c3248f5f48fe0fb672d7c", + "size_in_bytes": 1019 + }, + { + "_path": "lib/python3.10/encodings/big5hkscs.py", + "path_type": "hardlink", + "sha256": "21d051a00fb5c6a86ba187e0c50e811d659ce00991fd5f5b408f71ebb2ef0f16", + "sha256_in_prefix": "21d051a00fb5c6a86ba187e0c50e811d659ce00991fd5f5b408f71ebb2ef0f16", + "size_in_bytes": 1039 + }, + { + "_path": "lib/python3.10/encodings/bz2_codec.py", + "path_type": "hardlink", + "sha256": "1181a2a89102a2b1d2b2f1f4473236d5d1ececdd0be8fdaa498a3dbe21a185ab", + "sha256_in_prefix": "1181a2a89102a2b1d2b2f1f4473236d5d1ececdd0be8fdaa498a3dbe21a185ab", + "size_in_bytes": 2249 + }, + { + "_path": "lib/python3.10/encodings/charmap.py", + "path_type": "hardlink", + "sha256": "1b8b5fdb36ce3becc62a6115ed904a17083949ec8aaef5a80f7078cec232f43b", + "sha256_in_prefix": "1b8b5fdb36ce3becc62a6115ed904a17083949ec8aaef5a80f7078cec232f43b", + "size_in_bytes": 2084 + }, + { + "_path": "lib/python3.10/encodings/cp037.py", + "path_type": "hardlink", + "sha256": "fda6ca994d710e4e0c760e0204c29a4273fc0f14ebe3169306d2eb54c9953f58", + "sha256_in_prefix": "fda6ca994d710e4e0c760e0204c29a4273fc0f14ebe3169306d2eb54c9953f58", + "size_in_bytes": 13121 + }, + { + "_path": "lib/python3.10/encodings/cp1006.py", + "path_type": "hardlink", + "sha256": "eaded38b427841bdf280e878f1e26da506e743eaa9429075332af60cce429473", + "sha256_in_prefix": "eaded38b427841bdf280e878f1e26da506e743eaa9429075332af60cce429473", + "size_in_bytes": 13568 + }, + { + "_path": "lib/python3.10/encodings/cp1026.py", + "path_type": "hardlink", + "sha256": "f5227237dd7ce5005b16a8e4d8342f0d193193c878e3cf35b9305d22b3b1aaf9", + "sha256_in_prefix": "f5227237dd7ce5005b16a8e4d8342f0d193193c878e3cf35b9305d22b3b1aaf9", + "size_in_bytes": 13113 + }, + { + "_path": "lib/python3.10/encodings/cp1125.py", + "path_type": "hardlink", + "sha256": "f84c7d30ce222e6a50cff1a4c9737173411da108cbd2c9bb57c854480103c470", + "sha256_in_prefix": "f84c7d30ce222e6a50cff1a4c9737173411da108cbd2c9bb57c854480103c470", + "size_in_bytes": 34597 + }, + { + "_path": "lib/python3.10/encodings/cp1140.py", + "path_type": "hardlink", + "sha256": "3379d78b244aa905ffe1171a968caaf41b9a0154d1ddc76c05a2abaca2b289fd", + "sha256_in_prefix": "3379d78b244aa905ffe1171a968caaf41b9a0154d1ddc76c05a2abaca2b289fd", + "size_in_bytes": 13105 + }, + { + "_path": "lib/python3.10/encodings/cp1250.py", + "path_type": "hardlink", + "sha256": "ebcec1adf9167863fb0bab29708c546300c80a77ef07838c9e0437a59e265970", + "sha256_in_prefix": "ebcec1adf9167863fb0bab29708c546300c80a77ef07838c9e0437a59e265970", + "size_in_bytes": 13686 + }, + { + "_path": "lib/python3.10/encodings/cp1251.py", + "path_type": "hardlink", + "sha256": "d57f8cfa34494c5acb6692ddb31f616ae2dd89a075d2af6d36b0b7ec2ffe7af1", + "sha256_in_prefix": "d57f8cfa34494c5acb6692ddb31f616ae2dd89a075d2af6d36b0b7ec2ffe7af1", + "size_in_bytes": 13361 + }, + { + "_path": "lib/python3.10/encodings/cp1252.py", + "path_type": "hardlink", + "sha256": "19aa5bee667f5fb387924a813aec9fa1dda47769d09e8483a748bdb202be6a84", + "sha256_in_prefix": "19aa5bee667f5fb387924a813aec9fa1dda47769d09e8483a748bdb202be6a84", + "size_in_bytes": 13511 + }, + { + "_path": "lib/python3.10/encodings/cp1253.py", + "path_type": "hardlink", + "sha256": "8c27696dcfb6894b378869bc89f113703fbd1e9b13a83934463d5999b055d1e8", + "sha256_in_prefix": "8c27696dcfb6894b378869bc89f113703fbd1e9b13a83934463d5999b055d1e8", + "size_in_bytes": 13094 + }, + { + "_path": "lib/python3.10/encodings/cp1254.py", + "path_type": "hardlink", + "sha256": "06517ec2f74f1c6562d0a1a500c48ba43f2e6e9d0c3d28356d747f274f1a4c8d", + "sha256_in_prefix": "06517ec2f74f1c6562d0a1a500c48ba43f2e6e9d0c3d28356d747f274f1a4c8d", + "size_in_bytes": 13502 + }, + { + "_path": "lib/python3.10/encodings/cp1255.py", + "path_type": "hardlink", + "sha256": "54a1b5087578fa78e5bdd0afa6a9e80e8c5467c1e4226cf6e586cfe7a674a653", + "sha256_in_prefix": "54a1b5087578fa78e5bdd0afa6a9e80e8c5467c1e4226cf6e586cfe7a674a653", + "size_in_bytes": 12466 + }, + { + "_path": "lib/python3.10/encodings/cp1256.py", + "path_type": "hardlink", + "sha256": "ad3768ac2fef2a646b3301c20af705f4d4a1544f22fa8a84241bada27ab84133", + "sha256_in_prefix": "ad3768ac2fef2a646b3301c20af705f4d4a1544f22fa8a84241bada27ab84133", + "size_in_bytes": 12814 + }, + { + "_path": "lib/python3.10/encodings/cp1257.py", + "path_type": "hardlink", + "sha256": "d9149d2925b3f719809ef2297e541461079f15c658af207a3e498be314ab2c6b", + "sha256_in_prefix": "d9149d2925b3f719809ef2297e541461079f15c658af207a3e498be314ab2c6b", + "size_in_bytes": 13374 + }, + { + "_path": "lib/python3.10/encodings/cp1258.py", + "path_type": "hardlink", + "sha256": "672e05b51952a82c8dbd5603769195fcedf565e457bb86c0d5bae04955d04630", + "sha256_in_prefix": "672e05b51952a82c8dbd5603769195fcedf565e457bb86c0d5bae04955d04630", + "size_in_bytes": 13364 + }, + { + "_path": "lib/python3.10/encodings/cp273.py", + "path_type": "hardlink", + "sha256": "6c6aec3b213ea3aebc2c526dd4d121c95d4a25a2fc928a87cd80f8448988185f", + "sha256_in_prefix": "6c6aec3b213ea3aebc2c526dd4d121c95d4a25a2fc928a87cd80f8448988185f", + "size_in_bytes": 14132 + }, + { + "_path": "lib/python3.10/encodings/cp424.py", + "path_type": "hardlink", + "sha256": "30414c2186ea0802bbf3db034122ddec1f8a10061b97c50871e14b74ee36d0ca", + "sha256_in_prefix": "30414c2186ea0802bbf3db034122ddec1f8a10061b97c50871e14b74ee36d0ca", + "size_in_bytes": 12055 + }, + { + "_path": "lib/python3.10/encodings/cp437.py", + "path_type": "hardlink", + "sha256": "5c2a5015cd36cf7f561269f33dec4c323093d3d88b0673969accdabdcb9ce2cb", + "sha256_in_prefix": "5c2a5015cd36cf7f561269f33dec4c323093d3d88b0673969accdabdcb9ce2cb", + "size_in_bytes": 34564 + }, + { + "_path": "lib/python3.10/encodings/cp500.py", + "path_type": "hardlink", + "sha256": "630f503f9110d98ea3e1529f2f965ebc275a2f78d3de47f8e9b69d35589d764b", + "sha256_in_prefix": "630f503f9110d98ea3e1529f2f965ebc275a2f78d3de47f8e9b69d35589d764b", + "size_in_bytes": 13121 + }, + { + "_path": "lib/python3.10/encodings/cp720.py", + "path_type": "hardlink", + "sha256": "395496001271b92efe5df07fc0ae7c3410d1dd2bdfebbd3e4d8e806c8166beb0", + "sha256_in_prefix": "395496001271b92efe5df07fc0ae7c3410d1dd2bdfebbd3e4d8e806c8166beb0", + "size_in_bytes": 13686 + }, + { + "_path": "lib/python3.10/encodings/cp737.py", + "path_type": "hardlink", + "sha256": "be3ca1785a3970ec62310710eaf7de82932181b04d06fe4528f8adaba9fb8c4b", + "sha256_in_prefix": "be3ca1785a3970ec62310710eaf7de82932181b04d06fe4528f8adaba9fb8c4b", + "size_in_bytes": 34681 + }, + { + "_path": "lib/python3.10/encodings/cp775.py", + "path_type": "hardlink", + "sha256": "e0dba85b99329d7f16907e620adada06be5216abcb964406c827b569b2cf1aeb", + "sha256_in_prefix": "e0dba85b99329d7f16907e620adada06be5216abcb964406c827b569b2cf1aeb", + "size_in_bytes": 34476 + }, + { + "_path": "lib/python3.10/encodings/cp850.py", + "path_type": "hardlink", + "sha256": "257e29f235e2a8790dd68cee45668776648bab809ce8584f893cdd8fd007993c", + "sha256_in_prefix": "257e29f235e2a8790dd68cee45668776648bab809ce8584f893cdd8fd007993c", + "size_in_bytes": 34105 + }, + { + "_path": "lib/python3.10/encodings/cp852.py", + "path_type": "hardlink", + "sha256": "cc6faaa9dc4a933127da0aaacd1dc7a44c09266051af56bfe3215ff228636b6b", + "sha256_in_prefix": "cc6faaa9dc4a933127da0aaacd1dc7a44c09266051af56bfe3215ff228636b6b", + "size_in_bytes": 35002 + }, + { + "_path": "lib/python3.10/encodings/cp855.py", + "path_type": "hardlink", + "sha256": "7b25c61c9e8c47b218d3fbb801541a2861926ac712843d2113fff90e2074f5ba", + "sha256_in_prefix": "7b25c61c9e8c47b218d3fbb801541a2861926ac712843d2113fff90e2074f5ba", + "size_in_bytes": 33850 + }, + { + "_path": "lib/python3.10/encodings/cp856.py", + "path_type": "hardlink", + "sha256": "2e52ec5cb1eafa6739b5569b0b98ee89df5f7358b84ccdc8da64e86f017d359f", + "sha256_in_prefix": "2e52ec5cb1eafa6739b5569b0b98ee89df5f7358b84ccdc8da64e86f017d359f", + "size_in_bytes": 12423 + }, + { + "_path": "lib/python3.10/encodings/cp857.py", + "path_type": "hardlink", + "sha256": "8d1b769058bfccdb3c6c70c49a104f5081a2fcc9fad68f7b5eb3e4f67f0b33da", + "sha256_in_prefix": "8d1b769058bfccdb3c6c70c49a104f5081a2fcc9fad68f7b5eb3e4f67f0b33da", + "size_in_bytes": 33908 + }, + { + "_path": "lib/python3.10/encodings/cp858.py", + "path_type": "hardlink", + "sha256": "a24930c4a6ad0ff66dde9a69f2027e4b92c2c9c61dcda2992e940654c606577b", + "sha256_in_prefix": "a24930c4a6ad0ff66dde9a69f2027e4b92c2c9c61dcda2992e940654c606577b", + "size_in_bytes": 34015 + }, + { + "_path": "lib/python3.10/encodings/cp860.py", + "path_type": "hardlink", + "sha256": "2dfae7e31d3d9aa3013cff44a4d7ad842f257ac63765a9998436701b629cd86a", + "sha256_in_prefix": "2dfae7e31d3d9aa3013cff44a4d7ad842f257ac63765a9998436701b629cd86a", + "size_in_bytes": 34681 + }, + { + "_path": "lib/python3.10/encodings/cp861.py", + "path_type": "hardlink", + "sha256": "701930d77a2177497586e99bc3fe60f2d4beffb645608f167c76874a72ff405e", + "sha256_in_prefix": "701930d77a2177497586e99bc3fe60f2d4beffb645608f167c76874a72ff405e", + "size_in_bytes": 34633 + }, + { + "_path": "lib/python3.10/encodings/cp862.py", + "path_type": "hardlink", + "sha256": "15a2844b6ed9544c6400cf7299b42d0c2bef93c9bee70a9e89f66b8610ad6d6d", + "sha256_in_prefix": "15a2844b6ed9544c6400cf7299b42d0c2bef93c9bee70a9e89f66b8610ad6d6d", + "size_in_bytes": 33370 + }, + { + "_path": "lib/python3.10/encodings/cp863.py", + "path_type": "hardlink", + "sha256": "a3d57f61fce1b98fc81ea8e4ebebaf402fae40bbcdd35d4b8297b9bb49a79aa2", + "sha256_in_prefix": "a3d57f61fce1b98fc81ea8e4ebebaf402fae40bbcdd35d4b8297b9bb49a79aa2", + "size_in_bytes": 34252 + }, + { + "_path": "lib/python3.10/encodings/cp864.py", + "path_type": "hardlink", + "sha256": "15ad8f1fdfdd842c7522241372e7eddda7df687e815692a89157c5f256f21a08", + "sha256_in_prefix": "15ad8f1fdfdd842c7522241372e7eddda7df687e815692a89157c5f256f21a08", + "size_in_bytes": 33663 + }, + { + "_path": "lib/python3.10/encodings/cp865.py", + "path_type": "hardlink", + "sha256": "bdbaded987242ed2a8de7133ec2f61ddcc1c2e9de27816ab7cd0a4c678a3a907", + "sha256_in_prefix": "bdbaded987242ed2a8de7133ec2f61ddcc1c2e9de27816ab7cd0a4c678a3a907", + "size_in_bytes": 34618 + }, + { + "_path": "lib/python3.10/encodings/cp866.py", + "path_type": "hardlink", + "sha256": "9efcc8e85bbd1687272a0991f6d0429a4c06679db2d114b2ac95db27a70f9d13", + "sha256_in_prefix": "9efcc8e85bbd1687272a0991f6d0429a4c06679db2d114b2ac95db27a70f9d13", + "size_in_bytes": 34396 + }, + { + "_path": "lib/python3.10/encodings/cp869.py", + "path_type": "hardlink", + "sha256": "52582d9fb769b24eac7154f18d7dae856588297d6da98f37fb5efd8da883826d", + "sha256_in_prefix": "52582d9fb769b24eac7154f18d7dae856588297d6da98f37fb5efd8da883826d", + "size_in_bytes": 32965 + }, + { + "_path": "lib/python3.10/encodings/cp874.py", + "path_type": "hardlink", + "sha256": "fe4752fa2e65741e08a563a31ff914fe71068942ce9c6f4070b1dfd7b25e5e7f", + "sha256_in_prefix": "fe4752fa2e65741e08a563a31ff914fe71068942ce9c6f4070b1dfd7b25e5e7f", + "size_in_bytes": 12595 + }, + { + "_path": "lib/python3.10/encodings/cp875.py", + "path_type": "hardlink", + "sha256": "2fe72632015db2cba2bb4367055551da6fe22051b96d170c7b96fa271c46b257", + "sha256_in_prefix": "2fe72632015db2cba2bb4367055551da6fe22051b96d170c7b96fa271c46b257", + "size_in_bytes": 12854 + }, + { + "_path": "lib/python3.10/encodings/cp932.py", + "path_type": "hardlink", + "sha256": "99748e28113d2d49f5d666b49b78accd2c6e10a7852f7dd6dece9b5b71aa83c4", + "sha256_in_prefix": "99748e28113d2d49f5d666b49b78accd2c6e10a7852f7dd6dece9b5b71aa83c4", + "size_in_bytes": 1023 + }, + { + "_path": "lib/python3.10/encodings/cp949.py", + "path_type": "hardlink", + "sha256": "950a7d29467ce0590b4a1137830d43d88d8f20e4035dcaaa8b2a5c3c3f1de962", + "sha256_in_prefix": "950a7d29467ce0590b4a1137830d43d88d8f20e4035dcaaa8b2a5c3c3f1de962", + "size_in_bytes": 1023 + }, + { + "_path": "lib/python3.10/encodings/cp950.py", + "path_type": "hardlink", + "sha256": "27811178b450731fc955b1247656a605d04e5ee98e0d585e4596b94b703a27f6", + "sha256_in_prefix": "27811178b450731fc955b1247656a605d04e5ee98e0d585e4596b94b703a27f6", + "size_in_bytes": 1023 + }, + { + "_path": "lib/python3.10/encodings/euc_jis_2004.py", + "path_type": "hardlink", + "sha256": "9fa426cd9f17629f6320700ed18baa94839304cf1bcabbee7edb501747dc055d", + "sha256_in_prefix": "9fa426cd9f17629f6320700ed18baa94839304cf1bcabbee7edb501747dc055d", + "size_in_bytes": 1051 + }, + { + "_path": "lib/python3.10/encodings/euc_jisx0213.py", + "path_type": "hardlink", + "sha256": "e28315910da20218dae8b7d5becd81de1e283dfd8b0415a4980d67065de73a0b", + "sha256_in_prefix": "e28315910da20218dae8b7d5becd81de1e283dfd8b0415a4980d67065de73a0b", + "size_in_bytes": 1051 + }, + { + "_path": "lib/python3.10/encodings/euc_jp.py", + "path_type": "hardlink", + "sha256": "b453a439787b0efa031e43416a7d852a6be705c985e1200693eb96d87ea79cdc", + "sha256_in_prefix": "b453a439787b0efa031e43416a7d852a6be705c985e1200693eb96d87ea79cdc", + "size_in_bytes": 1027 + }, + { + "_path": "lib/python3.10/encodings/euc_kr.py", + "path_type": "hardlink", + "sha256": "633a1a5504bfad04b1ec9c96d44d4ebb3bb99066a218318e7d67d866e20887a6", + "sha256_in_prefix": "633a1a5504bfad04b1ec9c96d44d4ebb3bb99066a218318e7d67d866e20887a6", + "size_in_bytes": 1027 + }, + { + "_path": "lib/python3.10/encodings/gb18030.py", + "path_type": "hardlink", + "sha256": "6c10b4dc49bc63724e539137ede6936304fcca1c97c28d16d89f381e10849521", + "sha256_in_prefix": "6c10b4dc49bc63724e539137ede6936304fcca1c97c28d16d89f381e10849521", + "size_in_bytes": 1031 + }, + { + "_path": "lib/python3.10/encodings/gb2312.py", + "path_type": "hardlink", + "sha256": "3d2d567d8d079b78f3f3b566ed52ad2f38af61bf832b7dc28858b0039a032d6b", + "sha256_in_prefix": "3d2d567d8d079b78f3f3b566ed52ad2f38af61bf832b7dc28858b0039a032d6b", + "size_in_bytes": 1027 + }, + { + "_path": "lib/python3.10/encodings/gbk.py", + "path_type": "hardlink", + "sha256": "eff9b8cbc9ad2ef2e10e96afa83d3db1f775ea044aed275b7a35574ae0d8645b", + "sha256_in_prefix": "eff9b8cbc9ad2ef2e10e96afa83d3db1f775ea044aed275b7a35574ae0d8645b", + "size_in_bytes": 1015 + }, + { + "_path": "lib/python3.10/encodings/hex_codec.py", + "path_type": "hardlink", + "sha256": "fc5f0a31b59efe990b86efb98936769f33dd91d912ce55b49a5a4cfc516cd047", + "sha256_in_prefix": "fc5f0a31b59efe990b86efb98936769f33dd91d912ce55b49a5a4cfc516cd047", + "size_in_bytes": 1508 + }, + { + "_path": "lib/python3.10/encodings/hp_roman8.py", + "path_type": "hardlink", + "sha256": "c43cce763d12e8f71a63dbc16641bd87147eaf5f9d9054ea856864b216b2735b", + "sha256_in_prefix": "c43cce763d12e8f71a63dbc16641bd87147eaf5f9d9054ea856864b216b2735b", + "size_in_bytes": 13475 + }, + { + "_path": "lib/python3.10/encodings/hz.py", + "path_type": "hardlink", + "sha256": "025a9531e3046e52d3e039c0be04f9a5a74651d7683a13c7c7ebd4c7dfb5996a", + "sha256_in_prefix": "025a9531e3046e52d3e039c0be04f9a5a74651d7683a13c7c7ebd4c7dfb5996a", + "size_in_bytes": 1011 + }, + { + "_path": "lib/python3.10/encodings/idna.py", + "path_type": "hardlink", + "sha256": "4fc5a79f53d60fd0576f94dfe8aa7677357d9ad95315ea220ba523f53c89229b", + "sha256_in_prefix": "4fc5a79f53d60fd0576f94dfe8aa7677357d9ad95315ea220ba523f53c89229b", + "size_in_bytes": 9098 + }, + { + "_path": "lib/python3.10/encodings/iso2022_jp.py", + "path_type": "hardlink", + "sha256": "461a0e7f72eccb8b29f351c4e7926cfbda58e0edd6d0770bd82e0b36c5febe77", + "sha256_in_prefix": "461a0e7f72eccb8b29f351c4e7926cfbda58e0edd6d0770bd82e0b36c5febe77", + "size_in_bytes": 1053 + }, + { + "_path": "lib/python3.10/encodings/iso2022_jp_1.py", + "path_type": "hardlink", + "sha256": "63bacad13a979a5519fcaa4f1e1e07b2c7415005167fac3a689408c7d886fabd", + "sha256_in_prefix": "63bacad13a979a5519fcaa4f1e1e07b2c7415005167fac3a689408c7d886fabd", + "size_in_bytes": 1061 + }, + { + "_path": "lib/python3.10/encodings/iso2022_jp_2.py", + "path_type": "hardlink", + "sha256": "5d4248181548b0fc89a9f5ee9cf52ebecb235708ba87d47896ad14130884ef9f", + "sha256_in_prefix": "5d4248181548b0fc89a9f5ee9cf52ebecb235708ba87d47896ad14130884ef9f", + "size_in_bytes": 1061 + }, + { + "_path": "lib/python3.10/encodings/iso2022_jp_2004.py", + "path_type": "hardlink", + "sha256": "b4d1468bcd608b46f38cb0c6ef115510dcf9aa0f71e590792f407efc6e165164", + "sha256_in_prefix": "b4d1468bcd608b46f38cb0c6ef115510dcf9aa0f71e590792f407efc6e165164", + "size_in_bytes": 1073 + }, + { + "_path": "lib/python3.10/encodings/iso2022_jp_3.py", + "path_type": "hardlink", + "sha256": "3aceaa5661909de14e2861d864443b8472460ce39b99cce5c6965346d47aa5ac", + "sha256_in_prefix": "3aceaa5661909de14e2861d864443b8472460ce39b99cce5c6965346d47aa5ac", + "size_in_bytes": 1061 + }, + { + "_path": "lib/python3.10/encodings/iso2022_jp_ext.py", + "path_type": "hardlink", + "sha256": "f4c9ed8f3031995faa224bcb10153d2b6144944477d1f27d1a6cc4a879fac34c", + "sha256_in_prefix": "f4c9ed8f3031995faa224bcb10153d2b6144944477d1f27d1a6cc4a879fac34c", + "size_in_bytes": 1069 + }, + { + "_path": "lib/python3.10/encodings/iso2022_kr.py", + "path_type": "hardlink", + "sha256": "1c86362e17944f0bcf68db02f4995bdeea605867795fff7ab4079073f96705e4", + "sha256_in_prefix": "1c86362e17944f0bcf68db02f4995bdeea605867795fff7ab4079073f96705e4", + "size_in_bytes": 1053 + }, + { + "_path": "lib/python3.10/encodings/iso8859_1.py", + "path_type": "hardlink", + "sha256": "b5cebd515e057d670bf54e10b8a6f162ef3daa7f21b146aee3249160caf3c32d", + "sha256_in_prefix": "b5cebd515e057d670bf54e10b8a6f162ef3daa7f21b146aee3249160caf3c32d", + "size_in_bytes": 13176 + }, + { + "_path": "lib/python3.10/encodings/iso8859_10.py", + "path_type": "hardlink", + "sha256": "54c886b41819ebb7f4fb34b8dbae1c45f4fc0864f019ecd772676ccfac5fae7b", + "sha256_in_prefix": "54c886b41819ebb7f4fb34b8dbae1c45f4fc0864f019ecd772676ccfac5fae7b", + "size_in_bytes": 13589 + }, + { + "_path": "lib/python3.10/encodings/iso8859_11.py", + "path_type": "hardlink", + "sha256": "ed5a964470a241b4da7a6cfb718e4149d09644933af38f0497602baab6e563ef", + "sha256_in_prefix": "ed5a964470a241b4da7a6cfb718e4149d09644933af38f0497602baab6e563ef", + "size_in_bytes": 12335 + }, + { + "_path": "lib/python3.10/encodings/iso8859_13.py", + "path_type": "hardlink", + "sha256": "7312237e8e5d201d920b4130f057cfdf1b0be9baafaa246826e6d93204fcc206", + "sha256_in_prefix": "7312237e8e5d201d920b4130f057cfdf1b0be9baafaa246826e6d93204fcc206", + "size_in_bytes": 13271 + }, + { + "_path": "lib/python3.10/encodings/iso8859_14.py", + "path_type": "hardlink", + "sha256": "82778b995a0ee87c5f1180fcc52900359eee15bd9a6e3a0e25f0d963e0b2a343", + "sha256_in_prefix": "82778b995a0ee87c5f1180fcc52900359eee15bd9a6e3a0e25f0d963e0b2a343", + "size_in_bytes": 13652 + }, + { + "_path": "lib/python3.10/encodings/iso8859_15.py", + "path_type": "hardlink", + "sha256": "01976a81811873dc9a0c79db9fc00d1c30103487f3c6bc3a6d81b4043cd48e02", + "sha256_in_prefix": "01976a81811873dc9a0c79db9fc00d1c30103487f3c6bc3a6d81b4043cd48e02", + "size_in_bytes": 13212 + }, + { + "_path": "lib/python3.10/encodings/iso8859_16.py", + "path_type": "hardlink", + "sha256": "b5ac8f5a5d8f84c0f903b2b7c342184758d590d8bcf810d561f942fe5b372d66", + "sha256_in_prefix": "b5ac8f5a5d8f84c0f903b2b7c342184758d590d8bcf810d561f942fe5b372d66", + "size_in_bytes": 13557 + }, + { + "_path": "lib/python3.10/encodings/iso8859_2.py", + "path_type": "hardlink", + "sha256": "2b57cab6111cae9021505e3ae1b2adbbfc344ec48165fda322f6b069fbb18adc", + "sha256_in_prefix": "2b57cab6111cae9021505e3ae1b2adbbfc344ec48165fda322f6b069fbb18adc", + "size_in_bytes": 13404 + }, + { + "_path": "lib/python3.10/encodings/iso8859_3.py", + "path_type": "hardlink", + "sha256": "4ffdf89004bf0c5230caa7079f7ca3142fc112f8b923ddb2c7358369d2d3c242", + "sha256_in_prefix": "4ffdf89004bf0c5230caa7079f7ca3142fc112f8b923ddb2c7358369d2d3c242", + "size_in_bytes": 13089 + }, + { + "_path": "lib/python3.10/encodings/iso8859_4.py", + "path_type": "hardlink", + "sha256": "87bd130daa0eaef3e4cb465e10cffb2bcd194ff74097e0c186b4b8eb7be41ac5", + "sha256_in_prefix": "87bd130daa0eaef3e4cb465e10cffb2bcd194ff74097e0c186b4b8eb7be41ac5", + "size_in_bytes": 13376 + }, + { + "_path": "lib/python3.10/encodings/iso8859_5.py", + "path_type": "hardlink", + "sha256": "9961d96cc7b9fdf011ebcaaeaeca7b50b8670fadbd7b75fde66192f8c1f68f30", + "sha256_in_prefix": "9961d96cc7b9fdf011ebcaaeaeca7b50b8670fadbd7b75fde66192f8c1f68f30", + "size_in_bytes": 13015 + }, + { + "_path": "lib/python3.10/encodings/iso8859_6.py", + "path_type": "hardlink", + "sha256": "4840e68014346517680f593ca22f67133c39ba7e46f34b9be62c980a728448c6", + "sha256_in_prefix": "4840e68014346517680f593ca22f67133c39ba7e46f34b9be62c980a728448c6", + "size_in_bytes": 10833 + }, + { + "_path": "lib/python3.10/encodings/iso8859_7.py", + "path_type": "hardlink", + "sha256": "b352eca3b819488f64fb3338fd93f39c1e30f32bb13f2f9c577925e58f2960e4", + "sha256_in_prefix": "b352eca3b819488f64fb3338fd93f39c1e30f32bb13f2f9c577925e58f2960e4", + "size_in_bytes": 12844 + }, + { + "_path": "lib/python3.10/encodings/iso8859_8.py", + "path_type": "hardlink", + "sha256": "4cf9e8a8bbe04accb1c1a80853efb19ae0772d18f81e270adefc1b2386cb368e", + "sha256_in_prefix": "4cf9e8a8bbe04accb1c1a80853efb19ae0772d18f81e270adefc1b2386cb368e", + "size_in_bytes": 11036 + }, + { + "_path": "lib/python3.10/encodings/iso8859_9.py", + "path_type": "hardlink", + "sha256": "84d9b15263e81685f7513c5ab45caf80b2f73c301c68e659f7162c1b1882d359", + "sha256_in_prefix": "84d9b15263e81685f7513c5ab45caf80b2f73c301c68e659f7162c1b1882d359", + "size_in_bytes": 13156 + }, + { + "_path": "lib/python3.10/encodings/johab.py", + "path_type": "hardlink", + "sha256": "9586615917afd3d848c1c4328656603b2834af6115f2aec932fccc935e1a60fb", + "sha256_in_prefix": "9586615917afd3d848c1c4328656603b2834af6115f2aec932fccc935e1a60fb", + "size_in_bytes": 1023 + }, + { + "_path": "lib/python3.10/encodings/koi8_r.py", + "path_type": "hardlink", + "sha256": "4d4e353aee8039bb71e2145a6e68fe1e6833a1b4250b70ee0ac5ec70bbb8c51d", + "sha256_in_prefix": "4d4e353aee8039bb71e2145a6e68fe1e6833a1b4250b70ee0ac5ec70bbb8c51d", + "size_in_bytes": 13779 + }, + { + "_path": "lib/python3.10/encodings/koi8_t.py", + "path_type": "hardlink", + "sha256": "9c9043814abdbe7dc39ff98f3857d5d110a84c978ad2304158d810a4e9eacef1", + "sha256_in_prefix": "9c9043814abdbe7dc39ff98f3857d5d110a84c978ad2304158d810a4e9eacef1", + "size_in_bytes": 13193 + }, + { + "_path": "lib/python3.10/encodings/koi8_u.py", + "path_type": "hardlink", + "sha256": "d449f9858e357fa8c2edbd4b9fe739337e9f201cac3ded20f99bfcecd4970ff7", + "sha256_in_prefix": "d449f9858e357fa8c2edbd4b9fe739337e9f201cac3ded20f99bfcecd4970ff7", + "size_in_bytes": 13762 + }, + { + "_path": "lib/python3.10/encodings/kz1048.py", + "path_type": "hardlink", + "sha256": "76beb30e98a911f72f97609a2373782573c17c88a5fb3537db338aa382979ffc", + "sha256_in_prefix": "76beb30e98a911f72f97609a2373782573c17c88a5fb3537db338aa382979ffc", + "size_in_bytes": 13723 + }, + { + "_path": "lib/python3.10/encodings/latin_1.py", + "path_type": "hardlink", + "sha256": "b75503e532a27c636477396c855209ff5f3036536d2a4bede0a576c89382b60c", + "sha256_in_prefix": "b75503e532a27c636477396c855209ff5f3036536d2a4bede0a576c89382b60c", + "size_in_bytes": 1264 + }, + { + "_path": "lib/python3.10/encodings/mac_arabic.py", + "path_type": "hardlink", + "sha256": "5eafd9a3136abfbd8ed52df9c90203c7a283e7429ed60502a87a02511e0fb777", + "sha256_in_prefix": "5eafd9a3136abfbd8ed52df9c90203c7a283e7429ed60502a87a02511e0fb777", + "size_in_bytes": 36467 + }, + { + "_path": "lib/python3.10/encodings/mac_croatian.py", + "path_type": "hardlink", + "sha256": "a880cd05c82a8d11a29c65ee86a396def3344465dd71441b0bb4a73826024953", + "sha256_in_prefix": "a880cd05c82a8d11a29c65ee86a396def3344465dd71441b0bb4a73826024953", + "size_in_bytes": 13633 + }, + { + "_path": "lib/python3.10/encodings/mac_cyrillic.py", + "path_type": "hardlink", + "sha256": "83616786a1c6308b03a0dc82536908d24d0974b2248d67393d613fe558cea4bd", + "sha256_in_prefix": "83616786a1c6308b03a0dc82536908d24d0974b2248d67393d613fe558cea4bd", + "size_in_bytes": 13454 + }, + { + "_path": "lib/python3.10/encodings/mac_farsi.py", + "path_type": "hardlink", + "sha256": "f5763c38fb4ab0423fafe2fdca34d6f9932ac7f1a74c0cd8109d60234c7dc624", + "sha256_in_prefix": "f5763c38fb4ab0423fafe2fdca34d6f9932ac7f1a74c0cd8109d60234c7dc624", + "size_in_bytes": 15170 + }, + { + "_path": "lib/python3.10/encodings/mac_greek.py", + "path_type": "hardlink", + "sha256": "63016a323ddf98cb3aa9cfa78f3bab4768bedbfe9a5262a36a5aecb13d291f6e", + "sha256_in_prefix": "63016a323ddf98cb3aa9cfa78f3bab4768bedbfe9a5262a36a5aecb13d291f6e", + "size_in_bytes": 13721 + }, + { + "_path": "lib/python3.10/encodings/mac_iceland.py", + "path_type": "hardlink", + "sha256": "753cc1ac635caa7e1b4630fbcebef8db8db332c098154a5b11f652912bf64f37", + "sha256_in_prefix": "753cc1ac635caa7e1b4630fbcebef8db8db332c098154a5b11f652912bf64f37", + "size_in_bytes": 13498 + }, + { + "_path": "lib/python3.10/encodings/mac_latin2.py", + "path_type": "hardlink", + "sha256": "31670da18ce8b5394cd53fe6bf216268e7e8eae4c0247532e420e2e103727d50", + "sha256_in_prefix": "31670da18ce8b5394cd53fe6bf216268e7e8eae4c0247532e420e2e103727d50", + "size_in_bytes": 14118 + }, + { + "_path": "lib/python3.10/encodings/mac_roman.py", + "path_type": "hardlink", + "sha256": "230367d96aef8e8d7f185b4acfb84923714f39ddbcbf9cf38a06bf6f5d621c22", + "sha256_in_prefix": "230367d96aef8e8d7f185b4acfb84923714f39ddbcbf9cf38a06bf6f5d621c22", + "size_in_bytes": 13480 + }, + { + "_path": "lib/python3.10/encodings/mac_romanian.py", + "path_type": "hardlink", + "sha256": "49630cf035c19e896a123ed6e5fee18b5e485123daf2f15da38bf727ff387bee", + "sha256_in_prefix": "49630cf035c19e896a123ed6e5fee18b5e485123daf2f15da38bf727ff387bee", + "size_in_bytes": 13661 + }, + { + "_path": "lib/python3.10/encodings/mac_turkish.py", + "path_type": "hardlink", + "sha256": "99758a5cad2825cb3be3fa5d031e0821e4eba910a46f417fd890207b9b6be77b", + "sha256_in_prefix": "99758a5cad2825cb3be3fa5d031e0821e4eba910a46f417fd890207b9b6be77b", + "size_in_bytes": 13513 + }, + { + "_path": "lib/python3.10/encodings/mbcs.py", + "path_type": "hardlink", + "sha256": "f6ed445ed537c9f856d8defe8b56505727737d0dc9348d0a877abedab4bdd864", + "sha256_in_prefix": "f6ed445ed537c9f856d8defe8b56505727737d0dc9348d0a877abedab4bdd864", + "size_in_bytes": 1211 + }, + { + "_path": "lib/python3.10/encodings/oem.py", + "path_type": "hardlink", + "sha256": "481656d3a35f792d0e5109e3f821e6dbfcf097163a19b0cdfcbff3b3db99292f", + "sha256_in_prefix": "481656d3a35f792d0e5109e3f821e6dbfcf097163a19b0cdfcbff3b3db99292f", + "size_in_bytes": 1019 + }, + { + "_path": "lib/python3.10/encodings/palmos.py", + "path_type": "hardlink", + "sha256": "eccf7418adefcc2a59e9a07fc4e34363bd62f7e878d48c8a02730a8ed1c584c8", + "sha256_in_prefix": "eccf7418adefcc2a59e9a07fc4e34363bd62f7e878d48c8a02730a8ed1c584c8", + "size_in_bytes": 13519 + }, + { + "_path": "lib/python3.10/encodings/ptcp154.py", + "path_type": "hardlink", + "sha256": "0eabcb2c287d335e86b71b0abe5718bd6ddc9aaee234f0f0f2363845d2926d8d", + "sha256_in_prefix": "0eabcb2c287d335e86b71b0abe5718bd6ddc9aaee234f0f0f2363845d2926d8d", + "size_in_bytes": 14015 + }, + { + "_path": "lib/python3.10/encodings/punycode.py", + "path_type": "hardlink", + "sha256": "34edc8fb1c50e4d1cbaa1e008bb491cd7c12116c316e51974f333fe7b628eb7c", + "sha256_in_prefix": "34edc8fb1c50e4d1cbaa1e008bb491cd7c12116c316e51974f333fe7b628eb7c", + "size_in_bytes": 6883 + }, + { + "_path": "lib/python3.10/encodings/quopri_codec.py", + "path_type": "hardlink", + "sha256": "502a213c34c05a94ed063ee03f47680bd6efbb35036e06fb4dc809bf398cfa64", + "sha256_in_prefix": "502a213c34c05a94ed063ee03f47680bd6efbb35036e06fb4dc809bf398cfa64", + "size_in_bytes": 1525 + }, + { + "_path": "lib/python3.10/encodings/raw_unicode_escape.py", + "path_type": "hardlink", + "sha256": "fa6328486b8f5a5cbd10e377e80adb8cf94acbbe19c38b4e1bf708d831a80a3a", + "sha256_in_prefix": "fa6328486b8f5a5cbd10e377e80adb8cf94acbbe19c38b4e1bf708d831a80a3a", + "size_in_bytes": 1332 + }, + { + "_path": "lib/python3.10/encodings/rot_13.py", + "path_type": "hardlink", + "sha256": "14767f475acdc0bf48e6272280dd15b80efaecafb93c06be21136f83dd1ee7e4", + "sha256_in_prefix": "14767f475acdc0bf48e6272280dd15b80efaecafb93c06be21136f83dd1ee7e4", + "size_in_bytes": 2448 + }, + { + "_path": "lib/python3.10/encodings/shift_jis.py", + "path_type": "hardlink", + "sha256": "ad4ac50ebf58294304e412cc0f1b12980988dd6edc414e4110029c0a1abbe966", + "sha256_in_prefix": "ad4ac50ebf58294304e412cc0f1b12980988dd6edc414e4110029c0a1abbe966", + "size_in_bytes": 1039 + }, + { + "_path": "lib/python3.10/encodings/shift_jis_2004.py", + "path_type": "hardlink", + "sha256": "d21c5930f21063ea78fea3b0f76dfb8fd92858d2a4a200064a52126a43dd1a99", + "sha256_in_prefix": "d21c5930f21063ea78fea3b0f76dfb8fd92858d2a4a200064a52126a43dd1a99", + "size_in_bytes": 1059 + }, + { + "_path": "lib/python3.10/encodings/shift_jisx0213.py", + "path_type": "hardlink", + "sha256": "2c8d0b93bb36edf31c1236b1b4d1c0008553868bd2fc9137570115b96b834f2e", + "sha256_in_prefix": "2c8d0b93bb36edf31c1236b1b4d1c0008553868bd2fc9137570115b96b834f2e", + "size_in_bytes": 1059 + }, + { + "_path": "lib/python3.10/encodings/tis_620.py", + "path_type": "hardlink", + "sha256": "647c4719e2c1a7375105e15a89b377c66f6b699977dcabbb71d923a4607b7902", + "sha256_in_prefix": "647c4719e2c1a7375105e15a89b377c66f6b699977dcabbb71d923a4607b7902", + "size_in_bytes": 12300 + }, + { + "_path": "lib/python3.10/encodings/undefined.py", + "path_type": "hardlink", + "sha256": "85bba5c5e1007cd8c1ade5c0214bcc825396d2bbd02054e62a9f162104748b64", + "sha256_in_prefix": "85bba5c5e1007cd8c1ade5c0214bcc825396d2bbd02054e62a9f162104748b64", + "size_in_bytes": 1299 + }, + { + "_path": "lib/python3.10/encodings/unicode_escape.py", + "path_type": "hardlink", + "sha256": "507e7ca8f18df639fd823d7cc23ce4028a3550ceefdfa40b3c76f81d1a94531d", + "sha256_in_prefix": "507e7ca8f18df639fd823d7cc23ce4028a3550ceefdfa40b3c76f81d1a94531d", + "size_in_bytes": 1304 + }, + { + "_path": "lib/python3.10/encodings/utf_16.py", + "path_type": "hardlink", + "sha256": "6c36257f7b8d214473560d195e71bccef0c69a53e1e52d2800b7a7890aad7e58", + "sha256_in_prefix": "6c36257f7b8d214473560d195e71bccef0c69a53e1e52d2800b7a7890aad7e58", + "size_in_bytes": 5236 + }, + { + "_path": "lib/python3.10/encodings/utf_16_be.py", + "path_type": "hardlink", + "sha256": "3357196f3fa52433326a6626880e34964e00c5570aee50e9a0a0a7c6d86f6e4f", + "sha256_in_prefix": "3357196f3fa52433326a6626880e34964e00c5570aee50e9a0a0a7c6d86f6e4f", + "size_in_bytes": 1037 + }, + { + "_path": "lib/python3.10/encodings/utf_16_le.py", + "path_type": "hardlink", + "sha256": "3aedaf3eb49769282daef1eaedfd4fa1c31fe5eebeff67fe2307c89dc2e2fd80", + "sha256_in_prefix": "3aedaf3eb49769282daef1eaedfd4fa1c31fe5eebeff67fe2307c89dc2e2fd80", + "size_in_bytes": 1037 + }, + { + "_path": "lib/python3.10/encodings/utf_32.py", + "path_type": "hardlink", + "sha256": "2072eece5f6026ad2d3549ab193a9e38894ea15ca9d5b3cd408fd6b116acc0c2", + "sha256_in_prefix": "2072eece5f6026ad2d3549ab193a9e38894ea15ca9d5b3cd408fd6b116acc0c2", + "size_in_bytes": 5129 + }, + { + "_path": "lib/python3.10/encodings/utf_32_be.py", + "path_type": "hardlink", + "sha256": "cbba20e1f6d0879c7c4293446c371a9f79e7c90bf3c78a77a9b8fc72b18915dd", + "sha256_in_prefix": "cbba20e1f6d0879c7c4293446c371a9f79e7c90bf3c78a77a9b8fc72b18915dd", + "size_in_bytes": 930 + }, + { + "_path": "lib/python3.10/encodings/utf_32_le.py", + "path_type": "hardlink", + "sha256": "9134b91047d85b442898d59effe23e7e0cf4167ca341ae31119a731dbf880a7b", + "sha256_in_prefix": "9134b91047d85b442898d59effe23e7e0cf4167ca341ae31119a731dbf880a7b", + "size_in_bytes": 930 + }, + { + "_path": "lib/python3.10/encodings/utf_7.py", + "path_type": "hardlink", + "sha256": "9ff32314f4f1fa074f206bbf7fdb851504e5313128636d73b4bf75b886e4a87d", + "sha256_in_prefix": "9ff32314f4f1fa074f206bbf7fdb851504e5313128636d73b4bf75b886e4a87d", + "size_in_bytes": 946 + }, + { + "_path": "lib/python3.10/encodings/utf_8.py", + "path_type": "hardlink", + "sha256": "ba0cac060269583523ca9506473a755203037c57d466a11aa89a30a5f6756f3d", + "sha256_in_prefix": "ba0cac060269583523ca9506473a755203037c57d466a11aa89a30a5f6756f3d", + "size_in_bytes": 1005 + }, + { + "_path": "lib/python3.10/encodings/utf_8_sig.py", + "path_type": "hardlink", + "sha256": "1ef3da8d8aa08149e7f274dc64dbfce2155da812e5258ca8e8f832428d3b5c2d", + "sha256_in_prefix": "1ef3da8d8aa08149e7f274dc64dbfce2155da812e5258ca8e8f832428d3b5c2d", + "size_in_bytes": 4133 + }, + { + "_path": "lib/python3.10/encodings/uu_codec.py", + "path_type": "hardlink", + "sha256": "45ba92000718abf85f158563c755205e100356ce1b4ab9444b4d0a3d21f061a3", + "sha256_in_prefix": "45ba92000718abf85f158563c755205e100356ce1b4ab9444b4d0a3d21f061a3", + "size_in_bytes": 2851 + }, + { + "_path": "lib/python3.10/encodings/zlib_codec.py", + "path_type": "hardlink", + "sha256": "6ef01e8d3a5fe1cc52f7b5ae008df12f1dbce7304111bf8d4758f1bfc0115759", + "sha256_in_prefix": "6ef01e8d3a5fe1cc52f7b5ae008df12f1dbce7304111bf8d4758f1bfc0115759", + "size_in_bytes": 2204 + }, + { + "_path": "lib/python3.10/ensurepip/__init__.py", + "path_type": "hardlink", + "sha256": "cdaba5afb1a8028fe882f5c7604b1e03b1162efb45a79156eee9e98c69d9be34", + "sha256_in_prefix": "cdaba5afb1a8028fe882f5c7604b1e03b1162efb45a79156eee9e98c69d9be34", + "size_in_bytes": 9635 + }, + { + "_path": "lib/python3.10/ensurepip/__main__.py", + "path_type": "hardlink", + "sha256": "ee735f518d0fc4dfec81f7aa3da1e052372ed4202c0da4eddd2587840beaecd7", + "sha256_in_prefix": "ee735f518d0fc4dfec81f7aa3da1e052372ed4202c0da4eddd2587840beaecd7", + "size_in_bytes": 88 + }, + { + "_path": "lib/python3.10/ensurepip/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "e18bb5b77ba2d9f57c02e738c161b9ba963bfd27f15887300a4cb2f67a4f663c", + "sha256_in_prefix": "e18bb5b77ba2d9f57c02e738c161b9ba963bfd27f15887300a4cb2f67a4f663c", + "size_in_bytes": 6567 + }, + { + "_path": "lib/python3.10/ensurepip/__pycache__/__main__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "0c2219866c12a2dd2c8567a1622c1653449bda943351c8baced7f20c3f91a2d6", + "sha256_in_prefix": "0c2219866c12a2dd2c8567a1622c1653449bda943351c8baced7f20c3f91a2d6", + "size_in_bytes": 489 + }, + { + "_path": "lib/python3.10/ensurepip/__pycache__/_uninstall.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c7bbba725dfdd7738ea7fb2647c1a7bb6a50cd0d33bde83bf2329b144efcba23", + "sha256_in_prefix": "c7bbba725dfdd7738ea7fb2647c1a7bb6a50cd0d33bde83bf2329b144efcba23", + "size_in_bytes": 1195 + }, + { + "_path": "lib/python3.10/ensurepip/_bundled/__init__.py", + "path_type": "hardlink", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size_in_bytes": 0 + }, + { + "_path": "lib/python3.10/ensurepip/_bundled/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "5a1654a95b7c05d66da9d5176257d40db8e3975f37af9746d58814b666d3ce01", + "sha256_in_prefix": "5a1654a95b7c05d66da9d5176257d40db8e3975f37af9746d58814b666d3ce01", + "size_in_bytes": 397 + }, + { + "_path": "lib/python3.10/ensurepip/_bundled/pip-23.0.1-py3-none-any.whl", + "path_type": "hardlink", + "sha256": "236bcb61156d76c4b8a05821b988c7b8c35bf0da28a4b614e8d6ab5212c25c6f", + "sha256_in_prefix": "236bcb61156d76c4b8a05821b988c7b8c35bf0da28a4b614e8d6ab5212c25c6f", + "size_in_bytes": 2055563 + }, + { + "_path": "lib/python3.10/ensurepip/_bundled/setuptools-65.5.0-py3-none-any.whl", + "path_type": "hardlink", + "sha256": "f62ea9da9ed6289bfe868cd6845968a2c854d1427f8548d52cae02a42b4f0356", + "sha256_in_prefix": "f62ea9da9ed6289bfe868cd6845968a2c854d1427f8548d52cae02a42b4f0356", + "size_in_bytes": 1232695 + }, + { + "_path": "lib/python3.10/ensurepip/_uninstall.py", + "path_type": "hardlink", + "sha256": "3a6e95d01c45e2e47c05df3c81073b895c97c1eb0e5b90ab175d6d9263fc81f2", + "sha256_in_prefix": "3a6e95d01c45e2e47c05df3c81073b895c97c1eb0e5b90ab175d6d9263fc81f2", + "size_in_bytes": 808 + }, + { + "_path": "lib/python3.10/enum.py", + "path_type": "hardlink", + "sha256": "59a62af0e129ae688f5549d6a273c51c5db80b534521f98dae2e4ceb485d9f75", + "sha256_in_prefix": "59a62af0e129ae688f5549d6a273c51c5db80b534521f98dae2e4ceb485d9f75", + "size_in_bytes": 39831 + }, + { + "_path": "lib/python3.10/filecmp.py", + "path_type": "hardlink", + "sha256": "178f19895fdd43d5d3865b2bfe9ae7b665611a30d29cfc23d44f01417774851c", + "sha256_in_prefix": "178f19895fdd43d5d3865b2bfe9ae7b665611a30d29cfc23d44f01417774851c", + "size_in_bytes": 10178 + }, + { + "_path": "lib/python3.10/fileinput.py", + "path_type": "hardlink", + "sha256": "82aaa7e7f62fca7af709e2d80461a37e1c0b2015e9d6b1145bd646bf0983712b", + "sha256_in_prefix": "82aaa7e7f62fca7af709e2d80461a37e1c0b2015e9d6b1145bd646bf0983712b", + "size_in_bytes": 16442 + }, + { + "_path": "lib/python3.10/fnmatch.py", + "path_type": "hardlink", + "sha256": "8a47ad23c243c6af0314bca4fc59b077035b6074f1915b6fc2b7c00864a7c16d", + "sha256_in_prefix": "8a47ad23c243c6af0314bca4fc59b077035b6074f1915b6fc2b7c00864a7c16d", + "size_in_bytes": 6713 + }, + { + "_path": "lib/python3.10/fractions.py", + "path_type": "hardlink", + "sha256": "c98b837e35c0ed2dd71d1d3551490553e5490ce954233f48e63e756c5f15938e", + "sha256_in_prefix": "c98b837e35c0ed2dd71d1d3551490553e5490ce954233f48e63e756c5f15938e", + "size_in_bytes": 28242 + }, + { + "_path": "lib/python3.10/ftplib.py", + "path_type": "hardlink", + "sha256": "672300f448249dfd7825369e47111c37b8aa5355ef0a10df3226bd5f849e538e", + "sha256_in_prefix": "672300f448249dfd7825369e47111c37b8aa5355ef0a10df3226bd5f849e538e", + "size_in_bytes": 35496 + }, + { + "_path": "lib/python3.10/functools.py", + "path_type": "hardlink", + "sha256": "1604a69d2d60921502b375a8af0d662702abe625987b773637a34c09c76a8a25", + "sha256_in_prefix": "1604a69d2d60921502b375a8af0d662702abe625987b773637a34c09c76a8a25", + "size_in_bytes": 38076 + }, + { + "_path": "lib/python3.10/genericpath.py", + "path_type": "hardlink", + "sha256": "9d58ad64056a89f12258a62596c2073cd9e52b459dde152f710edc0cffcd865b", + "sha256_in_prefix": "9d58ad64056a89f12258a62596c2073cd9e52b459dde152f710edc0cffcd865b", + "size_in_bytes": 4975 + }, + { + "_path": "lib/python3.10/getopt.py", + "path_type": "hardlink", + "sha256": "efafb88c7c978e96bd6c232b7fa10bf50cef5e7fb0fb7dc8e5bce44e19f8c92f", + "sha256_in_prefix": "efafb88c7c978e96bd6c232b7fa10bf50cef5e7fb0fb7dc8e5bce44e19f8c92f", + "size_in_bytes": 7489 + }, + { + "_path": "lib/python3.10/getpass.py", + "path_type": "hardlink", + "sha256": "e74fd445337ff503223dd8aa4bdd7d04917067d00c796a10bedb7a1381a4960a", + "sha256_in_prefix": "e74fd445337ff503223dd8aa4bdd7d04917067d00c796a10bedb7a1381a4960a", + "size_in_bytes": 5990 + }, + { + "_path": "lib/python3.10/gettext.py", + "path_type": "hardlink", + "sha256": "46c4d4e2e72bcd572e64bfbce15975d8054a65af167664c6da193773c38dd1ae", + "sha256_in_prefix": "46c4d4e2e72bcd572e64bfbce15975d8054a65af167664c6da193773c38dd1ae", + "size_in_bytes": 27266 + }, + { + "_path": "lib/python3.10/glob.py", + "path_type": "hardlink", + "sha256": "bfedf57df8753377352059f500ffc6780fda3a2381450d1a3822b4714745ceaf", + "sha256_in_prefix": "bfedf57df8753377352059f500ffc6780fda3a2381450d1a3822b4714745ceaf", + "size_in_bytes": 7888 + }, + { + "_path": "lib/python3.10/graphlib.py", + "path_type": "hardlink", + "sha256": "c903f32178ae8205b73caca478c6505318dcc84b006acd6e9ca7da6479a1e05f", + "sha256_in_prefix": "c903f32178ae8205b73caca478c6505318dcc84b006acd6e9ca7da6479a1e05f", + "size_in_bytes": 9573 + }, + { + "_path": "lib/python3.10/gzip.py", + "path_type": "hardlink", + "sha256": "fb131d4bbe711c410f54c7f0b3c2c64292e1279199fd04c53837db03e542a907", + "sha256_in_prefix": "fb131d4bbe711c410f54c7f0b3c2c64292e1279199fd04c53837db03e542a907", + "size_in_bytes": 21849 + }, + { + "_path": "lib/python3.10/hashlib.py", + "path_type": "hardlink", + "sha256": "9d56ebad0263a48ac94e0b2b7a3723625f2ff4dc7707d1156580e008d40bc790", + "sha256_in_prefix": "9d56ebad0263a48ac94e0b2b7a3723625f2ff4dc7707d1156580e008d40bc790", + "size_in_bytes": 10229 + }, + { + "_path": "lib/python3.10/heapq.py", + "path_type": "hardlink", + "sha256": "0351667ed3afd3310ebd353526824d6f6f34d641ef0a785552c6893b7f95fdf3", + "sha256_in_prefix": "0351667ed3afd3310ebd353526824d6f6f34d641ef0a785552c6893b7f95fdf3", + "size_in_bytes": 22877 + }, + { + "_path": "lib/python3.10/hmac.py", + "path_type": "hardlink", + "sha256": "a4790b3cfd1b58875879621dbe8f4c0a30fb50a8582045b0d5c1a712afc8c36b", + "sha256_in_prefix": "a4790b3cfd1b58875879621dbe8f4c0a30fb50a8582045b0d5c1a712afc8c36b", + "size_in_bytes": 7717 + }, + { + "_path": "lib/python3.10/html/__init__.py", + "path_type": "hardlink", + "sha256": "923d82d821e75e8d235392c10c145ab8587927b3faf9c952bbd48081eebd8522", + "sha256_in_prefix": "923d82d821e75e8d235392c10c145ab8587927b3faf9c952bbd48081eebd8522", + "size_in_bytes": 4775 + }, + { + "_path": "lib/python3.10/html/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "d0e6855ffe1eccf5b100645cbea3827b5f1b6ec2b047577716e3ff7bf7244775", + "sha256_in_prefix": "d0e6855ffe1eccf5b100645cbea3827b5f1b6ec2b047577716e3ff7bf7244775", + "size_in_bytes": 3577 + }, + { + "_path": "lib/python3.10/html/__pycache__/entities.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "960cdc49f2aa303818592777243e1449063283ebdbfd5556971e0e0151f030d7", + "sha256_in_prefix": "960cdc49f2aa303818592777243e1449063283ebdbfd5556971e0e0151f030d7", + "size_in_bytes": 144684 + }, + { + "_path": "lib/python3.10/html/__pycache__/parser.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c41e0d7eed11b3133c75a0386166366ade37f68b91ff7b6e2984c643ea5e1f0d", + "sha256_in_prefix": "c41e0d7eed11b3133c75a0386166366ade37f68b91ff7b6e2984c643ea5e1f0d", + "size_in_bytes": 11018 + }, + { + "_path": "lib/python3.10/html/entities.py", + "path_type": "hardlink", + "sha256": "282b7cdd567bbbf3d7d7ccd49fae1d3ebc7f7ab64058d781193620913773731b", + "sha256_in_prefix": "282b7cdd567bbbf3d7d7ccd49fae1d3ebc7f7ab64058d781193620913773731b", + "size_in_bytes": 75383 + }, + { + "_path": "lib/python3.10/html/parser.py", + "path_type": "hardlink", + "sha256": "16aaf2af5459e50e0484af96476fdb58b229f04e46f0c8726fa2dc5ae3ad328d", + "sha256_in_prefix": "16aaf2af5459e50e0484af96476fdb58b229f04e46f0c8726fa2dc5ae3ad328d", + "size_in_bytes": 17392 + }, + { + "_path": "lib/python3.10/http/__init__.py", + "path_type": "hardlink", + "sha256": "47bf36a5cbbcd6ff1c0a5e1b12a82626c2a91bf4ee76ecdbd10e60ac4ca7a461", + "sha256_in_prefix": "47bf36a5cbbcd6ff1c0a5e1b12a82626c2a91bf4ee76ecdbd10e60ac4ca7a461", + "size_in_bytes": 6733 + }, + { + "_path": "lib/python3.10/http/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "7d27b1bb078fbe71922b6071c17f3b1210fbe616d9fb363eb13ef48bdd3aae1f", + "sha256_in_prefix": "7d27b1bb078fbe71922b6071c17f3b1210fbe616d9fb363eb13ef48bdd3aae1f", + "size_in_bytes": 6670 + }, + { + "_path": "lib/python3.10/http/__pycache__/client.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "2da5266975b4029cb40336bc13808c5ec5b14090d03ad3f81bd0fd36238617fa", + "sha256_in_prefix": "2da5266975b4029cb40336bc13808c5ec5b14090d03ad3f81bd0fd36238617fa", + "size_in_bytes": 35432 + }, + { + "_path": "lib/python3.10/http/__pycache__/cookiejar.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "abb1d2216f1509940053353286ef8cf774a24445d666f42a633b2fa585edc6f5", + "sha256_in_prefix": "abb1d2216f1509940053353286ef8cf774a24445d666f42a633b2fa585edc6f5", + "size_in_bytes": 53694 + }, + { + "_path": "lib/python3.10/http/__pycache__/cookies.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "92da78b238dce244b7e52a6a36d3175b1786eb83786c73afe4a6751fb18472e9", + "sha256_in_prefix": "92da78b238dce244b7e52a6a36d3175b1786eb83786c73afe4a6751fb18472e9", + "size_in_bytes": 15592 + }, + { + "_path": "lib/python3.10/http/__pycache__/server.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "ccde1961013b73c35e981946676eebed91539c0d1040f25b3e6dd08a39f0501f", + "sha256_in_prefix": "ccde1961013b73c35e981946676eebed91539c0d1040f25b3e6dd08a39f0501f", + "size_in_bytes": 35446 + }, + { + "_path": "lib/python3.10/http/client.py", + "path_type": "hardlink", + "sha256": "1d724c7d2242957dc789eeb6a446c31294db4747be5d4cbad562fbfa6475fb7d", + "sha256_in_prefix": "1d724c7d2242957dc789eeb6a446c31294db4747be5d4cbad562fbfa6475fb7d", + "size_in_bytes": 56795 + }, + { + "_path": "lib/python3.10/http/cookiejar.py", + "path_type": "hardlink", + "sha256": "03a8c15b1c5a5419774fef60f60405c8e70b1f791fe32c9e73ad7215173efe52", + "sha256_in_prefix": "03a8c15b1c5a5419774fef60f60405c8e70b1f791fe32c9e73ad7215173efe52", + "size_in_bytes": 77415 + }, + { + "_path": "lib/python3.10/http/cookies.py", + "path_type": "hardlink", + "sha256": "a4712e985f8d892e290e8317d0d4d692313a39d5b0bd22fc640b885a79043ff7", + "sha256_in_prefix": "a4712e985f8d892e290e8317d0d4d692313a39d5b0bd22fc640b885a79043ff7", + "size_in_bytes": 20482 + }, + { + "_path": "lib/python3.10/http/server.py", + "path_type": "hardlink", + "sha256": "3b91d9b7a7c7e58a828bdb505b981201965d9634b90e2a98291bd6a018963426", + "sha256_in_prefix": "3b91d9b7a7c7e58a828bdb505b981201965d9634b90e2a98291bd6a018963426", + "size_in_bytes": 48207 + }, + { + "_path": "lib/python3.10/idlelib/CREDITS.txt", + "path_type": "hardlink", + "sha256": "33e6a36056667d40e26f195c14371567470f53324c3fec43aec29e09d7d2a60b", + "sha256_in_prefix": "33e6a36056667d40e26f195c14371567470f53324c3fec43aec29e09d7d2a60b", + "size_in_bytes": 2152 + }, + { + "_path": "lib/python3.10/idlelib/ChangeLog", + "path_type": "hardlink", + "sha256": "b7f42699e5e5a7c82ebdf2a2962946b7228c933ece0ea7c0d7789f21a7dd7e64", + "sha256_in_prefix": "b7f42699e5e5a7c82ebdf2a2962946b7228c933ece0ea7c0d7789f21a7dd7e64", + "size_in_bytes": 56360 + }, + { + "_path": "lib/python3.10/idlelib/HISTORY.txt", + "path_type": "hardlink", + "sha256": "531067a78ad392f25631aba1d885f40786cf5f47854577162c9f90ff1f33164c", + "sha256_in_prefix": "531067a78ad392f25631aba1d885f40786cf5f47854577162c9f90ff1f33164c", + "size_in_bytes": 10312 + }, + { + "_path": "lib/python3.10/idlelib/Icons/README.txt", + "path_type": "hardlink", + "sha256": "60399d6129e3e486ce6b437bbf614ff4838bd4e7f42d461c3e5467cf3b4fa272", + "sha256_in_prefix": "60399d6129e3e486ce6b437bbf614ff4838bd4e7f42d461c3e5467cf3b4fa272", + "size_in_bytes": 443 + }, + { + "_path": "lib/python3.10/idlelib/Icons/folder.gif", + "path_type": "hardlink", + "sha256": "7c98d566a13fd599d1c11a375f387fef69b6c595c4f18c5d88c188a860be0e55", + "sha256_in_prefix": "7c98d566a13fd599d1c11a375f387fef69b6c595c4f18c5d88c188a860be0e55", + "size_in_bytes": 120 + }, + { + "_path": "lib/python3.10/idlelib/Icons/idle.ico", + "path_type": "hardlink", + "sha256": "7f13eeb5dca39d05e24b9eb069c6dcb2748633822d67288a8bf8b7e21cdddf55", + "sha256_in_prefix": "7f13eeb5dca39d05e24b9eb069c6dcb2748633822d67288a8bf8b7e21cdddf55", + "size_in_bytes": 57746 + }, + { + "_path": "lib/python3.10/idlelib/Icons/idle_16.gif", + "path_type": "hardlink", + "sha256": "fe3af292b38660a8a58b1a8b4fa4240aa190602e7e9a700ea0536b3181fc968e", + "sha256_in_prefix": "fe3af292b38660a8a58b1a8b4fa4240aa190602e7e9a700ea0536b3181fc968e", + "size_in_bytes": 634 + }, + { + "_path": "lib/python3.10/idlelib/Icons/idle_16.png", + "path_type": "hardlink", + "sha256": "78fb3fb0ec11f61bc6cf0947f3c3923aa18e1c6513684058ed0fa01ac858143e", + "sha256_in_prefix": "78fb3fb0ec11f61bc6cf0947f3c3923aa18e1c6513684058ed0fa01ac858143e", + "size_in_bytes": 1031 + }, + { + "_path": "lib/python3.10/idlelib/Icons/idle_256.png", + "path_type": "hardlink", + "sha256": "3f517467d12e0e3ecf20f9bd68ce4bd18a2b8088f32308fd978fd80e87d3628b", + "sha256_in_prefix": "3f517467d12e0e3ecf20f9bd68ce4bd18a2b8088f32308fd978fd80e87d3628b", + "size_in_bytes": 39205 + }, + { + "_path": "lib/python3.10/idlelib/Icons/idle_32.gif", + "path_type": "hardlink", + "sha256": "fe70991cfccd1267922e94d91e02e9a58d2d29fd3382a2f4975280b9023cb7b9", + "sha256_in_prefix": "fe70991cfccd1267922e94d91e02e9a58d2d29fd3382a2f4975280b9023cb7b9", + "size_in_bytes": 1019 + }, + { + "_path": "lib/python3.10/idlelib/Icons/idle_32.png", + "path_type": "hardlink", + "sha256": "797cd05f1964d57c4c6c248ac7f7ea6a38019ada32a9ab7e6c28d060f87b03de", + "sha256_in_prefix": "797cd05f1964d57c4c6c248ac7f7ea6a38019ada32a9ab7e6c28d060f87b03de", + "size_in_bytes": 2036 + }, + { + "_path": "lib/python3.10/idlelib/Icons/idle_48.gif", + "path_type": "hardlink", + "sha256": "37484901eb40eefa846308e1da3ff6f240ea98f769a2afc3cf4fdba00327ecbe", + "sha256_in_prefix": "37484901eb40eefa846308e1da3ff6f240ea98f769a2afc3cf4fdba00327ecbe", + "size_in_bytes": 1388 + }, + { + "_path": "lib/python3.10/idlelib/Icons/idle_48.png", + "path_type": "hardlink", + "sha256": "a09f433197c8870b12bb7859cc4c3fe2068908cb1ddbd4880ab0f6fee91b6c23", + "sha256_in_prefix": "a09f433197c8870b12bb7859cc4c3fe2068908cb1ddbd4880ab0f6fee91b6c23", + "size_in_bytes": 3977 + }, + { + "_path": "lib/python3.10/idlelib/Icons/minusnode.gif", + "path_type": "hardlink", + "sha256": "efa5aa1d1e3439ab85425bd2aa3a25b9e6c21309e672690cfb32219e1eb7a7f3", + "sha256_in_prefix": "efa5aa1d1e3439ab85425bd2aa3a25b9e6c21309e672690cfb32219e1eb7a7f3", + "size_in_bytes": 75 + }, + { + "_path": "lib/python3.10/idlelib/Icons/openfolder.gif", + "path_type": "hardlink", + "sha256": "9a59e2abf1840156e9db8f85a38822fd56ab79a139eb95ec86f1fba1bb87326b", + "sha256_in_prefix": "9a59e2abf1840156e9db8f85a38822fd56ab79a139eb95ec86f1fba1bb87326b", + "size_in_bytes": 125 + }, + { + "_path": "lib/python3.10/idlelib/Icons/plusnode.gif", + "path_type": "hardlink", + "sha256": "6ace9e90a2bcb16d06c4d78837137f2c14bc26b3bd9f24b7b6afeadb689bdafb", + "sha256_in_prefix": "6ace9e90a2bcb16d06c4d78837137f2c14bc26b3bd9f24b7b6afeadb689bdafb", + "size_in_bytes": 78 + }, + { + "_path": "lib/python3.10/idlelib/Icons/python.gif", + "path_type": "hardlink", + "sha256": "158c31382f8e5b41fded0c2aa9cc66a382928b003cdd8b5b0518836ad9c89377", + "sha256_in_prefix": "158c31382f8e5b41fded0c2aa9cc66a382928b003cdd8b5b0518836ad9c89377", + "size_in_bytes": 380 + }, + { + "_path": "lib/python3.10/idlelib/Icons/tk.gif", + "path_type": "hardlink", + "sha256": "7f16cb2e322891dbd9101302c09ffda0c2a3a72d053bb8c0927d507414c59cad", + "sha256_in_prefix": "7f16cb2e322891dbd9101302c09ffda0c2a3a72d053bb8c0927d507414c59cad", + "size_in_bytes": 72 + }, + { + "_path": "lib/python3.10/idlelib/NEWS.txt", + "path_type": "hardlink", + "sha256": "2b345c81377c4fa996c814fcf50ae8188c6a0ecfcdafc5c17145c3d5154478fa", + "sha256_in_prefix": "2b345c81377c4fa996c814fcf50ae8188c6a0ecfcdafc5c17145c3d5154478fa", + "size_in_bytes": 54195 + }, + { + "_path": "lib/python3.10/idlelib/NEWS2x.txt", + "path_type": "hardlink", + "sha256": "c89a3b513501ebace8e428aea68dce39d0af9f29196e08fc9ea49c99605e79e7", + "sha256_in_prefix": "c89a3b513501ebace8e428aea68dce39d0af9f29196e08fc9ea49c99605e79e7", + "size_in_bytes": 27172 + }, + { + "_path": "lib/python3.10/idlelib/README.txt", + "path_type": "hardlink", + "sha256": "4f2dc8ffdbfc7837b60edc32ac2f593a220f4abf0ea00cc477382ad8ecf8eb3d", + "sha256_in_prefix": "4f2dc8ffdbfc7837b60edc32ac2f593a220f4abf0ea00cc477382ad8ecf8eb3d", + "size_in_bytes": 11653 + }, + { + "_path": "lib/python3.10/idlelib/TODO.txt", + "path_type": "hardlink", + "sha256": "f88e0fb30fa0ab5d0dc3030442ed92713f34170336c4dd2623723dc34829df89", + "sha256_in_prefix": "f88e0fb30fa0ab5d0dc3030442ed92713f34170336c4dd2623723dc34829df89", + "size_in_bytes": 8478 + }, + { + "_path": "lib/python3.10/idlelib/__init__.py", + "path_type": "hardlink", + "sha256": "3f8058df4fec56eb20ff67ff84c86fd3d9697e2384c5a290ed696f6d3187aa45", + "sha256_in_prefix": "3f8058df4fec56eb20ff67ff84c86fd3d9697e2384c5a290ed696f6d3187aa45", + "size_in_bytes": 396 + }, + { + "_path": "lib/python3.10/idlelib/__main__.py", + "path_type": "hardlink", + "sha256": "f8f55514d26791588de02fe685af0ab129174b32ab93efa39faf6140b6795d9d", + "sha256_in_prefix": "f8f55514d26791588de02fe685af0ab129174b32ab93efa39faf6140b6795d9d", + "size_in_bytes": 159 + }, + { + "_path": "lib/python3.10/idlelib/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "60fdbb4c8b8dc1a4487a108b8c6d4ea4e577210ba8913e769755b133a8d81fa2", + "sha256_in_prefix": "60fdbb4c8b8dc1a4487a108b8c6d4ea4e577210ba8913e769755b133a8d81fa2", + "size_in_bytes": 759 + }, + { + "_path": "lib/python3.10/idlelib/__pycache__/__main__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "96395fec860d1ad45b96dfa920b1997c4a4861fabad18d87b6f012e71c0d4877", + "sha256_in_prefix": "96395fec860d1ad45b96dfa920b1997c4a4861fabad18d87b6f012e71c0d4877", + "size_in_bytes": 520 + }, + { + "_path": "lib/python3.10/idlelib/__pycache__/autocomplete.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c8cc11ee35a7e4badcce8883f1f7469287f5389c7f30ebe5b3c1e0cbd1bf254e", + "sha256_in_prefix": "c8cc11ee35a7e4badcce8883f1f7469287f5389c7f30ebe5b3c1e0cbd1bf254e", + "size_in_bytes": 7383 + }, + { + "_path": "lib/python3.10/idlelib/__pycache__/autocomplete_w.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "2ab60b2bc098cae143b8da5ef6491695c93652774fc6b9cd998635b98c4a6762", + "sha256_in_prefix": "2ab60b2bc098cae143b8da5ef6491695c93652774fc6b9cd998635b98c4a6762", + "size_in_bytes": 11591 + }, + { + "_path": "lib/python3.10/idlelib/__pycache__/autoexpand.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "fb44fee858ad36ecc7279b20760bd1f714633c7fd8484621c5508df4ba5543ae", + "sha256_in_prefix": "fb44fee858ad36ecc7279b20760bd1f714633c7fd8484621c5508df4ba5543ae", + "size_in_bytes": 3101 + }, + { + "_path": "lib/python3.10/idlelib/__pycache__/browser.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c40cdfab622aad4ab2e5566dd5879c8051dc6f76c4f1fc7b095e942bd7eb76d9", + "sha256_in_prefix": "c40cdfab622aad4ab2e5566dd5879c8051dc6f76c4f1fc7b095e942bd7eb76d9", + "size_in_bytes": 9892 + }, + { + "_path": "lib/python3.10/idlelib/__pycache__/calltip.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "43a1418952cab930e0f6aa4e38b43bdf754a674f3c6f741bac9bfb89ccea407b", + "sha256_in_prefix": "43a1418952cab930e0f6aa4e38b43bdf754a674f3c6f741bac9bfb89ccea407b", + "size_in_bytes": 6055 + }, + { + "_path": "lib/python3.10/idlelib/__pycache__/calltip_w.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "b4715304849ddec09de6091bdee996f1d12d54b08efec8b3dd8e25438abad8b7", + "sha256_in_prefix": "b4715304849ddec09de6091bdee996f1d12d54b08efec8b3dd8e25438abad8b7", + "size_in_bytes": 6455 + }, + { + "_path": "lib/python3.10/idlelib/__pycache__/codecontext.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "ee17eaff1c0857773b9109f2999e6e92018a7bfabfa2efd076d9b956f0cf21f5", + "sha256_in_prefix": "ee17eaff1c0857773b9109f2999e6e92018a7bfabfa2efd076d9b956f0cf21f5", + "size_in_bytes": 9193 + }, + { + "_path": "lib/python3.10/idlelib/__pycache__/colorizer.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c19be59231c089984fb8bdee2ea24278d37169d6275530c269cd60eda6bfe0d3", + "sha256_in_prefix": "c19be59231c089984fb8bdee2ea24278d37169d6275530c269cd60eda6bfe0d3", + "size_in_bytes": 11973 + }, + { + "_path": "lib/python3.10/idlelib/__pycache__/config.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "419899138cc94508306250e8dc663d326f0f78b730a66abca14ced1a9da07bfc", + "sha256_in_prefix": "419899138cc94508306250e8dc663d326f0f78b730a66abca14ced1a9da07bfc", + "size_in_bytes": 30614 + }, + { + "_path": "lib/python3.10/idlelib/__pycache__/config_key.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "bdfe46aeb88bbaea568bdf5874aca7cd8ed1b71c2252acf3cac26ff5162df2dc", + "sha256_in_prefix": "bdfe46aeb88bbaea568bdf5874aca7cd8ed1b71c2252acf3cac26ff5162df2dc", + "size_in_bytes": 13075 + }, + { + "_path": "lib/python3.10/idlelib/__pycache__/configdialog.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "d5e1fe66fbe57e4d3ced0b5deee04c0996deeb6d049a1b2328c453ab417384b6", + "sha256_in_prefix": "d5e1fe66fbe57e4d3ced0b5deee04c0996deeb6d049a1b2328c453ab417384b6", + "size_in_bytes": 80378 + }, + { + "_path": "lib/python3.10/idlelib/__pycache__/debugger.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "be579f296df9fdb14ee215a157c6583315cd54c8ba9ab9ba2642bb242dfe4fcd", + "sha256_in_prefix": "be579f296df9fdb14ee215a157c6583315cd54c8ba9ab9ba2642bb242dfe4fcd", + "size_in_bytes": 14386 + }, + { + "_path": "lib/python3.10/idlelib/__pycache__/debugger_r.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "1d9194c0d9c9a47b5c379bae368d7b216771bb6b9021f690d6b18f2c7c2aaf8a", + "sha256_in_prefix": "1d9194c0d9c9a47b5c379bae368d7b216771bb6b9021f690d6b18f2c7c2aaf8a", + "size_in_bytes": 13847 + }, + { + "_path": "lib/python3.10/idlelib/__pycache__/debugobj.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "3de72482064122b4575164ae3c8d40acd2a7d329de049fef98c1a49ef4da6605", + "sha256_in_prefix": "3de72482064122b4575164ae3c8d40acd2a7d329de049fef98c1a49ef4da6605", + "size_in_bytes": 5489 + }, + { + "_path": "lib/python3.10/idlelib/__pycache__/debugobj_r.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "d89f97e76359a9f453efe9cd5263f89b8ec098dd0c214b9b150f84d183a86a01", + "sha256_in_prefix": "d89f97e76359a9f453efe9cd5263f89b8ec098dd0c214b9b150f84d183a86a01", + "size_in_bytes": 2240 + }, + { + "_path": "lib/python3.10/idlelib/__pycache__/delegator.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "35005e32db0e8f1b43bd15b03d38d327b03098c6cedf20d8abc53e9c6082d599", + "sha256_in_prefix": "35005e32db0e8f1b43bd15b03d38d327b03098c6cedf20d8abc53e9c6082d599", + "size_in_bytes": 1545 + }, + { + "_path": "lib/python3.10/idlelib/__pycache__/dynoption.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "98d937523f0ad4b6bf04448a6085c6613d0ffe373201659b2658599c9ceeeb45", + "sha256_in_prefix": "98d937523f0ad4b6bf04448a6085c6613d0ffe373201659b2658599c9ceeeb45", + "size_in_bytes": 2546 + }, + { + "_path": "lib/python3.10/idlelib/__pycache__/editor.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "f888934e9f171870b7bc44041db000879538e26de39247a66eb3c362007b889a", + "sha256_in_prefix": "f888934e9f171870b7bc44041db000879538e26de39247a66eb3c362007b889a", + "size_in_bytes": 47325 + }, + { + "_path": "lib/python3.10/idlelib/__pycache__/filelist.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "1e1ebf945e105e8250b60e14b967a6c088713189479d584c922f1c9ba55ad234", + "sha256_in_prefix": "1e1ebf945e105e8250b60e14b967a6c088713189479d584c922f1c9ba55ad234", + "size_in_bytes": 3700 + }, + { + "_path": "lib/python3.10/idlelib/__pycache__/format.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "ebeefd9dbafbddac7a8c7cee96af0c1c95a12d916b8c80b5297dd60e486d909c", + "sha256_in_prefix": "ebeefd9dbafbddac7a8c7cee96af0c1c95a12d916b8c80b5297dd60e486d909c", + "size_in_bytes": 13772 + }, + { + "_path": "lib/python3.10/idlelib/__pycache__/grep.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "2a4d0edeb1ff77c09a556397e03dbdcf5958022ca480381afcec0418a559ef0f", + "sha256_in_prefix": "2a4d0edeb1ff77c09a556397e03dbdcf5958022ca480381afcec0418a559ef0f", + "size_in_bytes": 8120 + }, + { + "_path": "lib/python3.10/idlelib/__pycache__/help.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "20527c9f852193f30337014be11714a7649c0cd5aaa327c7540875196937fc2c", + "sha256_in_prefix": "20527c9f852193f30337014be11714a7649c0cd5aaa327c7540875196937fc2c", + "size_in_bytes": 10828 + }, + { + "_path": "lib/python3.10/idlelib/__pycache__/help_about.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "69a1c0dea2d9856340c4e294b8dbcfee62c34d597816ca969d35b390121b053a", + "sha256_in_prefix": "69a1c0dea2d9856340c4e294b8dbcfee62c34d597816ca969d35b390121b053a", + "size_in_bytes": 7854 + }, + { + "_path": "lib/python3.10/idlelib/__pycache__/history.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "ef0245c930717969433f6af32696b80fd77413c48df21a549853f5e2d524d3c6", + "sha256_in_prefix": "ef0245c930717969433f6af32696b80fd77413c48df21a549853f5e2d524d3c6", + "size_in_bytes": 3649 + }, + { + "_path": "lib/python3.10/idlelib/__pycache__/hyperparser.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "ae29afb00a5c751f755d439ca34755ac0172d15f611adf254768d0ad2ae47256", + "sha256_in_prefix": "ae29afb00a5c751f755d439ca34755ac0172d15f611adf254768d0ad2ae47256", + "size_in_bytes": 7268 + }, + { + "_path": "lib/python3.10/idlelib/__pycache__/idle.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "4ebe0af8c8044411485831b3a0d1c68ff6d6e1935275677971db0e2e66bf79c2", + "sha256_in_prefix": "4ebe0af8c8044411485831b3a0d1c68ff6d6e1935275677971db0e2e66bf79c2", + "size_in_bytes": 326 + }, + { + "_path": "lib/python3.10/idlelib/__pycache__/iomenu.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "804a9a288d3e2814863aa1b3149e5183f7611c135b086d3f506e8e8fc27944ae", + "sha256_in_prefix": "804a9a288d3e2814863aa1b3149e5183f7611c135b086d3f506e8e8fc27944ae", + "size_in_bytes": 12035 + }, + { + "_path": "lib/python3.10/idlelib/__pycache__/macosx.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "1d46c530233a8c6af608fdcf0189aee185f976f16a828cd396a5e8296cf8d586", + "sha256_in_prefix": "1d46c530233a8c6af608fdcf0189aee185f976f16a828cd396a5e8296cf8d586", + "size_in_bytes": 8054 + }, + { + "_path": "lib/python3.10/idlelib/__pycache__/mainmenu.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "498ec1e22959d872a1965fbd0b6948b0d82aa706dc30eab95f838c65d789f7b5", + "sha256_in_prefix": "498ec1e22959d872a1965fbd0b6948b0d82aa706dc30eab95f838c65d789f7b5", + "size_in_bytes": 3518 + }, + { + "_path": "lib/python3.10/idlelib/__pycache__/multicall.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "14c9470136f97dc9d92bcaab4152fde28797750048966611abf790cff5252c46", + "sha256_in_prefix": "14c9470136f97dc9d92bcaab4152fde28797750048966611abf790cff5252c46", + "size_in_bytes": 14970 + }, + { + "_path": "lib/python3.10/idlelib/__pycache__/outwin.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "6d841be126b82979839f373101ed99032d6629744081f6df0565aef33bcaaf42", + "sha256_in_prefix": "6d841be126b82979839f373101ed99032d6629744081f6df0565aef33bcaaf42", + "size_in_bytes": 6250 + }, + { + "_path": "lib/python3.10/idlelib/__pycache__/parenmatch.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "e8beb23581d791bb64636a7e6f0c86f8c561f6545bd0682a9a37cd7a128d927a", + "sha256_in_prefix": "e8beb23581d791bb64636a7e6f0c86f8c561f6545bd0682a9a37cd7a128d927a", + "size_in_bytes": 6624 + }, + { + "_path": "lib/python3.10/idlelib/__pycache__/pathbrowser.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "963e096daab319a91a84e13eeefe81637d24ad7e2f8462936e65e7bbb20204b2", + "sha256_in_prefix": "963e096daab319a91a84e13eeefe81637d24ad7e2f8462936e65e7bbb20204b2", + "size_in_bytes": 4041 + }, + { + "_path": "lib/python3.10/idlelib/__pycache__/percolator.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "40acdd76eacab8cc249b67b0879d517ddc384a2029b42a05c3c1f728e631a601", + "sha256_in_prefix": "40acdd76eacab8cc249b67b0879d517ddc384a2029b42a05c3c1f728e631a601", + "size_in_bytes": 4239 + }, + { + "_path": "lib/python3.10/idlelib/__pycache__/pyparse.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "2eaa4e8bef8a27ef6bdb54ef4910794c34c2d3a64b492a8388fa87f30e2fa8c9", + "sha256_in_prefix": "2eaa4e8bef8a27ef6bdb54ef4910794c34c2d3a64b492a8388fa87f30e2fa8c9", + "size_in_bytes": 12271 + }, + { + "_path": "lib/python3.10/idlelib/__pycache__/pyshell.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "a3b37bd7433a14404a0c4934f953098d530668dfe0f30bbc084d3ea5fa83412e", + "sha256_in_prefix": "a3b37bd7433a14404a0c4934f953098d530668dfe0f30bbc084d3ea5fa83412e", + "size_in_bytes": 47203 + }, + { + "_path": "lib/python3.10/idlelib/__pycache__/query.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "76c37e7efcaab04ed5e0631e544ba7a1138ba26fdb6dd9ae388198b915367d82", + "sha256_in_prefix": "76c37e7efcaab04ed5e0631e544ba7a1138ba26fdb6dd9ae388198b915367d82", + "size_in_bytes": 13047 + }, + { + "_path": "lib/python3.10/idlelib/__pycache__/redirector.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "07fbc39d76aa40982558420b6fdb8e86db5163dde51429333e331aafc9c05f52", + "sha256_in_prefix": "07fbc39d76aa40982558420b6fdb8e86db5163dde51429333e331aafc9c05f52", + "size_in_bytes": 7050 + }, + { + "_path": "lib/python3.10/idlelib/__pycache__/replace.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "38c877b8f34eed1bce317bda75661490b1d92fdc5c25f0f044118f920cdb9364", + "sha256_in_prefix": "38c877b8f34eed1bce317bda75661490b1d92fdc5c25f0f044118f920cdb9364", + "size_in_bytes": 9742 + }, + { + "_path": "lib/python3.10/idlelib/__pycache__/rpc.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "19284c7d53d93ce28cf46300711213cc9e530801e4bfa7635e7f64074c630263", + "sha256_in_prefix": "19284c7d53d93ce28cf46300711213cc9e530801e4bfa7635e7f64074c630263", + "size_in_bytes": 19777 + }, + { + "_path": "lib/python3.10/idlelib/__pycache__/run.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "a458349db90f56c3412abbde6fd7632d5062ec80aa89b9310a61d4b48c6782a2", + "sha256_in_prefix": "a458349db90f56c3412abbde6fd7632d5062ec80aa89b9310a61d4b48c6782a2", + "size_in_bytes": 19117 + }, + { + "_path": "lib/python3.10/idlelib/__pycache__/runscript.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "0dcaabf75d12207ee028ba77de36fb8f05be6b89230c5646c355d5f6e5f24b1d", + "sha256_in_prefix": "0dcaabf75d12207ee028ba77de36fb8f05be6b89230c5646c355d5f6e5f24b1d", + "size_in_bytes": 7126 + }, + { + "_path": "lib/python3.10/idlelib/__pycache__/scrolledlist.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "620b85fedf9188e6761b269aed83306c2864691a063bee5bb26a3743160ac736", + "sha256_in_prefix": "620b85fedf9188e6761b269aed83306c2864691a063bee5bb26a3743160ac736", + "size_in_bytes": 5573 + }, + { + "_path": "lib/python3.10/idlelib/__pycache__/search.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "7a7bcb8d784354919116311e4bfb4e7593d97658d8e01d859ad29dd5042d381c", + "sha256_in_prefix": "7a7bcb8d784354919116311e4bfb4e7593d97658d8e01d859ad29dd5042d381c", + "size_in_bytes": 6186 + }, + { + "_path": "lib/python3.10/idlelib/__pycache__/searchbase.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "00640954353bcf683505d0da743a8870df31b2b3a16305e2e460e7a42a29d88d", + "sha256_in_prefix": "00640954353bcf683505d0da743a8870df31b2b3a16305e2e460e7a42a29d88d", + "size_in_bytes": 8591 + }, + { + "_path": "lib/python3.10/idlelib/__pycache__/searchengine.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "dc66999dafd19e0990f9bbd446b1dd8c8e3706baa8d34b6d54f94422f63198eb", + "sha256_in_prefix": "dc66999dafd19e0990f9bbd446b1dd8c8e3706baa8d34b6d54f94422f63198eb", + "size_in_bytes": 7025 + }, + { + "_path": "lib/python3.10/idlelib/__pycache__/sidebar.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "41d6c4cd111349500f80912f0ab3d51086eced0deb34b71cded43bcca0bbaa3d", + "sha256_in_prefix": "41d6c4cd111349500f80912f0ab3d51086eced0deb34b71cded43bcca0bbaa3d", + "size_in_bytes": 18153 + }, + { + "_path": "lib/python3.10/idlelib/__pycache__/squeezer.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "0c475cb934b8fd02bbd52814ef262f283f1b7d4ee74f027373597bcd69b0ad8e", + "sha256_in_prefix": "0c475cb934b8fd02bbd52814ef262f283f1b7d4ee74f027373597bcd69b0ad8e", + "size_in_bytes": 9833 + }, + { + "_path": "lib/python3.10/idlelib/__pycache__/stackviewer.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "f84a19f63b5fb60995179963524a1b909b88b968d45f8d75db36cf7e2ca93376", + "sha256_in_prefix": "f84a19f63b5fb60995179963524a1b909b88b968d45f8d75db36cf7e2ca93376", + "size_in_bytes": 5354 + }, + { + "_path": "lib/python3.10/idlelib/__pycache__/statusbar.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c4aaae5cad941d62dfcf0239fe03a3f226dd1357f149d8cf61622368afe1f933", + "sha256_in_prefix": "c4aaae5cad941d62dfcf0239fe03a3f226dd1357f149d8cf61622368afe1f933", + "size_in_bytes": 2250 + }, + { + "_path": "lib/python3.10/idlelib/__pycache__/textview.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "ddb85fe57c2b456b05fb410dcbf2ea5883b4e2704a4e5cbb585c7c98dc84a247", + "sha256_in_prefix": "ddb85fe57c2b456b05fb410dcbf2ea5883b4e2704a4e5cbb585c7c98dc84a247", + "size_in_bytes": 7316 + }, + { + "_path": "lib/python3.10/idlelib/__pycache__/tooltip.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "1a2472d0d8af4f0a4e5f9661892ceced90895f2224024972712ba30489f91438", + "sha256_in_prefix": "1a2472d0d8af4f0a4e5f9661892ceced90895f2224024972712ba30489f91438", + "size_in_bytes": 6840 + }, + { + "_path": "lib/python3.10/idlelib/__pycache__/tree.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "a434275ef5e3ffb9e1b4ab1dc6e61f8762bb517d597791f6180a705a657284ba", + "sha256_in_prefix": "a434275ef5e3ffb9e1b4ab1dc6e61f8762bb517d597791f6180a705a657284ba", + "size_in_bytes": 15841 + }, + { + "_path": "lib/python3.10/idlelib/__pycache__/undo.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "6d564454dfc0f05e528fa7caeb00933c3ce61345accf3d600bd62c4891412694", + "sha256_in_prefix": "6d564454dfc0f05e528fa7caeb00933c3ce61345accf3d600bd62c4891412694", + "size_in_bytes": 10975 + }, + { + "_path": "lib/python3.10/idlelib/__pycache__/util.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "e72ca7704749eef78e4178cec7ab31c059807513d61cf79058cbb375cfb38f54", + "sha256_in_prefix": "e72ca7704749eef78e4178cec7ab31c059807513d61cf79058cbb375cfb38f54", + "size_in_bytes": 1032 + }, + { + "_path": "lib/python3.10/idlelib/__pycache__/window.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "521138abde0285f54bee7a61775760d279795e9f9eada87e1df8bdd0e024dae6", + "sha256_in_prefix": "521138abde0285f54bee7a61775760d279795e9f9eada87e1df8bdd0e024dae6", + "size_in_bytes": 3488 + }, + { + "_path": "lib/python3.10/idlelib/__pycache__/zoomheight.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "fd8ac3630181438c44ef7a8722074537680c1e497f15ab1f5c25eceb2a24df12", + "sha256_in_prefix": "fd8ac3630181438c44ef7a8722074537680c1e497f15ab1f5c25eceb2a24df12", + "size_in_bytes": 3092 + }, + { + "_path": "lib/python3.10/idlelib/__pycache__/zzdummy.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "96937ed75ff51cf087334f5fe39e14799413d40410d704e9bcf3c6b1ee5110f8", + "sha256_in_prefix": "96937ed75ff51cf087334f5fe39e14799413d40410d704e9bcf3c6b1ee5110f8", + "size_in_bytes": 2735 + }, + { + "_path": "lib/python3.10/idlelib/autocomplete.py", + "path_type": "hardlink", + "sha256": "0d36f7694a50cbaa22d9bf03b91fa0658a147bd90dd867714a9b411febb36427", + "sha256_in_prefix": "0d36f7694a50cbaa22d9bf03b91fa0658a147bd90dd867714a9b411febb36427", + "size_in_bytes": 9354 + }, + { + "_path": "lib/python3.10/idlelib/autocomplete_w.py", + "path_type": "hardlink", + "sha256": "2f05996827309ef6147f8b888352a1b9911678e70dc9046bd5363dab7733a329", + "sha256_in_prefix": "2f05996827309ef6147f8b888352a1b9911678e70dc9046bd5363dab7733a329", + "size_in_bytes": 21097 + }, + { + "_path": "lib/python3.10/idlelib/autoexpand.py", + "path_type": "hardlink", + "sha256": "c8eb28ef7addf5a664a7e3addfbfebe29040a8695e1db515828305aacba2ee4e", + "sha256_in_prefix": "c8eb28ef7addf5a664a7e3addfbfebe29040a8695e1db515828305aacba2ee4e", + "size_in_bytes": 3216 + }, + { + "_path": "lib/python3.10/idlelib/browser.py", + "path_type": "hardlink", + "sha256": "bd656af7051ed0aa83529ceccff4a3dc8c44ea94e6c1ca28e17e89f998020f6a", + "sha256_in_prefix": "bd656af7051ed0aa83529ceccff4a3dc8c44ea94e6c1ca28e17e89f998020f6a", + "size_in_bytes": 8586 + }, + { + "_path": "lib/python3.10/idlelib/calltip.py", + "path_type": "hardlink", + "sha256": "3a723fdf88c0018dfadd19757142a643b01b785c6df17a50bbe21463663ab590", + "sha256_in_prefix": "3a723fdf88c0018dfadd19757142a643b01b785c6df17a50bbe21463663ab590", + "size_in_bytes": 7267 + }, + { + "_path": "lib/python3.10/idlelib/calltip_w.py", + "path_type": "hardlink", + "sha256": "f60fde563751ad8d77dfcd892558d6c4306764d9affade5018147e84c7246900", + "sha256_in_prefix": "f60fde563751ad8d77dfcd892558d6c4306764d9affade5018147e84c7246900", + "size_in_bytes": 7158 + }, + { + "_path": "lib/python3.10/idlelib/codecontext.py", + "path_type": "hardlink", + "sha256": "628a13325b3bf2f76dea9254b20178b3232261f83c660f0e33785e6215dd6492", + "sha256_in_prefix": "628a13325b3bf2f76dea9254b20178b3232261f83c660f0e33785e6215dd6492", + "size_in_bytes": 11420 + }, + { + "_path": "lib/python3.10/idlelib/colorizer.py", + "path_type": "hardlink", + "sha256": "74ed1bf4c7053d42d37e786969414fcb4dfc648f22430a361720ed8f877d3293", + "sha256_in_prefix": "74ed1bf4c7053d42d37e786969414fcb4dfc648f22430a361720ed8f877d3293", + "size_in_bytes": 14773 + }, + { + "_path": "lib/python3.10/idlelib/config-extensions.def", + "path_type": "hardlink", + "sha256": "e75df0b77ff61253be457af636d5eb7c55a3ff2b6a733beea844d2b294972ebf", + "sha256_in_prefix": "e75df0b77ff61253be457af636d5eb7c55a3ff2b6a733beea844d2b294972ebf", + "size_in_bytes": 2266 + }, + { + "_path": "lib/python3.10/idlelib/config-highlight.def", + "path_type": "hardlink", + "sha256": "609eada44ff4aa9d5cd10ad8b4c29bb76db8ebc74912a0ae86f5ea3cd19b7547", + "sha256_in_prefix": "609eada44ff4aa9d5cd10ad8b4c29bb76db8ebc74912a0ae86f5ea3cd19b7547", + "size_in_bytes": 2864 + }, + { + "_path": "lib/python3.10/idlelib/config-keys.def", + "path_type": "hardlink", + "sha256": "bee81ba5c5abec1e35e313268f8d8fe72d305d0ad73abfba3d2ea1e2b2308710", + "sha256_in_prefix": "bee81ba5c5abec1e35e313268f8d8fe72d305d0ad73abfba3d2ea1e2b2308710", + "size_in_bytes": 10910 + }, + { + "_path": "lib/python3.10/idlelib/config-main.def", + "path_type": "hardlink", + "sha256": "e783704ad5cd9b3f44c026f55c98be2c52190bf9b7832251283f3e953ba80f87", + "sha256_in_prefix": "e783704ad5cd9b3f44c026f55c98be2c52190bf9b7832251283f3e953ba80f87", + "size_in_bytes": 3168 + }, + { + "_path": "lib/python3.10/idlelib/config.py", + "path_type": "hardlink", + "sha256": "533a7d9cc6eef591f65fc9357df533604ca93a47051846482d554de60f40b9e5", + "sha256_in_prefix": "533a7d9cc6eef591f65fc9357df533604ca93a47051846482d554de60f40b9e5", + "size_in_bytes": 38174 + }, + { + "_path": "lib/python3.10/idlelib/config_key.py", + "path_type": "hardlink", + "sha256": "b4184b23a1cb5e128701b65d95f1ed8c0e7f56867eac1e70c9b2a79b00ae682b", + "sha256_in_prefix": "b4184b23a1cb5e128701b65d95f1ed8c0e7f56867eac1e70c9b2a79b00ae682b", + "size_in_bytes": 15230 + }, + { + "_path": "lib/python3.10/idlelib/configdialog.py", + "path_type": "hardlink", + "sha256": "f09aeb0c344210574a4c7fa641b78d058ccd1c387b627f8b99db90bb94029dde", + "sha256_in_prefix": "f09aeb0c344210574a4c7fa641b78d058ccd1c387b627f8b99db90bb94029dde", + "size_in_bytes": 105728 + }, + { + "_path": "lib/python3.10/idlelib/debugger.py", + "path_type": "hardlink", + "sha256": "126415c89631586d2f51931274a2d8c3dde2c9a4132e8a1f6954c97de78aa417", + "sha256_in_prefix": "126415c89631586d2f51931274a2d8c3dde2c9a4132e8a1f6954c97de78aa417", + "size_in_bytes": 19104 + }, + { + "_path": "lib/python3.10/idlelib/debugger_r.py", + "path_type": "hardlink", + "sha256": "ca94d058b89af51dbad41ae8b7e20973fdaa0c31e1fb29b141499e6339d29f55", + "sha256_in_prefix": "ca94d058b89af51dbad41ae8b7e20973fdaa0c31e1fb29b141499e6339d29f55", + "size_in_bytes": 12167 + }, + { + "_path": "lib/python3.10/idlelib/debugobj.py", + "path_type": "hardlink", + "sha256": "db8add0abc885fc629c6746aca77cd40026b2dac8d7edb93f1fcf6ea9d28334f", + "sha256_in_prefix": "db8add0abc885fc629c6746aca77cd40026b2dac8d7edb93f1fcf6ea9d28334f", + "size_in_bytes": 4055 + }, + { + "_path": "lib/python3.10/idlelib/debugobj_r.py", + "path_type": "hardlink", + "sha256": "4e583b43fdf9bd4a731d70e074ee597aba03f3c8c36302bdc7e74650fb1fcc11", + "sha256_in_prefix": "4e583b43fdf9bd4a731d70e074ee597aba03f3c8c36302bdc7e74650fb1fcc11", + "size_in_bytes": 1082 + }, + { + "_path": "lib/python3.10/idlelib/delegator.py", + "path_type": "hardlink", + "sha256": "3b79bbd9ef3bc789559f5af7b0c844d5292ae02368d167dd5751ead2343109d5", + "sha256_in_prefix": "3b79bbd9ef3bc789559f5af7b0c844d5292ae02368d167dd5751ead2343109d5", + "size_in_bytes": 1043 + }, + { + "_path": "lib/python3.10/idlelib/dynoption.py", + "path_type": "hardlink", + "sha256": "c8a26c028d87253f0317ef79c7490ef08eb7ed02034328abb8dedb30ca61c199", + "sha256_in_prefix": "c8a26c028d87253f0317ef79c7490ef08eb7ed02034328abb8dedb30ca61c199", + "size_in_bytes": 1991 + }, + { + "_path": "lib/python3.10/idlelib/editor.py", + "path_type": "hardlink", + "sha256": "2d9010e59ffce802d6f5ec40bc178a3cc168ac9518a61ee89796c5382e86aed8", + "sha256_in_prefix": "2d9010e59ffce802d6f5ec40bc178a3cc168ac9518a61ee89796c5382e86aed8", + "size_in_bytes": 66385 + }, + { + "_path": "lib/python3.10/idlelib/extend.txt", + "path_type": "hardlink", + "sha256": "5bceaf660c46faf8f9fbf2be5e23389d6e6477d1e458fee680e606bcc95d2853", + "sha256_in_prefix": "5bceaf660c46faf8f9fbf2be5e23389d6e6477d1e458fee680e606bcc95d2853", + "size_in_bytes": 3631 + }, + { + "_path": "lib/python3.10/idlelib/filelist.py", + "path_type": "hardlink", + "sha256": "b2923b72d89db91bda3abdfc9a7a42789e4a20a70f4ff8cab0a737995249f0d3", + "sha256_in_prefix": "b2923b72d89db91bda3abdfc9a7a42789e4a20a70f4ff8cab0a737995249f0d3", + "size_in_bytes": 3876 + }, + { + "_path": "lib/python3.10/idlelib/format.py", + "path_type": "hardlink", + "sha256": "dc2b00fb239f38543bf973d94daef2c52457b905d4d89c640993823127b7923c", + "sha256_in_prefix": "dc2b00fb239f38543bf973d94daef2c52457b905d4d89c640993823127b7923c", + "size_in_bytes": 15777 + }, + { + "_path": "lib/python3.10/idlelib/grep.py", + "path_type": "hardlink", + "sha256": "fb50ba574b03745100cdaed82ae64105baac6a43cfb52ed4af5e7c2a9579ee9f", + "sha256_in_prefix": "fb50ba574b03745100cdaed82ae64105baac6a43cfb52ed4af5e7c2a9579ee9f", + "size_in_bytes": 7479 + }, + { + "_path": "lib/python3.10/idlelib/help.html", + "path_type": "hardlink", + "sha256": "0561d384ebee70e8bd3d7beeca4902a57b723f500a4a3f45fc7cbf506b04ac66", + "sha256_in_prefix": "0561d384ebee70e8bd3d7beeca4902a57b723f500a4a3f45fc7cbf506b04ac66", + "size_in_bytes": 79125 + }, + { + "_path": "lib/python3.10/idlelib/help.py", + "path_type": "hardlink", + "sha256": "5016f926ffee9ac3b9e07f76d5d4ee3d770fdffc865f2e1d90e9edd0bf642485", + "sha256_in_prefix": "5016f926ffee9ac3b9e07f76d5d4ee3d770fdffc865f2e1d90e9edd0bf642485", + "size_in_bytes": 11855 + }, + { + "_path": "lib/python3.10/idlelib/help_about.py", + "path_type": "hardlink", + "sha256": "527dc9c6dcea4ffef3e775c6cfea98d1df200f903e1f5e94459f4c552661509f", + "sha256_in_prefix": "527dc9c6dcea4ffef3e775c6cfea98d1df200f903e1f5e94459f4c552661509f", + "size_in_bytes": 9106 + }, + { + "_path": "lib/python3.10/idlelib/history.py", + "path_type": "hardlink", + "sha256": "3a87611a95f1efc7fdd265e1b43eec7ad21ebe8047cf5a5a3365ffafe940c6ad", + "sha256_in_prefix": "3a87611a95f1efc7fdd265e1b43eec7ad21ebe8047cf5a5a3365ffafe940c6ad", + "size_in_bytes": 4064 + }, + { + "_path": "lib/python3.10/idlelib/hyperparser.py", + "path_type": "hardlink", + "sha256": "18563d2b4c248aed70b7f29fd903fd51d1b5aceb3dc93c23f9a54141eed7a9b0", + "sha256_in_prefix": "18563d2b4c248aed70b7f29fd903fd51d1b5aceb3dc93c23f9a54141eed7a9b0", + "size_in_bytes": 12889 + }, + { + "_path": "lib/python3.10/idlelib/idle.bat", + "path_type": "hardlink", + "sha256": "15a3977f0d2c6a8e87db2ef7050ea10afb3a88b064bf5ef95439924e42464114", + "sha256_in_prefix": "15a3977f0d2c6a8e87db2ef7050ea10afb3a88b064bf5ef95439924e42464114", + "size_in_bytes": 177 + }, + { + "_path": "lib/python3.10/idlelib/idle.py", + "path_type": "hardlink", + "sha256": "33ffa2f718e123fd1c4e536bb4a471978515787ee9fbf7806a92073a787a733a", + "sha256_in_prefix": "33ffa2f718e123fd1c4e536bb4a471978515787ee9fbf7806a92073a787a733a", + "size_in_bytes": 454 + }, + { + "_path": "lib/python3.10/idlelib/idle.pyw", + "path_type": "hardlink", + "sha256": "26101d297127132c5e9634499f41ad00e125ea308343a20b278bee9e9225eb5c", + "sha256_in_prefix": "26101d297127132c5e9634499f41ad00e125ea308343a20b278bee9e9225eb5c", + "size_in_bytes": 570 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/README.txt", + "path_type": "hardlink", + "sha256": "bfe6188362a0bc7db8b94c3dd313b97c83ad6d10b79451fd2a8a4bd773cd392b", + "sha256_in_prefix": "bfe6188362a0bc7db8b94c3dd313b97c83ad6d10b79451fd2a8a4bd773cd392b", + "size_in_bytes": 8729 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__init__.py", + "path_type": "hardlink", + "sha256": "228f8efbf4c316bd701b09a72b084a08248e26a346c6a7636a142391a8b3e674", + "sha256_in_prefix": "228f8efbf4c316bd701b09a72b084a08248e26a346c6a7636a142391a8b3e674", + "size_in_bytes": 712 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "536bcb2ea46adf49d286c2b231bba9a8781b8cf0e4e1e6c81cc6e21cb68a248d", + "sha256_in_prefix": "536bcb2ea46adf49d286c2b231bba9a8781b8cf0e4e1e6c81cc6e21cb68a248d", + "size_in_bytes": 1106 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/htest.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "fe4d519fa20c070839320608e12b97d790a4042f5959469543a91a88d3fcf5f4", + "sha256_in_prefix": "fe4d519fa20c070839320608e12b97d790a4042f5959469543a91a88d3fcf5f4", + "size_in_bytes": 14197 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/mock_idle.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "cf8dd4edb5dd08cf0154edebc0ad5dc385dc91062065de8c8762099dd3ef1bee", + "sha256_in_prefix": "cf8dd4edb5dd08cf0154edebc0ad5dc385dc91062065de8c8762099dd3ef1bee", + "size_in_bytes": 2891 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/mock_tk.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "8122bf0ca5d5238c2fff6dd87077bcfbf8e9864bc3c4ee5ac069d6a50e61c648", + "sha256_in_prefix": "8122bf0ca5d5238c2fff6dd87077bcfbf8e9864bc3c4ee5ac069d6a50e61c648", + "size_in_bytes": 11078 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/template.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "248902a31f5c5907adeeec4574e416334b8f4b30972b66276d44caa0803613a4", + "sha256_in_prefix": "248902a31f5c5907adeeec4574e416334b8f4b30972b66276d44caa0803613a4", + "size_in_bytes": 1323 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/test_autocomplete.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "22dd4a32f2e80d8e64d4898f6ed84755d9dd1f14acd76393efe6ba1ad944e269", + "sha256_in_prefix": "22dd4a32f2e80d8e64d4898f6ed84755d9dd1f14acd76393efe6ba1ad944e269", + "size_in_bytes": 10019 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/test_autocomplete_w.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "1e2e0d15b2fdafeb88883e6780c699a229541fa77d1f52ce66601008d4e5c70c", + "sha256_in_prefix": "1e2e0d15b2fdafeb88883e6780c699a229541fa77d1f52ce66601008d4e5c70c", + "size_in_bytes": 1583 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/test_autoexpand.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "98847eb575ddba74b6b9dcbcf99585dead1080ee3b09d4b12d80bc3e706061dc", + "sha256_in_prefix": "98847eb575ddba74b6b9dcbcf99585dead1080ee3b09d4b12d80bc3e706061dc", + "size_in_bytes": 4221 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/test_browser.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "6b829ff9c3f060c1a974dfa8bf257b7583b6382ac8e09cfbcf58bece1a6dfa76", + "sha256_in_prefix": "6b829ff9c3f060c1a974dfa8bf257b7583b6382ac8e09cfbcf58bece1a6dfa76", + "size_in_bytes": 9697 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/test_calltip.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "d661f3e68ea484cec6b568a42df66b0280f3b42179a574f40bc3298456a244c0", + "sha256_in_prefix": "d661f3e68ea484cec6b568a42df66b0280f3b42179a574f40bc3298456a244c0", + "size_in_bytes": 18829 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/test_calltip_w.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "20dff599e8f90076c07fc96066b5dbb20746795741d7c9364b28615dc4672f00", + "sha256_in_prefix": "20dff599e8f90076c07fc96066b5dbb20746795741d7c9364b28615dc4672f00", + "size_in_bytes": 1523 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/test_codecontext.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "6d6b71bd183427a6706ca51cfb98420bb8afda2806f2b5a8b2d8639083f57aac", + "sha256_in_prefix": "6d6b71bd183427a6706ca51cfb98420bb8afda2806f2b5a8b2d8639083f57aac", + "size_in_bytes": 11555 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/test_colorizer.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "f8245b2f7bcb2624e252775539d8b3fc6b4375c2fba2f2ecf1708d13483db5ce", + "sha256_in_prefix": "f8245b2f7bcb2624e252775539d8b3fc6b4375c2fba2f2ecf1708d13483db5ce", + "size_in_bytes": 17031 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/test_config.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "ee94691f84da6e141486d85120455628d57e71257121e07e924c1f97ddb9af10", + "sha256_in_prefix": "ee94691f84da6e141486d85120455628d57e71257121e07e924c1f97ddb9af10", + "size_in_bytes": 24933 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/test_config_key.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "925cc599d8c2a3675838e3b2548ab8e340d925af35394f3146b91b59a9a796c1", + "sha256_in_prefix": "925cc599d8c2a3675838e3b2548ab8e340d925af35394f3146b91b59a9a796c1", + "size_in_bytes": 12375 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/test_configdialog.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "0abf3da08a690f319f1dccb2b17fbc020e32270287122d7666a31cd1d343e1df", + "sha256_in_prefix": "0abf3da08a690f319f1dccb2b17fbc020e32270287122d7666a31cd1d343e1df", + "size_in_bytes": 40590 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/test_debugger.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "247a1b2845fe7ce943bd67ab7d759af1bdf7906cb182a504df97014a5b5c595e", + "sha256_in_prefix": "247a1b2845fe7ce943bd67ab7d759af1bdf7906cb182a504df97014a5b5c595e", + "size_in_bytes": 1365 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/test_debugger_r.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "541fc620a845a6a6e998ecefac6dc360a809f813333e790faba4b1c036d70d25", + "sha256_in_prefix": "541fc620a845a6a6e998ecefac6dc360a809f813333e790faba4b1c036d70d25", + "size_in_bytes": 1367 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/test_debugobj.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "59670f1def2ed9da23d1fe5ce69a7620823b02f5b5a44c85169dfc12299aa51f", + "sha256_in_prefix": "59670f1def2ed9da23d1fe5ce69a7620823b02f5b5a44c85169dfc12299aa51f", + "size_in_bytes": 2818 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/test_debugobj_r.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "b6c6164504c9053d8b12d27e14aa123b890bdc618be1955adea96eb197b99770", + "sha256_in_prefix": "b6c6164504c9053d8b12d27e14aa123b890bdc618be1955adea96eb197b99770", + "size_in_bytes": 1354 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/test_delegator.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "63d4443b0f7524fdb53e0ded8e0057e7f60a90af0be0306c1adc60681740bb5a", + "sha256_in_prefix": "63d4443b0f7524fdb53e0ded8e0057e7f60a90af0be0306c1adc60681740bb5a", + "size_in_bytes": 1335 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/test_editmenu.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "2125e91fc328f7399226cbb163d3f05dc5f87b50056504a851b561069d4706fe", + "sha256_in_prefix": "2125e91fc328f7399226cbb163d3f05dc5f87b50056504a851b561069d4706fe", + "size_in_bytes": 3062 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/test_editor.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "d23cb5d9922818be5eccd3bb0fa6b46acbaf58ab3f246a58c8ec0470116b0ebb", + "sha256_in_prefix": "d23cb5d9922818be5eccd3bb0fa6b46acbaf58ab3f246a58c8ec0470116b0ebb", + "size_in_bytes": 6448 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/test_filelist.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "f97e42a3b79a9f2fa244072b30c9d7a9646f4c42edf462308f36d1b0ec4d5b81", + "sha256_in_prefix": "f97e42a3b79a9f2fa244072b30c9d7a9646f4c42edf462308f36d1b0ec4d5b81", + "size_in_bytes": 1585 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/test_format.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c91189d7a55dd152557a59c453a360043f9eb67233acb4c23e8e4f5d388903af", + "sha256_in_prefix": "c91189d7a55dd152557a59c453a360043f9eb67233acb4c23e8e4f5d388903af", + "size_in_bytes": 20565 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/test_grep.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "e2cfdaf11c1cc6cd5b712ee9d7c9d4e822c2c29871c8b751eabc8f6c55e49e33", + "sha256_in_prefix": "e2cfdaf11c1cc6cd5b712ee9d7c9d4e822c2c29871c8b751eabc8f6c55e49e33", + "size_in_bytes": 5254 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/test_help.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "5b86eb73c9e98a175f119f9c7a390dbd7efa22075520de053667d3716d2b6896", + "sha256_in_prefix": "5b86eb73c9e98a175f119f9c7a390dbd7efa22075520de053667d3716d2b6896", + "size_in_bytes": 1681 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/test_help_about.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "108e020d7ea353857c9bbabb1b42a1cbcd0132bcdd34ba57bc25887050b67567", + "sha256_in_prefix": "108e020d7ea353857c9bbabb1b42a1cbcd0132bcdd34ba57bc25887050b67567", + "size_in_bytes": 6830 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/test_history.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "1c0ed3efc0c444fd36639919c7355ecddef994d765ff74883b2b3ed2ad1db615", + "sha256_in_prefix": "1c0ed3efc0c444fd36639919c7355ecddef994d765ff74883b2b3ed2ad1db615", + "size_in_bytes": 6574 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/test_hyperparser.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "9bcbe811bb07ac287939253a13303e41abad9a3201b983e3da60556fac6bc9be", + "sha256_in_prefix": "9bcbe811bb07ac287939253a13303e41abad9a3201b983e3da60556fac6bc9be", + "size_in_bytes": 7618 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/test_iomenu.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "e309aec656546fe3551b18e8ce5af82b612733dc0cdd59256ffb8a18902a1a07", + "sha256_in_prefix": "e309aec656546fe3551b18e8ce5af82b612733dc0cdd59256ffb8a18902a1a07", + "size_in_bytes": 3307 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/test_macosx.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "7c99a181de25dbbdd0936d06fdde71d71ebc85295b553d65c76ab812fafb044a", + "sha256_in_prefix": "7c99a181de25dbbdd0936d06fdde71d71ebc85295b553d65c76ab812fafb044a", + "size_in_bytes": 4563 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/test_mainmenu.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "a5eb5ec4a7624534a07c4123378ebe71f19d49dcffd1ed44368a7ec7e4dd7236", + "sha256_in_prefix": "a5eb5ec4a7624534a07c4123378ebe71f19d49dcffd1ed44368a7ec7e4dd7236", + "size_in_bytes": 2114 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/test_multicall.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "e5229f1782d6a3b1a8776f1c771bdf2195e09eb207a59a7b621833707b7d1860", + "sha256_in_prefix": "e5229f1782d6a3b1a8776f1c771bdf2195e09eb207a59a7b621833707b7d1860", + "size_in_bytes": 2034 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/test_outwin.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "1e154854731744d547bf24d1ed110bd3081ab4939315aa380e7dc291bad9e2c4", + "sha256_in_prefix": "1e154854731744d547bf24d1ed110bd3081ab4939315aa380e7dc291bad9e2c4", + "size_in_bytes": 5595 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/test_parenmatch.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "4f45ad4cde2d195d55aad7b0707bb7754935774e5f8ceb20bce12b26fe39f85c", + "sha256_in_prefix": "4f45ad4cde2d195d55aad7b0707bb7754935774e5f8ceb20bce12b26fe39f85c", + "size_in_bytes": 4130 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/test_pathbrowser.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "1cc856c1c2d2f98f42ccbbb9f0e777cdfffbeca0e0239544a679425e9798a07f", + "sha256_in_prefix": "1cc856c1c2d2f98f42ccbbb9f0e777cdfffbeca0e0239544a679425e9798a07f", + "size_in_bytes": 3572 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/test_percolator.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "1096de60b1c1b906e236a1c2af4bf9e907c13226cb77e9ae926ff96460531642", + "sha256_in_prefix": "1096de60b1c1b906e236a1c2af4bf9e907c13226cb77e9ae926ff96460531642", + "size_in_bytes": 5112 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/test_pyparse.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "88d1cc40802111b1537e1fee36e58a483cfcb268aa0ba8f0d0eb5bcad676539a", + "sha256_in_prefix": "88d1cc40802111b1537e1fee36e58a483cfcb268aa0ba8f0d0eb5bcad676539a", + "size_in_bytes": 13955 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/test_pyshell.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "b0678afe797c935bf634aeff8076498871f0b4e7ca7d885dc2746eaa50530738", + "sha256_in_prefix": "b0678afe797c935bf634aeff8076498871f0b4e7ca7d885dc2746eaa50530738", + "size_in_bytes": 5723 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/test_query.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "4a37b59fca2ef7446d65bbdb5bcb3ca5a888ea4b9f7067ef35b4d7e34783ab09", + "sha256_in_prefix": "4a37b59fca2ef7446d65bbdb5bcb3ca5a888ea4b9f7067ef35b4d7e34783ab09", + "size_in_bytes": 18969 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/test_redirector.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "95e2357e6a3036068393998a00f4779f96906c2b5261953491247c438a22342f", + "sha256_in_prefix": "95e2357e6a3036068393998a00f4779f96906c2b5261953491247c438a22342f", + "size_in_bytes": 5349 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/test_replace.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "4558a38863be179c0fea38e642b970706fee1dfeb9b81baf737e87cbae11eed9", + "sha256_in_prefix": "4558a38863be179c0fea38e642b970706fee1dfeb9b81baf737e87cbae11eed9", + "size_in_bytes": 7124 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/test_rpc.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "b1f7a72785ba830faf757c4ebe0d58acec49c66c9e20423b74ff00ca481e056f", + "sha256_in_prefix": "b1f7a72785ba830faf757c4ebe0d58acec49c66c9e20423b74ff00ca481e056f", + "size_in_bytes": 1902 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/test_run.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "81827011d4ee162b6ebdfc89a5b5fb4fa3d397a3bf95c72f47518fa7690d7148", + "sha256_in_prefix": "81827011d4ee162b6ebdfc89a5b5fb4fa3d397a3bf95c72f47518fa7690d7148", + "size_in_bytes": 15444 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/test_runscript.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "dd14f1be69ab5dad8017826873b4f9ab7bfaa406652f241b4126d5bf077560bf", + "sha256_in_prefix": "dd14f1be69ab5dad8017826873b4f9ab7bfaa406652f241b4126d5bf077560bf", + "size_in_bytes": 1590 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/test_scrolledlist.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "b01d3927b7a4ed488d533930fa85a3f95303ce4dc0965fa92ab0bce02168df1c", + "sha256_in_prefix": "b01d3927b7a4ed488d533930fa85a3f95303ce4dc0965fa92ab0bce02168df1c", + "size_in_bytes": 1356 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/test_search.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "496ae962cb43004a826ea5941e27c58b66ed263552f928dd9c58637845d1789a", + "sha256_in_prefix": "496ae962cb43004a826ea5941e27c58b66ed263552f928dd9c58637845d1789a", + "size_in_bytes": 2745 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/test_searchbase.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "842b051fd584630d069c50c522337ed7e6c3effc9e660d458fd364c8154fa123", + "sha256_in_prefix": "842b051fd584630d069c50c522337ed7e6c3effc9e660d458fd364c8154fa123", + "size_in_bytes": 5598 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/test_searchengine.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "9297789408a08bfbb9eecf81c444ea1e0b2cc22866a61a53d02036f9da30137a", + "sha256_in_prefix": "9297789408a08bfbb9eecf81c444ea1e0b2cc22866a61a53d02036f9da30137a", + "size_in_bytes": 9638 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/test_sidebar.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "ca450d551ebda7dea40b2196fa0930506a012db51c0e831d38ec51a3365a18b9", + "sha256_in_prefix": "ca450d551ebda7dea40b2196fa0930506a012db51c0e831d38ec51a3365a18b9", + "size_in_bytes": 24820 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/test_squeezer.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "18cd4577760ee7de0f41c6c0e90eb05e6182c98b0d2154a9da3b1071aa6e657e", + "sha256_in_prefix": "18cd4577760ee7de0f41c6c0e90eb05e6182c98b0d2154a9da3b1071aa6e657e", + "size_in_bytes": 15950 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/test_stackviewer.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "a67cd6c2e7688a9e4b70ae5467858c3e7a6ac5b5a38eee4c162ae78bd905f55e", + "sha256_in_prefix": "a67cd6c2e7688a9e4b70ae5467858c3e7a6ac5b5a38eee4c162ae78bd905f55e", + "size_in_bytes": 1811 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/test_statusbar.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "7376a2704e72402edf0dfd951a30b4ad1336b2cc24dd607e22414ba0e65e8a5d", + "sha256_in_prefix": "7376a2704e72402edf0dfd951a30b4ad1336b2cc24dd607e22414ba0e65e8a5d", + "size_in_bytes": 1838 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/test_text.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "b8a7b06c73010b909a55d7494e0eec4fdbd86fd38bfea5b2c44323c5c2ccc927", + "sha256_in_prefix": "b8a7b06c73010b909a55d7494e0eec4fdbd86fd38bfea5b2c44323c5c2ccc927", + "size_in_bytes": 6524 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/test_textview.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "6507b26cae9202f04b34b4171e233ece12d20f13a67785c349f1cbf35c44e8a2", + "sha256_in_prefix": "6507b26cae9202f04b34b4171e233ece12d20f13a67785c349f1cbf35c44e8a2", + "size_in_bytes": 9422 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/test_tooltip.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "91b435283e45e06c17cb3f98224bf61630c20e15e076fbdbe3e6bd23ab7fdbe1", + "sha256_in_prefix": "91b435283e45e06c17cb3f98224bf61630c20e15e076fbdbe3e6bd23ab7fdbe1", + "size_in_bytes": 5448 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/test_tree.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "44efd8d8e54b552e64c1cb09378caf9e53fa3a4cdfec78bdc73859fce8f15828", + "sha256_in_prefix": "44efd8d8e54b552e64c1cb09378caf9e53fa3a4cdfec78bdc73859fce8f15828", + "size_in_bytes": 2949 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/test_undo.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "07d9bdb01eca4d177cc342eb676cb2467d2d8b36c75af5557d3205759d22701a", + "sha256_in_prefix": "07d9bdb01eca4d177cc342eb676cb2467d2d8b36c75af5557d3205759d22701a", + "size_in_bytes": 4418 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/test_util.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "50439a850b4ea089785b58d2999516da96363260ab1227319dd62aca44fd0af9", + "sha256_in_prefix": "50439a850b4ea089785b58d2999516da96363260ab1227319dd62aca44fd0af9", + "size_in_bytes": 954 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/test_warning.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c69c2720f0a04b95081f9513b1e595c0954d6245d4e7f37f7f32fed28f48ab66", + "sha256_in_prefix": "c69c2720f0a04b95081f9513b1e595c0954d6245d4e7f37f7f32fed28f48ab66", + "size_in_bytes": 2766 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/test_window.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "47e965392ad17e8f0596941ab785c8f311f4ec474ea49a1ace3b15609a1ba2bb", + "sha256_in_prefix": "47e965392ad17e8f0596941ab785c8f311f4ec474ea49a1ace3b15609a1ba2bb", + "size_in_bytes": 1891 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/test_zoomheight.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "0fb3f4c161c3d1b70252093ed20e1f05b8ca877a5a5a97b94ba710cc915392e4", + "sha256_in_prefix": "0fb3f4c161c3d1b70252093ed20e1f05b8ca877a5a5a97b94ba710cc915392e4", + "size_in_bytes": 1780 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/test_zzdummy.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "f7ad93e7ef728fb79d982374876e735bd2f5dcdb8052c9d328b0a6ca7fb18a11", + "sha256_in_prefix": "f7ad93e7ef728fb79d982374876e735bd2f5dcdb8052c9d328b0a6ca7fb18a11", + "size_in_bytes": 4766 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/tkinter_testing_utils.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "249addc02b7797c461e3643a6d74298a08d5c40a7511faec912a58b563bd3dff", + "sha256_in_prefix": "249addc02b7797c461e3643a6d74298a08d5c40a7511faec912a58b563bd3dff", + "size_in_bytes": 2436 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/example_noext", + "path_type": "hardlink", + "sha256": "526edff5d21fd1f1421f5ab6a706cb51732edcae235b9895f93a8f46e25505fe", + "sha256_in_prefix": "526edff5d21fd1f1421f5ab6a706cb51732edcae235b9895f93a8f46e25505fe", + "size_in_bytes": 68 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/example_stub.pyi", + "path_type": "hardlink", + "sha256": "5546cf759222c0f6ad74c740c6bf9558a731ef75d57988a5233beed40aa3a28b", + "sha256_in_prefix": "5546cf759222c0f6ad74c740c6bf9558a731ef75d57988a5233beed40aa3a28b", + "size_in_bytes": 87 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/htest.py", + "path_type": "hardlink", + "sha256": "48e03aae8546b4e1579edf21b47bd9835f11a6b097752d8226ca515c887e77e0", + "sha256_in_prefix": "48e03aae8546b4e1579edf21b47bd9835f11a6b097752d8226ca515c887e77e0", + "size_in_bytes": 15199 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/mock_idle.py", + "path_type": "hardlink", + "sha256": "637d74d26089c582fb784c2920f5bcb41e5b1fc8b9e0931ddc1cc8d92becbff4", + "sha256_in_prefix": "637d74d26089c582fb784c2920f5bcb41e5b1fc8b9e0931ddc1cc8d92becbff4", + "size_in_bytes": 1943 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/mock_tk.py", + "path_type": "hardlink", + "sha256": "7d60a26e82fd0469a95e02c2adda6607363a51ab67d5851cc323a58a595f74a7", + "sha256_in_prefix": "7d60a26e82fd0469a95e02c2adda6607363a51ab67d5851cc323a58a595f74a7", + "size_in_bytes": 11693 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/template.py", + "path_type": "hardlink", + "sha256": "43421286ad234a4240f8d4bc09f67bb58da0bf9d9b07bf93010989ef2c17f2f8", + "sha256_in_prefix": "43421286ad234a4240f8d4bc09f67bb58da0bf9d9b07bf93010989ef2c17f2f8", + "size_in_bytes": 642 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/test_autocomplete.py", + "path_type": "hardlink", + "sha256": "0ee1af80bb645bd57e6f6383f5e5473f901e9d40524992abf9c48a4163997eef", + "sha256_in_prefix": "0ee1af80bb645bd57e6f6383f5e5473f901e9d40524992abf9c48a4163997eef", + "size_in_bytes": 11093 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/test_autocomplete_w.py", + "path_type": "hardlink", + "sha256": "f8cd80196c2841f65f53ca5ae1c4fb99c7c215b29cf88774e0b189c99e4cee79", + "sha256_in_prefix": "f8cd80196c2841f65f53ca5ae1c4fb99c7c215b29cf88774e0b189c99e4cee79", + "size_in_bytes": 720 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/test_autoexpand.py", + "path_type": "hardlink", + "sha256": "85f913f8cbd5dfd5d52d3b7d00eedec231ec3e4ee7d117db4a2bb714eb1a7243", + "sha256_in_prefix": "85f913f8cbd5dfd5d52d3b7d00eedec231ec3e4ee7d117db4a2bb714eb1a7243", + "size_in_bytes": 4638 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/test_browser.py", + "path_type": "hardlink", + "sha256": "bdfd3bd9ab02ee535e77f3233920f80891eb84d7042f7db381afc7766b3702eb", + "sha256_in_prefix": "bdfd3bd9ab02ee535e77f3233920f80891eb84d7042f7db381afc7766b3702eb", + "size_in_bytes": 8420 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/test_calltip.py", + "path_type": "hardlink", + "sha256": "8fd994aed39f1b89a05137e2bf6e53401685ec408d5c424e267ff635bf8a6cdb", + "sha256_in_prefix": "8fd994aed39f1b89a05137e2bf6e53401685ec408d5c424e267ff635bf8a6cdb", + "size_in_bytes": 13194 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/test_calltip_w.py", + "path_type": "hardlink", + "sha256": "7462c048c689f82c3ae6b5782a18776762f88055b80ae77a92243b6c0606e004", + "sha256_in_prefix": "7462c048c689f82c3ae6b5782a18776762f88055b80ae77a92243b6c0606e004", + "size_in_bytes": 686 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/test_codecontext.py", + "path_type": "hardlink", + "sha256": "84e6b890b22b2abcc0865c691162b93c6ffb9b4e17f05011bdaffa770a52fcf0", + "sha256_in_prefix": "84e6b890b22b2abcc0865c691162b93c6ffb9b4e17f05011bdaffa770a52fcf0", + "size_in_bytes": 16082 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/test_colorizer.py", + "path_type": "hardlink", + "sha256": "6a3fbb630e0ecc7aafc9c8bc56ece3462911c733aa3bb4c52ee55c1d897301d4", + "sha256_in_prefix": "6a3fbb630e0ecc7aafc9c8bc56ece3462911c733aa3bb4c52ee55c1d897301d4", + "size_in_bytes": 22882 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/test_config.py", + "path_type": "hardlink", + "sha256": "98f856694b51330c729d4a87f5efd4c6c805db01edcea77d80b17f89d71bc054", + "sha256_in_prefix": "98f856694b51330c729d4a87f5efd4c6c805db01edcea77d80b17f89d71bc054", + "size_in_bytes": 32046 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/test_config_key.py", + "path_type": "hardlink", + "sha256": "54d0c65e1f66d37c415d3fe533c8db891974f08e8fca6374596280d64db86586", + "sha256_in_prefix": "54d0c65e1f66d37c415d3fe533c8db891974f08e8fca6374596280d64db86586", + "size_in_bytes": 11462 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/test_configdialog.py", + "path_type": "hardlink", + "sha256": "657ef252b2fa26800bddf96c2d0027c65a9d38ea4d87458f0386965c36abd1f5", + "sha256_in_prefix": "657ef252b2fa26800bddf96c2d0027c65a9d38ea4d87458f0386965c36abd1f5", + "size_in_bytes": 55344 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/test_debugger.py", + "path_type": "hardlink", + "sha256": "1881dcf94b0a44fe355f2acabfe25d8d67871402bbc19aaab37c6ff955575f1d", + "sha256_in_prefix": "1881dcf94b0a44fe355f2acabfe25d8d67871402bbc19aaab37c6ff955575f1d", + "size_in_bytes": 571 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/test_debugger_r.py", + "path_type": "hardlink", + "sha256": "ccc0ba5e03ee1df449f78a164efdc6739f5a530315ab3971ac05c652bc779cea", + "sha256_in_prefix": "ccc0ba5e03ee1df449f78a164efdc6739f5a530315ab3971ac05c652bc779cea", + "size_in_bytes": 965 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/test_debugobj.py", + "path_type": "hardlink", + "sha256": "e35a9f45b223d5c7e7f3bbfd8bc6495b1156c40b0ce3747ade0aed7b41aa23ac", + "sha256_in_prefix": "e35a9f45b223d5c7e7f3bbfd8bc6495b1156c40b0ce3747ade0aed7b41aa23ac", + "size_in_bytes": 1561 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/test_debugobj_r.py", + "path_type": "hardlink", + "sha256": "22d74368ba175175b9c14315f9d82fd7ddde60ae93d2e5572e9a647de7e869eb", + "sha256_in_prefix": "22d74368ba175175b9c14315f9d82fd7ddde60ae93d2e5572e9a647de7e869eb", + "size_in_bytes": 545 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/test_delegator.py", + "path_type": "hardlink", + "sha256": "559d39df8c1ff38d177943f245b87f5379ee5ea93399fd6b5f7bfa882e6ed8ca", + "sha256_in_prefix": "559d39df8c1ff38d177943f245b87f5379ee5ea93399fd6b5f7bfa882e6ed8ca", + "size_in_bytes": 1567 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/test_editmenu.py", + "path_type": "hardlink", + "sha256": "ed3800137d48ffcf86ecb71afe5a24cd9ed381571f23036438ba8a97f502326a", + "sha256_in_prefix": "ed3800137d48ffcf86ecb71afe5a24cd9ed381571f23036438ba8a97f502326a", + "size_in_bytes": 2564 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/test_editor.py", + "path_type": "hardlink", + "sha256": "7a858680c0c8753aad533388164f04ba3e82855ee8a8b9cfa537f01d923e49c9", + "sha256_in_prefix": "7a858680c0c8753aad533388164f04ba3e82855ee8a8b9cfa537f01d923e49c9", + "size_in_bytes": 7220 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/test_filelist.py", + "path_type": "hardlink", + "sha256": "d4cea5fdba68fb9e361541820d44eed003c317f4ef14bb9df3406b8d2c53ef7c", + "sha256_in_prefix": "d4cea5fdba68fb9e361541820d44eed003c317f4ef14bb9df3406b8d2c53ef7c", + "size_in_bytes": 795 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/test_format.py", + "path_type": "hardlink", + "sha256": "b356a2a8f5fe14c39c6af73623484df4ed930cc16ef4605f3b04fd9b618867a6", + "sha256_in_prefix": "b356a2a8f5fe14c39c6af73623484df4ed930cc16ef4605f3b04fd9b618867a6", + "size_in_bytes": 23610 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/test_grep.py", + "path_type": "hardlink", + "sha256": "ca64de882b5608e016b7df8f739089c9f262643bce09979b76399cc4be1ea12c", + "sha256_in_prefix": "ca64de882b5608e016b7df8f739089c9f262643bce09979b76399cc4be1ea12c", + "size_in_bytes": 5072 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/test_help.py", + "path_type": "hardlink", + "sha256": "e39288f4326136cadb4fab81fe31223187136bc3d9bdf65a9d67fd152e50a6e9", + "sha256_in_prefix": "e39288f4326136cadb4fab81fe31223187136bc3d9bdf65a9d67fd152e50a6e9", + "size_in_bytes": 849 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/test_help_about.py", + "path_type": "hardlink", + "sha256": "d0268651a7c7b4aec72da3e81c45b8488d33de3459300b7226dccc31ad956309", + "sha256_in_prefix": "d0268651a7c7b4aec72da3e81c45b8488d33de3459300b7226dccc31ad956309", + "size_in_bytes": 5919 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/test_history.py", + "path_type": "hardlink", + "sha256": "6319fe7810ed91786b503de80701a291a4f9abe54c9e101c19c0917b709e62f3", + "sha256_in_prefix": "6319fe7810ed91786b503de80701a291a4f9abe54c9e101c19c0917b709e62f3", + "size_in_bytes": 5517 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/test_hyperparser.py", + "path_type": "hardlink", + "sha256": "cd2fbc788d4d75b514e53951dc90d00d41a8a87baad31bc1e380b7449bfcf183", + "sha256_in_prefix": "cd2fbc788d4d75b514e53951dc90d00d41a8a87baad31bc1e380b7449bfcf183", + "size_in_bytes": 9082 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/test_iomenu.py", + "path_type": "hardlink", + "sha256": "c951a80a012812b1922b6486c7e4c4c82c5fbb5c2f10a6e30ef21e9ba6fb0621", + "sha256_in_prefix": "c951a80a012812b1922b6486c7e4c4c82c5fbb5c2f10a6e30ef21e9ba6fb0621", + "size_in_bytes": 2194 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/test_macosx.py", + "path_type": "hardlink", + "sha256": "975e48ab453711c5072988e2e66a7fe51e716ac64e494f022a5ff82781ccd368", + "sha256_in_prefix": "975e48ab453711c5072988e2e66a7fe51e716ac64e494f022a5ff82781ccd368", + "size_in_bytes": 3444 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/test_mainmenu.py", + "path_type": "hardlink", + "sha256": "faa064ffd9c8e30b1205e46bb4ede816c74b7948cfa34c7795ed19c35eac10d5", + "sha256_in_prefix": "faa064ffd9c8e30b1205e46bb4ede816c74b7948cfa34c7795ed19c35eac10d5", + "size_in_bytes": 1638 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/test_multicall.py", + "path_type": "hardlink", + "sha256": "1bfb51912275d8e346dce0a40ab84316b15e3f142e66529a8c9cfd52210c1a1f", + "sha256_in_prefix": "1bfb51912275d8e346dce0a40ab84316b15e3f142e66529a8c9cfd52210c1a1f", + "size_in_bytes": 1317 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/test_outwin.py", + "path_type": "hardlink", + "sha256": "255ae7e3271491d7bacb0cc32d0cc9b88c689c58d8543dad1bafec569109c7c6", + "sha256_in_prefix": "255ae7e3271491d7bacb0cc32d0cc9b88c689c58d8543dad1bafec569109c7c6", + "size_in_bytes": 5422 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/test_parenmatch.py", + "path_type": "hardlink", + "sha256": "5e0ba86116e28d46e7db9ed33d85cf7caa837e1779e1b8feb5f6b6b4a837551e", + "sha256_in_prefix": "5e0ba86116e28d46e7db9ed33d85cf7caa837e1779e1b8feb5f6b6b4a837551e", + "size_in_bytes": 3544 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/test_pathbrowser.py", + "path_type": "hardlink", + "sha256": "a7d9c5085ff5c64232897f6ee0a09258a41a35f153f47ff0f3b8fa97ec67be9e", + "sha256_in_prefix": "a7d9c5085ff5c64232897f6ee0a09258a41a35f153f47ff0f3b8fa97ec67be9e", + "size_in_bytes": 2422 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/test_percolator.py", + "path_type": "hardlink", + "sha256": "133b134a46b23cf2c635be3116415fd388e3a1c1581bf1a77d7f7f0aff3a725b", + "sha256_in_prefix": "133b134a46b23cf2c635be3116415fd388e3a1c1581bf1a77d7f7f0aff3a725b", + "size_in_bytes": 4065 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/test_pyparse.py", + "path_type": "hardlink", + "sha256": "8f386a9f535369afb495322e104077c66c5a3abb91917ec69f868b405120cf35", + "sha256_in_prefix": "8f386a9f535369afb495322e104077c66c5a3abb91917ec69f868b405120cf35", + "size_in_bytes": 19365 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/test_pyshell.py", + "path_type": "hardlink", + "sha256": "ff47aecd0657edbd7bc920473fe2e55b0bb0db6f347dc52f5e81b767897d3bc5", + "sha256_in_prefix": "ff47aecd0657edbd7bc920473fe2e55b0bb0db6f347dc52f5e81b767897d3bc5", + "size_in_bytes": 4965 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/test_query.py", + "path_type": "hardlink", + "sha256": "632c2dc13a158a5902e5b758166151ffa377db7f5a0c368bc3b0741a237876c3", + "sha256_in_prefix": "632c2dc13a158a5902e5b758166151ffa377db7f5a0c368bc3b0741a237876c3", + "size_in_bytes": 15454 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/test_redirector.py", + "path_type": "hardlink", + "sha256": "517c1fe16da359e01f3cdfdf3f7aead4283e8b8e1107522b72f59d4c4f3ade4c", + "sha256_in_prefix": "517c1fe16da359e01f3cdfdf3f7aead4283e8b8e1107522b72f59d4c4f3ade4c", + "size_in_bytes": 4176 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/test_replace.py", + "path_type": "hardlink", + "sha256": "321333b3eaad9ecbf633186bc625d4a60c4c736def0fa00665add2ab899eecb1", + "sha256_in_prefix": "321333b3eaad9ecbf633186bc625d4a60c4c736def0fa00665add2ab899eecb1", + "size_in_bytes": 8299 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/test_rpc.py", + "path_type": "hardlink", + "sha256": "1e2d997f442002389b3dadb47ed8134947c664a32ef637f43afdcbd1b5c13823", + "sha256_in_prefix": "1e2d997f442002389b3dadb47ed8134947c664a32ef637f43afdcbd1b5c13823", + "size_in_bytes": 805 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/test_run.py", + "path_type": "hardlink", + "sha256": "3a116bd1038efdb87831c45bece072fae2464cd568f1ddb9cca1d7fb85bf34a9", + "sha256_in_prefix": "3a116bd1038efdb87831c45bece072fae2464cd568f1ddb9cca1d7fb85bf34a9", + "size_in_bytes": 15687 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/test_runscript.py", + "path_type": "hardlink", + "sha256": "4264a834dc230d397725f398d905d0746321d543c56644e5c89af59fe3fedb61", + "sha256_in_prefix": "4264a834dc230d397725f398d905d0746321d543c56644e5c89af59fe3fedb61", + "size_in_bytes": 777 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/test_scrolledlist.py", + "path_type": "hardlink", + "sha256": "a84ec601c8786daf0564e978c97c0e14095c23f9a08bb64950f9cb541b074b3a", + "sha256_in_prefix": "a84ec601c8786daf0564e978c97c0e14095c23f9a08bb64950f9cb541b074b3a", + "size_in_bytes": 496 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/test_search.py", + "path_type": "hardlink", + "sha256": "c0550b241c99a566f61929515ca97aedf99f73568df3dfe93078ed22cb54892b", + "sha256_in_prefix": "c0550b241c99a566f61929515ca97aedf99f73568df3dfe93078ed22cb54892b", + "size_in_bytes": 2459 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/test_searchbase.py", + "path_type": "hardlink", + "sha256": "2b8550dd411b75c6152c4da90843e1221094400080f9a1752e383d0b776f775b", + "sha256_in_prefix": "2b8550dd411b75c6152c4da90843e1221094400080f9a1752e383d0b776f775b", + "size_in_bytes": 5691 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/test_searchengine.py", + "path_type": "hardlink", + "sha256": "519ddd5633eb8732539594f79ed21a6544f65e599a0d5c8c84db3a488ccdad97", + "sha256_in_prefix": "519ddd5633eb8732539594f79ed21a6544f65e599a0d5c8c84db3a488ccdad97", + "size_in_bytes": 11588 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/test_sidebar.py", + "path_type": "hardlink", + "sha256": "3d5410aa97577c88566586aedc0258389289aca9aedc034a11b8e06c49edb6fc", + "sha256_in_prefix": "3d5410aa97577c88566586aedc0258389289aca9aedc034a11b8e06c49edb6fc", + "size_in_bytes": 26573 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/test_squeezer.py", + "path_type": "hardlink", + "sha256": "9f5b9ca3ff2dc7bd2b9308d417f1698893f236677f3b41694144fa029db75506", + "sha256_in_prefix": "9f5b9ca3ff2dc7bd2b9308d417f1698893f236677f3b41694144fa029db75506", + "size_in_bytes": 19680 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/test_stackviewer.py", + "path_type": "hardlink", + "sha256": "483502cfbfce0ac87198cfd6d0ec7e5eec68834042ed949875730a35764c83ca", + "sha256_in_prefix": "483502cfbfce0ac87198cfd6d0ec7e5eec68834042ed949875730a35764c83ca", + "size_in_bytes": 1206 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/test_statusbar.py", + "path_type": "hardlink", + "sha256": "0e9b262b9ad0046cbb0af1101a651fcb88cd1cba38e474b863abbb074b260a02", + "sha256_in_prefix": "0e9b262b9ad0046cbb0af1101a651fcb88cd1cba38e474b863abbb074b260a02", + "size_in_bytes": 1133 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/test_text.py", + "path_type": "hardlink", + "sha256": "55abe8a9d0bdb45efecb879207f1259702cdcf47dbc636d7cca8dd458f0dc70f", + "sha256_in_prefix": "55abe8a9d0bdb45efecb879207f1259702cdcf47dbc636d7cca8dd458f0dc70f", + "size_in_bytes": 6970 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/test_textview.py", + "path_type": "hardlink", + "sha256": "e45b199106608c7c981c149d3b4ccf092e7a2e7e9430cc76887cd769b9aaf533", + "sha256_in_prefix": "e45b199106608c7c981c149d3b4ccf092e7a2e7e9430cc76887cd769b9aaf533", + "size_in_bytes": 7364 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/test_tooltip.py", + "path_type": "hardlink", + "sha256": "b9a82e57761bbca3d4e07193652e8294895765092ef8a651f4dcf63acec7f153", + "sha256_in_prefix": "b9a82e57761bbca3d4e07193652e8294895765092ef8a651f4dcf63acec7f153", + "size_in_bytes": 5385 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/test_tree.py", + "path_type": "hardlink", + "sha256": "62ae68d64105485107e8173f94ce09739f276004bc8fa65efa5add2c6188e166", + "sha256_in_prefix": "62ae68d64105485107e8173f94ce09739f276004bc8fa65efa5add2c6188e166", + "size_in_bytes": 1752 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/test_undo.py", + "path_type": "hardlink", + "sha256": "c5178b2dd77d794938fa52adce719d4948a92ba1a689068cec1fb6888d033e0e", + "sha256_in_prefix": "c5178b2dd77d794938fa52adce719d4948a92ba1a689068cec1fb6888d033e0e", + "size_in_bytes": 4228 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/test_util.py", + "path_type": "hardlink", + "sha256": "300f627fc2199deb246ec793ef47b032de742d763a4170c8bb15e19ccbf602a5", + "sha256_in_prefix": "300f627fc2199deb246ec793ef47b032de742d763a4170c8bb15e19ccbf602a5", + "size_in_bytes": 308 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/test_warning.py", + "path_type": "hardlink", + "sha256": "d1efc442b3fb93de89fb0988c73f8536fc5099afb761d2b69ec101c239c8c193", + "sha256_in_prefix": "d1efc442b3fb93de89fb0988c73f8536fc5099afb761d2b69ec101c239c8c193", + "size_in_bytes": 2740 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/test_window.py", + "path_type": "hardlink", + "sha256": "336f2b6994f5aacca9689f32249db20a8dac36934314b7d5ba391d94169d63c6", + "sha256_in_prefix": "336f2b6994f5aacca9689f32249db20a8dac36934314b7d5ba391d94169d63c6", + "size_in_bytes": 1075 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/test_zoomheight.py", + "path_type": "hardlink", + "sha256": "6300aa47014a5c2dfc9bc0d6c3fb234dff4e4b60a6527d4cdfbb8c416f99df44", + "sha256_in_prefix": "6300aa47014a5c2dfc9bc0d6c3fb234dff4e4b60a6527d4cdfbb8c416f99df44", + "size_in_bytes": 999 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/test_zzdummy.py", + "path_type": "hardlink", + "sha256": "4502524aaa1923393725c04e6b2f27077399190e42bc8903415e95718c5f3c6f", + "sha256_in_prefix": "4502524aaa1923393725c04e6b2f27077399190e42bc8903415e95718c5f3c6f", + "size_in_bytes": 4455 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/tkinter_testing_utils.py", + "path_type": "hardlink", + "sha256": "ece147cef65152a54b0a3d4319bdf8ed82d9a6310273b0056cc17a2de4d744cd", + "sha256_in_prefix": "ece147cef65152a54b0a3d4319bdf8ed82d9a6310273b0056cc17a2de4d744cd", + "size_in_bytes": 2333 + }, + { + "_path": "lib/python3.10/idlelib/iomenu.py", + "path_type": "hardlink", + "sha256": "46d2505e3e2cd9737d732ec7949f1712550c93dc949318d64b81339160716cc6", + "sha256_in_prefix": "46d2505e3e2cd9737d732ec7949f1712550c93dc949318d64b81339160716cc6", + "size_in_bytes": 15971 + }, + { + "_path": "lib/python3.10/idlelib/macosx.py", + "path_type": "hardlink", + "sha256": "783748f1198726cd0ca7a779ead35bf157ff076bfab4a8562a8c257ff1f3afec", + "sha256_in_prefix": "783748f1198726cd0ca7a779ead35bf157ff076bfab4a8562a8c257ff1f3afec", + "size_in_bytes": 10150 + }, + { + "_path": "lib/python3.10/idlelib/mainmenu.py", + "path_type": "hardlink", + "sha256": "092fad4454f593d7bf2e5e1e746acade92bb346d06476ba527f162f843ae3208", + "sha256_in_prefix": "092fad4454f593d7bf2e5e1e746acade92bb346d06476ba527f162f843ae3208", + "size_in_bytes": 3938 + }, + { + "_path": "lib/python3.10/idlelib/multicall.py", + "path_type": "hardlink", + "sha256": "277f16699b17c3fd176c1b259959ed235bb9bb59d54731203c9c33c2e0e43172", + "sha256_in_prefix": "277f16699b17c3fd176c1b259959ed235bb9bb59d54731203c9c33c2e0e43172", + "size_in_bytes": 18648 + }, + { + "_path": "lib/python3.10/idlelib/outwin.py", + "path_type": "hardlink", + "sha256": "39a6018927b4543c3fcbd857f3bd1de7097c8f185bdee8f3373c7c3c4da70e84", + "sha256_in_prefix": "39a6018927b4543c3fcbd857f3bd1de7097c8f185bdee8f3373c7c3c4da70e84", + "size_in_bytes": 5709 + }, + { + "_path": "lib/python3.10/idlelib/parenmatch.py", + "path_type": "hardlink", + "sha256": "f122e13c385a135cbbbe8b1d87efeed43ddd3e0be9ddd8aa24b267b61fac4287", + "sha256_in_prefix": "f122e13c385a135cbbbe8b1d87efeed43ddd3e0be9ddd8aa24b267b61fac4287", + "size_in_bytes": 7204 + }, + { + "_path": "lib/python3.10/idlelib/pathbrowser.py", + "path_type": "hardlink", + "sha256": "0d0bf5c92b0f2a5fe25ddf95729f6cba8a9ac48c7c0d1c2fdd7a7532586f2ea4", + "sha256_in_prefix": "0d0bf5c92b0f2a5fe25ddf95729f6cba8a9ac48c7c0d1c2fdd7a7532586f2ea4", + "size_in_bytes": 3193 + }, + { + "_path": "lib/python3.10/idlelib/percolator.py", + "path_type": "hardlink", + "sha256": "b55510d26956f8695d9309ad4a9615a7bae8ca95bd2a9f277abcd463bf2c8464", + "sha256_in_prefix": "b55510d26956f8695d9309ad4a9615a7bae8ca95bd2a9f277abcd463bf2c8464", + "size_in_bytes": 3546 + }, + { + "_path": "lib/python3.10/idlelib/pyparse.py", + "path_type": "hardlink", + "sha256": "21c6bf43370998d5a5a6670f7b13409335e9a2c1a350ed586bbe63be5f226648", + "sha256_in_prefix": "21c6bf43370998d5a5a6670f7b13409335e9a2c1a350ed586bbe63be5f226648", + "size_in_bytes": 19864 + }, + { + "_path": "lib/python3.10/idlelib/pyshell.py", + "path_type": "hardlink", + "sha256": "08630ec45901fcdf4d9a6e97dacf70c57a4c4be5c6e81c738d226588b7c71fdf", + "sha256_in_prefix": "08630ec45901fcdf4d9a6e97dacf70c57a4c4be5c6e81c738d226588b7c71fdf", + "size_in_bytes": 62971 + }, + { + "_path": "lib/python3.10/idlelib/query.py", + "path_type": "hardlink", + "sha256": "a8984d77e39ffa556b775cb915fa38d4d8de8fb7afa20c10e47ff62c2f191b29", + "sha256_in_prefix": "a8984d77e39ffa556b775cb915fa38d4d8de8fb7afa20c10e47ff62c2f191b29", + "size_in_bytes": 15075 + }, + { + "_path": "lib/python3.10/idlelib/redirector.py", + "path_type": "hardlink", + "sha256": "f9bd3a01148a0d6627692f4ef22f93361cd19e4e279510c45a522ef10ff6650d", + "sha256_in_prefix": "f9bd3a01148a0d6627692f4ef22f93361cd19e4e279510c45a522ef10ff6650d", + "size_in_bytes": 6875 + }, + { + "_path": "lib/python3.10/idlelib/replace.py", + "path_type": "hardlink", + "sha256": "2137f4472712a4730b04986821fcf67df32f0a5b7e65ded3a1a9d50d76f85046", + "sha256_in_prefix": "2137f4472712a4730b04986821fcf67df32f0a5b7e65ded3a1a9d50d76f85046", + "size_in_bytes": 9999 + }, + { + "_path": "lib/python3.10/idlelib/rpc.py", + "path_type": "hardlink", + "sha256": "d0a01feddf24c7d8b5e1ebc14318cc128a542feba1bb3d277fdaa56caef81e27", + "sha256_in_prefix": "d0a01feddf24c7d8b5e1ebc14318cc128a542feba1bb3d277fdaa56caef81e27", + "size_in_bytes": 21082 + }, + { + "_path": "lib/python3.10/idlelib/run.py", + "path_type": "hardlink", + "sha256": "936bf5133b4a336604208b1e3182464affc95205e47eba447d5b172f58567ee7", + "sha256_in_prefix": "936bf5133b4a336604208b1e3182464affc95205e47eba447d5b172f58567ee7", + "size_in_bytes": 21504 + }, + { + "_path": "lib/python3.10/idlelib/runscript.py", + "path_type": "hardlink", + "sha256": "b92740fddc7b1d603b1736a135bd15518081f20c0db1e1a779cab715ee9120fe", + "sha256_in_prefix": "b92740fddc7b1d603b1736a135bd15518081f20c0db1e1a779cab715ee9120fe", + "size_in_bytes": 8273 + }, + { + "_path": "lib/python3.10/idlelib/scrolledlist.py", + "path_type": "hardlink", + "sha256": "fd08b385ac576e43fa8dc10efb644425b9847d6b70b19f0b2ef484d7c0776f82", + "sha256_in_prefix": "fd08b385ac576e43fa8dc10efb644425b9847d6b70b19f0b2ef484d7c0776f82", + "size_in_bytes": 4465 + }, + { + "_path": "lib/python3.10/idlelib/search.py", + "path_type": "hardlink", + "sha256": "85db5685f1d80d59ff013e045a963057e03af2588994b9805806385309847fe6", + "sha256_in_prefix": "85db5685f1d80d59ff013e045a963057e03af2588994b9805806385309847fe6", + "size_in_bytes": 5566 + }, + { + "_path": "lib/python3.10/idlelib/searchbase.py", + "path_type": "hardlink", + "sha256": "5e13c99d9f264166d9204eeff0492d43d03f2afd8f66494b3e110d7665ab29cc", + "sha256_in_prefix": "5e13c99d9f264166d9204eeff0492d43d03f2afd8f66494b3e110d7665ab29cc", + "size_in_bytes": 7856 + }, + { + "_path": "lib/python3.10/idlelib/searchengine.py", + "path_type": "hardlink", + "sha256": "a4a43d2c270d06643806bc76c1345b98898f0f36e692fa71bbe4d99b497aebbf", + "sha256_in_prefix": "a4a43d2c270d06643806bc76c1345b98898f0f36e692fa71bbe4d99b497aebbf", + "size_in_bytes": 7365 + }, + { + "_path": "lib/python3.10/idlelib/sidebar.py", + "path_type": "hardlink", + "sha256": "6be736f823317d714f82cd8239280d3be62d568e31e5592bc21e573b36de33ec", + "sha256_in_prefix": "6be736f823317d714f82cd8239280d3be62d568e31e5592bc21e573b36de33ec", + "size_in_bytes": 20357 + }, + { + "_path": "lib/python3.10/idlelib/squeezer.py", + "path_type": "hardlink", + "sha256": "112221334fee94a88cba2ca7ac455e1bd6ab796397cbe036b1e8a98bc0787e30", + "sha256_in_prefix": "112221334fee94a88cba2ca7ac455e1bd6ab796397cbe036b1e8a98bc0787e30", + "size_in_bytes": 12834 + }, + { + "_path": "lib/python3.10/idlelib/stackviewer.py", + "path_type": "hardlink", + "sha256": "926a667aa9936ec65cd80b2650d2f0f3434c2ee54f0be91939259add06ef7fd4", + "sha256_in_prefix": "926a667aa9936ec65cd80b2650d2f0f3434c2ee54f0be91939259add06ef7fd4", + "size_in_bytes": 4454 + }, + { + "_path": "lib/python3.10/idlelib/statusbar.py", + "path_type": "hardlink", + "sha256": "7847dfee4e6e1a025ae8b5bfe7d4503d86cf731653dc452804429c3b96c709eb", + "sha256_in_prefix": "7847dfee4e6e1a025ae8b5bfe7d4503d86cf731653dc452804429c3b96c709eb", + "size_in_bytes": 1472 + }, + { + "_path": "lib/python3.10/idlelib/textview.py", + "path_type": "hardlink", + "sha256": "7351da2057dfbfb1523cb1f80bb4965bdb7d9f4271a557571e511f373688d269", + "sha256_in_prefix": "7351da2057dfbfb1523cb1f80bb4965bdb7d9f4271a557571e511f373688d269", + "size_in_bytes": 6813 + }, + { + "_path": "lib/python3.10/idlelib/tooltip.py", + "path_type": "hardlink", + "sha256": "dff2c8d2225e5737ffbc37e8ec7c49ece4fd6bfbd6e910e4e79ffc01b91f7145", + "sha256_in_prefix": "dff2c8d2225e5737ffbc37e8ec7c49ece4fd6bfbd6e910e4e79ffc01b91f7145", + "size_in_bytes": 6557 + }, + { + "_path": "lib/python3.10/idlelib/tree.py", + "path_type": "hardlink", + "sha256": "2daa545a8e3c1988ef653a2f4f42e6338f793a245cb1e3d82226159ff9a08347", + "sha256_in_prefix": "2daa545a8e3c1988ef653a2f4f42e6338f793a245cb1e3d82226159ff9a08347", + "size_in_bytes": 16370 + }, + { + "_path": "lib/python3.10/idlelib/undo.py", + "path_type": "hardlink", + "sha256": "915f353f4eb7052a48cc63f202816bdd3345a03598fb871ff5966304f255d739", + "sha256_in_prefix": "915f353f4eb7052a48cc63f202816bdd3345a03598fb871ff5966304f255d739", + "size_in_bytes": 11046 + }, + { + "_path": "lib/python3.10/idlelib/util.py", + "path_type": "hardlink", + "sha256": "1ec6c3961e1792d904b66f0d56dc048396b661860f2fba63fee9388ab17026bb", + "sha256_in_prefix": "1ec6c3961e1792d904b66f0d56dc048396b661860f2fba63fee9388ab17026bb", + "size_in_bytes": 701 + }, + { + "_path": "lib/python3.10/idlelib/window.py", + "path_type": "hardlink", + "sha256": "ca31d8c01c9b468fcad0a4e529c8e205c1e4ecf30520545db654d466bd7158bd", + "sha256_in_prefix": "ca31d8c01c9b468fcad0a4e529c8e205c1e4ecf30520545db654d466bd7158bd", + "size_in_bytes": 2616 + }, + { + "_path": "lib/python3.10/idlelib/zoomheight.py", + "path_type": "hardlink", + "sha256": "5f6ff83cb0df3ee5e7d997ffe23efb341b994bfbaf00b79a4832d54231a095dd", + "sha256_in_prefix": "5f6ff83cb0df3ee5e7d997ffe23efb341b994bfbaf00b79a4832d54231a095dd", + "size_in_bytes": 4203 + }, + { + "_path": "lib/python3.10/idlelib/zzdummy.py", + "path_type": "hardlink", + "sha256": "5e248f0ea4f35052d23bb2c43564aa567b8cebaf91fd63ba0be8fef2f4167945", + "sha256_in_prefix": "5e248f0ea4f35052d23bb2c43564aa567b8cebaf91fd63ba0be8fef2f4167945", + "size_in_bytes": 2005 + }, + { + "_path": "lib/python3.10/imaplib.py", + "path_type": "hardlink", + "sha256": "6793eee3515221c6e20b47804d209e9a07215b487ffae02ce811fab385aae053", + "sha256_in_prefix": "6793eee3515221c6e20b47804d209e9a07215b487ffae02ce811fab385aae053", + "size_in_bytes": 54866 + }, + { + "_path": "lib/python3.10/imghdr.py", + "path_type": "hardlink", + "sha256": "653ad8d50f1c3cb3a0cc4d2876c60aaa40732c42779dea2e1db547639d27b085", + "sha256_in_prefix": "653ad8d50f1c3cb3a0cc4d2876c60aaa40732c42779dea2e1db547639d27b085", + "size_in_bytes": 3808 + }, + { + "_path": "lib/python3.10/imp.py", + "path_type": "hardlink", + "sha256": "bf581d7c70e2682ed8259f6b6e33950cf49a4ae065fab4abad81659969b1fbac", + "sha256_in_prefix": "bf581d7c70e2682ed8259f6b6e33950cf49a4ae065fab4abad81659969b1fbac", + "size_in_bytes": 10591 + }, + { + "_path": "lib/python3.10/importlib/__init__.py", + "path_type": "hardlink", + "sha256": "49ad4fdc8139026f7f3773e3f50f09207ff6bd8e92a2c382545525235448e525", + "sha256_in_prefix": "49ad4fdc8139026f7f3773e3f50f09207ff6bd8e92a2c382545525235448e525", + "size_in_bytes": 6089 + }, + { + "_path": "lib/python3.10/importlib/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "ed8c61f5bef5c4129c831c93b729be226d80967152c3b37b8ac5b33e106b8730", + "sha256_in_prefix": "ed8c61f5bef5c4129c831c93b729be226d80967152c3b37b8ac5b33e106b8730", + "size_in_bytes": 4059 + }, + { + "_path": "lib/python3.10/importlib/__pycache__/_abc.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "32aaae2628ea2492b9de31ff1182056a19dda1fe73f17d572697afc2fc3aa481", + "sha256_in_prefix": "32aaae2628ea2492b9de31ff1182056a19dda1fe73f17d572697afc2fc3aa481", + "size_in_bytes": 2225 + }, + { + "_path": "lib/python3.10/importlib/__pycache__/_adapters.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "2d43ed6c0f8a722f5d8f03f0d57ca33b9af49ec7f465a91fa563c2e23f24855a", + "sha256_in_prefix": "2d43ed6c0f8a722f5d8f03f0d57ca33b9af49ec7f465a91fa563c2e23f24855a", + "size_in_bytes": 3957 + }, + { + "_path": "lib/python3.10/importlib/__pycache__/_bootstrap.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "77b795dddf79b11e61d6b06aadde233dce697f8121e4211e95944e971cb3bc86", + "sha256_in_prefix": "77b795dddf79b11e61d6b06aadde233dce697f8121e4211e95944e971cb3bc86", + "size_in_bytes": 30382 + }, + { + "_path": "lib/python3.10/importlib/__pycache__/_bootstrap_external.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "4245e02741fc6f5edfc5aacaf393bb5c6eef4122de976e6e17401832ce2aba94", + "sha256_in_prefix": "4245e02741fc6f5edfc5aacaf393bb5c6eef4122de976e6e17401832ce2aba94", + "size_in_bytes": 44567 + }, + { + "_path": "lib/python3.10/importlib/__pycache__/_common.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "d47a886887717c997471bb86cca37c742aa9868119f0fb4c8a204f29c24de4cd", + "sha256_in_prefix": "d47a886887717c997471bb86cca37c742aa9868119f0fb4c8a204f29c24de4cd", + "size_in_bytes": 3221 + }, + { + "_path": "lib/python3.10/importlib/__pycache__/abc.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "1119596ad3bfcade124597f559e2dcf942cb514383b110e71882a6cbacb72ac6", + "sha256_in_prefix": "1119596ad3bfcade124597f559e2dcf942cb514383b110e71882a6cbacb72ac6", + "size_in_bytes": 16145 + }, + { + "_path": "lib/python3.10/importlib/__pycache__/machinery.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "a47d4ef72eeaa685616bdb926d80ac2bc76eb24f409b9d61f4bef26288bd8ca2", + "sha256_in_prefix": "a47d4ef72eeaa685616bdb926d80ac2bc76eb24f409b9d61f4bef26288bd8ca2", + "size_in_bytes": 1198 + }, + { + "_path": "lib/python3.10/importlib/__pycache__/readers.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "1592c18750f632901d652ea7619208fc890fd7f452d19a6ede98185c9735cf41", + "sha256_in_prefix": "1592c18750f632901d652ea7619208fc890fd7f452d19a6ede98185c9735cf41", + "size_in_bytes": 5436 + }, + { + "_path": "lib/python3.10/importlib/__pycache__/resources.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "d1c4e365909311d280c1d3e110ea02b974916d6dad7f761a91a93ba78c04716e", + "sha256_in_prefix": "d1c4e365909311d280c1d3e110ea02b974916d6dad7f761a91a93ba78c04716e", + "size_in_bytes": 5623 + }, + { + "_path": "lib/python3.10/importlib/__pycache__/util.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "76d3e4d4841f5c94c383e135914f0fcae74858e521f0a10b9c73f50af6984195", + "sha256_in_prefix": "76d3e4d4841f5c94c383e135914f0fcae74858e521f0a10b9c73f50af6984195", + "size_in_bytes": 9583 + }, + { + "_path": "lib/python3.10/importlib/_abc.py", + "path_type": "hardlink", + "sha256": "e24fa90513d1fd6e10df30dc28044dfcad857b88161c79de10f7109c18227e8d", + "sha256_in_prefix": "e24fa90513d1fd6e10df30dc28044dfcad857b88161c79de10f7109c18227e8d", + "size_in_bytes": 1852 + }, + { + "_path": "lib/python3.10/importlib/_adapters.py", + "path_type": "hardlink", + "sha256": "c6990a3ce5601e274ce7d374ec0f4ee49b3987745441b89ae691c635dcb7f67a", + "sha256_in_prefix": "c6990a3ce5601e274ce7d374ec0f4ee49b3987745441b89ae691c635dcb7f67a", + "size_in_bytes": 1908 + }, + { + "_path": "lib/python3.10/importlib/_bootstrap.py", + "path_type": "hardlink", + "sha256": "11125bbe628d2f82afdcd480c6454f6248f229d9caf6a8ac1e231c3402facaa1", + "sha256_in_prefix": "11125bbe628d2f82afdcd480c6454f6248f229d9caf6a8ac1e231c3402facaa1", + "size_in_bytes": 41467 + }, + { + "_path": "lib/python3.10/importlib/_bootstrap_external.py", + "path_type": "hardlink", + "sha256": "51eca63c5ee15e9663fbdc000c61a88cd0b722af44d78c3de814c78148bd376b", + "sha256_in_prefix": "51eca63c5ee15e9663fbdc000c61a88cd0b722af44d78c3de814c78148bd376b", + "size_in_bytes": 64850 + }, + { + "_path": "lib/python3.10/importlib/_common.py", + "path_type": "hardlink", + "sha256": "12d117b6545421b414f25a30b43bebc727cb07edd6332ce087422899818d4712", + "sha256_in_prefix": "12d117b6545421b414f25a30b43bebc727cb07edd6332ce087422899818d4712", + "size_in_bytes": 3222 + }, + { + "_path": "lib/python3.10/importlib/abc.py", + "path_type": "hardlink", + "sha256": "d35fb80460981eed5dadf5e2a8f7a920c632805442e769caa225c1295e36a490", + "sha256_in_prefix": "d35fb80460981eed5dadf5e2a8f7a920c632805442e769caa225c1295e36a490", + "size_in_bytes": 14421 + }, + { + "_path": "lib/python3.10/importlib/machinery.py", + "path_type": "hardlink", + "sha256": "b7b47efe3d95ae817e0c61d852682ddf8b8ce95aaf36ae4cf333e145416baf18", + "sha256_in_prefix": "b7b47efe3d95ae817e0c61d852682ddf8b8ce95aaf36ae4cf333e145416baf18", + "size_in_bytes": 831 + }, + { + "_path": "lib/python3.10/importlib/metadata/__init__.py", + "path_type": "hardlink", + "sha256": "cbdafd8f6361fab14fae1eb719abfefc609ac1a24aa2cd717753f0d110883849", + "sha256_in_prefix": "cbdafd8f6361fab14fae1eb719abfefc609ac1a24aa2cd717753f0d110883849", + "size_in_bytes": 30596 + }, + { + "_path": "lib/python3.10/importlib/metadata/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "dd2d7a687ff06905dce7b12c7bd23e86a788fb5e90826bfd2990e4fe649caf87", + "sha256_in_prefix": "dd2d7a687ff06905dce7b12c7bd23e86a788fb5e90826bfd2990e4fe649caf87", + "size_in_bytes": 37350 + }, + { + "_path": "lib/python3.10/importlib/metadata/__pycache__/_adapters.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "7d45d62c129de831011bfc0ba3ff40a0e8cc760c94a65a4d0b555e8888beb1a0", + "sha256_in_prefix": "7d45d62c129de831011bfc0ba3ff40a0e8cc760c94a65a4d0b555e8888beb1a0", + "size_in_bytes": 2598 + }, + { + "_path": "lib/python3.10/importlib/metadata/__pycache__/_collections.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "bb5f38b00399658bbe51117395ba78a912d68230bb513023167d4dfa10b994ea", + "sha256_in_prefix": "bb5f38b00399658bbe51117395ba78a912d68230bb513023167d4dfa10b994ea", + "size_in_bytes": 1773 + }, + { + "_path": "lib/python3.10/importlib/metadata/__pycache__/_functools.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "8f13178b2e4cda41d542e6561650a1a9f99b74f29451a5e438156551055baec8", + "sha256_in_prefix": "8f13178b2e4cda41d542e6561650a1a9f99b74f29451a5e438156551055baec8", + "size_in_bytes": 3363 + }, + { + "_path": "lib/python3.10/importlib/metadata/__pycache__/_itertools.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "1135e90d816aee6e6bcf65c52bb12e8520d64a1c2c8643d5229212093361c719", + "sha256_in_prefix": "1135e90d816aee6e6bcf65c52bb12e8520d64a1c2c8643d5229212093361c719", + "size_in_bytes": 825 + }, + { + "_path": "lib/python3.10/importlib/metadata/__pycache__/_meta.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "54781ce683592efdb225202f9064ad772ee1e80e7da995f38286a3870de55ede", + "sha256_in_prefix": "54781ce683592efdb225202f9064ad772ee1e80e7da995f38286a3870de55ede", + "size_in_bytes": 2518 + }, + { + "_path": "lib/python3.10/importlib/metadata/__pycache__/_text.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "e53cc3236689d15d95a0ed6e93512077ca079a364ce84cc636bd29d791aa6971", + "sha256_in_prefix": "e53cc3236689d15d95a0ed6e93512077ca079a364ce84cc636bd29d791aa6971", + "size_in_bytes": 3055 + }, + { + "_path": "lib/python3.10/importlib/metadata/_adapters.py", + "path_type": "hardlink", + "sha256": "07a7c28b9fbc98b543154663de4ac8e67028fa62a9d5d1ffa886afc88c85ac9b", + "sha256_in_prefix": "07a7c28b9fbc98b543154663de4ac8e67028fa62a9d5d1ffa886afc88c85ac9b", + "size_in_bytes": 1862 + }, + { + "_path": "lib/python3.10/importlib/metadata/_collections.py", + "path_type": "hardlink", + "sha256": "089d0e4c21c88d6034648552e2fa0e440b27d91e11d9c40112d3ec6442690126", + "sha256_in_prefix": "089d0e4c21c88d6034648552e2fa0e440b27d91e11d9c40112d3ec6442690126", + "size_in_bytes": 743 + }, + { + "_path": "lib/python3.10/importlib/metadata/_functools.py", + "path_type": "hardlink", + "sha256": "3ec636fb8aeb297e1155e442d681a9d65075a660bd78a37cf3f7fe6c3f6e3a80", + "sha256_in_prefix": "3ec636fb8aeb297e1155e442d681a9d65075a660bd78a37cf3f7fe6c3f6e3a80", + "size_in_bytes": 2895 + }, + { + "_path": "lib/python3.10/importlib/metadata/_itertools.py", + "path_type": "hardlink", + "sha256": "e53523fc03c91eade9be39f4e219cfda860179b3f6368ec798d1ff864386c0b4", + "sha256_in_prefix": "e53523fc03c91eade9be39f4e219cfda860179b3f6368ec798d1ff864386c0b4", + "size_in_bytes": 607 + }, + { + "_path": "lib/python3.10/importlib/metadata/_meta.py", + "path_type": "hardlink", + "sha256": "39a4210c5a7a366a23384af485b6c93b1c6d7b8cf34822a5c0c2971c8855d8ee", + "sha256_in_prefix": "39a4210c5a7a366a23384af485b6c93b1c6d7b8cf34822a5c0c2971c8855d8ee", + "size_in_bytes": 1130 + }, + { + "_path": "lib/python3.10/importlib/metadata/_text.py", + "path_type": "hardlink", + "sha256": "f0e01097af5970343ee1c4f1f9156f1f0f43661e9dbf72ac289336d9b7c329f9", + "sha256_in_prefix": "f0e01097af5970343ee1c4f1f9156f1f0f43661e9dbf72ac289336d9b7c329f9", + "size_in_bytes": 2198 + }, + { + "_path": "lib/python3.10/importlib/readers.py", + "path_type": "hardlink", + "sha256": "1162c32e66cc667f8856942d00e3152be2c37d87b6724d375f7b1265e8673f03", + "sha256_in_prefix": "1162c32e66cc667f8856942d00e3152be2c37d87b6724d375f7b1265e8673f03", + "size_in_bytes": 3587 + }, + { + "_path": "lib/python3.10/importlib/resources.py", + "path_type": "hardlink", + "sha256": "ac7824f7f6847dbe9de151e29b4c17aed94376f0b8d70aaa5db2c6925b752545", + "sha256_in_prefix": "ac7824f7f6847dbe9de151e29b4c17aed94376f0b8d70aaa5db2c6925b752545", + "size_in_bytes": 5705 + }, + { + "_path": "lib/python3.10/importlib/util.py", + "path_type": "hardlink", + "sha256": "de645b9f6d595f5e415d117f4d04ce77f144ce5ad2a6477659a9b5547d54b9dd", + "sha256_in_prefix": "de645b9f6d595f5e415d117f4d04ce77f144ce5ad2a6477659a9b5547d54b9dd", + "size_in_bytes": 11487 + }, + { + "_path": "lib/python3.10/inspect.py", + "path_type": "hardlink", + "sha256": "98cc184ae793fa1c45de2f28de2539f6d63bf7bec8338df580549f8263baa905", + "sha256_in_prefix": "98cc184ae793fa1c45de2f28de2539f6d63bf7bec8338df580549f8263baa905", + "size_in_bytes": 124378 + }, + { + "_path": "lib/python3.10/io.py", + "path_type": "hardlink", + "sha256": "ee094fcf87d17a3a25816c663b67bd8797dccc3eebabad5a23f6da162146a0a8", + "sha256_in_prefix": "ee094fcf87d17a3a25816c663b67bd8797dccc3eebabad5a23f6da162146a0a8", + "size_in_bytes": 4196 + }, + { + "_path": "lib/python3.10/ipaddress.py", + "path_type": "hardlink", + "sha256": "7868f0b3f21270719534601ee94de4d20efb67f97627e2c8c1233ef4265e5227", + "sha256_in_prefix": "7868f0b3f21270719534601ee94de4d20efb67f97627e2c8c1233ef4265e5227", + "size_in_bytes": 74723 + }, + { + "_path": "lib/python3.10/json/__init__.py", + "path_type": "hardlink", + "sha256": "d5d41e2c29049515d295d81a6d40b4890fbec8d8482cfb401630f8ef2f77e4d5", + "sha256_in_prefix": "d5d41e2c29049515d295d81a6d40b4890fbec8d8482cfb401630f8ef2f77e4d5", + "size_in_bytes": 14020 + }, + { + "_path": "lib/python3.10/json/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "99d9c9f0f6ee6ed9a7c1b792d2072a93e599db450eb96a93dffdd9c5b66831a4", + "sha256_in_prefix": "99d9c9f0f6ee6ed9a7c1b792d2072a93e599db450eb96a93dffdd9c5b66831a4", + "size_in_bytes": 12518 + }, + { + "_path": "lib/python3.10/json/__pycache__/decoder.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "eef4483f23106ec31133385f4a309c41fb874c4af0573e0e6fc55f61a8215e60", + "sha256_in_prefix": "eef4483f23106ec31133385f4a309c41fb874c4af0573e0e6fc55f61a8215e60", + "size_in_bytes": 10020 + }, + { + "_path": "lib/python3.10/json/__pycache__/encoder.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "8810e89fb9819e78fb5b8083f62e187b86ca9024b05ceb592f41357e6ff0d450", + "sha256_in_prefix": "8810e89fb9819e78fb5b8083f62e187b86ca9024b05ceb592f41357e6ff0d450", + "size_in_bytes": 11371 + }, + { + "_path": "lib/python3.10/json/__pycache__/scanner.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "5da4b940d82f78906c9d42977d54af7954276150aa368572af643d33053faff3", + "sha256_in_prefix": "5da4b940d82f78906c9d42977d54af7954276150aa368572af643d33053faff3", + "size_in_bytes": 2170 + }, + { + "_path": "lib/python3.10/json/__pycache__/tool.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "39af1a0b6a65b116ae874cfa2cfbdbafa05278a28b091a73e237f1ef50111dc6", + "sha256_in_prefix": "39af1a0b6a65b116ae874cfa2cfbdbafa05278a28b091a73e237f1ef50111dc6", + "size_in_bytes": 3070 + }, + { + "_path": "lib/python3.10/json/decoder.py", + "path_type": "hardlink", + "sha256": "9f02654649816145bc76f8c210a5fe3ba1de142d4d97a1c93105732e747c285b", + "sha256_in_prefix": "9f02654649816145bc76f8c210a5fe3ba1de142d4d97a1c93105732e747c285b", + "size_in_bytes": 12473 + }, + { + "_path": "lib/python3.10/json/encoder.py", + "path_type": "hardlink", + "sha256": "06b881b824f71e95d72af4ab865de4c35553e791b6d959a125caac61401cc350", + "sha256_in_prefix": "06b881b824f71e95d72af4ab865de4c35553e791b6d959a125caac61401cc350", + "size_in_bytes": 16074 + }, + { + "_path": "lib/python3.10/json/scanner.py", + "path_type": "hardlink", + "sha256": "8604d9d03786d0d509abb49e9f069337278ea988c244069ae8ca2c89acc2cb08", + "sha256_in_prefix": "8604d9d03786d0d509abb49e9f069337278ea988c244069ae8ca2c89acc2cb08", + "size_in_bytes": 2425 + }, + { + "_path": "lib/python3.10/json/tool.py", + "path_type": "hardlink", + "sha256": "d5174b728b376a12cff3f17472d6b9b609c1d3926f7ee02d74d60c80afd60c77", + "sha256_in_prefix": "d5174b728b376a12cff3f17472d6b9b609c1d3926f7ee02d74d60c80afd60c77", + "size_in_bytes": 3339 + }, + { + "_path": "lib/python3.10/keyword.py", + "path_type": "hardlink", + "sha256": "afbe73afb68d32fa998e5ff3d081090deec457152470f5331cc2bd430a0e9d2a", + "sha256_in_prefix": "afbe73afb68d32fa998e5ff3d081090deec457152470f5331cc2bd430a0e9d2a", + "size_in_bytes": 1061 + }, + { + "_path": "lib/python3.10/lib-dynload/_asyncio.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "5d82cecfbc015a419b2748d3068546318c085ccc11eb4e8cf491bf73663d981f", + "sha256_in_prefix": "5d82cecfbc015a419b2748d3068546318c085ccc11eb4e8cf491bf73663d981f", + "size_in_bytes": 101456 + }, + { + "_path": "lib/python3.10/lib-dynload/_bisect.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "093be40932b968de7c0bdb664862a6bc90f86da863de6742895332ba54a7f7e8", + "sha256_in_prefix": "093be40932b968de7c0bdb664862a6bc90f86da863de6742895332ba54a7f7e8", + "size_in_bytes": 69584 + }, + { + "_path": "lib/python3.10/lib-dynload/_blake2.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "57ec51989c1b33acbfc0aa2232f53b4011f408a59d0b8b47a060837e9ed12097", + "sha256_in_prefix": "57ec51989c1b33acbfc0aa2232f53b4011f408a59d0b8b47a060837e9ed12097", + "size_in_bytes": 89008 + }, + { + "_path": "lib/python3.10/lib-dynload/_bz2.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "2d304f30e3b43a8f274e31950dda5b86be4c22786874c6af1c1affc3493832e9", + "sha256_in_prefix": "2d304f30e3b43a8f274e31950dda5b86be4c22786874c6af1c1affc3493832e9", + "size_in_bytes": 72320 + }, + { + "_path": "lib/python3.10/lib-dynload/_codecs_cn.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "21fb70f49261b06ed5e642a83efc14335f1af4e97ed87827cf66d8fbd21be61b", + "sha256_in_prefix": "21fb70f49261b06ed5e642a83efc14335f1af4e97ed87827cf66d8fbd21be61b", + "size_in_bytes": 185712 + }, + { + "_path": "lib/python3.10/lib-dynload/_codecs_hk.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "b1865fbc76c9ce0b4182e23787692b7afcf219b2b25cbc2edd3c98f85e2c7061", + "sha256_in_prefix": "b1865fbc76c9ce0b4182e23787692b7afcf219b2b25cbc2edd3c98f85e2c7061", + "size_in_bytes": 185936 + }, + { + "_path": "lib/python3.10/lib-dynload/_codecs_iso2022.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "85380a8f0a705c559c33923eeb97e9d72e6eb6916070529349998c59158a7a35", + "sha256_in_prefix": "85380a8f0a705c559c33923eeb97e9d72e6eb6916070529349998c59158a7a35", + "size_in_bytes": 71888 + }, + { + "_path": "lib/python3.10/lib-dynload/_codecs_jp.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "f85999cb766472fdd70161e74fd72b2a9a02da233eb9a4f71e12023f2dda0876", + "sha256_in_prefix": "f85999cb766472fdd70161e74fd72b2a9a02da233eb9a4f71e12023f2dda0876", + "size_in_bytes": 302816 + }, + { + "_path": "lib/python3.10/lib-dynload/_codecs_kr.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "10715f7fd430d75bf305aa69478c51f4926e14e24eafa2e157d59c9fb12fd919", + "sha256_in_prefix": "10715f7fd430d75bf305aa69478c51f4926e14e24eafa2e157d59c9fb12fd919", + "size_in_bytes": 169200 + }, + { + "_path": "lib/python3.10/lib-dynload/_codecs_tw.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "084fa36e86104f23e1c486f2cbc5e675f6307c39fe9a15a953ea649ec723393f", + "sha256_in_prefix": "084fa36e86104f23e1c486f2cbc5e675f6307c39fe9a15a953ea649ec723393f", + "size_in_bytes": 152112 + }, + { + "_path": "lib/python3.10/lib-dynload/_contextvars.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "9f81f0981e5e0702e646fd4c18a38ffe1fb07185689103819c767c2be5579aef", + "sha256_in_prefix": "9f81f0981e5e0702e646fd4c18a38ffe1fb07185689103819c767c2be5579aef", + "size_in_bytes": 67824 + }, + { + "_path": "lib/python3.10/lib-dynload/_crypt.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "e1743c18375b0a0c6a5cc85d92a5b721cc2c9f26299b0cfdfa4e94ed14bb7a23", + "sha256_in_prefix": "e1743c18375b0a0c6a5cc85d92a5b721cc2c9f26299b0cfdfa4e94ed14bb7a23", + "size_in_bytes": 68096 + }, + { + "_path": "lib/python3.10/lib-dynload/_csv.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "bebece637699577ef329cee12258b82aca31823f45d94c2c7e19236551948abe", + "sha256_in_prefix": "bebece637699577ef329cee12258b82aca31823f45d94c2c7e19236551948abe", + "size_in_bytes": 90496 + }, + { + "_path": "lib/python3.10/lib-dynload/_ctypes.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "7ca787e2114ad9dea7af10b4f7f819060c0e2b5b57c8cc9a80baa0b58c3c0c0d", + "sha256_in_prefix": "7ca787e2114ad9dea7af10b4f7f819060c0e2b5b57c8cc9a80baa0b58c3c0c0d", + "size_in_bytes": 159808 + }, + { + "_path": "lib/python3.10/lib-dynload/_ctypes_test.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "cf0315de6e074dc567a8316a1c7a076073222a7ba2b27b46b3235ad8b5872c14", + "sha256_in_prefix": "cf0315de6e074dc567a8316a1c7a076073222a7ba2b27b46b3235ad8b5872c14", + "size_in_bytes": 73136 + }, + { + "_path": "lib/python3.10/lib-dynload/_curses.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "2126810ac3c2f2c218ae3356d38830727cd33dcb1fdd606c161cef97d5ffb6a9", + "sha256_in_prefix": "2126810ac3c2f2c218ae3356d38830727cd33dcb1fdd606c161cef97d5ffb6a9", + "size_in_bytes": 175808 + }, + { + "_path": "lib/python3.10/lib-dynload/_curses_panel.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "154184360b4ddb7432e76039a4d74ffd10f62bfa03b192a386b99f975135a52a", + "sha256_in_prefix": "154184360b4ddb7432e76039a4d74ffd10f62bfa03b192a386b99f975135a52a", + "size_in_bytes": 72480 + }, + { + "_path": "lib/python3.10/lib-dynload/_datetime.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "9df24fd2dafa324c86618e001e88f75a0f01b9f39c9d0e47a432ac414e5d2723", + "sha256_in_prefix": "9df24fd2dafa324c86618e001e88f75a0f01b9f39c9d0e47a432ac414e5d2723", + "size_in_bytes": 133552 + }, + { + "_path": "lib/python3.10/lib-dynload/_dbm.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "f297074703e243e526bfa98ee2c6050f41d2bd54eb2068aa96ab4f4a8b342ce7", + "sha256_in_prefix": "f297074703e243e526bfa98ee2c6050f41d2bd54eb2068aa96ab4f4a8b342ce7", + "size_in_bytes": 71680 + }, + { + "_path": "lib/python3.10/lib-dynload/_decimal.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "87c2befbcd4a4e300be8fa0cc9996307cd5ca3b212b2cd5678c19bd26cde5957", + "sha256_in_prefix": "87c2befbcd4a4e300be8fa0cc9996307cd5ca3b212b2cd5678c19bd26cde5957", + "size_in_bytes": 328496 + }, + { + "_path": "lib/python3.10/lib-dynload/_elementtree.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "ca13a24024cc57c4b6d7115a06a0640d1807fbaaa1d7074a6f35724856c6e69e", + "sha256_in_prefix": "ca13a24024cc57c4b6d7115a06a0640d1807fbaaa1d7074a6f35724856c6e69e", + "size_in_bytes": 117536 + }, + { + "_path": "lib/python3.10/lib-dynload/_hashlib.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "dc8fc554194ab1647d3d537dded321fb6869ccca13f7c9606c239fed8520b6a6", + "sha256_in_prefix": "dc8fc554194ab1647d3d537dded321fb6869ccca13f7c9606c239fed8520b6a6", + "size_in_bytes": 97648 + }, + { + "_path": "lib/python3.10/lib-dynload/_heapq.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "d2f656ea36691d8d47a8d771d9dbdea34fe4ba3b59d60dfc09641c19eec76fe8", + "sha256_in_prefix": "d2f656ea36691d8d47a8d771d9dbdea34fe4ba3b59d60dfc09641c19eec76fe8", + "size_in_bytes": 68976 + }, + { + "_path": "lib/python3.10/lib-dynload/_json.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "d585e6946c0d97b6c3df8d38cce215805272f4f5d896818e21bd0e0024dbcaf3", + "sha256_in_prefix": "d585e6946c0d97b6c3df8d38cce215805272f4f5d896818e21bd0e0024dbcaf3", + "size_in_bytes": 90944 + }, + { + "_path": "lib/python3.10/lib-dynload/_lsprof.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "bc296921f35ec5aab4307212fa8a25f03a0d5f7c460b4b8a16bec490ba368aa2", + "sha256_in_prefix": "bc296921f35ec5aab4307212fa8a25f03a0d5f7c460b4b8a16bec490ba368aa2", + "size_in_bytes": 71552 + }, + { + "_path": "lib/python3.10/lib-dynload/_lzma.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "fdec3ee1405d89479cf9fac9da05ed7c1d4d6f1e7325304deaae489fb0693cea", + "sha256_in_prefix": "fdec3ee1405d89479cf9fac9da05ed7c1d4d6f1e7325304deaae489fb0693cea", + "size_in_bytes": 92576 + }, + { + "_path": "lib/python3.10/lib-dynload/_md5.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "b44c0ef7a580fed725d21ea638cc34709ff558f6b0a7f42612776cf47dd5ede0", + "sha256_in_prefix": "b44c0ef7a580fed725d21ea638cc34709ff558f6b0a7f42612776cf47dd5ede0", + "size_in_bytes": 70096 + }, + { + "_path": "lib/python3.10/lib-dynload/_multibytecodec.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "320ac2b5148921271b7ff4b13186adde5a0e9ec084d208062e014387262bac4b", + "sha256_in_prefix": "320ac2b5148921271b7ff4b13186adde5a0e9ec084d208062e014387262bac4b", + "size_in_bytes": 96064 + }, + { + "_path": "lib/python3.10/lib-dynload/_multiprocessing.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "8a42d99ff591b75523c6af6fceb58e62201177a86324644a41020cbfbcb56ac0", + "sha256_in_prefix": "8a42d99ff591b75523c6af6fceb58e62201177a86324644a41020cbfbcb56ac0", + "size_in_bytes": 72368 + }, + { + "_path": "lib/python3.10/lib-dynload/_opcode.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "12ce463dcc75122a9a7bbb853888883aff782c81b560af2a8df1031d99d97a27", + "sha256_in_prefix": "12ce463dcc75122a9a7bbb853888883aff782c81b560af2a8df1031d99d97a27", + "size_in_bytes": 68352 + }, + { + "_path": "lib/python3.10/lib-dynload/_pickle.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "3d08e01bf1b6a7e4aaba137ad801c5709f90d6fb9aa2f09b9ace0f58986af071", + "sha256_in_prefix": "3d08e01bf1b6a7e4aaba137ad801c5709f90d6fb9aa2f09b9ace0f58986af071", + "size_in_bytes": 170192 + }, + { + "_path": "lib/python3.10/lib-dynload/_posixshmem.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "f132715c6ef4cac68d6b79da8f8c4fc2097f1cac34647f6ddff9c8e3e6aae866", + "sha256_in_prefix": "f132715c6ef4cac68d6b79da8f8c4fc2097f1cac34647f6ddff9c8e3e6aae866", + "size_in_bytes": 68848 + }, + { + "_path": "lib/python3.10/lib-dynload/_posixsubprocess.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "0de0c19ffdd93ba192cd8ac7498b2d941248bcc6035831d0028b7006a2f6a5f5", + "sha256_in_prefix": "0de0c19ffdd93ba192cd8ac7498b2d941248bcc6035831d0028b7006a2f6a5f5", + "size_in_bytes": 71424 + }, + { + "_path": "lib/python3.10/lib-dynload/_queue.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "686d2b524eb935d27f54acf67747b700fd0ba0c36e128560358d1443789775a9", + "sha256_in_prefix": "686d2b524eb935d27f54acf67747b700fd0ba0c36e128560358d1443789775a9", + "size_in_bytes": 71616 + }, + { + "_path": "lib/python3.10/lib-dynload/_random.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "3b65f017ded61b01dac6bc7c6f717635f78dbd16a5330f9f9fd7b6c35f5c6f0f", + "sha256_in_prefix": "3b65f017ded61b01dac6bc7c6f717635f78dbd16a5330f9f9fd7b6c35f5c6f0f", + "size_in_bytes": 71328 + }, + { + "_path": "lib/python3.10/lib-dynload/_scproxy.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "25a2f54dd02fcfb0ea1bd6e786b19fb559d78eeb72e5fb7bb458593497ae1c3c", + "sha256_in_prefix": "25a2f54dd02fcfb0ea1bd6e786b19fb559d78eeb72e5fb7bb458593497ae1c3c", + "size_in_bytes": 70304 + }, + { + "_path": "lib/python3.10/lib-dynload/_sha1.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "1baec840a885c37418f4f01d42626ca9ae4c74fee46578e8385787bb9154c0b0", + "sha256_in_prefix": "1baec840a885c37418f4f01d42626ca9ae4c74fee46578e8385787bb9154c0b0", + "size_in_bytes": 70064 + }, + { + "_path": "lib/python3.10/lib-dynload/_sha256.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "4c46541b4f433fbbaa3fd9d77e20c5e31f8a31d4b8b21330e7f317d7879e29e4", + "sha256_in_prefix": "4c46541b4f433fbbaa3fd9d77e20c5e31f8a31d4b8b21330e7f317d7879e29e4", + "size_in_bytes": 70304 + }, + { + "_path": "lib/python3.10/lib-dynload/_sha3.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "d8cbbde36785565c0ebd59ad7bc29be3b5d7e6ca7b7e94ca2e918f211373cc20", + "sha256_in_prefix": "d8cbbde36785565c0ebd59ad7bc29be3b5d7e6ca7b7e94ca2e918f211373cc20", + "size_in_bytes": 105408 + }, + { + "_path": "lib/python3.10/lib-dynload/_sha512.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "e6a56cb1fa53a72f13205b762033b965905d6fdc62c0ace3ac07c5ede287243e", + "sha256_in_prefix": "e6a56cb1fa53a72f13205b762033b965905d6fdc62c0ace3ac07c5ede287243e", + "size_in_bytes": 70384 + }, + { + "_path": "lib/python3.10/lib-dynload/_socket.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "ada2dfc76199e983a6475217d70c1fd2a145d7fe8f6c72bf95e211d8408431c6", + "sha256_in_prefix": "ada2dfc76199e983a6475217d70c1fd2a145d7fe8f6c72bf95e211d8408431c6", + "size_in_bytes": 131760 + }, + { + "_path": "lib/python3.10/lib-dynload/_sqlite3.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "7f5b3546c90806db8b4c0a1f3bf6f4d4fedf40429678631d948c8c85c7850a80", + "sha256_in_prefix": "7f5b3546c90806db8b4c0a1f3bf6f4d4fedf40429678631d948c8c85c7850a80", + "size_in_bytes": 143104 + }, + { + "_path": "lib/python3.10/lib-dynload/_ssl.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "2c5e2d0f2bcb5e810d6e4066571732f82b83c4849be43be101f16b001df2bb21", + "sha256_in_prefix": "2c5e2d0f2bcb5e810d6e4066571732f82b83c4849be43be101f16b001df2bb21", + "size_in_bytes": 221152 + }, + { + "_path": "lib/python3.10/lib-dynload/_statistics.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "d5cdee50b02ecfc16a0e68a9d72e36722037f7c79087531e59dc60f277686f97", + "sha256_in_prefix": "d5cdee50b02ecfc16a0e68a9d72e36722037f7c79087531e59dc60f277686f97", + "size_in_bytes": 68032 + }, + { + "_path": "lib/python3.10/lib-dynload/_struct.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "1ef1e50d20e45ffabfaa312556aa1806296d7e55f49c1cebedad96df974e81b0", + "sha256_in_prefix": "1ef1e50d20e45ffabfaa312556aa1806296d7e55f49c1cebedad96df974e81b0", + "size_in_bytes": 94512 + }, + { + "_path": "lib/python3.10/lib-dynload/_testbuffer.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "b2a372eab64f5f154934827214c057abbb9159a8cfc9df1b9257220fbca0b63a", + "sha256_in_prefix": "b2a372eab64f5f154934827214c057abbb9159a8cfc9df1b9257220fbca0b63a", + "size_in_bytes": 91744 + }, + { + "_path": "lib/python3.10/lib-dynload/_testcapi.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "cc8d5522a7b943c2f61df8660f624dbf848cd67d2cbd33ecfcd85b52cae8d00a", + "sha256_in_prefix": "cc8d5522a7b943c2f61df8660f624dbf848cd67d2cbd33ecfcd85b52cae8d00a", + "size_in_bytes": 185872 + }, + { + "_path": "lib/python3.10/lib-dynload/_testclinic.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "6ac27c133ceea5cd6620dc98c042dd9001e13feaa03e96bd6fbd5e7eeca993f4", + "sha256_in_prefix": "6ac27c133ceea5cd6620dc98c042dd9001e13feaa03e96bd6fbd5e7eeca993f4", + "size_in_bytes": 93168 + }, + { + "_path": "lib/python3.10/lib-dynload/_testimportmultiple.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "0a2ad3912e5c75aff7575a996b3faf310f7615c59d9703cbb62438ce8de3e708", + "sha256_in_prefix": "0a2ad3912e5c75aff7575a996b3faf310f7615c59d9703cbb62438ce8de3e708", + "size_in_bytes": 67488 + }, + { + "_path": "lib/python3.10/lib-dynload/_testinternalcapi.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "d25de0c437ec2ef952440c638aef9a8bd17b795d755b9d827daf6090430e7b33", + "sha256_in_prefix": "d25de0c437ec2ef952440c638aef9a8bd17b795d755b9d827daf6090430e7b33", + "size_in_bytes": 69888 + }, + { + "_path": "lib/python3.10/lib-dynload/_testmultiphase.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "96d6f3b62d3068a68b51ab3c14b74e828d725fd1b0dad1f7e6ed4437c33c6481", + "sha256_in_prefix": "96d6f3b62d3068a68b51ab3c14b74e828d725fd1b0dad1f7e6ed4437c33c6481", + "size_in_bytes": 75616 + }, + { + "_path": "lib/python3.10/lib-dynload/_tkinter.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "1b913c8475e5679e6553922a0a49247dfb0b2943bf1b2da31829c1f8b1f62bcd", + "sha256_in_prefix": "1b913c8475e5679e6553922a0a49247dfb0b2943bf1b2da31829c1f8b1f62bcd", + "size_in_bytes": 118704 + }, + { + "_path": "lib/python3.10/lib-dynload/_uuid.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "98d3ae290d22078e7827832ca18b118ee48ea6f1fec48de15f06012d8802a691", + "sha256_in_prefix": "98d3ae290d22078e7827832ca18b118ee48ea6f1fec48de15f06012d8802a691", + "size_in_bytes": 67760 + }, + { + "_path": "lib/python3.10/lib-dynload/_xxsubinterpreters.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "18ca17c7aebc862dedb1b25fedfb8b4f4ae525bdbd15f8d0b7b52de183737560", + "sha256_in_prefix": "18ca17c7aebc862dedb1b25fedfb8b4f4ae525bdbd15f8d0b7b52de183737560", + "size_in_bytes": 92560 + }, + { + "_path": "lib/python3.10/lib-dynload/_xxtestfuzz.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "b98a21e3eeccb3bec24cdaf8b7b753447dbe9272c69077d473dd2f414604f7e6", + "sha256_in_prefix": "b98a21e3eeccb3bec24cdaf8b7b753447dbe9272c69077d473dd2f414604f7e6", + "size_in_bytes": 70512 + }, + { + "_path": "lib/python3.10/lib-dynload/_zoneinfo.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "5bb8471f614e6fb2e4d0dc63cb33accf0f55b45a385a1c8a871a867ce6ad6d53", + "sha256_in_prefix": "5bb8471f614e6fb2e4d0dc63cb33accf0f55b45a385a1c8a871a867ce6ad6d53", + "size_in_bytes": 89296 + }, + { + "_path": "lib/python3.10/lib-dynload/array.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "03385b53f0120668ec1f7e3c666b76d9169395b772b263b71b7ce8e8c9b4d2ea", + "sha256_in_prefix": "03385b53f0120668ec1f7e3c666b76d9169395b772b263b71b7ce8e8c9b4d2ea", + "size_in_bytes": 96720 + }, + { + "_path": "lib/python3.10/lib-dynload/audioop.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "69fb3868ac2687b1fdbc62607e3095df3fedf63800de5b3b6deb6cc264ec3535", + "sha256_in_prefix": "69fb3868ac2687b1fdbc62607e3095df3fedf63800de5b3b6deb6cc264ec3535", + "size_in_bytes": 88832 + }, + { + "_path": "lib/python3.10/lib-dynload/binascii.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "367dc521b4957609975bc76bdd1875516966f506d8b7e1c537357fd3c048dcb7", + "sha256_in_prefix": "367dc521b4957609975bc76bdd1875516966f506d8b7e1c537357fd3c048dcb7", + "size_in_bytes": 72208 + }, + { + "_path": "lib/python3.10/lib-dynload/cmath.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "10ec429b03e7f8c194c20b7e5a2ab5f0b75c6511936889d24b68eddf5e2aaab6", + "sha256_in_prefix": "10ec429b03e7f8c194c20b7e5a2ab5f0b75c6511936889d24b68eddf5e2aaab6", + "size_in_bytes": 88464 + }, + { + "_path": "lib/python3.10/lib-dynload/fcntl.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "4b6b194820b3c99323db40cd235ff80a56d8a26bd4e8e6bed53413c8a977dd9d", + "sha256_in_prefix": "4b6b194820b3c99323db40cd235ff80a56d8a26bd4e8e6bed53413c8a977dd9d", + "size_in_bytes": 69696 + }, + { + "_path": "lib/python3.10/lib-dynload/grp.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "043015ebd519ab6c812e1c6802b7dbeda772584705860f9293ea2df328d4b71a", + "sha256_in_prefix": "043015ebd519ab6c812e1c6802b7dbeda772584705860f9293ea2df328d4b71a", + "size_in_bytes": 70032 + }, + { + "_path": "lib/python3.10/lib-dynload/math.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "bae02e2ebc3d45cde92eded9967c3426610ee898f3f56cfca12d27f72b77ec62", + "sha256_in_prefix": "bae02e2ebc3d45cde92eded9967c3426610ee898f3f56cfca12d27f72b77ec62", + "size_in_bytes": 110496 + }, + { + "_path": "lib/python3.10/lib-dynload/mmap.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "309c7db7782142c11b8544ab9b0cb2bf924238bd509199535464f63e3e70dc50", + "sha256_in_prefix": "309c7db7782142c11b8544ab9b0cb2bf924238bd509199535464f63e3e70dc50", + "size_in_bytes": 72944 + }, + { + "_path": "lib/python3.10/lib-dynload/nis.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "6e0b3b6f94b5ca158123721f9ecdbfd08994631a2df8dbb5b93e1a616057ff85", + "sha256_in_prefix": "6e0b3b6f94b5ca158123721f9ecdbfd08994631a2df8dbb5b93e1a616057ff85", + "size_in_bytes": 70160 + }, + { + "_path": "lib/python3.10/lib-dynload/pyexpat.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "13f5fb80dfeedaf96b72697864e5db6b8bcac48ca88a8fb369d988acacdf1c97", + "sha256_in_prefix": "13f5fb80dfeedaf96b72697864e5db6b8bcac48ca88a8fb369d988acacdf1c97", + "size_in_bytes": 223792 + }, + { + "_path": "lib/python3.10/lib-dynload/readline.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "d62506fc346eb5287d4e62fdcfe88e187d2bca7509bf31b175222ff17b4927c6", + "sha256_in_prefix": "d62506fc346eb5287d4e62fdcfe88e187d2bca7509bf31b175222ff17b4927c6", + "size_in_bytes": 78880 + }, + { + "_path": "lib/python3.10/lib-dynload/resource.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "aad53ed365f18c5151c6d54160faf04945402267f92f13d3d72d9f2370cbf14e", + "sha256_in_prefix": "aad53ed365f18c5151c6d54160faf04945402267f92f13d3d72d9f2370cbf14e", + "size_in_bytes": 69840 + }, + { + "_path": "lib/python3.10/lib-dynload/select.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "429ebd6360354ddb97160562d7a4b4381977871df2434929368f35b3597c289d", + "sha256_in_prefix": "429ebd6360354ddb97160562d7a4b4381977871df2434929368f35b3597c289d", + "size_in_bytes": 74784 + }, + { + "_path": "lib/python3.10/lib-dynload/syslog.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "227f8733262f756d1dae9770c7b50d2e4c56204f955d3aac7afa80cb57308cc7", + "sha256_in_prefix": "227f8733262f756d1dae9770c7b50d2e4c56204f955d3aac7afa80cb57308cc7", + "size_in_bytes": 68960 + }, + { + "_path": "lib/python3.10/lib-dynload/termios.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "ab6809871a3fe9428352a0cd0c1b81b9d8f6591488dc2e923c8bb79fb36844d2", + "sha256_in_prefix": "ab6809871a3fe9428352a0cd0c1b81b9d8f6591488dc2e923c8bb79fb36844d2", + "size_in_bytes": 70384 + }, + { + "_path": "lib/python3.10/lib-dynload/unicodedata.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "55dbf2389a2a0bd99588e56617d781f6b266800fec3aa11af09861d94a5d3d21", + "sha256_in_prefix": "55dbf2389a2a0bd99588e56617d781f6b266800fec3aa11af09861d94a5d3d21", + "size_in_bytes": 1169200 + }, + { + "_path": "lib/python3.10/lib-dynload/xxlimited.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "ce30331a8a898af31de6e13f75bcd2b1084a7c5786af50696dc2a2978ba7d319", + "sha256_in_prefix": "ce30331a8a898af31de6e13f75bcd2b1084a7c5786af50696dc2a2978ba7d319", + "size_in_bytes": 69648 + }, + { + "_path": "lib/python3.10/lib-dynload/xxlimited_35.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "46aea107d229dd52cc1f0695a199da37f52dfb272f20265b6664ec233ce6f296", + "sha256_in_prefix": "46aea107d229dd52cc1f0695a199da37f52dfb272f20265b6664ec233ce6f296", + "size_in_bytes": 69648 + }, + { + "_path": "lib/python3.10/lib-dynload/zlib.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "4a5190a629ec2840f1f0f351efb6fc70f26884469a0ff8a273cda9dab7a669b5", + "sha256_in_prefix": "4a5190a629ec2840f1f0f351efb6fc70f26884469a0ff8a273cda9dab7a669b5", + "size_in_bytes": 91872 + }, + { + "_path": "lib/python3.10/lib2to3/Grammar.txt", + "path_type": "hardlink", + "sha256": "508e62e787dd756eb0a4eb1b8d128320ca02cd246ab14cc8ce0a476dc88cc5b6", + "sha256_in_prefix": "508e62e787dd756eb0a4eb1b8d128320ca02cd246ab14cc8ce0a476dc88cc5b6", + "size_in_bytes": 8696 + }, + { + "_path": "lib/python3.10/lib2to3/Grammar3.10.14.final.0.pickle", + "path_type": "hardlink", + "sha256": "97c8ed74d091fcfd23498029bb819c29d096c3dcb1326edee5dfb0591ade2e4b", + "sha256_in_prefix": "97c8ed74d091fcfd23498029bb819c29d096c3dcb1326edee5dfb0591ade2e4b", + "size_in_bytes": 15313 + }, + { + "_path": "lib/python3.10/lib2to3/PatternGrammar.txt", + "path_type": "hardlink", + "sha256": "ee5ba5db3b6722a0e2fbe2560ebc1c883e72328ef9c3b4da1c7c5d1cc649bce3", + "sha256_in_prefix": "ee5ba5db3b6722a0e2fbe2560ebc1c883e72328ef9c3b4da1c7c5d1cc649bce3", + "size_in_bytes": 793 + }, + { + "_path": "lib/python3.10/lib2to3/PatternGrammar3.10.14.final.0.pickle", + "path_type": "hardlink", + "sha256": "36ee934395b9209737b13893ddaff05fad8e239c2fdfac29d401d3fceeb30768", + "sha256_in_prefix": "36ee934395b9209737b13893ddaff05fad8e239c2fdfac29d401d3fceeb30768", + "size_in_bytes": 1225 + }, + { + "_path": "lib/python3.10/lib2to3/__init__.py", + "path_type": "hardlink", + "sha256": "f4d8715dcaeb8183319e613f00574170b06ca2ff7af34e62d6e869919fc129d7", + "sha256_in_prefix": "f4d8715dcaeb8183319e613f00574170b06ca2ff7af34e62d6e869919fc129d7", + "size_in_bytes": 163 + }, + { + "_path": "lib/python3.10/lib2to3/__main__.py", + "path_type": "hardlink", + "sha256": "c7b09f90e66dea194ad63dc02c6425dff977d16f1f21a157b7475905c219a707", + "sha256_in_prefix": "c7b09f90e66dea194ad63dc02c6425dff977d16f1f21a157b7475905c219a707", + "size_in_bytes": 67 + }, + { + "_path": "lib/python3.10/lib2to3/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "1b02c9ca58e6c8f5c9b8387a9025af2441cfcbd90252844d481b7980698a4f65", + "sha256_in_prefix": "1b02c9ca58e6c8f5c9b8387a9025af2441cfcbd90252844d481b7980698a4f65", + "size_in_bytes": 557 + }, + { + "_path": "lib/python3.10/lib2to3/__pycache__/__main__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "d8b3e9c76ad9a5ea0e3d131cf7f1b21c85e24bce0d2402d5b374df0aa91a0573", + "sha256_in_prefix": "d8b3e9c76ad9a5ea0e3d131cf7f1b21c85e24bce0d2402d5b374df0aa91a0573", + "size_in_bytes": 470 + }, + { + "_path": "lib/python3.10/lib2to3/__pycache__/btm_matcher.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "985059cae6b09e1c75af04894992e94642ee0581cd460f3121896520f6215b7a", + "sha256_in_prefix": "985059cae6b09e1c75af04894992e94642ee0581cd460f3121896520f6215b7a", + "size_in_bytes": 5154 + }, + { + "_path": "lib/python3.10/lib2to3/__pycache__/btm_utils.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "cfac9ada7b6531474db27d749f8c133c62a5bd60c419e3245174d7eff7d35e91", + "sha256_in_prefix": "cfac9ada7b6531474db27d749f8c133c62a5bd60c419e3245174d7eff7d35e91", + "size_in_bytes": 6415 + }, + { + "_path": "lib/python3.10/lib2to3/__pycache__/fixer_base.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "18aa507e920bdd621c617c2d93e22e9dceec358140adde9b0742421fe4b9834a", + "sha256_in_prefix": "18aa507e920bdd621c617c2d93e22e9dceec358140adde9b0742421fe4b9834a", + "size_in_bytes": 6533 + }, + { + "_path": "lib/python3.10/lib2to3/__pycache__/fixer_util.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "006ce04570582b4b390aa58d3cb9d81615b018cf97872c0030cc85106c44cbef", + "sha256_in_prefix": "006ce04570582b4b390aa58d3cb9d81615b018cf97872c0030cc85106c44cbef", + "size_in_bytes": 12322 + }, + { + "_path": "lib/python3.10/lib2to3/__pycache__/main.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "d51e2194073e0bed35ad82a9b7d5a46a4f051f949b72c857c7c55a9ea0b2c2bd", + "sha256_in_prefix": "d51e2194073e0bed35ad82a9b7d5a46a4f051f949b72c857c7c55a9ea0b2c2bd", + "size_in_bytes": 8956 + }, + { + "_path": "lib/python3.10/lib2to3/__pycache__/patcomp.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "e373e9e143bdbace0185178f9ef5269d2d1218a350e4c1212391deb8759caa9b", + "sha256_in_prefix": "e373e9e143bdbace0185178f9ef5269d2d1218a350e4c1212391deb8759caa9b", + "size_in_bytes": 5790 + }, + { + "_path": "lib/python3.10/lib2to3/__pycache__/pygram.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "3c96ddaa10c83dcb2117caee99008b0388247aac1696289623514b8ab02a0e62", + "sha256_in_prefix": "3c96ddaa10c83dcb2117caee99008b0388247aac1696289623514b8ab02a0e62", + "size_in_bytes": 1521 + }, + { + "_path": "lib/python3.10/lib2to3/__pycache__/pytree.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c05ae3d4ca3c49613836ab97fed7f1df9204be912186b0aa964c8212bfb7a5c2", + "sha256_in_prefix": "c05ae3d4ca3c49613836ab97fed7f1df9204be912186b0aa964c8212bfb7a5c2", + "size_in_bytes": 24658 + }, + { + "_path": "lib/python3.10/lib2to3/__pycache__/refactor.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "854a51c18991f6c51fa6241bdc8efa4f05bf7ab60b6338619dd459130af0adac", + "sha256_in_prefix": "854a51c18991f6c51fa6241bdc8efa4f05bf7ab60b6338619dd459130af0adac", + "size_in_bytes": 20993 + }, + { + "_path": "lib/python3.10/lib2to3/btm_matcher.py", + "path_type": "hardlink", + "sha256": "a1aa5d35558acf4b6016054963285cb145f97a764926bea07cbd674563f3248d", + "sha256_in_prefix": "a1aa5d35558acf4b6016054963285cb145f97a764926bea07cbd674563f3248d", + "size_in_bytes": 6623 + }, + { + "_path": "lib/python3.10/lib2to3/btm_utils.py", + "path_type": "hardlink", + "sha256": "79d210510630052adafcc7c4ad8cf16acd2fd8e9adb46deea952cd81bfbea661", + "sha256_in_prefix": "79d210510630052adafcc7c4ad8cf16acd2fd8e9adb46deea952cd81bfbea661", + "size_in_bytes": 9966 + }, + { + "_path": "lib/python3.10/lib2to3/fixer_base.py", + "path_type": "hardlink", + "sha256": "c795a53ca849c42212c8ec33a74284e0377df852eb4ea599aba62d5af1df282a", + "sha256_in_prefix": "c795a53ca849c42212c8ec33a74284e0377df852eb4ea599aba62d5af1df282a", + "size_in_bytes": 6690 + }, + { + "_path": "lib/python3.10/lib2to3/fixer_util.py", + "path_type": "hardlink", + "sha256": "306d0b2ea8169bdca711c6a31c0b1a3ce710d38ae2b6568ef519aa38451af608", + "sha256_in_prefix": "306d0b2ea8169bdca711c6a31c0b1a3ce710d38ae2b6568ef519aa38451af608", + "size_in_bytes": 15206 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/__init__.py", + "path_type": "hardlink", + "sha256": "836cdb388117cf81e78d9fa2a141cca1b14b0179733322e710067749a1b16fe9", + "sha256_in_prefix": "836cdb388117cf81e78d9fa2a141cca1b14b0179733322e710067749a1b16fe9", + "size_in_bytes": 47 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "93e8548856ef6bf93ea186d1fdba8197089808cd28b42ef626685cf7b6a58469", + "sha256_in_prefix": "93e8548856ef6bf93ea186d1fdba8197089808cd28b42ef626685cf7b6a58469", + "size_in_bytes": 392 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/__pycache__/fix_apply.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "ff7a631568f2de4dc231d87dfb6214eeb876c5d7c7d01a0a51ae12c9ea50d5ad", + "sha256_in_prefix": "ff7a631568f2de4dc231d87dfb6214eeb876c5d7c7d01a0a51ae12c9ea50d5ad", + "size_in_bytes": 1906 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/__pycache__/fix_asserts.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "3412f5906c832fa3cb85f17fe4765d9b5810b9e2c9780886d978a9c480a42445", + "sha256_in_prefix": "3412f5906c832fa3cb85f17fe4765d9b5810b9e2c9780886d978a9c480a42445", + "size_in_bytes": 1272 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/__pycache__/fix_basestring.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "91e5fd9b8309e4eb325b35b2fcd0a4791e77823de257b6688bef6c5c3b88e21a", + "sha256_in_prefix": "91e5fd9b8309e4eb325b35b2fcd0a4791e77823de257b6688bef6c5c3b88e21a", + "size_in_bytes": 915 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/__pycache__/fix_buffer.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "54c3990071adec2d7d27c6bc0286a041ea45003f0f7cb2d8e810d2d9acbf51a8", + "sha256_in_prefix": "54c3990071adec2d7d27c6bc0286a041ea45003f0f7cb2d8e810d2d9acbf51a8", + "size_in_bytes": 1060 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/__pycache__/fix_dict.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "739c4aab2fb7ac30fd98b099870bb1bbe235add8922e995432cb2c02b6367e8e", + "sha256_in_prefix": "739c4aab2fb7ac30fd98b099870bb1bbe235add8922e995432cb2c02b6367e8e", + "size_in_bytes": 3541 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/__pycache__/fix_except.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "9f2766d40807ecc5e58b9fce5e0487f9a35fc1d2363d256dcb32522df9af1d95", + "sha256_in_prefix": "9f2766d40807ecc5e58b9fce5e0487f9a35fc1d2363d256dcb32522df9af1d95", + "size_in_bytes": 3026 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/__pycache__/fix_exec.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "8fff89150b7437eac22691e3dd03c78244a6f4262f0f41d4b2ea752162734de3", + "sha256_in_prefix": "8fff89150b7437eac22691e3dd03c78244a6f4262f0f41d4b2ea752162734de3", + "size_in_bytes": 1385 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/__pycache__/fix_execfile.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "cd70cd5b2ab2d37ebed507c53987d1039259564905ef92065627b01f2b1ccfd9", + "sha256_in_prefix": "cd70cd5b2ab2d37ebed507c53987d1039259564905ef92065627b01f2b1ccfd9", + "size_in_bytes": 1931 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/__pycache__/fix_exitfunc.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "42acd0268b7cd2f1a20f42f9d6e50a9b1cf8729e88600c61c71fbb28e309c979", + "sha256_in_prefix": "42acd0268b7cd2f1a20f42f9d6e50a9b1cf8729e88600c61c71fbb28e309c979", + "size_in_bytes": 2560 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/__pycache__/fix_filter.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "89a95c38b3f21c58ac2a3c9e2c3695f32d57000fd05ca50fa478f65f9756081e", + "sha256_in_prefix": "89a95c38b3f21c58ac2a3c9e2c3695f32d57000fd05ca50fa478f65f9756081e", + "size_in_bytes": 2694 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/__pycache__/fix_funcattrs.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "47d68dabdd87defedc9d9a68746dc3315e8e5013f288d9ca4f3f9cfdb1a55c88", + "sha256_in_prefix": "47d68dabdd87defedc9d9a68746dc3315e8e5013f288d9ca4f3f9cfdb1a55c88", + "size_in_bytes": 1228 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/__pycache__/fix_future.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "37f42df688fe16352ca07112d67773f55954edd07b14cab34488fbd961b4d11c", + "sha256_in_prefix": "37f42df688fe16352ca07112d67773f55954edd07b14cab34488fbd961b4d11c", + "size_in_bytes": 777 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/__pycache__/fix_getcwdu.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "18d9e6fbafe6fb87ce597cf75d585a563ee5af732dae4821860b1369103c15f7", + "sha256_in_prefix": "18d9e6fbafe6fb87ce597cf75d585a563ee5af732dae4821860b1369103c15f7", + "size_in_bytes": 1040 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/__pycache__/fix_has_key.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "9914a49cf9b5a8facf2a6e6995fe4430f7d396bcbff9c7e86d27e651557a5e11", + "sha256_in_prefix": "9914a49cf9b5a8facf2a6e6995fe4430f7d396bcbff9c7e86d27e651557a5e11", + "size_in_bytes": 2872 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/__pycache__/fix_idioms.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "276271f603ee7fb123102c7ce54fe0196a56e1fc19687a7783b3a9519b9a2fa8", + "sha256_in_prefix": "276271f603ee7fb123102c7ce54fe0196a56e1fc19687a7783b3a9519b9a2fa8", + "size_in_bytes": 4159 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/__pycache__/fix_import.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "76eee902357e30b260f4fdb6fddd2fe85cda0213987997dcf2a0bf40d0241c35", + "sha256_in_prefix": "76eee902357e30b260f4fdb6fddd2fe85cda0213987997dcf2a0bf40d0241c35", + "size_in_bytes": 3065 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/__pycache__/fix_imports.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "552e4f13c0e4c4a35d6b5b340813cdd3220d62f40f32f3162ae66dd589d4b867", + "sha256_in_prefix": "552e4f13c0e4c4a35d6b5b340813cdd3220d62f40f32f3162ae66dd589d4b867", + "size_in_bytes": 4881 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/__pycache__/fix_imports2.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c2c3d99afa5d9a4209fb20bdef4a80428f78565d6acc2eedb3e862dc3f39976b", + "sha256_in_prefix": "c2c3d99afa5d9a4209fb20bdef4a80428f78565d6acc2eedb3e862dc3f39976b", + "size_in_bytes": 798 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/__pycache__/fix_input.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "70a4e1080bc86eee1bf089434c2a1e3cbef995e6fead3ce75ed9fa81e07a7ac7", + "sha256_in_prefix": "70a4e1080bc86eee1bf089434c2a1e3cbef995e6fead3ce75ed9fa81e07a7ac7", + "size_in_bytes": 1202 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/__pycache__/fix_intern.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "0edbf433583034efa7dc5ed591276404c2ec039b26951f2eb49d337377a40a94", + "sha256_in_prefix": "0edbf433583034efa7dc5ed591276404c2ec039b26951f2eb49d337377a40a94", + "size_in_bytes": 1384 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/__pycache__/fix_isinstance.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c0a6acb713e31566255f63be5c85a5d082b96ba28933f36377ab71fe17b29cc7", + "sha256_in_prefix": "c0a6acb713e31566255f63be5c85a5d082b96ba28933f36377ab71fe17b29cc7", + "size_in_bytes": 1809 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/__pycache__/fix_itertools.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "65d83e64457adbcbafa88299bf79c0b1609ecac08637d89d64528a22bc1c2b72", + "sha256_in_prefix": "65d83e64457adbcbafa88299bf79c0b1609ecac08637d89d64528a22bc1c2b72", + "size_in_bytes": 1800 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/__pycache__/fix_itertools_imports.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "2dd4ea544b7f67dadcfa00bf07c67c47e42996979229ce458304b5da1273aa2d", + "sha256_in_prefix": "2dd4ea544b7f67dadcfa00bf07c67c47e42996979229ce458304b5da1273aa2d", + "size_in_bytes": 1820 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/__pycache__/fix_long.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "e1b74de8b0cecb58d2e1add118121ce87444074bd6de5aeca72e8aca31daef4f", + "sha256_in_prefix": "e1b74de8b0cecb58d2e1add118121ce87444074bd6de5aeca72e8aca31daef4f", + "size_in_bytes": 963 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/__pycache__/fix_map.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "81c04645d66e85a5d0d2ac4e9007043d3cab1101e09c7a2315285c80cf447d81", + "sha256_in_prefix": "81c04645d66e85a5d0d2ac4e9007043d3cab1101e09c7a2315285c80cf447d81", + "size_in_bytes": 3329 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/__pycache__/fix_metaclass.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "7b8b9fe63190c6e14021121122021165600ccbcd1d80778a221fe00b084b9730", + "sha256_in_prefix": "7b8b9fe63190c6e14021121122021165600ccbcd1d80778a221fe00b084b9730", + "size_in_bytes": 5659 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/__pycache__/fix_methodattrs.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c9851a2ce780b0631fc98d863c918d1b9809585e85403b4dd3facf8a2092cb13", + "sha256_in_prefix": "c9851a2ce780b0631fc98d863c918d1b9809585e85403b4dd3facf8a2092cb13", + "size_in_bytes": 931 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/__pycache__/fix_ne.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "e61244431683b365bce16d323ef998ab74bdb7fb90336e262335339b5a22e39d", + "sha256_in_prefix": "e61244431683b365bce16d323ef998ab74bdb7fb90336e262335339b5a22e39d", + "size_in_bytes": 1063 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/__pycache__/fix_next.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "42e68ba33ca23326ff3e6e20a2266377f8b7ee02169cc18d9ae5dcce1f136f10", + "sha256_in_prefix": "42e68ba33ca23326ff3e6e20a2266377f8b7ee02169cc18d9ae5dcce1f136f10", + "size_in_bytes": 3331 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/__pycache__/fix_nonzero.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "1d92b7c6e36fa274a7e0dff5c3b6a24733a22373e04ef9c87ac46dd99822a056", + "sha256_in_prefix": "1d92b7c6e36fa274a7e0dff5c3b6a24733a22373e04ef9c87ac46dd99822a056", + "size_in_bytes": 1175 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/__pycache__/fix_numliterals.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "861de63051d4015e105487742a3521e03c794abb9a36ef9ae345864cb39948d7", + "sha256_in_prefix": "861de63051d4015e105487742a3521e03c794abb9a36ef9ae345864cb39948d7", + "size_in_bytes": 1275 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/__pycache__/fix_operator.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "5d2bface10c06c8c4968810df48b918ed731903385e45a264c6557621a689ba3", + "sha256_in_prefix": "5d2bface10c06c8c4968810df48b918ed731903385e45a264c6557621a689ba3", + "size_in_bytes": 4406 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/__pycache__/fix_paren.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "067f4e6d429e6ca9670c8a003729afc8b6b354d7f12cb71c1846aae074e311f3", + "sha256_in_prefix": "067f4e6d429e6ca9670c8a003729afc8b6b354d7f12cb71c1846aae074e311f3", + "size_in_bytes": 1641 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/__pycache__/fix_print.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "ab5ac976bd1d0af4274e2ecb1b8df1459d0c5e3c8a67be3ce63749a705f2a5fc", + "sha256_in_prefix": "ab5ac976bd1d0af4274e2ecb1b8df1459d0c5e3c8a67be3ce63749a705f2a5fc", + "size_in_bytes": 2563 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/__pycache__/fix_raise.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c0c1eea837159c096017603c38d8736bc876fb8c1fd0bb3c253fc263f196bd9a", + "sha256_in_prefix": "c0c1eea837159c096017603c38d8736bc876fb8c1fd0bb3c253fc263f196bd9a", + "size_in_bytes": 2503 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/__pycache__/fix_raw_input.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "fdd48d2c94657d28474babbe891224235182a9bb52bdac4ea8b3c4ba0f192865", + "sha256_in_prefix": "fdd48d2c94657d28474babbe891224235182a9bb52bdac4ea8b3c4ba0f192865", + "size_in_bytes": 1047 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/__pycache__/fix_reduce.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "1323171a926e80f63291ea138da5abd96c64f84669065e2d5ab882b34712abf3", + "sha256_in_prefix": "1323171a926e80f63291ea138da5abd96c64f84669065e2d5ab882b34712abf3", + "size_in_bytes": 1380 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/__pycache__/fix_reload.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "6e06fed2efd1cce85e7ec849c5054bc2664fcc6cfe9fee0583de2872dcda8b74", + "sha256_in_prefix": "6e06fed2efd1cce85e7ec849c5054bc2664fcc6cfe9fee0583de2872dcda8b74", + "size_in_bytes": 1396 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/__pycache__/fix_renames.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "a204c5389f0c9e82da2d00e43f28073cfff2c9f14a7f748c4ebe6bb671a0bf1e", + "sha256_in_prefix": "a204c5389f0c9e82da2d00e43f28073cfff2c9f14a7f748c4ebe6bb671a0bf1e", + "size_in_bytes": 2279 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/__pycache__/fix_repr.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "57e89280ec1acd737e8be1e497ab38b2998f47d247ef3a94450e6e0937b1d2a7", + "sha256_in_prefix": "57e89280ec1acd737e8be1e497ab38b2998f47d247ef3a94450e6e0937b1d2a7", + "size_in_bytes": 1097 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/__pycache__/fix_set_literal.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "9ad794f270691e8f8d3d231460de9d629ed62ee29df9d58268622345d1a86647", + "sha256_in_prefix": "9ad794f270691e8f8d3d231460de9d629ed62ee29df9d58268622345d1a86647", + "size_in_bytes": 1937 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/__pycache__/fix_standarderror.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "2783f1851d7b91843a4887d5538532163e0d5f8b9070f7a1485f5c24aaceb242", + "sha256_in_prefix": "2783f1851d7b91843a4887d5538532163e0d5f8b9070f7a1485f5c24aaceb242", + "size_in_bytes": 972 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/__pycache__/fix_sys_exc.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "a4d3d117d6b5f23c0806991441f6aab456601080fca3b7cddb28ea6eb408aa6b", + "sha256_in_prefix": "a4d3d117d6b5f23c0806991441f6aab456601080fca3b7cddb28ea6eb408aa6b", + "size_in_bytes": 1665 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/__pycache__/fix_throw.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "880e4b2277cc45d4ae7d7e059b02cd105f877d9c2603c1fd9572bf0711eafa74", + "sha256_in_prefix": "880e4b2277cc45d4ae7d7e059b02cd105f877d9c2603c1fd9572bf0711eafa74", + "size_in_bytes": 2060 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/__pycache__/fix_tuple_params.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "a504c3a60a736cb416d39fa3ccfdc37c4af92cca79e572b7d602e812aa07d02f", + "sha256_in_prefix": "a504c3a60a736cb416d39fa3ccfdc37c4af92cca79e572b7d602e812aa07d02f", + "size_in_bytes": 4843 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/__pycache__/fix_types.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "2de0f410675f9d03573514bc8d759929de9690bcad798ce684a82ede7b3b5675", + "sha256_in_prefix": "2de0f410675f9d03573514bc8d759929de9690bcad798ce684a82ede7b3b5675", + "size_in_bytes": 2195 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/__pycache__/fix_unicode.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "19f656c7db621edd6e5686cbf909d6b79509d1a67c1cf657815466b8d451fe52", + "sha256_in_prefix": "19f656c7db621edd6e5686cbf909d6b79509d1a67c1cf657815466b8d451fe52", + "size_in_bytes": 1807 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/__pycache__/fix_urllib.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "79b094e213ca1a3de5556d52f8faab2ac280c1e4e6173904e15ee78794f37689", + "sha256_in_prefix": "79b094e213ca1a3de5556d52f8faab2ac280c1e4e6173904e15ee78794f37689", + "size_in_bytes": 6134 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/__pycache__/fix_ws_comma.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "a71bd0027df0e2f8a5990153367b61889846724a7f88995a309bbc92f632bd5b", + "sha256_in_prefix": "a71bd0027df0e2f8a5990153367b61889846724a7f88995a309bbc92f632bd5b", + "size_in_bytes": 1371 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/__pycache__/fix_xrange.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "ae14b56664e98a2069472b315f9e654b829904dd1391cc5802071d0b286bdabb", + "sha256_in_prefix": "ae14b56664e98a2069472b315f9e654b829904dd1391cc5802071d0b286bdabb", + "size_in_bytes": 2781 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/__pycache__/fix_xreadlines.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "49a721ee909357d7185da97cd31a81da425d526d566fcab430ee2e0dfda400ea", + "sha256_in_prefix": "49a721ee909357d7185da97cd31a81da425d526d566fcab430ee2e0dfda400ea", + "size_in_bytes": 1116 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/__pycache__/fix_zip.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c56aaa5f1185cbd93133070af451c4e34f5996fcd7cf393f5c3144816d26d6a3", + "sha256_in_prefix": "c56aaa5f1185cbd93133070af451c4e34f5996fcd7cf393f5c3144816d26d6a3", + "size_in_bytes": 1833 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/fix_apply.py", + "path_type": "hardlink", + "sha256": "b5171e32758a78450854f40867775d4aca58665bc920ebece04fcfcc153af02a", + "sha256_in_prefix": "b5171e32758a78450854f40867775d4aca58665bc920ebece04fcfcc153af02a", + "size_in_bytes": 2346 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/fix_asserts.py", + "path_type": "hardlink", + "sha256": "4c77972812cb5ec0a72afbce3e1d618c27ef7b239329c5c952c2bcbe77dba5dd", + "sha256_in_prefix": "4c77972812cb5ec0a72afbce3e1d618c27ef7b239329c5c952c2bcbe77dba5dd", + "size_in_bytes": 984 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/fix_basestring.py", + "path_type": "hardlink", + "sha256": "d041443d6499a735bb78fec9da1bf33b3d034b5192c98bc273b16a44692fc88f", + "sha256_in_prefix": "d041443d6499a735bb78fec9da1bf33b3d034b5192c98bc273b16a44692fc88f", + "size_in_bytes": 320 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/fix_buffer.py", + "path_type": "hardlink", + "sha256": "2da37b49c30d6a0b4db43146ebb4ac8e5ffcb9814816b4742e464cb856977883", + "sha256_in_prefix": "2da37b49c30d6a0b4db43146ebb4ac8e5ffcb9814816b4742e464cb856977883", + "size_in_bytes": 590 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/fix_dict.py", + "path_type": "hardlink", + "sha256": "38f460596ebfb64046aab3d9a65935bd4c76a470118fb7d10a088dc0ecdc53ea", + "sha256_in_prefix": "38f460596ebfb64046aab3d9a65935bd4c76a470118fb7d10a088dc0ecdc53ea", + "size_in_bytes": 3760 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/fix_except.py", + "path_type": "hardlink", + "sha256": "7ff6f560c3c3d7a5d9ceef5ba31c556341f7ce1bc1b52d96b063f6c2c4765651", + "sha256_in_prefix": "7ff6f560c3c3d7a5d9ceef5ba31c556341f7ce1bc1b52d96b063f6c2c4765651", + "size_in_bytes": 3344 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/fix_exec.py", + "path_type": "hardlink", + "sha256": "9e0893327205dea12004e88d18c580286e7977e081b5eda7baf5b7bc93bc6c52", + "sha256_in_prefix": "9e0893327205dea12004e88d18c580286e7977e081b5eda7baf5b7bc93bc6c52", + "size_in_bytes": 979 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/fix_execfile.py", + "path_type": "hardlink", + "sha256": "6ff65db1192099457cb3d9f2618a893c6ac430028550284f3a34d5c08042b0eb", + "sha256_in_prefix": "6ff65db1192099457cb3d9f2618a893c6ac430028550284f3a34d5c08042b0eb", + "size_in_bytes": 2048 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/fix_exitfunc.py", + "path_type": "hardlink", + "sha256": "ef4f18f651d32410c43644c27590903d41e38e763b0e108e6c685a3412a7d29c", + "sha256_in_prefix": "ef4f18f651d32410c43644c27590903d41e38e763b0e108e6c685a3412a7d29c", + "size_in_bytes": 2495 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/fix_filter.py", + "path_type": "hardlink", + "sha256": "2c7f0121193395750eab2b2abf5059d9a3b1a61f81763f52511265d7bca5cb21", + "sha256_in_prefix": "2c7f0121193395750eab2b2abf5059d9a3b1a61f81763f52511265d7bca5cb21", + "size_in_bytes": 2765 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/fix_funcattrs.py", + "path_type": "hardlink", + "sha256": "111df53fac6a121d61abe33883a68e731820ddc4864b0a4c1000cf2ac5f019cd", + "sha256_in_prefix": "111df53fac6a121d61abe33883a68e731820ddc4864b0a4c1000cf2ac5f019cd", + "size_in_bytes": 644 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/fix_future.py", + "path_type": "hardlink", + "sha256": "baba8cafb48dd9181a0e1f7b0f20b585ce2925e8f347e00b87407a256bb16663", + "sha256_in_prefix": "baba8cafb48dd9181a0e1f7b0f20b585ce2925e8f347e00b87407a256bb16663", + "size_in_bytes": 547 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/fix_getcwdu.py", + "path_type": "hardlink", + "sha256": "5bc5252f683a401e7d81c5911617c4af1a1bcdf99a51c4bf1cfccb00446ff220", + "sha256_in_prefix": "5bc5252f683a401e7d81c5911617c4af1a1bcdf99a51c4bf1cfccb00446ff220", + "size_in_bytes": 451 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/fix_has_key.py", + "path_type": "hardlink", + "sha256": "32943d3b921c1c3f0d3776d19e5120806990b817bc99a7e22799847abfda1f63", + "sha256_in_prefix": "32943d3b921c1c3f0d3776d19e5120806990b817bc99a7e22799847abfda1f63", + "size_in_bytes": 3196 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/fix_idioms.py", + "path_type": "hardlink", + "sha256": "600e34faf36e14307e59d55088e3979881d497b8fc9d77659e77709f9e8bafd7", + "sha256_in_prefix": "600e34faf36e14307e59d55088e3979881d497b8fc9d77659e77709f9e8bafd7", + "size_in_bytes": 4876 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/fix_import.py", + "path_type": "hardlink", + "sha256": "803baf96f9603c957eb974f252b0ad9829c889a293e0ce6829db1bce3da6dd4e", + "sha256_in_prefix": "803baf96f9603c957eb974f252b0ad9829c889a293e0ce6829db1bce3da6dd4e", + "size_in_bytes": 3256 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/fix_imports.py", + "path_type": "hardlink", + "sha256": "cdf7ee6d85e2b148230984cfc4ea3f193be458958ea42ef290854a9672a64370", + "sha256_in_prefix": "cdf7ee6d85e2b148230984cfc4ea3f193be458958ea42ef290854a9672a64370", + "size_in_bytes": 5684 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/fix_imports2.py", + "path_type": "hardlink", + "sha256": "b6f3c628839ffe7fd72569dd6ca2210e18edae3e180002747ea011b76b7ec0ef", + "sha256_in_prefix": "b6f3c628839ffe7fd72569dd6ca2210e18edae3e180002747ea011b76b7ec0ef", + "size_in_bytes": 289 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/fix_input.py", + "path_type": "hardlink", + "sha256": "10c5ef3b45a4ee7e88af8852181916a788aae2bea52b08f3473815c1c43598d1", + "sha256_in_prefix": "10c5ef3b45a4ee7e88af8852181916a788aae2bea52b08f3473815c1c43598d1", + "size_in_bytes": 708 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/fix_intern.py", + "path_type": "hardlink", + "sha256": "8d29a162536b99c91bd2f9259dda7f39fec751949d6354d2c1f2e5d070c87d66", + "sha256_in_prefix": "8d29a162536b99c91bd2f9259dda7f39fec751949d6354d2c1f2e5d070c87d66", + "size_in_bytes": 1144 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/fix_isinstance.py", + "path_type": "hardlink", + "sha256": "8408c92b99f50d8c4978b47a2b2155588e315f2ebbe58c160dcdcdcb89e19914", + "sha256_in_prefix": "8408c92b99f50d8c4978b47a2b2155588e315f2ebbe58c160dcdcdcb89e19914", + "size_in_bytes": 1608 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/fix_itertools.py", + "path_type": "hardlink", + "sha256": "578a51b9935020b03a510de15ece55fcd02c9474f37a54c158fb97ba5fd15af1", + "sha256_in_prefix": "578a51b9935020b03a510de15ece55fcd02c9474f37a54c158fb97ba5fd15af1", + "size_in_bytes": 1548 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/fix_itertools_imports.py", + "path_type": "hardlink", + "sha256": "2e419cfbd7f2a326ae7fa10873aa377112ebec32545238fdf988acb088c3cdb7", + "sha256_in_prefix": "2e419cfbd7f2a326ae7fa10873aa377112ebec32545238fdf988acb088c3cdb7", + "size_in_bytes": 2086 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/fix_long.py", + "path_type": "hardlink", + "sha256": "306b80e0a72c0d16dd934b7d51ab0c9a4224f83be5d6cbad8a7158a0a5d73551", + "sha256_in_prefix": "306b80e0a72c0d16dd934b7d51ab0c9a4224f83be5d6cbad8a7158a0a5d73551", + "size_in_bytes": 476 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/fix_map.py", + "path_type": "hardlink", + "sha256": "b82c0762c44adf2af7745c030afe291e2badfe360925046c8e58d85340717696", + "sha256_in_prefix": "b82c0762c44adf2af7745c030afe291e2badfe360925046c8e58d85340717696", + "size_in_bytes": 3640 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/fix_metaclass.py", + "path_type": "hardlink", + "sha256": "45a30c866aa2ff69e089da147ed09986aad4516b5e5dd943f8dfcb7d3946a3e1", + "sha256_in_prefix": "45a30c866aa2ff69e089da147ed09986aad4516b5e5dd943f8dfcb7d3946a3e1", + "size_in_bytes": 8197 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/fix_methodattrs.py", + "path_type": "hardlink", + "sha256": "8d60082f98ce52ee4955099bfd447cbadfa0e9b24ccb8d135cecc833168d44e8", + "sha256_in_prefix": "8d60082f98ce52ee4955099bfd447cbadfa0e9b24ccb8d135cecc833168d44e8", + "size_in_bytes": 606 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/fix_ne.py", + "path_type": "hardlink", + "sha256": "4f9cb1388ba86f29422d20979d3423fdf3541ba35a17ed44d6f4a517ff784ecd", + "sha256_in_prefix": "4f9cb1388ba86f29422d20979d3423fdf3541ba35a17ed44d6f4a517ff784ecd", + "size_in_bytes": 571 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/fix_next.py", + "path_type": "hardlink", + "sha256": "5c7d86d9f81b2498486d626c7feced1b92f23171cf9e42881abb78de1a93bccd", + "sha256_in_prefix": "5c7d86d9f81b2498486d626c7feced1b92f23171cf9e42881abb78de1a93bccd", + "size_in_bytes": 3174 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/fix_nonzero.py", + "path_type": "hardlink", + "sha256": "c2cd7e3ba44508643a20eec4ea4c19f2f1adfd36f6b974d7c143e449571ae736", + "sha256_in_prefix": "c2cd7e3ba44508643a20eec4ea4c19f2f1adfd36f6b974d7c143e449571ae736", + "size_in_bytes": 591 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/fix_numliterals.py", + "path_type": "hardlink", + "sha256": "1c4dd0f7881999abde6cf4d232836fa3e55fc41a7d5aa2b9866092f65707db7f", + "sha256_in_prefix": "1c4dd0f7881999abde6cf4d232836fa3e55fc41a7d5aa2b9866092f65707db7f", + "size_in_bytes": 768 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/fix_operator.py", + "path_type": "hardlink", + "sha256": "023872fe9f03a25387cf2c17fc950cf0f990353df66e603c3a1cd3199dbccd86", + "sha256_in_prefix": "023872fe9f03a25387cf2c17fc950cf0f990353df66e603c3a1cd3199dbccd86", + "size_in_bytes": 3426 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/fix_paren.py", + "path_type": "hardlink", + "sha256": "53734f1d7778ad28a4ec3ab4415923e2da8f230de4cd527589829f570e9f254d", + "sha256_in_prefix": "53734f1d7778ad28a4ec3ab4415923e2da8f230de4cd527589829f570e9f254d", + "size_in_bytes": 1226 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/fix_print.py", + "path_type": "hardlink", + "sha256": "cf2690f1b502249289f52cd544190db0b94d59df5eca139829cd2bf0742e9dba", + "sha256_in_prefix": "cf2690f1b502249289f52cd544190db0b94d59df5eca139829cd2bf0742e9dba", + "size_in_bytes": 2844 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/fix_raise.py", + "path_type": "hardlink", + "sha256": "c38ffec5862597ee8f9dac50385af943ee312bfc394366be08b2fc12563ca1a5", + "sha256_in_prefix": "c38ffec5862597ee8f9dac50385af943ee312bfc394366be08b2fc12563ca1a5", + "size_in_bytes": 2926 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/fix_raw_input.py", + "path_type": "hardlink", + "sha256": "ce04cbaa76d414949afc230360dd9a29ff579bd868cc7f8805230d126ac9ce9b", + "sha256_in_prefix": "ce04cbaa76d414949afc230360dd9a29ff579bd868cc7f8805230d126ac9ce9b", + "size_in_bytes": 454 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/fix_reduce.py", + "path_type": "hardlink", + "sha256": "9a03910a6c183586e1db01863fcde6417d06745fb3e63032333d71c5e82e7919", + "sha256_in_prefix": "9a03910a6c183586e1db01863fcde6417d06745fb3e63032333d71c5e82e7919", + "size_in_bytes": 837 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/fix_reload.py", + "path_type": "hardlink", + "sha256": "17570148167e43b2155b6e1c814a3cca9e3ef53750c504932a9c7d62a8b68a3f", + "sha256_in_prefix": "17570148167e43b2155b6e1c814a3cca9e3ef53750c504932a9c7d62a8b68a3f", + "size_in_bytes": 1081 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/fix_renames.py", + "path_type": "hardlink", + "sha256": "8b71472317bf3adabf819e665c725d03e3064baa45f6ffbfd78cca83eaa46e8d", + "sha256_in_prefix": "8b71472317bf3adabf819e665c725d03e3064baa45f6ffbfd78cca83eaa46e8d", + "size_in_bytes": 2221 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/fix_repr.py", + "path_type": "hardlink", + "sha256": "d16930b7ef8577747cfef602aba854c64ce85d4ae1e54a18a456eaa202643e3d", + "sha256_in_prefix": "d16930b7ef8577747cfef602aba854c64ce85d4ae1e54a18a456eaa202643e3d", + "size_in_bytes": 613 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/fix_set_literal.py", + "path_type": "hardlink", + "sha256": "33f2c0b6e16357e083c3a98877e7317abe1578a44c288e5979c9d96fb5aa6727", + "sha256_in_prefix": "33f2c0b6e16357e083c3a98877e7317abe1578a44c288e5979c9d96fb5aa6727", + "size_in_bytes": 1697 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/fix_standarderror.py", + "path_type": "hardlink", + "sha256": "ce7eb37bc7fb29aa138b1cec6656ae8b4886cbfa700e119a1bb8484284cb717a", + "sha256_in_prefix": "ce7eb37bc7fb29aa138b1cec6656ae8b4886cbfa700e119a1bb8484284cb717a", + "size_in_bytes": 449 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/fix_sys_exc.py", + "path_type": "hardlink", + "sha256": "0143830586d09d702ca3eeaa8f86698e5fd18af69fd28147e71a1a77600d356a", + "sha256_in_prefix": "0143830586d09d702ca3eeaa8f86698e5fd18af69fd28147e71a1a77600d356a", + "size_in_bytes": 1034 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/fix_throw.py", + "path_type": "hardlink", + "sha256": "fec731ed523d5cdfa21893833b52b2844eabfd1549792c1c9f8ceac2d0e8e901", + "sha256_in_prefix": "fec731ed523d5cdfa21893833b52b2844eabfd1549792c1c9f8ceac2d0e8e901", + "size_in_bytes": 1582 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/fix_tuple_params.py", + "path_type": "hardlink", + "sha256": "f3307d4750d0657d9c42b857d5f37bdb5824f9358939da7d16d13f61eb8abc72", + "sha256_in_prefix": "f3307d4750d0657d9c42b857d5f37bdb5824f9358939da7d16d13f61eb8abc72", + "size_in_bytes": 5565 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/fix_types.py", + "path_type": "hardlink", + "sha256": "a0a133cfc78e82e1f71ce628408e7d10a38552ba3e3228ebd113838c1ce44484", + "sha256_in_prefix": "a0a133cfc78e82e1f71ce628408e7d10a38552ba3e3228ebd113838c1ce44484", + "size_in_bytes": 1774 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/fix_unicode.py", + "path_type": "hardlink", + "sha256": "01b2a9b1084b6a0424f27eec488c761f75f053a409608ec36a9ee0ede0d38097", + "sha256_in_prefix": "01b2a9b1084b6a0424f27eec488c761f75f053a409608ec36a9ee0ede0d38097", + "size_in_bytes": 1256 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/fix_urllib.py", + "path_type": "hardlink", + "sha256": "3d1c04d976ff4d2841025a785aaab0cc4ee06c9c9b4e09d1e2456949fa273856", + "sha256_in_prefix": "3d1c04d976ff4d2841025a785aaab0cc4ee06c9c9b4e09d1e2456949fa273856", + "size_in_bytes": 8367 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/fix_ws_comma.py", + "path_type": "hardlink", + "sha256": "5e7a16daec0b2619110516804bf90cac459a4d0315198fd4eff69c36c54378dd", + "sha256_in_prefix": "5e7a16daec0b2619110516804bf90cac459a4d0315198fd4eff69c36c54378dd", + "size_in_bytes": 1090 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/fix_xrange.py", + "path_type": "hardlink", + "sha256": "60d8ce92db6f399606d2e40a3c631ba566127e8cd637ebbf35b822672139cab2", + "sha256_in_prefix": "60d8ce92db6f399606d2e40a3c631ba566127e8cd637ebbf35b822672139cab2", + "size_in_bytes": 2694 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/fix_xreadlines.py", + "path_type": "hardlink", + "sha256": "e8c2f19f7047bfc7539fd78839929004d8fe0efba1fbcbd9d712d285e43834ba", + "sha256_in_prefix": "e8c2f19f7047bfc7539fd78839929004d8fe0efba1fbcbd9d712d285e43834ba", + "size_in_bytes": 689 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/fix_zip.py", + "path_type": "hardlink", + "sha256": "55ce115556c7513dd967364dc6a40c39210c874e8168cf090ddd6dc606df34cb", + "sha256_in_prefix": "55ce115556c7513dd967364dc6a40c39210c874e8168cf090ddd6dc606df34cb", + "size_in_bytes": 1289 + }, + { + "_path": "lib/python3.10/lib2to3/main.py", + "path_type": "hardlink", + "sha256": "8f5dfa77b8c8b375daba8bb88aaa195395674311e2513b29575a70821e3aa0b8", + "sha256_in_prefix": "8f5dfa77b8c8b375daba8bb88aaa195395674311e2513b29575a70821e3aa0b8", + "size_in_bytes": 11854 + }, + { + "_path": "lib/python3.10/lib2to3/patcomp.py", + "path_type": "hardlink", + "sha256": "a033a3eb91a39f96747d4300aa3394965e529c71896cd6503dd27e6b685eede5", + "sha256_in_prefix": "a033a3eb91a39f96747d4300aa3394965e529c71896cd6503dd27e6b685eede5", + "size_in_bytes": 7054 + }, + { + "_path": "lib/python3.10/lib2to3/pgen2/__init__.py", + "path_type": "hardlink", + "sha256": "858eb0f50533bd3bd16fe32815f77fabfed92ede885070b6cb15827ec66ea500", + "sha256_in_prefix": "858eb0f50533bd3bd16fe32815f77fabfed92ede885070b6cb15827ec66ea500", + "size_in_bytes": 143 + }, + { + "_path": "lib/python3.10/lib2to3/pgen2/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "81589c3a2af682e1045d474543b352bd7a1252e3ec04278a34667385c9baad93", + "sha256_in_prefix": "81589c3a2af682e1045d474543b352bd7a1252e3ec04278a34667385c9baad93", + "size_in_bytes": 422 + }, + { + "_path": "lib/python3.10/lib2to3/pgen2/__pycache__/conv.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "88674e611f0fca9a0b0fbbb691a47f3f6939abc20b8641e06997931c2b18c937", + "sha256_in_prefix": "88674e611f0fca9a0b0fbbb691a47f3f6939abc20b8641e06997931c2b18c937", + "size_in_bytes": 7268 + }, + { + "_path": "lib/python3.10/lib2to3/pgen2/__pycache__/driver.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c26041ac4e0c0c86d839eefa6eef0e930b1099b0bf014894c79f5d27f15184d2", + "sha256_in_prefix": "c26041ac4e0c0c86d839eefa6eef0e930b1099b0bf014894c79f5d27f15184d2", + "size_in_bytes": 5393 + }, + { + "_path": "lib/python3.10/lib2to3/pgen2/__pycache__/grammar.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "7249f7a4616c475996a4e1c8cd887c7d3b80467fd3a2358d90a1c583b0342f62", + "sha256_in_prefix": "7249f7a4616c475996a4e1c8cd887c7d3b80467fd3a2358d90a1c583b0342f62", + "size_in_bytes": 5974 + }, + { + "_path": "lib/python3.10/lib2to3/pgen2/__pycache__/literals.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "79e6e92b7745ff3eb3ab0b9c0cdcf3dfef7e77d27634084607cdd4caff36f27c", + "sha256_in_prefix": "79e6e92b7745ff3eb3ab0b9c0cdcf3dfef7e77d27634084607cdd4caff36f27c", + "size_in_bytes": 1796 + }, + { + "_path": "lib/python3.10/lib2to3/pgen2/__pycache__/parse.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "4aef6f7ca78275aaa4a3d9d6c075cf804e4dda5b1baf9c99706ee3f62f0ef079", + "sha256_in_prefix": "4aef6f7ca78275aaa4a3d9d6c075cf804e4dda5b1baf9c99706ee3f62f0ef079", + "size_in_bytes": 6767 + }, + { + "_path": "lib/python3.10/lib2to3/pgen2/__pycache__/pgen.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "8905a8b54458377effb1af75bb8cb3baae14d9b932e0a1a282b41ac5d18e5cf2", + "sha256_in_prefix": "8905a8b54458377effb1af75bb8cb3baae14d9b932e0a1a282b41ac5d18e5cf2", + "size_in_bytes": 10103 + }, + { + "_path": "lib/python3.10/lib2to3/pgen2/__pycache__/token.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "6217c4151f416eaee9dacca02ac55ee2fc510b6ca4195fefa8137029a5496a41", + "sha256_in_prefix": "6217c4151f416eaee9dacca02ac55ee2fc510b6ca4195fefa8137029a5496a41", + "size_in_bytes": 2138 + }, + { + "_path": "lib/python3.10/lib2to3/pgen2/__pycache__/tokenize.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "246f56fdb4fd398ba20012874448134d41dd144be2020a9ad0618d4cb58c5fa9", + "sha256_in_prefix": "246f56fdb4fd398ba20012874448134d41dd144be2020a9ad0618d4cb58c5fa9", + "size_in_bytes": 15354 + }, + { + "_path": "lib/python3.10/lib2to3/pgen2/conv.py", + "path_type": "hardlink", + "sha256": "e2946a686c12e02248fafb1a57e7514e0c22bdb2b4a66e644215c86fedc37bff", + "sha256_in_prefix": "e2946a686c12e02248fafb1a57e7514e0c22bdb2b4a66e644215c86fedc37bff", + "size_in_bytes": 9642 + }, + { + "_path": "lib/python3.10/lib2to3/pgen2/driver.py", + "path_type": "hardlink", + "sha256": "57af5e220cd6c6b75e8dead2cea395ead2297dd98e398ad705ca2bce0e9e6594", + "sha256_in_prefix": "57af5e220cd6c6b75e8dead2cea395ead2297dd98e398ad705ca2bce0e9e6594", + "size_in_bytes": 5969 + }, + { + "_path": "lib/python3.10/lib2to3/pgen2/grammar.py", + "path_type": "hardlink", + "sha256": "b04309478d2086cde92de4ba62c87bd986d05d7181c51e186a30d64468c95fa9", + "sha256_in_prefix": "b04309478d2086cde92de4ba62c87bd986d05d7181c51e186a30d64468c95fa9", + "size_in_bytes": 5533 + }, + { + "_path": "lib/python3.10/lib2to3/pgen2/literals.py", + "path_type": "hardlink", + "sha256": "84bc9d5387a2e20fab844e530358571afa39fa3fc0e8024270b5f7d8ac5a595a", + "sha256_in_prefix": "84bc9d5387a2e20fab844e530358571afa39fa3fc0e8024270b5f7d8ac5a595a", + "size_in_bytes": 1635 + }, + { + "_path": "lib/python3.10/lib2to3/pgen2/parse.py", + "path_type": "hardlink", + "sha256": "e245e005e524ab445a570df31f70c6fd7b901ee3b0b68bd3bcf4b41b37fa7bb6", + "sha256_in_prefix": "e245e005e524ab445a570df31f70c6fd7b901ee3b0b68bd3bcf4b41b37fa7bb6", + "size_in_bytes": 8155 + }, + { + "_path": "lib/python3.10/lib2to3/pgen2/pgen.py", + "path_type": "hardlink", + "sha256": "8fe2ac7e0303f0110d75832d746e6661fcd5373fa498d929163f557fd1027434", + "sha256_in_prefix": "8fe2ac7e0303f0110d75832d746e6661fcd5373fa498d929163f557fd1027434", + "size_in_bytes": 13830 + }, + { + "_path": "lib/python3.10/lib2to3/pgen2/token.py", + "path_type": "hardlink", + "sha256": "47c7f968e1e3bf66d53fb4a6a9fc848cdae11d66d49bb70c7cf41961ea91f30c", + "sha256_in_prefix": "47c7f968e1e3bf66d53fb4a6a9fc848cdae11d66d49bb70c7cf41961ea91f30c", + "size_in_bytes": 1302 + }, + { + "_path": "lib/python3.10/lib2to3/pgen2/tokenize.py", + "path_type": "hardlink", + "sha256": "aaa0b98f6a65e08e9f8e34358198e329d29554a0d4b5f5059924a252eeb0f5c4", + "sha256_in_prefix": "aaa0b98f6a65e08e9f8e34358198e329d29554a0d4b5f5059924a252eeb0f5c4", + "size_in_bytes": 21119 + }, + { + "_path": "lib/python3.10/lib2to3/pygram.py", + "path_type": "hardlink", + "sha256": "b49d77876a9d1822ff6be04daf464341a8e4c0c3414240abf519254de2a97a48", + "sha256_in_prefix": "b49d77876a9d1822ff6be04daf464341a8e4c0c3414240abf519254de2a97a48", + "size_in_bytes": 1305 + }, + { + "_path": "lib/python3.10/lib2to3/pytree.py", + "path_type": "hardlink", + "sha256": "e53689352fb4fc83d85a09369650389ee01db802ad872a8abfc0bf6603ec38b9", + "sha256_in_prefix": "e53689352fb4fc83d85a09369650389ee01db802ad872a8abfc0bf6603ec38b9", + "size_in_bytes": 27974 + }, + { + "_path": "lib/python3.10/lib2to3/refactor.py", + "path_type": "hardlink", + "sha256": "6e9a4262fb65cd4d277f009df73ffa5748f5fe3b963d3c5395c160d5f88b089b", + "sha256_in_prefix": "6e9a4262fb65cd4d277f009df73ffa5748f5fe3b963d3c5395c160d5f88b089b", + "size_in_bytes": 27507 + }, + { + "_path": "lib/python3.10/lib2to3/tests/__init__.py", + "path_type": "hardlink", + "sha256": "6af7ab5586854297ec737d4aa485b96f13641a556106223eba0d761a5fb962ea", + "sha256_in_prefix": "6af7ab5586854297ec737d4aa485b96f13641a556106223eba0d761a5fb962ea", + "size_in_bytes": 168 + }, + { + "_path": "lib/python3.10/lib2to3/tests/__main__.py", + "path_type": "hardlink", + "sha256": "cb9a3ce8f18e7d0a0cadb73cc9264772462de953499534736998d3c54f8c7c3c", + "sha256_in_prefix": "cb9a3ce8f18e7d0a0cadb73cc9264772462de953499534736998d3c54f8c7c3c", + "size_in_bytes": 58 + }, + { + "_path": "lib/python3.10/lib2to3/tests/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "e720c6c82441211635526289237c22eec6ba8551e721f116eaebc216c78afbb5", + "sha256_in_prefix": "e720c6c82441211635526289237c22eec6ba8551e721f116eaebc216c78afbb5", + "size_in_bytes": 621 + }, + { + "_path": "lib/python3.10/lib2to3/tests/__pycache__/__main__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "52d5c996f9ace80427b7941d5a032fe8ecfa04d90bb30b94a7d3ebcc7a6d8648", + "sha256_in_prefix": "52d5c996f9ace80427b7941d5a032fe8ecfa04d90bb30b94a7d3ebcc7a6d8648", + "size_in_bytes": 468 + }, + { + "_path": "lib/python3.10/lib2to3/tests/__pycache__/pytree_idempotency.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "ff9f4d6f87a501d836d3de3fdfdc8bb24ca12090d8bd8f45f878791d3759fbed", + "sha256_in_prefix": "ff9f4d6f87a501d836d3de3fdfdc8bb24ca12090d8bd8f45f878791d3759fbed", + "size_in_bytes": 2173 + }, + { + "_path": "lib/python3.10/lib2to3/tests/__pycache__/support.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "d9d66c79bf1ab9266924728a148e590ab529092811ffbeb17d6dde179fa0d14d", + "sha256_in_prefix": "d9d66c79bf1ab9266924728a148e590ab529092811ffbeb17d6dde179fa0d14d", + "size_in_bytes": 2495 + }, + { + "_path": "lib/python3.10/lib2to3/tests/__pycache__/test_all_fixers.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "546b78f776b33ee4250e5c5a492867b7d46c44461c65976312991a338a19b9a5", + "sha256_in_prefix": "546b78f776b33ee4250e5c5a492867b7d46c44461c65976312991a338a19b9a5", + "size_in_bytes": 1729 + }, + { + "_path": "lib/python3.10/lib2to3/tests/__pycache__/test_fixers.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "6da1b749a7ac00031314aa6b9b172c56838e56a35d538b2c744bc78e55b52201", + "sha256_in_prefix": "6da1b749a7ac00031314aa6b9b172c56838e56a35d538b2c744bc78e55b52201", + "size_in_bytes": 126918 + }, + { + "_path": "lib/python3.10/lib2to3/tests/__pycache__/test_main.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "ebb9b658e2354c4f9a1360cf94165e3859f13fffbd575bbece05b7a5b5e2860a", + "sha256_in_prefix": "ebb9b658e2354c4f9a1360cf94165e3859f13fffbd575bbece05b7a5b5e2860a", + "size_in_bytes": 5424 + }, + { + "_path": "lib/python3.10/lib2to3/tests/__pycache__/test_parser.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "2ef218b2988f4b904dc748d73fb7fa90187b657a3df8334fac6b387c944c8f9c", + "sha256_in_prefix": "2ef218b2988f4b904dc748d73fb7fa90187b657a3df8334fac6b387c944c8f9c", + "size_in_bytes": 31767 + }, + { + "_path": "lib/python3.10/lib2to3/tests/__pycache__/test_pytree.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "5e02b8b4202b4c8ed7d1b50baaf73232e95087696bba1437ea4095faea22b427", + "sha256_in_prefix": "5e02b8b4202b4c8ed7d1b50baaf73232e95087696bba1437ea4095faea22b427", + "size_in_bytes": 14856 + }, + { + "_path": "lib/python3.10/lib2to3/tests/__pycache__/test_refactor.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "b926a5729b0c081bc5ce470a363ded43a7439376b77b2809c50a920d4cb7bdc3", + "sha256_in_prefix": "b926a5729b0c081bc5ce470a363ded43a7439376b77b2809c50a920d4cb7bdc3", + "size_in_bytes": 13473 + }, + { + "_path": "lib/python3.10/lib2to3/tests/__pycache__/test_util.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "f446faaf6f35b09bf2801dd6937cb1b8c038f3e5b2d4a353b14991b8545fdd69", + "sha256_in_prefix": "f446faaf6f35b09bf2801dd6937cb1b8c038f3e5b2d4a353b14991b8545fdd69", + "size_in_bytes": 19515 + }, + { + "_path": "lib/python3.10/lib2to3/tests/data/README", + "path_type": "hardlink", + "sha256": "83999cc221401dc2fccca9d3dbe395c82a9f009db310a00e811c68c606547719", + "sha256_in_prefix": "83999cc221401dc2fccca9d3dbe395c82a9f009db310a00e811c68c606547719", + "size_in_bytes": 404 + }, + { + "_path": "lib/python3.10/lib2to3/tests/data/__pycache__/infinite_recursion.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "02ef2b0f48bd029d955b77b13316853afe3efe39261f313122e5af76c701b303", + "sha256_in_prefix": "02ef2b0f48bd029d955b77b13316853afe3efe39261f313122e5af76c701b303", + "size_in_bytes": 66845 + }, + { + "_path": "lib/python3.10/lib2to3/tests/data/__pycache__/py3_test_grammar.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "cc402c30cf02d467c3dde60f1605548ece67ada0e0e60d6769a35c261de55340", + "sha256_in_prefix": "cc402c30cf02d467c3dde60f1605548ece67ada0e0e60d6769a35c261de55340", + "size_in_bytes": 36106 + }, + { + "_path": "lib/python3.10/lib2to3/tests/data/bom.py", + "path_type": "hardlink", + "sha256": "16c62c93da9ed9338601adb171f1aac3d28c1c9cae35ee1b6de7948de837e436", + "sha256_in_prefix": "16c62c93da9ed9338601adb171f1aac3d28c1c9cae35ee1b6de7948de837e436", + "size_in_bytes": 37 + }, + { + "_path": "lib/python3.10/lib2to3/tests/data/crlf.py", + "path_type": "hardlink", + "sha256": "d910ad886333abf3664a4fb4290d3b81307a16c6d9ca14356b3644a9aae6e714", + "sha256_in_prefix": "d910ad886333abf3664a4fb4290d3b81307a16c6d9ca14356b3644a9aae6e714", + "size_in_bytes": 50 + }, + { + "_path": "lib/python3.10/lib2to3/tests/data/different_encoding.py", + "path_type": "hardlink", + "sha256": "e5d82fa54d5060994445e1d3825f49999aa98a093803393d88a5e8030c62337f", + "sha256_in_prefix": "e5d82fa54d5060994445e1d3825f49999aa98a093803393d88a5e8030c62337f", + "size_in_bytes": 230 + }, + { + "_path": "lib/python3.10/lib2to3/tests/data/false_encoding.py", + "path_type": "hardlink", + "sha256": "f3c15c2784af8783069df41ca628371df3dbe59758942461bfa4bc5902d9d9b3", + "sha256_in_prefix": "f3c15c2784af8783069df41ca628371df3dbe59758942461bfa4bc5902d9d9b3", + "size_in_bytes": 40 + }, + { + "_path": "lib/python3.10/lib2to3/tests/data/fixers/__pycache__/bad_order.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "557d1d653ed310b3c6bee9f19297f37377e9acb9fd888580153072435750b9a1", + "sha256_in_prefix": "557d1d653ed310b3c6bee9f19297f37377e9acb9fd888580153072435750b9a1", + "size_in_bytes": 635 + }, + { + "_path": "lib/python3.10/lib2to3/tests/data/fixers/__pycache__/no_fixer_cls.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "b6a68457c651f012286e58d153278cc7d11e218e316fa53b5ed2ba33cbec3acc", + "sha256_in_prefix": "b6a68457c651f012286e58d153278cc7d11e218e316fa53b5ed2ba33cbec3acc", + "size_in_bytes": 408 + }, + { + "_path": "lib/python3.10/lib2to3/tests/data/fixers/__pycache__/parrot_example.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "32e4216d348666d9f57aa0d649ad47c552259c042f21bb7813212ba8d1c06b1d", + "sha256_in_prefix": "32e4216d348666d9f57aa0d649ad47c552259c042f21bb7813212ba8d1c06b1d", + "size_in_bytes": 506 + }, + { + "_path": "lib/python3.10/lib2to3/tests/data/fixers/bad_order.py", + "path_type": "hardlink", + "sha256": "b78e533e055c607b009b1ad93dbbf16a3595f6522b95536eff974b202a34e8fd", + "sha256_in_prefix": "b78e533e055c607b009b1ad93dbbf16a3595f6522b95536eff974b202a34e8fd", + "size_in_bytes": 89 + }, + { + "_path": "lib/python3.10/lib2to3/tests/data/fixers/myfixes/__init__.py", + "path_type": "hardlink", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size_in_bytes": 0 + }, + { + "_path": "lib/python3.10/lib2to3/tests/data/fixers/myfixes/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "82fea1beaba5643f9561a0d9a7008993463e2640d268835109537f5eddb463dd", + "sha256_in_prefix": "82fea1beaba5643f9561a0d9a7008993463e2640d268835109537f5eddb463dd", + "size_in_bytes": 412 + }, + { + "_path": "lib/python3.10/lib2to3/tests/data/fixers/myfixes/__pycache__/fix_explicit.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "9044737f31be21a7a75962b965194af64b699bd400e64968d6e3e3fb7039f8ad", + "sha256_in_prefix": "9044737f31be21a7a75962b965194af64b699bd400e64968d6e3e3fb7039f8ad", + "size_in_bytes": 761 + }, + { + "_path": "lib/python3.10/lib2to3/tests/data/fixers/myfixes/__pycache__/fix_first.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "a2804b8dc23410c291a768608568aafd9a03b29e0034c59eb74745a333de4b1b", + "sha256_in_prefix": "a2804b8dc23410c291a768608568aafd9a03b29e0034c59eb74745a333de4b1b", + "size_in_bytes": 763 + }, + { + "_path": "lib/python3.10/lib2to3/tests/data/fixers/myfixes/__pycache__/fix_last.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "cdffad21b0c80bfdb4c686bb32f2b7b3446701c63598a593a5fcc085cfe2a3cb", + "sha256_in_prefix": "cdffad21b0c80bfdb4c686bb32f2b7b3446701c63598a593a5fcc085cfe2a3cb", + "size_in_bytes": 760 + }, + { + "_path": "lib/python3.10/lib2to3/tests/data/fixers/myfixes/__pycache__/fix_parrot.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "feefdad9e6d6fa424b1c6b8e6dc2497c9ee614f172f55303b10f11e700dbdea2", + "sha256_in_prefix": "feefdad9e6d6fa424b1c6b8e6dc2497c9ee614f172f55303b10f11e700dbdea2", + "size_in_bytes": 997 + }, + { + "_path": "lib/python3.10/lib2to3/tests/data/fixers/myfixes/__pycache__/fix_preorder.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "2dbc0e453899f733e9b93b9cad25863b28381cb3289ad672c51319ac1f44b4fa", + "sha256_in_prefix": "2dbc0e453899f733e9b93b9cad25863b28381cb3289ad672c51319ac1f44b4fa", + "size_in_bytes": 768 + }, + { + "_path": "lib/python3.10/lib2to3/tests/data/fixers/myfixes/fix_explicit.py", + "path_type": "hardlink", + "sha256": "e46f1bf431aa68e36406b32cd94afaafd109452df427aa726855be4176077b56", + "sha256_in_prefix": "e46f1bf431aa68e36406b32cd94afaafd109452df427aa726855be4176077b56", + "size_in_bytes": 123 + }, + { + "_path": "lib/python3.10/lib2to3/tests/data/fixers/myfixes/fix_first.py", + "path_type": "hardlink", + "sha256": "a2e3c4212f38d27aff680c0a7f6c377829438a7c7a4f85ad4789b22de7ca73a9", + "sha256_in_prefix": "a2e3c4212f38d27aff680c0a7f6c377829438a7c7a4f85ad4789b22de7ca73a9", + "size_in_bytes": 124 + }, + { + "_path": "lib/python3.10/lib2to3/tests/data/fixers/myfixes/fix_last.py", + "path_type": "hardlink", + "sha256": "042acb60984c6f721fa89c42cebe22572acc9434cc7f27d2fb4362b3602deb1d", + "sha256_in_prefix": "042acb60984c6f721fa89c42cebe22572acc9434cc7f27d2fb4362b3602deb1d", + "size_in_bytes": 125 + }, + { + "_path": "lib/python3.10/lib2to3/tests/data/fixers/myfixes/fix_parrot.py", + "path_type": "hardlink", + "sha256": "627f9028bbdde32e61ceceeb929520023607de25aebdc039c2d568d9c1a8d1db", + "sha256_in_prefix": "627f9028bbdde32e61ceceeb929520023607de25aebdc039c2d568d9c1a8d1db", + "size_in_bytes": 347 + }, + { + "_path": "lib/python3.10/lib2to3/tests/data/fixers/myfixes/fix_preorder.py", + "path_type": "hardlink", + "sha256": "c7c15747f0d13d0884b48d424c3b38d5e05cfece09c539c906d5dec48be3d083", + "sha256_in_prefix": "c7c15747f0d13d0884b48d424c3b38d5e05cfece09c539c906d5dec48be3d083", + "size_in_bytes": 127 + }, + { + "_path": "lib/python3.10/lib2to3/tests/data/fixers/no_fixer_cls.py", + "path_type": "hardlink", + "sha256": "c0a16cfbe6b674abb6534c984f06af296a01668b208f0967f25f8a4348e625a3", + "sha256_in_prefix": "c0a16cfbe6b674abb6534c984f06af296a01668b208f0967f25f8a4348e625a3", + "size_in_bytes": 75 + }, + { + "_path": "lib/python3.10/lib2to3/tests/data/fixers/parrot_example.py", + "path_type": "hardlink", + "sha256": "6d9acb2151507735aa72c6aeaf15142a75cb0d3b37b48215ac45ee17106adc18", + "sha256_in_prefix": "6d9acb2151507735aa72c6aeaf15142a75cb0d3b37b48215ac45ee17106adc18", + "size_in_bytes": 23 + }, + { + "_path": "lib/python3.10/lib2to3/tests/data/infinite_recursion.py", + "path_type": "hardlink", + "sha256": "b8f8f36cea94f8189a18558ae6badafbe89f20e5edc5471c7068ed53d1e2c031", + "sha256_in_prefix": "b8f8f36cea94f8189a18558ae6badafbe89f20e5edc5471c7068ed53d1e2c031", + "size_in_bytes": 93031 + }, + { + "_path": "lib/python3.10/lib2to3/tests/data/py2_test_grammar.py", + "path_type": "hardlink", + "sha256": "253e51525c7e1ef847ab32b2556bc4213371e636fb498e0040980036bdd3f8ed", + "sha256_in_prefix": "253e51525c7e1ef847ab32b2556bc4213371e636fb498e0040980036bdd3f8ed", + "size_in_bytes": 30910 + }, + { + "_path": "lib/python3.10/lib2to3/tests/data/py3_test_grammar.py", + "path_type": "hardlink", + "sha256": "6b7a9e6082077b5ea379c0dcefe21455a21c57f69e51e9f16d1efe25176d0663", + "sha256_in_prefix": "6b7a9e6082077b5ea379c0dcefe21455a21c57f69e51e9f16d1efe25176d0663", + "size_in_bytes": 31173 + }, + { + "_path": "lib/python3.10/lib2to3/tests/pytree_idempotency.py", + "path_type": "hardlink", + "sha256": "56e652f53a8cf79d0c18660763830183b373b2a4049ac6fb835c4b328817d156", + "sha256_in_prefix": "56e652f53a8cf79d0c18660763830183b373b2a4049ac6fb835c4b328817d156", + "size_in_bytes": 2453 + }, + { + "_path": "lib/python3.10/lib2to3/tests/support.py", + "path_type": "hardlink", + "sha256": "d00dd6cf406be2cd020e16ffefc4e01c8bc45324e02341a71c52993f07ef5c34", + "sha256_in_prefix": "d00dd6cf406be2cd020e16ffefc4e01c8bc45324e02341a71c52993f07ef5c34", + "size_in_bytes": 1948 + }, + { + "_path": "lib/python3.10/lib2to3/tests/test_all_fixers.py", + "path_type": "hardlink", + "sha256": "6794fe0491d3587f50932556ed87a85b59f0b22dd01ff31b2f12149a24cf9496", + "sha256_in_prefix": "6794fe0491d3587f50932556ed87a85b59f0b22dd01ff31b2f12149a24cf9496", + "size_in_bytes": 1209 + }, + { + "_path": "lib/python3.10/lib2to3/tests/test_fixers.py", + "path_type": "hardlink", + "sha256": "8a9f1197a95ada1732be8815d4f2228ac90c05d4af7435fd1464380a10e3ca17", + "sha256_in_prefix": "8a9f1197a95ada1732be8815d4f2228ac90c05d4af7435fd1464380a10e3ca17", + "size_in_bytes": 122906 + }, + { + "_path": "lib/python3.10/lib2to3/tests/test_main.py", + "path_type": "hardlink", + "sha256": "3f61027bbcdf521589b58fca01c3a5d2cf9ee40f69e48567b2175647fb5e2cbb", + "sha256_in_prefix": "3f61027bbcdf521589b58fca01c3a5d2cf9ee40f69e48567b2175647fb5e2cbb", + "size_in_bytes": 5740 + }, + { + "_path": "lib/python3.10/lib2to3/tests/test_parser.py", + "path_type": "hardlink", + "sha256": "275051121a652b3f17928d42f6d0d6d50a5e8f1d9a4986ab4cbfd53841d2f5a2", + "sha256_in_prefix": "275051121a652b3f17928d42f6d0d6d50a5e8f1d9a4986ab4cbfd53841d2f5a2", + "size_in_bytes": 23655 + }, + { + "_path": "lib/python3.10/lib2to3/tests/test_pytree.py", + "path_type": "hardlink", + "sha256": "6fbcd26438397c6c3de40f4546c7112c81f784356e614ae529d8c90570d40f71", + "sha256_in_prefix": "6fbcd26438397c6c3de40f4546c7112c81f784356e614ae529d8c90570d40f71", + "size_in_bytes": 16382 + }, + { + "_path": "lib/python3.10/lib2to3/tests/test_refactor.py", + "path_type": "hardlink", + "sha256": "1a12117d8c600e848b41f0c89ec1758d650a8425dd9bc40b502fce6298d4cdc0", + "sha256_in_prefix": "1a12117d8c600e848b41f0c89ec1758d650a8425dd9bc40b502fce6298d4cdc0", + "size_in_bytes": 12586 + }, + { + "_path": "lib/python3.10/lib2to3/tests/test_util.py", + "path_type": "hardlink", + "sha256": "02c744eb87a94e5ebd94e5966e103dcf29da97b458543600f3aa79c8158d47a9", + "sha256_in_prefix": "02c744eb87a94e5ebd94e5966e103dcf29da97b458543600f3aa79c8158d47a9", + "size_in_bytes": 21207 + }, + { + "_path": "lib/python3.10/linecache.py", + "path_type": "hardlink", + "sha256": "e814839fc75010db274ae034f45b0fff7e529ccb702319048545fef84c2045b7", + "sha256_in_prefix": "e814839fc75010db274ae034f45b0fff7e529ccb702319048545fef84c2045b7", + "size_in_bytes": 5690 + }, + { + "_path": "lib/python3.10/locale.py", + "path_type": "hardlink", + "sha256": "5f7e28c368751d372719e305a41ca76862f341b1de5d3163db7b2e3452848881", + "sha256_in_prefix": "5f7e28c368751d372719e305a41ca76862f341b1de5d3163db7b2e3452848881", + "size_in_bytes": 78124 + }, + { + "_path": "lib/python3.10/logging/__init__.py", + "path_type": "hardlink", + "sha256": "9069cd43c7a8aa8170b654b1ee21e0d35c15baebfb61e49ecb490df968dce07e", + "sha256_in_prefix": "9069cd43c7a8aa8170b654b1ee21e0d35c15baebfb61e49ecb490df968dce07e", + "size_in_bytes": 80232 + }, + { + "_path": "lib/python3.10/logging/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "5515f31b3f52dec2b93d7b09ba38015bb881afb793a3190634560155ee12439a", + "sha256_in_prefix": "5515f31b3f52dec2b93d7b09ba38015bb881afb793a3190634560155ee12439a", + "size_in_bytes": 67145 + }, + { + "_path": "lib/python3.10/logging/__pycache__/config.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "b9b36862e8bfb51444acc5ac0a64854be843b1dd337464f4982e2c3acdffa01b", + "sha256_in_prefix": "b9b36862e8bfb51444acc5ac0a64854be843b1dd337464f4982e2c3acdffa01b", + "size_in_bytes": 23437 + }, + { + "_path": "lib/python3.10/logging/__pycache__/handlers.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "8c8526fb1bbc9c866e62c6675a08b487450df4ba1248098a090831105d3e84db", + "sha256_in_prefix": "8c8526fb1bbc9c866e62c6675a08b487450df4ba1248098a090831105d3e84db", + "size_in_bytes": 44938 + }, + { + "_path": "lib/python3.10/logging/config.py", + "path_type": "hardlink", + "sha256": "90b3442116d6534013a82a2ec0bc0b499cc0cedbba2ceb551bb6d01f15d8bd3b", + "sha256_in_prefix": "90b3442116d6534013a82a2ec0bc0b499cc0cedbba2ceb551bb6d01f15d8bd3b", + "size_in_bytes": 36495 + }, + { + "_path": "lib/python3.10/logging/handlers.py", + "path_type": "hardlink", + "sha256": "6712cc3a6fc313fa00d6995f154e043608bb518b3affbd3d603ddf97a5c15feb", + "sha256_in_prefix": "6712cc3a6fc313fa00d6995f154e043608bb518b3affbd3d603ddf97a5c15feb", + "size_in_bytes": 61416 + }, + { + "_path": "lib/python3.10/lzma.py", + "path_type": "hardlink", + "sha256": "58fb9d2fdc8a8af7b25e218f17ea3b51bdfa53bdf40f440ab33c605974ca5c2e", + "sha256_in_prefix": "58fb9d2fdc8a8af7b25e218f17ea3b51bdfa53bdf40f440ab33c605974ca5c2e", + "size_in_bytes": 13277 + }, + { + "_path": "lib/python3.10/mailbox.py", + "path_type": "hardlink", + "sha256": "e695a76d936f009d926e50eae09e34e1256ceee86ffb5b5825748e98f9080036", + "sha256_in_prefix": "e695a76d936f009d926e50eae09e34e1256ceee86ffb5b5825748e98f9080036", + "size_in_bytes": 78794 + }, + { + "_path": "lib/python3.10/mailcap.py", + "path_type": "hardlink", + "sha256": "b0ce7d29e8233ec412ac6aa16a9e62b3353d4acd44c6b870f6b6ffe1dbebba6f", + "sha256_in_prefix": "b0ce7d29e8233ec412ac6aa16a9e62b3353d4acd44c6b870f6b6ffe1dbebba6f", + "size_in_bytes": 9116 + }, + { + "_path": "lib/python3.10/mimetypes.py", + "path_type": "hardlink", + "sha256": "1c2ce66381de7f675fe2e3b2f73ec6b718fbec596bbca0fb17aa5a02ff31b007", + "sha256_in_prefix": "1c2ce66381de7f675fe2e3b2f73ec6b718fbec596bbca0fb17aa5a02ff31b007", + "size_in_bytes": 22539 + }, + { + "_path": "lib/python3.10/modulefinder.py", + "path_type": "hardlink", + "sha256": "eccfc7972b42dc3064832d3b98d2db8e1486d570d75c80a874cdb55b84d6e05e", + "sha256_in_prefix": "eccfc7972b42dc3064832d3b98d2db8e1486d570d75c80a874cdb55b84d6e05e", + "size_in_bytes": 24401 + }, + { + "_path": "lib/python3.10/multiprocessing/__init__.py", + "path_type": "hardlink", + "sha256": "a5a42976033c7d63ee2740acceef949a3582dcb0e0442845f9717e1be771c68b", + "sha256_in_prefix": "a5a42976033c7d63ee2740acceef949a3582dcb0e0442845f9717e1be771c68b", + "size_in_bytes": 916 + }, + { + "_path": "lib/python3.10/multiprocessing/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "7119c96bfdc06241f487a53fa8477cb96df32a5c60376e6f8cbaefa2dedba8ae", + "sha256_in_prefix": "7119c96bfdc06241f487a53fa8477cb96df32a5c60376e6f8cbaefa2dedba8ae", + "size_in_bytes": 923 + }, + { + "_path": "lib/python3.10/multiprocessing/__pycache__/connection.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "698b3ff2922b99b3ddfa6930eeb9671659bd52f0298b411fd2b50d7d2c67917c", + "sha256_in_prefix": "698b3ff2922b99b3ddfa6930eeb9671659bd52f0298b411fd2b50d7d2c67917c", + "size_in_bytes": 25828 + }, + { + "_path": "lib/python3.10/multiprocessing/__pycache__/context.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "ff0825c0a0bc2d54b92dfe208c07142f15fbec8061b89033a7ef4957d49e01cd", + "sha256_in_prefix": "ff0825c0a0bc2d54b92dfe208c07142f15fbec8061b89033a7ef4957d49e01cd", + "size_in_bytes": 13108 + }, + { + "_path": "lib/python3.10/multiprocessing/__pycache__/forkserver.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "7d99ad134906ee1c7f48a8c8733d49bda497d0d4dc94eafb7a47f7725aa97268", + "sha256_in_prefix": "7d99ad134906ee1c7f48a8c8733d49bda497d0d4dc94eafb7a47f7725aa97268", + "size_in_bytes": 8680 + }, + { + "_path": "lib/python3.10/multiprocessing/__pycache__/heap.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "adf230f62060842f36d0fdf46369a5108a9a91c8ee58bd01eb7f580b5c725065", + "sha256_in_prefix": "adf230f62060842f36d0fdf46369a5108a9a91c8ee58bd01eb7f580b5c725065", + "size_in_bytes": 7922 + }, + { + "_path": "lib/python3.10/multiprocessing/__pycache__/managers.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "d8d4799fd9853cb773fe9efae977fc011836cb8415f082739aee0ce512fb1253", + "sha256_in_prefix": "d8d4799fd9853cb773fe9efae977fc011836cb8415f082739aee0ce512fb1253", + "size_in_bytes": 41016 + }, + { + "_path": "lib/python3.10/multiprocessing/__pycache__/pool.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "360690cb24fbf21abc552a77c724c312f33f2d7521d531d0048848f16db91e48", + "sha256_in_prefix": "360690cb24fbf21abc552a77c724c312f33f2d7521d531d0048848f16db91e48", + "size_in_bytes": 25456 + }, + { + "_path": "lib/python3.10/multiprocessing/__pycache__/popen_fork.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "75947faab10a426efa0db5359bd7cd9708e7864a5850cec824bffadea896c293", + "sha256_in_prefix": "75947faab10a426efa0db5359bd7cd9708e7864a5850cec824bffadea896c293", + "size_in_bytes": 2775 + }, + { + "_path": "lib/python3.10/multiprocessing/__pycache__/popen_forkserver.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "d891318726a51d932dc7fa3db3aaa63ba610ac12b22409b94ddaeebee0a9a140", + "sha256_in_prefix": "d891318726a51d932dc7fa3db3aaa63ba610ac12b22409b94ddaeebee0a9a140", + "size_in_bytes": 2720 + }, + { + "_path": "lib/python3.10/multiprocessing/__pycache__/popen_spawn_posix.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "267a866112e3f8e96b94c30035db97d02b2708196dd41edde17d6285016490f3", + "sha256_in_prefix": "267a866112e3f8e96b94c30035db97d02b2708196dd41edde17d6285016490f3", + "size_in_bytes": 2603 + }, + { + "_path": "lib/python3.10/multiprocessing/__pycache__/popen_spawn_win32.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "2059138e46c3c71273961a36cbdd43d33d32d28213a0eacec9c21275b1c4ddd9", + "sha256_in_prefix": "2059138e46c3c71273961a36cbdd43d33d32d28213a0eacec9c21275b1c4ddd9", + "size_in_bytes": 3728 + }, + { + "_path": "lib/python3.10/multiprocessing/__pycache__/process.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "ba4baaa39198313e2577badb0e21d3d8ca0f9f66accf73b2275b7ac2de34f25b", + "sha256_in_prefix": "ba4baaa39198313e2577badb0e21d3d8ca0f9f66accf73b2275b7ac2de34f25b", + "size_in_bytes": 11516 + }, + { + "_path": "lib/python3.10/multiprocessing/__pycache__/queues.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "815a84f8a716de3901fb35605680bedca94f87f7f85efb42ab13e2c8f8278e79", + "sha256_in_prefix": "815a84f8a716de3901fb35605680bedca94f87f7f85efb42ab13e2c8f8278e79", + "size_in_bytes": 10539 + }, + { + "_path": "lib/python3.10/multiprocessing/__pycache__/reduction.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "e8390a5f1c473a25096220c9388d86f9b42459b795ff96ffe04f88aa105b37be", + "sha256_in_prefix": "e8390a5f1c473a25096220c9388d86f9b42459b795ff96ffe04f88aa105b37be", + "size_in_bytes": 8551 + }, + { + "_path": "lib/python3.10/multiprocessing/__pycache__/resource_sharer.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "13d44ae69ae9fb82ef1e1df0f3ff49a303ec7f2cb39d81492be9705cce0cd792", + "sha256_in_prefix": "13d44ae69ae9fb82ef1e1df0f3ff49a303ec7f2cb39d81492be9705cce0cd792", + "size_in_bytes": 5555 + }, + { + "_path": "lib/python3.10/multiprocessing/__pycache__/resource_tracker.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "0b04ef4df52aab76bf2b39b4a4085245dcc21b24008012be840365d0d1ef1cc2", + "sha256_in_prefix": "0b04ef4df52aab76bf2b39b4a4085245dcc21b24008012be840365d0d1ef1cc2", + "size_in_bytes": 5739 + }, + { + "_path": "lib/python3.10/multiprocessing/__pycache__/shared_memory.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "d7694f2367cdc3eee4aadde323843effe8e679451955ea1071fc5f2566a65d27", + "sha256_in_prefix": "d7694f2367cdc3eee4aadde323843effe8e679451955ea1071fc5f2566a65d27", + "size_in_bytes": 14738 + }, + { + "_path": "lib/python3.10/multiprocessing/__pycache__/sharedctypes.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "7eeb055d025b67f131d1c4bd559f3094ffca96cd764790cc0dd04d6c4430a16e", + "sha256_in_prefix": "7eeb055d025b67f131d1c4bd559f3094ffca96cd764790cc0dd04d6c4430a16e", + "size_in_bytes": 7354 + }, + { + "_path": "lib/python3.10/multiprocessing/__pycache__/spawn.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "addb0214ac778648926f7403fe73b575f162f4275da369ee5d33e1d2e52707f8", + "sha256_in_prefix": "addb0214ac778648926f7403fe73b575f162f4275da369ee5d33e1d2e52707f8", + "size_in_bytes": 6991 + }, + { + "_path": "lib/python3.10/multiprocessing/__pycache__/synchronize.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "124fcd0bbc13f73bf8c2b6586ffb405482f72e8d7b00ace0a6ef7743ed00d0aa", + "sha256_in_prefix": "124fcd0bbc13f73bf8c2b6586ffb405482f72e8d7b00ace0a6ef7743ed00d0aa", + "size_in_bytes": 11581 + }, + { + "_path": "lib/python3.10/multiprocessing/__pycache__/util.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "41cbade17bef0e6561af73666dc2ce9c51608d5a972a7a97166ed661d13b0a1e", + "sha256_in_prefix": "41cbade17bef0e6561af73666dc2ce9c51608d5a972a7a97166ed661d13b0a1e", + "size_in_bytes": 11751 + }, + { + "_path": "lib/python3.10/multiprocessing/connection.py", + "path_type": "hardlink", + "sha256": "a6c0161f3bf0c2c38d0a7797148a11aa0e5334d9f22cb9f50f4204c775e9072d", + "sha256_in_prefix": "a6c0161f3bf0c2c38d0a7797148a11aa0e5334d9f22cb9f50f4204c775e9072d", + "size_in_bytes": 31685 + }, + { + "_path": "lib/python3.10/multiprocessing/context.py", + "path_type": "hardlink", + "sha256": "bd8628d1e140d933d40ed14b51009820c1b0b9b5b6c71971df5fc761da65bd08", + "sha256_in_prefix": "bd8628d1e140d933d40ed14b51009820c1b0b9b5b6c71971df5fc761da65bd08", + "size_in_bytes": 11597 + }, + { + "_path": "lib/python3.10/multiprocessing/dummy/__init__.py", + "path_type": "hardlink", + "sha256": "9127a40ea0ff342cb414383b5e7c594a05be2dd835fe246bd3bb0dc036a32a90", + "sha256_in_prefix": "9127a40ea0ff342cb414383b5e7c594a05be2dd835fe246bd3bb0dc036a32a90", + "size_in_bytes": 3061 + }, + { + "_path": "lib/python3.10/multiprocessing/dummy/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "57417753c3bbcbc1b76875cf970f75cf31a706f67e5c5657ba603d773a9ba5fd", + "sha256_in_prefix": "57417753c3bbcbc1b76875cf970f75cf31a706f67e5c5657ba603d773a9ba5fd", + "size_in_bytes": 4122 + }, + { + "_path": "lib/python3.10/multiprocessing/dummy/__pycache__/connection.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "814c6f2b044193f7ee0f49069a9538f30786f528473dc042886e858b8d7605f5", + "sha256_in_prefix": "814c6f2b044193f7ee0f49069a9538f30786f528473dc042886e858b8d7605f5", + "size_in_bytes": 2822 + }, + { + "_path": "lib/python3.10/multiprocessing/dummy/connection.py", + "path_type": "hardlink", + "sha256": "d63dd1979fde9c133efe430ee870e6ba6de43c0a0513866ce3ce475791fe57ab", + "sha256_in_prefix": "d63dd1979fde9c133efe430ee870e6ba6de43c0a0513866ce3ce475791fe57ab", + "size_in_bytes": 1598 + }, + { + "_path": "lib/python3.10/multiprocessing/forkserver.py", + "path_type": "hardlink", + "sha256": "578e1a3733c81c09c70a1f427b467adb20c7197069d773e85ecd6e9236150a72", + "sha256_in_prefix": "578e1a3733c81c09c70a1f427b467adb20c7197069d773e85ecd6e9236150a72", + "size_in_bytes": 12142 + }, + { + "_path": "lib/python3.10/multiprocessing/heap.py", + "path_type": "hardlink", + "sha256": "f6bb79bb99b9ae484935f0d68822e9603a1622dd0b6c4966c79db232a93ba614", + "sha256_in_prefix": "f6bb79bb99b9ae484935f0d68822e9603a1622dd0b6c4966c79db232a93ba614", + "size_in_bytes": 11626 + }, + { + "_path": "lib/python3.10/multiprocessing/managers.py", + "path_type": "hardlink", + "sha256": "32d6c5ca78875c43c5d4d18daa7c771aefa2a881f9196c9faf309b25413b0908", + "sha256_in_prefix": "32d6c5ca78875c43c5d4d18daa7c771aefa2a881f9196c9faf309b25413b0908", + "size_in_bytes": 47502 + }, + { + "_path": "lib/python3.10/multiprocessing/pool.py", + "path_type": "hardlink", + "sha256": "1539ad7e8aa4b8df03778f1fe5381d928928c5837be7172747bf07c3e6cb4a78", + "sha256_in_prefix": "1539ad7e8aa4b8df03778f1fe5381d928928c5837be7172747bf07c3e6cb4a78", + "size_in_bytes": 32759 + }, + { + "_path": "lib/python3.10/multiprocessing/popen_fork.py", + "path_type": "hardlink", + "sha256": "0a09db57e7fab7061c01a61778feea6e2b6bb02ccbc150332f2960b05258ef95", + "sha256_in_prefix": "0a09db57e7fab7061c01a61778feea6e2b6bb02ccbc150332f2960b05258ef95", + "size_in_bytes": 2377 + }, + { + "_path": "lib/python3.10/multiprocessing/popen_forkserver.py", + "path_type": "hardlink", + "sha256": "0588ad0e5a36718b4377dc2a2a97864a10986c25a33dc3bfed12595711b0cdab", + "sha256_in_prefix": "0588ad0e5a36718b4377dc2a2a97864a10986c25a33dc3bfed12595711b0cdab", + "size_in_bytes": 2230 + }, + { + "_path": "lib/python3.10/multiprocessing/popen_spawn_posix.py", + "path_type": "hardlink", + "sha256": "97b5d25aa479516894489877e6a7921252ee35f51e118c2f1f91f32919e7caa8", + "sha256_in_prefix": "97b5d25aa479516894489877e6a7921252ee35f51e118c2f1f91f32919e7caa8", + "size_in_bytes": 2029 + }, + { + "_path": "lib/python3.10/multiprocessing/popen_spawn_win32.py", + "path_type": "hardlink", + "sha256": "03dbaf94f9a13bc241ccd70453f1a68b1d90fea6095b53576605cfc2d379028d", + "sha256_in_prefix": "03dbaf94f9a13bc241ccd70453f1a68b1d90fea6095b53576605cfc2d379028d", + "size_in_bytes": 4011 + }, + { + "_path": "lib/python3.10/multiprocessing/process.py", + "path_type": "hardlink", + "sha256": "9a5f6ca49fb78452678bed74f9b09491c688571f9f09edb97758933294356513", + "sha256_in_prefix": "9a5f6ca49fb78452678bed74f9b09491c688571f9f09edb97758933294356513", + "size_in_bytes": 12089 + }, + { + "_path": "lib/python3.10/multiprocessing/queues.py", + "path_type": "hardlink", + "sha256": "c6a5e3d6918de807074142eb4257746093ca78ffd897d828d559b7ea711c71a8", + "sha256_in_prefix": "c6a5e3d6918de807074142eb4257746093ca78ffd897d828d559b7ea711c71a8", + "size_in_bytes": 12023 + }, + { + "_path": "lib/python3.10/multiprocessing/reduction.py", + "path_type": "hardlink", + "sha256": "4999f8b9ae7b3e8a7f5de302612b4131498dc2e238a2c47f894905c1c63294fe", + "sha256_in_prefix": "4999f8b9ae7b3e8a7f5de302612b4131498dc2e238a2c47f894905c1c63294fe", + "size_in_bytes": 9512 + }, + { + "_path": "lib/python3.10/multiprocessing/resource_sharer.py", + "path_type": "hardlink", + "sha256": "9c40292e1310a9df0aba77da34a9779fcbdd7a20863f12ab48bd496b49cd0049", + "sha256_in_prefix": "9c40292e1310a9df0aba77da34a9779fcbdd7a20863f12ab48bd496b49cd0049", + "size_in_bytes": 5132 + }, + { + "_path": "lib/python3.10/multiprocessing/resource_tracker.py", + "path_type": "hardlink", + "sha256": "613a2865ca3417b8d54c08b989198d5b846ee6fa92ddf3efbbdb98fac497aae9", + "sha256_in_prefix": "613a2865ca3417b8d54c08b989198d5b846ee6fa92ddf3efbbdb98fac497aae9", + "size_in_bytes": 8973 + }, + { + "_path": "lib/python3.10/multiprocessing/shared_memory.py", + "path_type": "hardlink", + "sha256": "51301e70710220e1c494ff5383ac94442a38a4a6622f2eb94e40128c45de1aeb", + "sha256_in_prefix": "51301e70710220e1c494ff5383ac94442a38a4a6622f2eb94e40128c45de1aeb", + "size_in_bytes": 18458 + }, + { + "_path": "lib/python3.10/multiprocessing/sharedctypes.py", + "path_type": "hardlink", + "sha256": "77ef522912474652490b7df523112858e51721e63dcf109b8567a35ce9b31b0d", + "sha256_in_prefix": "77ef522912474652490b7df523112858e51721e63dcf109b8567a35ce9b31b0d", + "size_in_bytes": 6306 + }, + { + "_path": "lib/python3.10/multiprocessing/spawn.py", + "path_type": "hardlink", + "sha256": "16ce6d81f8b5ef7228e5500bff04b37bdceb3d7dfc8d6de3ad523598798c43f4", + "sha256_in_prefix": "16ce6d81f8b5ef7228e5500bff04b37bdceb3d7dfc8d6de3ad523598798c43f4", + "size_in_bytes": 9296 + }, + { + "_path": "lib/python3.10/multiprocessing/synchronize.py", + "path_type": "hardlink", + "sha256": "c357514f2359baf9570adcce2a6818a2456477019eaa138f26f8fcc2b6f467b0", + "sha256_in_prefix": "c357514f2359baf9570adcce2a6818a2456477019eaa138f26f8fcc2b6f467b0", + "size_in_bytes": 11610 + }, + { + "_path": "lib/python3.10/multiprocessing/util.py", + "path_type": "hardlink", + "sha256": "027d6642308f741f94d44fc79c23e4d1a1c275159823720ccb05b0a8e705450a", + "sha256_in_prefix": "027d6642308f741f94d44fc79c23e4d1a1c275159823720ccb05b0a8e705450a", + "size_in_bytes": 14024 + }, + { + "_path": "lib/python3.10/netrc.py", + "path_type": "hardlink", + "sha256": "fc92648a61d2e29b3b7954f8c0bc4c68b7a1da5c8d87979c634f14e47b96298d", + "sha256_in_prefix": "fc92648a61d2e29b3b7954f8c0bc4c68b7a1da5c8d87979c634f14e47b96298d", + "size_in_bytes": 5747 + }, + { + "_path": "lib/python3.10/nntplib.py", + "path_type": "hardlink", + "sha256": "4ff3d30528c355d965d93ccc123d31284905c0922befa08ad36387d2a8bbe84e", + "sha256_in_prefix": "4ff3d30528c355d965d93ccc123d31284905c0922befa08ad36387d2a8bbe84e", + "size_in_bytes": 41023 + }, + { + "_path": "lib/python3.10/ntpath.py", + "path_type": "hardlink", + "sha256": "ad0799b417b2d0246869768bea784702c6838be1f2151ed99fa8132327f66387", + "sha256_in_prefix": "ad0799b417b2d0246869768bea784702c6838be1f2151ed99fa8132327f66387", + "size_in_bytes": 29481 + }, + { + "_path": "lib/python3.10/nturl2path.py", + "path_type": "hardlink", + "sha256": "980982ba66cc403d17874369d2770e09845b3d49f1d4514e1c52e01518114332", + "sha256_in_prefix": "980982ba66cc403d17874369d2770e09845b3d49f1d4514e1c52e01518114332", + "size_in_bytes": 2887 + }, + { + "_path": "lib/python3.10/numbers.py", + "path_type": "hardlink", + "sha256": "6d70991643a109e9c99e94d6ea2734a995fa8e89114a70ea09737413fa9ae292", + "sha256_in_prefix": "6d70991643a109e9c99e94d6ea2734a995fa8e89114a70ea09737413fa9ae292", + "size_in_bytes": 10348 + }, + { + "_path": "lib/python3.10/opcode.py", + "path_type": "hardlink", + "sha256": "042223e56632d8ff283e63e190e0496f9af6945f0d6dfb692ac9d129aabc85dc", + "sha256_in_prefix": "042223e56632d8ff283e63e190e0496f9af6945f0d6dfb692ac9d129aabc85dc", + "size_in_bytes": 5902 + }, + { + "_path": "lib/python3.10/operator.py", + "path_type": "hardlink", + "sha256": "fd931e2bf493ddd239208b0c0a2249324602b48aabc984c85b7d8dcc4d99a17d", + "sha256_in_prefix": "fd931e2bf493ddd239208b0c0a2249324602b48aabc984c85b7d8dcc4d99a17d", + "size_in_bytes": 10751 + }, + { + "_path": "lib/python3.10/optparse.py", + "path_type": "hardlink", + "sha256": "07d224301cba312fa0697bff9cd5a4bb4f778a90629632091b3f4ae874d89af5", + "sha256_in_prefix": "07d224301cba312fa0697bff9cd5a4bb4f778a90629632091b3f4ae874d89af5", + "size_in_bytes": 60369 + }, + { + "_path": "lib/python3.10/os.py", + "path_type": "hardlink", + "sha256": "70e420e105d021d5ba2ec4d8a9b2131561db6d93e800e8580ddeb86cbd6959c3", + "sha256_in_prefix": "70e420e105d021d5ba2ec4d8a9b2131561db6d93e800e8580ddeb86cbd6959c3", + "size_in_bytes": 39557 + }, + { + "_path": "lib/python3.10/pathlib.py", + "path_type": "hardlink", + "sha256": "936f14a3ecc4ac5e896e4d673666d76b25a9d581f3b4c8d8d424e830fda2a69b", + "sha256_in_prefix": "936f14a3ecc4ac5e896e4d673666d76b25a9d581f3b4c8d8d424e830fda2a69b", + "size_in_bytes": 49575 + }, + { + "_path": "lib/python3.10/pdb.py", + "path_type": "hardlink", + "sha256": "2b9b37cf7a19ec1ac0809d3384db2dfd6eb59b77283aa53c8659cac70faf2df0", + "sha256_in_prefix": "2b9b37cf7a19ec1ac0809d3384db2dfd6eb59b77283aa53c8659cac70faf2df0", + "size_in_bytes": 63225 + }, + { + "_path": "lib/python3.10/pickle.py", + "path_type": "hardlink", + "sha256": "f29792b7bad19b9b7a6096aae01e9a6a0a3ec28029576af74efc530ee331c412", + "sha256_in_prefix": "f29792b7bad19b9b7a6096aae01e9a6a0a3ec28029576af74efc530ee331c412", + "size_in_bytes": 64949 + }, + { + "_path": "lib/python3.10/pickletools.py", + "path_type": "hardlink", + "sha256": "bcc8d00ebadd684aba19169e853e6f23bc36d609ae0c8119912f1e39e9f0c1e9", + "sha256_in_prefix": "bcc8d00ebadd684aba19169e853e6f23bc36d609ae0c8119912f1e39e9f0c1e9", + "size_in_bytes": 93486 + }, + { + "_path": "lib/python3.10/pipes.py", + "path_type": "hardlink", + "sha256": "58e152ce03c6429b8dabd8d715a1872c2a4018e7d329973b4fdea3520cfaaa10", + "sha256_in_prefix": "58e152ce03c6429b8dabd8d715a1872c2a4018e7d329973b4fdea3520cfaaa10", + "size_in_bytes": 8914 + }, + { + "_path": "lib/python3.10/pkgutil.py", + "path_type": "hardlink", + "sha256": "1dac904eeefb73362f13c41d783572433c25d3f45d92f1e44873b6920b7adef1", + "sha256_in_prefix": "1dac904eeefb73362f13c41d783572433c25d3f45d92f1e44873b6920b7adef1", + "size_in_bytes": 24576 + }, + { + "_path": "lib/python3.10/platform.py", + "path_type": "hardlink", + "sha256": "1ac006643ac07400e0c4f9af0113adcbad32d0ef7c5f47c65e083ff6ba487095", + "sha256_in_prefix": "1ac006643ac07400e0c4f9af0113adcbad32d0ef7c5f47c65e083ff6ba487095", + "size_in_bytes": 42187 + }, + { + "_path": "lib/python3.10/plistlib.py", + "path_type": "hardlink", + "sha256": "974c0acf063616c8e5ef6f4ef4781e535ea8ebcbf3b99a32d7db04cc2cbd5715", + "sha256_in_prefix": "974c0acf063616c8e5ef6f4ef4781e535ea8ebcbf3b99a32d7db04cc2cbd5715", + "size_in_bytes": 28352 + }, + { + "_path": "lib/python3.10/poplib.py", + "path_type": "hardlink", + "sha256": "7b341e6adb4e4341b211a221a7224849ea415fc1e39c014b05ae7d9a566819f4", + "sha256_in_prefix": "7b341e6adb4e4341b211a221a7224849ea415fc1e39c014b05ae7d9a566819f4", + "size_in_bytes": 15198 + }, + { + "_path": "lib/python3.10/posixpath.py", + "path_type": "hardlink", + "sha256": "2c770bac0680a5a180b1310102d14e1e120f2f2e8e47925b1574ec808cb8ad6d", + "sha256_in_prefix": "2c770bac0680a5a180b1310102d14e1e120f2f2e8e47925b1574ec808cb8ad6d", + "size_in_bytes": 16250 + }, + { + "_path": "lib/python3.10/pprint.py", + "path_type": "hardlink", + "sha256": "1f7c72d37dca932cd875eb3c732d17c01de6273fd30f8b38f85e236ed94cd2e3", + "sha256_in_prefix": "1f7c72d37dca932cd875eb3c732d17c01de6273fd30f8b38f85e236ed94cd2e3", + "size_in_bytes": 24444 + }, + { + "_path": "lib/python3.10/profile.py", + "path_type": "hardlink", + "sha256": "4d87bdc8b85bf0a9bdee3e9d975a8a1a0c7360cb264fb68c4c48a102e718e3a3", + "sha256_in_prefix": "4d87bdc8b85bf0a9bdee3e9d975a8a1a0c7360cb264fb68c4c48a102e718e3a3", + "size_in_bytes": 22883 + }, + { + "_path": "lib/python3.10/pstats.py", + "path_type": "hardlink", + "sha256": "21497bb01230584b135b7bd89241a28d7d7994b577edacd4ea2403e80f794a81", + "sha256_in_prefix": "21497bb01230584b135b7bd89241a28d7d7994b577edacd4ea2403e80f794a81", + "size_in_bytes": 29326 + }, + { + "_path": "lib/python3.10/pty.py", + "path_type": "hardlink", + "sha256": "eded59f53eb5c3cceee139935d8fb11e723dc460785909492cd2e937f6494fb5", + "sha256_in_prefix": "eded59f53eb5c3cceee139935d8fb11e723dc460785909492cd2e937f6494fb5", + "size_in_bytes": 5213 + }, + { + "_path": "lib/python3.10/py_compile.py", + "path_type": "hardlink", + "sha256": "3464f04938b57a7aafbc5c394ccd4c46823ee607f7fe36b48b91ecbc30ff4e48", + "sha256_in_prefix": "3464f04938b57a7aafbc5c394ccd4c46823ee607f7fe36b48b91ecbc30ff4e48", + "size_in_bytes": 7837 + }, + { + "_path": "lib/python3.10/pyclbr.py", + "path_type": "hardlink", + "sha256": "e8ca09333701ba41244e20b8c2c37b7ed0499b88c4b2ca82cac51ef89ca9e647", + "sha256_in_prefix": "e8ca09333701ba41244e20b8c2c37b7ed0499b88c4b2ca82cac51ef89ca9e647", + "size_in_bytes": 11396 + }, + { + "_path": "lib/python3.10/pydoc.py", + "path_type": "hardlink", + "sha256": "1db5ab5321c1f0488c79beacb553bf6ef2c59c51d996f12de96aeb678d2a4ca7", + "sha256_in_prefix": "1db5ab5321c1f0488c79beacb553bf6ef2c59c51d996f12de96aeb678d2a4ca7", + "size_in_bytes": 109589 + }, + { + "_path": "lib/python3.10/pydoc_data/__init__.py", + "path_type": "hardlink", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size_in_bytes": 0 + }, + { + "_path": "lib/python3.10/pydoc_data/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "1430d8511e270e6af999b2df4eae2c35a213f74b24f33bc3a9e03a63eb0e960a", + "sha256_in_prefix": "1430d8511e270e6af999b2df4eae2c35a213f74b24f33bc3a9e03a63eb0e960a", + "size_in_bytes": 389 + }, + { + "_path": "lib/python3.10/pydoc_data/__pycache__/topics.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "fd6e1e5f54325f0ccd986430ef3e81c04fc6fd1d7431833688af0beab7f934c8", + "sha256_in_prefix": "fd6e1e5f54325f0ccd986430ef3e81c04fc6fd1d7431833688af0beab7f934c8", + "size_in_bytes": 473761 + }, + { + "_path": "lib/python3.10/pydoc_data/_pydoc.css", + "path_type": "hardlink", + "sha256": "7b8cc50cbc204745d38fa3d57b3bd6bb4c3f6ea0d346bef61b3cc423eb15b9d1", + "sha256_in_prefix": "7b8cc50cbc204745d38fa3d57b3bd6bb4c3f6ea0d346bef61b3cc423eb15b9d1", + "size_in_bytes": 96 + }, + { + "_path": "lib/python3.10/pydoc_data/topics.py", + "path_type": "hardlink", + "sha256": "1536be360c4cbe467096f954b0a3b2c8776628eacad8d016bb7faf2a34c0580d", + "sha256_in_prefix": "1536be360c4cbe467096f954b0a3b2c8776628eacad8d016bb7faf2a34c0580d", + "size_in_bytes": 745585 + }, + { + "_path": "lib/python3.10/queue.py", + "path_type": "hardlink", + "sha256": "f6c37fc37cd7440979f7d22d40ee818fa3b714c573610c08fa52911d541193f0", + "sha256_in_prefix": "f6c37fc37cd7440979f7d22d40ee818fa3b714c573610c08fa52911d541193f0", + "size_in_bytes": 11496 + }, + { + "_path": "lib/python3.10/quopri.py", + "path_type": "hardlink", + "sha256": "7070b61e5a582423a1bb405e3d23cb3e26c4faafcb142a8cbb88ec3f2d6104e9", + "sha256_in_prefix": "7070b61e5a582423a1bb405e3d23cb3e26c4faafcb142a8cbb88ec3f2d6104e9", + "size_in_bytes": 7268 + }, + { + "_path": "lib/python3.10/random.py", + "path_type": "hardlink", + "sha256": "ce80a2471965e64ae93caea14490f16850432e65dce87f15edfe25b6f562f8d1", + "sha256_in_prefix": "ce80a2471965e64ae93caea14490f16850432e65dce87f15edfe25b6f562f8d1", + "size_in_bytes": 33221 + }, + { + "_path": "lib/python3.10/re.py", + "path_type": "hardlink", + "sha256": "018b1a2c70e8ef537cc328d1026afdeca5839392ce47235a7b8d22e1b788cdc7", + "sha256_in_prefix": "018b1a2c70e8ef537cc328d1026afdeca5839392ce47235a7b8d22e1b788cdc7", + "size_in_bytes": 15860 + }, + { + "_path": "lib/python3.10/reprlib.py", + "path_type": "hardlink", + "sha256": "dc786fbc528e10bc6ea3c1fa84e4178e85c4f3c9b937a4b191546aec317e9cb9", + "sha256_in_prefix": "dc786fbc528e10bc6ea3c1fa84e4178e85c4f3c9b937a4b191546aec317e9cb9", + "size_in_bytes": 5267 + }, + { + "_path": "lib/python3.10/rlcompleter.py", + "path_type": "hardlink", + "sha256": "6cb81b6458eba5bf1a3c8ffe20d65c168853e650e1feadca0567a4fd778de71f", + "sha256_in_prefix": "6cb81b6458eba5bf1a3c8ffe20d65c168853e650e1feadca0567a4fd778de71f", + "size_in_bytes": 7817 + }, + { + "_path": "lib/python3.10/runpy.py", + "path_type": "hardlink", + "sha256": "fa52a1f6a3cc484d4798a1ad9438db68836fcc2b7c8f442d1a24b4ba5f01f55c", + "sha256_in_prefix": "fa52a1f6a3cc484d4798a1ad9438db68836fcc2b7c8f442d1a24b4ba5f01f55c", + "size_in_bytes": 13111 + }, + { + "_path": "lib/python3.10/sched.py", + "path_type": "hardlink", + "sha256": "edfb309483d7cb05e06ad86d1fdeb819629f71402dc6710a1bec36c7afcaac50", + "sha256_in_prefix": "edfb309483d7cb05e06ad86d1fdeb819629f71402dc6710a1bec36c7afcaac50", + "size_in_bytes": 6351 + }, + { + "_path": "lib/python3.10/secrets.py", + "path_type": "hardlink", + "sha256": "695195792d0f738bbdcd22ab0493e787d7a167adb1ac453b2b400ce4ebf66842", + "sha256_in_prefix": "695195792d0f738bbdcd22ab0493e787d7a167adb1ac453b2b400ce4ebf66842", + "size_in_bytes": 2036 + }, + { + "_path": "lib/python3.10/selectors.py", + "path_type": "hardlink", + "sha256": "b16e673c110fd6a362414308ef73ffc3c15125c87361333b309791735931040d", + "sha256_in_prefix": "b16e673c110fd6a362414308ef73ffc3c15125c87361333b309791735931040d", + "size_in_bytes": 19536 + }, + { + "_path": "lib/python3.10/shelve.py", + "path_type": "hardlink", + "sha256": "b978c6f0ffa901b041d6518afed03f2938a62168066013ee7d23baac31c356c0", + "sha256_in_prefix": "b978c6f0ffa901b041d6518afed03f2938a62168066013ee7d23baac31c356c0", + "size_in_bytes": 8560 + }, + { + "_path": "lib/python3.10/shlex.py", + "path_type": "hardlink", + "sha256": "42ab6060f316e121e374e6621d8c1c98b8db323903c3df289a810c45a8ae46a7", + "sha256_in_prefix": "42ab6060f316e121e374e6621d8c1c98b8db323903c3df289a810c45a8ae46a7", + "size_in_bytes": 13501 + }, + { + "_path": "lib/python3.10/shutil.py", + "path_type": "hardlink", + "sha256": "d96cf3b8b17c717f14dc67643cc8ad0943fb4b960d3e32981b2991613d39dde9", + "sha256_in_prefix": "d96cf3b8b17c717f14dc67643cc8ad0943fb4b960d3e32981b2991613d39dde9", + "size_in_bytes": 54572 + }, + { + "_path": "lib/python3.10/signal.py", + "path_type": "hardlink", + "sha256": "6ae9e49fe09b607bc161fc80067de9763aa48f523567a34992f00be06057f00a", + "sha256_in_prefix": "6ae9e49fe09b607bc161fc80067de9763aa48f523567a34992f00be06057f00a", + "size_in_bytes": 2438 + }, + { + "_path": "lib/python3.10/site-packages/README.txt", + "path_type": "hardlink", + "sha256": "cba8fece8f62c36306ba27a128f124a257710e41fc619301ee97be93586917cb", + "sha256_in_prefix": "cba8fece8f62c36306ba27a128f124a257710e41fc619301ee97be93586917cb", + "size_in_bytes": 119 + }, + { + "_path": "lib/python3.10/site.py", + "path_type": "hardlink", + "sha256": "46b88ba081e7a1b606cfe603c78e60b8f2bf30c7ba098bcbd51a3076990c97ea", + "sha256_in_prefix": "46b88ba081e7a1b606cfe603c78e60b8f2bf30c7ba098bcbd51a3076990c97ea", + "size_in_bytes": 22926 + }, + { + "_path": "lib/python3.10/smtpd.py", + "path_type": "hardlink", + "sha256": "1789da8d39e12e65a29677f5cb1c08e03373a483a0547775c86ae9a51230c3c8", + "sha256_in_prefix": "1789da8d39e12e65a29677f5cb1c08e03373a483a0547775c86ae9a51230c3c8", + "size_in_bytes": 35165 + }, + { + "_path": "lib/python3.10/smtplib.py", + "path_type": "hardlink", + "sha256": "b154e27998d0ef0b32fcc665299cdb30883ffe039ede3c4faac3a9db6618d35d", + "sha256_in_prefix": "b154e27998d0ef0b32fcc665299cdb30883ffe039ede3c4faac3a9db6618d35d", + "size_in_bytes": 45418 + }, + { + "_path": "lib/python3.10/sndhdr.py", + "path_type": "hardlink", + "sha256": "50770b17429ae1387cbccef9ee4e0f1f4cb43494e01079f0564bf25b62f3ee21", + "sha256_in_prefix": "50770b17429ae1387cbccef9ee4e0f1f4cb43494e01079f0564bf25b62f3ee21", + "size_in_bytes": 7099 + }, + { + "_path": "lib/python3.10/socket.py", + "path_type": "hardlink", + "sha256": "a11ad8b558a58696a39a92658e400ed74f060a7d78e71eb79fc88842dfa5f361", + "sha256_in_prefix": "a11ad8b558a58696a39a92658e400ed74f060a7d78e71eb79fc88842dfa5f361", + "size_in_bytes": 36785 + }, + { + "_path": "lib/python3.10/socketserver.py", + "path_type": "hardlink", + "sha256": "59007916cf2f540185bf47f3be35648d5141b9c0f4668b214900c4c35037179e", + "sha256_in_prefix": "59007916cf2f540185bf47f3be35648d5141b9c0f4668b214900c4c35037179e", + "size_in_bytes": 27296 + }, + { + "_path": "lib/python3.10/sqlite3/__init__.py", + "path_type": "hardlink", + "sha256": "29878411a7bcefcd56a3751fe689dea2c99bda75a13a485d78898834a323f0c0", + "sha256_in_prefix": "29878411a7bcefcd56a3751fe689dea2c99bda75a13a485d78898834a323f0c0", + "size_in_bytes": 2536 + }, + { + "_path": "lib/python3.10/sqlite3/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "55360da2ae9b05f3467604fa1a594c6c2e5b3d3f12ca4ea1ca4d6cb7c6782d3f", + "sha256_in_prefix": "55360da2ae9b05f3467604fa1a594c6c2e5b3d3f12ca4ea1ca4d6cb7c6782d3f", + "size_in_bytes": 1900 + }, + { + "_path": "lib/python3.10/sqlite3/__pycache__/dbapi2.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "65c9f68ae5025c866e4141f2371653f7d7e88855631c375dff3b5eabcd0c317b", + "sha256_in_prefix": "65c9f68ae5025c866e4141f2371653f7d7e88855631c375dff3b5eabcd0c317b", + "size_in_bytes": 3228 + }, + { + "_path": "lib/python3.10/sqlite3/__pycache__/dump.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "beb43d5c4078fd62d7b4ddc7e6231ce4e4686ec85470f47bb2670349465bbb8b", + "sha256_in_prefix": "beb43d5c4078fd62d7b4ddc7e6231ce4e4686ec85470f47bb2670349465bbb8b", + "size_in_bytes": 2489 + }, + { + "_path": "lib/python3.10/sqlite3/dbapi2.py", + "path_type": "hardlink", + "sha256": "c7c6837ae3618807d68ea16daf832862ee8472c7d35ab05a0b3c0d4ed94b6ddf", + "sha256_in_prefix": "c7c6837ae3618807d68ea16daf832862ee8472c7d35ab05a0b3c0d4ed94b6ddf", + "size_in_bytes": 3323 + }, + { + "_path": "lib/python3.10/sqlite3/dump.py", + "path_type": "hardlink", + "sha256": "64927fabf1b761c7f6b100bf0312434386381152b7f8c75f1e543a5a4c8ab59a", + "sha256_in_prefix": "64927fabf1b761c7f6b100bf0312434386381152b7f8c75f1e543a5a4c8ab59a", + "size_in_bytes": 3292 + }, + { + "_path": "lib/python3.10/sre_compile.py", + "path_type": "hardlink", + "sha256": "800f4c7df096e10336cd54f1aa6382721d6fcb974669463fe67f7a9189e52407", + "sha256_in_prefix": "800f4c7df096e10336cd54f1aa6382721d6fcb974669463fe67f7a9189e52407", + "size_in_bytes": 27973 + }, + { + "_path": "lib/python3.10/sre_constants.py", + "path_type": "hardlink", + "sha256": "6d5f1ff40e42f4be9b98899b58684dffcdb9c0ef1b3b942c17a3fcafc0bbcdc1", + "sha256_in_prefix": "6d5f1ff40e42f4be9b98899b58684dffcdb9c0ef1b3b942c17a3fcafc0bbcdc1", + "size_in_bytes": 7177 + }, + { + "_path": "lib/python3.10/sre_parse.py", + "path_type": "hardlink", + "sha256": "dad10892e970f3b9d0ad874d893edde31c0303e39ea5e2678935129e29128c2f", + "sha256_in_prefix": "dad10892e970f3b9d0ad874d893edde31c0303e39ea5e2678935129e29128c2f", + "size_in_bytes": 40779 + }, + { + "_path": "lib/python3.10/ssl.py", + "path_type": "hardlink", + "sha256": "1c6e62f53e0b4a80395a5f786c9718681b012fc1b6aacee7bc35385f9bbe882c", + "sha256_in_prefix": "1c6e62f53e0b4a80395a5f786c9718681b012fc1b6aacee7bc35385f9bbe882c", + "size_in_bytes": 53895 + }, + { + "_path": "lib/python3.10/stat.py", + "path_type": "hardlink", + "sha256": "052af0327eae6941b69b05c088b3e748f79995635f80ac4cc7125eb333eb4c77", + "sha256_in_prefix": "052af0327eae6941b69b05c088b3e748f79995635f80ac4cc7125eb333eb4c77", + "size_in_bytes": 5485 + }, + { + "_path": "lib/python3.10/statistics.py", + "path_type": "hardlink", + "sha256": "88678d0406c9b3a1acff23d36eb35db88a2c6ca379c3a665226cea8d56c223ca", + "sha256_in_prefix": "88678d0406c9b3a1acff23d36eb35db88a2c6ca379c3a665226cea8d56c223ca", + "size_in_bytes": 43205 + }, + { + "_path": "lib/python3.10/string.py", + "path_type": "hardlink", + "sha256": "bc57c407a8397ee2bea8683d0ce0a563a060c74c785ff36fc6555d66a9c7a566", + "sha256_in_prefix": "bc57c407a8397ee2bea8683d0ce0a563a060c74c785ff36fc6555d66a9c7a566", + "size_in_bytes": 10566 + }, + { + "_path": "lib/python3.10/stringprep.py", + "path_type": "hardlink", + "sha256": "60b6c83581093029312efb6670b11c540090b3f78bcf72264467b494f02f21a5", + "sha256_in_prefix": "60b6c83581093029312efb6670b11c540090b3f78bcf72264467b494f02f21a5", + "size_in_bytes": 12917 + }, + { + "_path": "lib/python3.10/struct.py", + "path_type": "hardlink", + "sha256": "9c231f9497caf513a22dee8f790b07f969b0e45854a0bdd6dd84b492e08c2856", + "sha256_in_prefix": "9c231f9497caf513a22dee8f790b07f969b0e45854a0bdd6dd84b492e08c2856", + "size_in_bytes": 257 + }, + { + "_path": "lib/python3.10/subprocess.py", + "path_type": "hardlink", + "sha256": "53bb0d0780e166ef4ae94f3b2a817a8aae49a84d899db1f4c31f933d429057d6", + "sha256_in_prefix": "53bb0d0780e166ef4ae94f3b2a817a8aae49a84d899db1f4c31f933d429057d6", + "size_in_bytes": 84917 + }, + { + "_path": "lib/python3.10/sunau.py", + "path_type": "hardlink", + "sha256": "6163b749f5a2afd7709eb98e2d9bc1db8811aaeb693553932841dba6b8bca537", + "sha256_in_prefix": "6163b749f5a2afd7709eb98e2d9bc1db8811aaeb693553932841dba6b8bca537", + "size_in_bytes": 18158 + }, + { + "_path": "lib/python3.10/symtable.py", + "path_type": "hardlink", + "sha256": "c0d1e1dc50c420d12beea9d1b535c3c3ce9b07d0a2f1286beb2f01693179162f", + "sha256_in_prefix": "c0d1e1dc50c420d12beea9d1b535c3c3ce9b07d0a2f1286beb2f01693179162f", + "size_in_bytes": 10217 + }, + { + "_path": "lib/python3.10/sysconfig.py", + "path_type": "hardlink", + "sha256": "898e17eaa2aec44e7662e8e7f4bfce26921ee417d2d973ade6b9b544500dc2f5", + "sha256_in_prefix": "898e17eaa2aec44e7662e8e7f4bfce26921ee417d2d973ade6b9b544500dc2f5", + "size_in_bytes": 27689 + }, + { + "_path": "lib/python3.10/tabnanny.py", + "path_type": "hardlink", + "sha256": "73bc1829f10634726db7a22f1cb5c06f76802d54cd7edba0ecff145156caa2f8", + "sha256_in_prefix": "73bc1829f10634726db7a22f1cb5c06f76802d54cd7edba0ecff145156caa2f8", + "size_in_bytes": 11299 + }, + { + "_path": "lib/python3.10/tarfile.py", + "path_type": "hardlink", + "sha256": "9250a120ae805be109bc8360182de2cb2b7f74924baa6c86f996c1e919bc3e3f", + "sha256_in_prefix": "9250a120ae805be109bc8360182de2cb2b7f74924baa6c86f996c1e919bc3e3f", + "size_in_bytes": 106113 + }, + { + "_path": "lib/python3.10/telnetlib.py", + "path_type": "hardlink", + "sha256": "ea39572ed5af144022e46767c959d01d1bcb3a596b62dcfd9db6adc77cedd924", + "sha256_in_prefix": "ea39572ed5af144022e46767c959d01d1bcb3a596b62dcfd9db6adc77cedd924", + "size_in_bytes": 23254 + }, + { + "_path": "lib/python3.10/tempfile.py", + "path_type": "hardlink", + "sha256": "676356b31756112053515fc1d550a99faf0f4bbaff6ccd4cc8a56310474f5c3a", + "sha256_in_prefix": "676356b31756112053515fc1d550a99faf0f4bbaff6ccd4cc8a56310474f5c3a", + "size_in_bytes": 29469 + }, + { + "_path": "lib/python3.10/test/__init__.py", + "path_type": "hardlink", + "sha256": "836cdb388117cf81e78d9fa2a141cca1b14b0179733322e710067749a1b16fe9", + "sha256_in_prefix": "836cdb388117cf81e78d9fa2a141cca1b14b0179733322e710067749a1b16fe9", + "size_in_bytes": 47 + }, + { + "_path": "lib/python3.10/test/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "76ae972f02eec2bceb87a49f9ada7759c46501ff700a1ce9105f9d66356103ad", + "sha256_in_prefix": "76ae972f02eec2bceb87a49f9ada7759c46501ff700a1ce9105f9d66356103ad", + "size_in_bytes": 383 + }, + { + "_path": "lib/python3.10/test/__pycache__/test_script_helper.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "1b3aebe6ae43cd21839c2be1491879f884c4e8147b05464b3f819ab4080a2085", + "sha256_in_prefix": "1b3aebe6ae43cd21839c2be1491879f884c4e8147b05464b3f819ab4080a2085", + "size_in_bytes": 5968 + }, + { + "_path": "lib/python3.10/test/__pycache__/test_support.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "d87cb6f467e2c8d763266b6875e3f4d7288fc53598fb4be4a7a42e1763969fc3", + "sha256_in_prefix": "d87cb6f467e2c8d763266b6875e3f4d7288fc53598fb4be4a7a42e1763969fc3", + "size_in_bytes": 23150 + }, + { + "_path": "lib/python3.10/test/support/__init__.py", + "path_type": "hardlink", + "sha256": "0eeaf28055f176f6da9a928ff632e57181fea92247b03afb89336940ded6b3e1", + "sha256_in_prefix": "0eeaf28055f176f6da9a928ff632e57181fea92247b03afb89336940ded6b3e1", + "size_in_bytes": 71365 + }, + { + "_path": "lib/python3.10/test/support/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "f6003ecdc175ab6e7d44c29405c1f6dd4e1e8a8e0fd3b81b3129277145541ea2", + "sha256_in_prefix": "f6003ecdc175ab6e7d44c29405c1f6dd4e1e8a8e0fd3b81b3129277145541ea2", + "size_in_bytes": 57885 + }, + { + "_path": "lib/python3.10/test/support/__pycache__/bytecode_helper.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "3d4f106960c78c28fb40993476c7bfc8519d4bd188de480c6af4afaf5354e090", + "sha256_in_prefix": "3d4f106960c78c28fb40993476c7bfc8519d4bd188de480c6af4afaf5354e090", + "size_in_bytes": 1956 + }, + { + "_path": "lib/python3.10/test/support/__pycache__/hashlib_helper.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "bd7b24dc5863eba10ba0fba557dcfd96a4454e2729301f02f38bcd3ea5abef4b", + "sha256_in_prefix": "bd7b24dc5863eba10ba0fba557dcfd96a4454e2729301f02f38bcd3ea5abef4b", + "size_in_bytes": 2152 + }, + { + "_path": "lib/python3.10/test/support/__pycache__/import_helper.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "fe909658efd453f66021e08f2b51878bfa1e3ba344cf2158e815130ee708ca7a", + "sha256_in_prefix": "fe909658efd453f66021e08f2b51878bfa1e3ba344cf2158e815130ee708ca7a", + "size_in_bytes": 7572 + }, + { + "_path": "lib/python3.10/test/support/__pycache__/interpreters.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "0390d2fe729b6bc6b1ee9bab4fd4f0c584813f8f044c51742d9fa24eb3184d03", + "sha256_in_prefix": "0390d2fe729b6bc6b1ee9bab4fd4f0c584813f8f044c51742d9fa24eb3184d03", + "size_in_bytes": 7358 + }, + { + "_path": "lib/python3.10/test/support/__pycache__/logging_helper.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "94315596cb9308204e3e17ab559d7de3b92ed5c8eb962193a0bf2752fed464c5", + "sha256_in_prefix": "94315596cb9308204e3e17ab559d7de3b92ed5c8eb962193a0bf2752fed464c5", + "size_in_bytes": 1418 + }, + { + "_path": "lib/python3.10/test/support/__pycache__/os_helper.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "5cd463a0420baf75c2c6685399d03a0c81292c027565ef23735b2819b62bcce8", + "sha256_in_prefix": "5cd463a0420baf75c2c6685399d03a0c81292c027565ef23735b2819b62bcce8", + "size_in_bytes": 14408 + }, + { + "_path": "lib/python3.10/test/support/__pycache__/script_helper.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "2b8fad0a3381c48d70c207bcdea02a959e52ad8e0189ab0d5916050f37c97035", + "sha256_in_prefix": "2b8fad0a3381c48d70c207bcdea02a959e52ad8e0189ab0d5916050f37c97035", + "size_in_bytes": 8058 + }, + { + "_path": "lib/python3.10/test/support/__pycache__/socket_helper.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "dd644a3f6ee4c555eb8bd6abf5e509a87738fc7a66de9ea7410a0abdb453f5ca", + "sha256_in_prefix": "dd644a3f6ee4c555eb8bd6abf5e509a87738fc7a66de9ea7410a0abdb453f5ca", + "size_in_bytes": 9882 + }, + { + "_path": "lib/python3.10/test/support/__pycache__/testresult.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "6af20774698c4594490477856ef930b2a970e7e850b6ef6f7a899e6c8c3b13cc", + "sha256_in_prefix": "6af20774698c4594490477856ef930b2a970e7e850b6ef6f7a899e6c8c3b13cc", + "size_in_bytes": 7036 + }, + { + "_path": "lib/python3.10/test/support/__pycache__/threading_helper.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "fa452c780f48faa87c4e5d32f9afbe45d6b99beb16f2532fd8b27a8667ef41ce", + "sha256_in_prefix": "fa452c780f48faa87c4e5d32f9afbe45d6b99beb16f2532fd8b27a8667ef41ce", + "size_in_bytes": 6577 + }, + { + "_path": "lib/python3.10/test/support/__pycache__/warnings_helper.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "8c06c922c74f46bc4c707551a7af22f80d0b2e43f582633682a092cf721e707c", + "sha256_in_prefix": "8c06c922c74f46bc4c707551a7af22f80d0b2e43f582633682a092cf721e707c", + "size_in_bytes": 6606 + }, + { + "_path": "lib/python3.10/test/support/bytecode_helper.py", + "path_type": "hardlink", + "sha256": "8adf3d7f67b83b0eb473e070655421b57627b820e42119886db4345d665b087e", + "sha256_in_prefix": "8adf3d7f67b83b0eb473e070655421b57627b820e42119886db4345d665b087e", + "size_in_bytes": 1647 + }, + { + "_path": "lib/python3.10/test/support/hashlib_helper.py", + "path_type": "hardlink", + "sha256": "19924c427e33c86284ef2a41f76ab6937ab36f12e3d1ef4e617cdbf616a8fc12", + "sha256_in_prefix": "19924c427e33c86284ef2a41f76ab6937ab36f12e3d1ef4e617cdbf616a8fc12", + "size_in_bytes": 1907 + }, + { + "_path": "lib/python3.10/test/support/import_helper.py", + "path_type": "hardlink", + "sha256": "555ffc6a817da1f66e75545cad174aa96ec0ecf7a47145760e62f2fe0004ed10", + "sha256_in_prefix": "555ffc6a817da1f66e75545cad174aa96ec0ecf7a47145760e62f2fe0004ed10", + "size_in_bytes": 7736 + }, + { + "_path": "lib/python3.10/test/support/interpreters.py", + "path_type": "hardlink", + "sha256": "d77d05cea8a58266c831522ea230300068f0efe734ad07dee4e0cf3cf0e014c4", + "sha256_in_prefix": "d77d05cea8a58266c831522ea230300068f0efe734ad07dee4e0cf3cf0e014c4", + "size_in_bytes": 5829 + }, + { + "_path": "lib/python3.10/test/support/logging_helper.py", + "path_type": "hardlink", + "sha256": "be1927e654180fcf6d84257be161fe6fa59796774e862c89b6b78adb656738f3", + "sha256_in_prefix": "be1927e654180fcf6d84257be161fe6fa59796774e862c89b6b78adb656738f3", + "size_in_bytes": 916 + }, + { + "_path": "lib/python3.10/test/support/os_helper.py", + "path_type": "hardlink", + "sha256": "0f8cf59c74fa4abb8d59f56d03878e29e62554f1c5e34b3e799f5f68e55e73dc", + "sha256_in_prefix": "0f8cf59c74fa4abb8d59f56d03878e29e62554f1c5e34b3e799f5f68e55e73dc", + "size_in_bytes": 19964 + }, + { + "_path": "lib/python3.10/test/support/script_helper.py", + "path_type": "hardlink", + "sha256": "079acd395f0bc2364bd3c521f19a2e821faed3361a19681d7e7177e306845375", + "sha256_in_prefix": "079acd395f0bc2364bd3c521f19a2e821faed3361a19681d7e7177e306845375", + "size_in_bytes": 11409 + }, + { + "_path": "lib/python3.10/test/support/socket_helper.py", + "path_type": "hardlink", + "sha256": "8e60a6e35d6aaa03731b97b8f3af8977beb0d568ce41a057f9abc42e171264b7", + "sha256_in_prefix": "8e60a6e35d6aaa03731b97b8f3af8977beb0d568ce41a057f9abc42e171264b7", + "size_in_bytes": 11474 + }, + { + "_path": "lib/python3.10/test/support/testresult.py", + "path_type": "hardlink", + "sha256": "f9304f77efa894b86b2650b55ff7421feddba93374a3cd9f9db3c2f68590a0e9", + "sha256_in_prefix": "f9304f77efa894b86b2650b55ff7421feddba93374a3cd9f9db3c2f68590a0e9", + "size_in_bytes": 5998 + }, + { + "_path": "lib/python3.10/test/support/threading_helper.py", + "path_type": "hardlink", + "sha256": "23d031ef03ec40bef75133864328490939370baa949c2224a2719bccc4a05980", + "sha256_in_prefix": "23d031ef03ec40bef75133864328490939370baa949c2224a2719bccc4a05980", + "size_in_bytes": 6650 + }, + { + "_path": "lib/python3.10/test/support/warnings_helper.py", + "path_type": "hardlink", + "sha256": "974c1b45d7b109a97ba99ab5cc6a5173d85a931a80adb9952837f24d92ae13f5", + "sha256_in_prefix": "974c1b45d7b109a97ba99ab5cc6a5173d85a931a80adb9952837f24d92ae13f5", + "size_in_bytes": 6593 + }, + { + "_path": "lib/python3.10/test/test_script_helper.py", + "path_type": "hardlink", + "sha256": "cfd8d3769843cf0c4d330f124203fafce3f9710677029427f7c06f1fd64cfe30", + "sha256_in_prefix": "cfd8d3769843cf0c4d330f124203fafce3f9710677029427f7c06f1fd64cfe30", + "size_in_bytes": 5916 + }, + { + "_path": "lib/python3.10/test/test_support.py", + "path_type": "hardlink", + "sha256": "f2c579443c1591f815c914b0a17e813f17370d5bdcf808bcf18580a36843a7ec", + "sha256_in_prefix": "f2c579443c1591f815c914b0a17e813f17370d5bdcf808bcf18580a36843a7ec", + "size_in_bytes": 25942 + }, + { + "_path": "lib/python3.10/textwrap.py", + "path_type": "hardlink", + "sha256": "e1541a31ac906294f915cadd0d780e1e5b256dc1897b560cdaf3fbf46d104cf0", + "sha256_in_prefix": "e1541a31ac906294f915cadd0d780e1e5b256dc1897b560cdaf3fbf46d104cf0", + "size_in_bytes": 19772 + }, + { + "_path": "lib/python3.10/this.py", + "path_type": "hardlink", + "sha256": "481d0cb3de511eae0b5713dad18542b07eafd9c013bb7690f7497bad49923a71", + "sha256_in_prefix": "481d0cb3de511eae0b5713dad18542b07eafd9c013bb7690f7497bad49923a71", + "size_in_bytes": 1003 + }, + { + "_path": "lib/python3.10/threading.py", + "path_type": "hardlink", + "sha256": "a21926e636bec8c2e5579f3e79cce144c36379ef93c4596252af29970983553d", + "sha256_in_prefix": "a21926e636bec8c2e5579f3e79cce144c36379ef93c4596252af29970983553d", + "size_in_bytes": 57200 + }, + { + "_path": "lib/python3.10/timeit.py", + "path_type": "hardlink", + "sha256": "86b8a277862aaa9da236a728244b866d32ab97cf42e5ded9787cce27b1671610", + "sha256_in_prefix": "86b8a277862aaa9da236a728244b866d32ab97cf42e5ded9787cce27b1671610", + "size_in_bytes": 13495 + }, + { + "_path": "lib/python3.10/tkinter/__init__.py", + "path_type": "hardlink", + "sha256": "ea1e062d70a21f50a491af04e34131edec1c0ea372507afd78b203e42f99962a", + "sha256_in_prefix": "ea1e062d70a21f50a491af04e34131edec1c0ea372507afd78b203e42f99962a", + "size_in_bytes": 170790 + }, + { + "_path": "lib/python3.10/tkinter/__main__.py", + "path_type": "hardlink", + "sha256": "9738a6cb9cdd8139721dd82118bd527897db5325d807222883f70fb1c5a1c27e", + "sha256_in_prefix": "9738a6cb9cdd8139721dd82118bd527897db5325d807222883f70fb1c5a1c27e", + "size_in_bytes": 148 + }, + { + "_path": "lib/python3.10/tkinter/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "56cd7e82f1931f3dc12f5618d749ace03ad2965c4da0e737b06686631f945c77", + "sha256_in_prefix": "56cd7e82f1931f3dc12f5618d749ace03ad2965c4da0e737b06686631f945c77", + "size_in_bytes": 169622 + }, + { + "_path": "lib/python3.10/tkinter/__pycache__/__main__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "42f1b4c081e10c4ddf19309fd42342dbb13d651adfd06e190781f72dacd113cd", + "sha256_in_prefix": "42f1b4c081e10c4ddf19309fd42342dbb13d651adfd06e190781f72dacd113cd", + "size_in_bytes": 561 + }, + { + "_path": "lib/python3.10/tkinter/__pycache__/colorchooser.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "fb40046b9fbb2ccf6b1d40385420e92ca87a7429835cef270cf3bb7c4cdf6f0f", + "sha256_in_prefix": "fb40046b9fbb2ccf6b1d40385420e92ca87a7429835cef270cf3bb7c4cdf6f0f", + "size_in_bytes": 2554 + }, + { + "_path": "lib/python3.10/tkinter/__pycache__/commondialog.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "7827b30a73479616ab42f6a602a5d40a7c769b9cc14de0107ef7a6b274c57c5e", + "sha256_in_prefix": "7827b30a73479616ab42f6a602a5d40a7c769b9cc14de0107ef7a6b274c57c5e", + "size_in_bytes": 1602 + }, + { + "_path": "lib/python3.10/tkinter/__pycache__/constants.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "04987ec48aed2ed6da93ca18506db319a599a19fc69b8bb18cdbb2e3becbbcd9", + "sha256_in_prefix": "04987ec48aed2ed6da93ca18506db319a599a19fc69b8bb18cdbb2e3becbbcd9", + "size_in_bytes": 1911 + }, + { + "_path": "lib/python3.10/tkinter/__pycache__/dialog.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "251f48181f8f5259ab5c6d011a0484284ba6d2c7dc64eedb9fad855ad4e73bd8", + "sha256_in_prefix": "251f48181f8f5259ab5c6d011a0484284ba6d2c7dc64eedb9fad855ad4e73bd8", + "size_in_bytes": 1762 + }, + { + "_path": "lib/python3.10/tkinter/__pycache__/dnd.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "e6ca643e38cfd66ed6bdc84f63751a6a1a51314719cc4c76ac63cdd828c1ea3c", + "sha256_in_prefix": "e6ca643e38cfd66ed6bdc84f63751a6a1a51314719cc4c76ac63cdd828c1ea3c", + "size_in_bytes": 11658 + }, + { + "_path": "lib/python3.10/tkinter/__pycache__/filedialog.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "f2a89f8fb803c4cf2321390250cf061ad87bb5dfac66889bb8222751260a022c", + "sha256_in_prefix": "f2a89f8fb803c4cf2321390250cf061ad87bb5dfac66889bb8222751260a022c", + "size_in_bytes": 12448 + }, + { + "_path": "lib/python3.10/tkinter/__pycache__/font.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "fe68ac163290682be5b74956df99dd680a9c36ab0c94c38ed22fe0009ced8af9", + "sha256_in_prefix": "fe68ac163290682be5b74956df99dd680a9c36ab0c94c38ed22fe0009ced8af9", + "size_in_bytes": 6869 + }, + { + "_path": "lib/python3.10/tkinter/__pycache__/messagebox.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "ac2fb04d2a22f914dd225877f5d7bfa2382e0dcfb8e324e9a776ace5905f95db", + "sha256_in_prefix": "ac2fb04d2a22f914dd225877f5d7bfa2382e0dcfb8e324e9a776ace5905f95db", + "size_in_bytes": 3180 + }, + { + "_path": "lib/python3.10/tkinter/__pycache__/scrolledtext.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "156eb824aeff84b618ffceabbe8b9fa2950df2408d1407e6647c7697d7f0414c", + "sha256_in_prefix": "156eb824aeff84b618ffceabbe8b9fa2950df2408d1407e6647c7697d7f0414c", + "size_in_bytes": 2452 + }, + { + "_path": "lib/python3.10/tkinter/__pycache__/simpledialog.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "61195dc94845cf79a4d11b8a2e63b401b94344403a4c2f36d85f76743edca780", + "sha256_in_prefix": "61195dc94845cf79a4d11b8a2e63b401b94344403a4c2f36d85f76743edca780", + "size_in_bytes": 11185 + }, + { + "_path": "lib/python3.10/tkinter/__pycache__/tix.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "636caa84634c31a21a4155caade53213e1870cd8808bd9352e23feb7b75b0bd6", + "sha256_in_prefix": "636caa84634c31a21a4155caade53213e1870cd8808bd9352e23feb7b75b0bd6", + "size_in_bytes": 73944 + }, + { + "_path": "lib/python3.10/tkinter/__pycache__/ttk.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "e2d9bcc92a66befaa2ecabe7ee3956cc5094061713087ea70f293b76af1153f3", + "sha256_in_prefix": "e2d9bcc92a66befaa2ecabe7ee3956cc5094061713087ea70f293b76af1153f3", + "size_in_bytes": 55672 + }, + { + "_path": "lib/python3.10/tkinter/colorchooser.py", + "path_type": "hardlink", + "sha256": "1224241dcfb4ec6aff3cafc66adeb2b2a3759397a28693173915458c50040143", + "sha256_in_prefix": "1224241dcfb4ec6aff3cafc66adeb2b2a3759397a28693173915458c50040143", + "size_in_bytes": 2660 + }, + { + "_path": "lib/python3.10/tkinter/commondialog.py", + "path_type": "hardlink", + "sha256": "82dd1551f85ace68ac465f54b89c4d71bd21e3c0478d65deb1b5e4e07f5111d6", + "sha256_in_prefix": "82dd1551f85ace68ac465f54b89c4d71bd21e3c0478d65deb1b5e4e07f5111d6", + "size_in_bytes": 1296 + }, + { + "_path": "lib/python3.10/tkinter/constants.py", + "path_type": "hardlink", + "sha256": "c01314dc51d1c8effeba2528720a65da133596d4143200c68595c02067bf1da2", + "sha256_in_prefix": "c01314dc51d1c8effeba2528720a65da133596d4143200c68595c02067bf1da2", + "size_in_bytes": 1493 + }, + { + "_path": "lib/python3.10/tkinter/dialog.py", + "path_type": "hardlink", + "sha256": "4f8201d3ada7b6d0f450b417e55747adaee5f894412c4875169b0736a5ff0faa", + "sha256_in_prefix": "4f8201d3ada7b6d0f450b417e55747adaee5f894412c4875169b0736a5ff0faa", + "size_in_bytes": 1535 + }, + { + "_path": "lib/python3.10/tkinter/dnd.py", + "path_type": "hardlink", + "sha256": "542b804b243b502b5525a8b1f04a02a120b1db4e3599f5c7865e60693ed3672a", + "sha256_in_prefix": "542b804b243b502b5525a8b1f04a02a120b1db4e3599f5c7865e60693ed3672a", + "size_in_bytes": 11644 + }, + { + "_path": "lib/python3.10/tkinter/filedialog.py", + "path_type": "hardlink", + "sha256": "77a7a130572c2f0351f1f0dec0db4e7ac9e71970b74dfcb6c2d93b66da869df6", + "sha256_in_prefix": "77a7a130572c2f0351f1f0dec0db4e7ac9e71970b74dfcb6c2d93b66da869df6", + "size_in_bytes": 14947 + }, + { + "_path": "lib/python3.10/tkinter/font.py", + "path_type": "hardlink", + "sha256": "a73482badacc4a69ff7fae9445793a4d858212fdef103360a478bbfd6ed2f496", + "sha256_in_prefix": "a73482badacc4a69ff7fae9445793a4d858212fdef103360a478bbfd6ed2f496", + "size_in_bytes": 7000 + }, + { + "_path": "lib/python3.10/tkinter/messagebox.py", + "path_type": "hardlink", + "sha256": "cdbf655c66778a19f0e25754a5f198a850c8bd958ce651e8fe4b2b52ad7f9c63", + "sha256_in_prefix": "cdbf655c66778a19f0e25754a5f198a850c8bd958ce651e8fe4b2b52ad7f9c63", + "size_in_bytes": 3861 + }, + { + "_path": "lib/python3.10/tkinter/scrolledtext.py", + "path_type": "hardlink", + "sha256": "c7cc050ec9cc3cc6a47215b5bc79b2d3e5c6ed895a4300ab0e20f6c249385e3f", + "sha256_in_prefix": "c7cc050ec9cc3cc6a47215b5bc79b2d3e5c6ed895a4300ab0e20f6c249385e3f", + "size_in_bytes": 1816 + }, + { + "_path": "lib/python3.10/tkinter/simpledialog.py", + "path_type": "hardlink", + "sha256": "63349ae75f9d74a49376f3375e38e5059c9424b918bfd2c67cf45ec70dcf3eac", + "sha256_in_prefix": "63349ae75f9d74a49376f3375e38e5059c9424b918bfd2c67cf45ec70dcf3eac", + "size_in_bytes": 11753 + }, + { + "_path": "lib/python3.10/tkinter/tix.py", + "path_type": "hardlink", + "sha256": "5d7a11093a1f6510de786b0e9d67902ab33a57f637cd8f5e2603cf6c5c609a18", + "sha256_in_prefix": "5d7a11093a1f6510de786b0e9d67902ab33a57f637cd8f5e2603cf6c5c609a18", + "size_in_bytes": 77032 + }, + { + "_path": "lib/python3.10/tkinter/ttk.py", + "path_type": "hardlink", + "sha256": "42bace4a50322971cda8cab2df8fcadd4bb66d272f258eb329ee713064eefa85", + "sha256_in_prefix": "42bace4a50322971cda8cab2df8fcadd4bb66d272f258eb329ee713064eefa85", + "size_in_bytes": 57151 + }, + { + "_path": "lib/python3.10/token.py", + "path_type": "hardlink", + "sha256": "2cabb6a81cafa84b475fc852c20b6bad45955ec0f88063720a831495215f776b", + "sha256_in_prefix": "2cabb6a81cafa84b475fc852c20b6bad45955ec0f88063720a831495215f776b", + "size_in_bytes": 2386 + }, + { + "_path": "lib/python3.10/tokenize.py", + "path_type": "hardlink", + "sha256": "b76fe3cc91541b872f16a879db6c9ff44c7ba4c2df366d40a3a211948edafba5", + "sha256_in_prefix": "b76fe3cc91541b872f16a879db6c9ff44c7ba4c2df366d40a3a211948edafba5", + "size_in_bytes": 25921 + }, + { + "_path": "lib/python3.10/trace.py", + "path_type": "hardlink", + "sha256": "e18581573c2b0e989a66c537cf16500dcb25e60d2ab8d8b22b6723c4c1c3c70a", + "sha256_in_prefix": "e18581573c2b0e989a66c537cf16500dcb25e60d2ab8d8b22b6723c4c1c3c70a", + "size_in_bytes": 29215 + }, + { + "_path": "lib/python3.10/traceback.py", + "path_type": "hardlink", + "sha256": "5297dd527101c24fb7665a64fc4770a108a3e410ca2a77f82b1285c3aad29c42", + "sha256_in_prefix": "5297dd527101c24fb7665a64fc4770a108a3e410ca2a77f82b1285c3aad29c42", + "size_in_bytes": 26222 + }, + { + "_path": "lib/python3.10/tracemalloc.py", + "path_type": "hardlink", + "sha256": "c2cc84a05b824df79840c98729a0e94ef8909b11c528a1b2c5a00aa436b97b25", + "sha256_in_prefix": "c2cc84a05b824df79840c98729a0e94ef8909b11c528a1b2c5a00aa436b97b25", + "size_in_bytes": 18047 + }, + { + "_path": "lib/python3.10/tty.py", + "path_type": "hardlink", + "sha256": "066a541e6d38ead952d63cc32afbac51a33acf354799f235c582eab17488105d", + "sha256_in_prefix": "066a541e6d38ead952d63cc32afbac51a33acf354799f235c582eab17488105d", + "size_in_bytes": 879 + }, + { + "_path": "lib/python3.10/turtle.py", + "path_type": "hardlink", + "sha256": "c616d28c16d0a1e122dd7f43acaa2d8e8bfe50002492043914da594653ed774e", + "sha256_in_prefix": "c616d28c16d0a1e122dd7f43acaa2d8e8bfe50002492043914da594653ed774e", + "size_in_bytes": 143760 + }, + { + "_path": "lib/python3.10/turtledemo/__init__.py", + "path_type": "hardlink", + "sha256": "5f465277c96c107a5af544b0a962561f97cb0bfd75906d9bf9741450ed02b0e1", + "sha256_in_prefix": "5f465277c96c107a5af544b0a962561f97cb0bfd75906d9bf9741450ed02b0e1", + "size_in_bytes": 314 + }, + { + "_path": "lib/python3.10/turtledemo/__main__.py", + "path_type": "hardlink", + "sha256": "6608b2ef9db6022c3088651dc0f6fc1206e7ddcc466186e44ab7a8d86341dbb9", + "sha256_in_prefix": "6608b2ef9db6022c3088651dc0f6fc1206e7ddcc466186e44ab7a8d86341dbb9", + "size_in_bytes": 15050 + }, + { + "_path": "lib/python3.10/turtledemo/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "ec946af752ff883a525910278384dd1181286b89ca4200112b463ab17cc63b71", + "sha256_in_prefix": "ec946af752ff883a525910278384dd1181286b89ca4200112b463ab17cc63b71", + "size_in_bytes": 711 + }, + { + "_path": "lib/python3.10/turtledemo/__pycache__/__main__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "ea6a3e7b9b386d50a6b7a20c79e09f08e9fce13800d1fc5d7fa69b1b41acad02", + "sha256_in_prefix": "ea6a3e7b9b386d50a6b7a20c79e09f08e9fce13800d1fc5d7fa69b1b41acad02", + "size_in_bytes": 13560 + }, + { + "_path": "lib/python3.10/turtledemo/__pycache__/bytedesign.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "b183073635a59476d81bdfdf00920ea23e8561b24e273f29b68d73ef853a1b12", + "sha256_in_prefix": "b183073635a59476d81bdfdf00920ea23e8561b24e273f29b68d73ef853a1b12", + "size_in_bytes": 4338 + }, + { + "_path": "lib/python3.10/turtledemo/__pycache__/chaos.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c1f5cdb3d09f04eaba13d74cbb3c4551ae95f7431fc401e88fd23a57775d8699", + "sha256_in_prefix": "c1f5cdb3d09f04eaba13d74cbb3c4551ae95f7431fc401e88fd23a57775d8699", + "size_in_bytes": 1971 + }, + { + "_path": "lib/python3.10/turtledemo/__pycache__/clock.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "eb97c17ec423082f46571ab83ca65ba59c47a6428ded9d03929a4da7b6b74d96", + "sha256_in_prefix": "eb97c17ec423082f46571ab83ca65ba59c47a6428ded9d03929a4da7b6b74d96", + "size_in_bytes": 3692 + }, + { + "_path": "lib/python3.10/turtledemo/__pycache__/colormixer.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "7261c5f70b2800f9a26e7d5968404b0c28e5b905edaf52bb15f08b3e363eeb91", + "sha256_in_prefix": "7261c5f70b2800f9a26e7d5968404b0c28e5b905edaf52bb15f08b3e363eeb91", + "size_in_bytes": 2098 + }, + { + "_path": "lib/python3.10/turtledemo/__pycache__/forest.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "ead7237ef26e6d12503be8118c218adb46c824675ef8e7e8ac15d0f93ca25b78", + "sha256_in_prefix": "ead7237ef26e6d12503be8118c218adb46c824675ef8e7e8ac15d0f93ca25b78", + "size_in_bytes": 3541 + }, + { + "_path": "lib/python3.10/turtledemo/__pycache__/fractalcurves.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "825c4da13fd2370873c3e3323fa16d182413e58946c2c1d6edc068625138d5dd", + "sha256_in_prefix": "825c4da13fd2370873c3e3323fa16d182413e58946c2c1d6edc068625138d5dd", + "size_in_bytes": 3152 + }, + { + "_path": "lib/python3.10/turtledemo/__pycache__/lindenmayer.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "266afdda325903684300bf65260e2ff829c871cea6913b1b40fa656f7dba9368", + "sha256_in_prefix": "266afdda325903684300bf65260e2ff829c871cea6913b1b40fa656f7dba9368", + "size_in_bytes": 3045 + }, + { + "_path": "lib/python3.10/turtledemo/__pycache__/minimal_hanoi.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "9ea4fa55248778648f8d252b0a2d5c3e6d095fd1f439f1239ec9bf419fa9843f", + "sha256_in_prefix": "9ea4fa55248778648f8d252b0a2d5c3e6d095fd1f439f1239ec9bf419fa9843f", + "size_in_bytes": 3090 + }, + { + "_path": "lib/python3.10/turtledemo/__pycache__/nim.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "805536d9c3bae97f7510d19fd3315f6130ea8bdc891918d56fa5add93ef026e7", + "sha256_in_prefix": "805536d9c3bae97f7510d19fd3315f6130ea8bdc891918d56fa5add93ef026e7", + "size_in_bytes": 7662 + }, + { + "_path": "lib/python3.10/turtledemo/__pycache__/paint.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "7e66f91987b2944d4c0c5f8e5fa7547cd0b1b3dd9ba68a51393fd6192a601366", + "sha256_in_prefix": "7e66f91987b2944d4c0c5f8e5fa7547cd0b1b3dd9ba68a51393fd6192a601366", + "size_in_bytes": 1882 + }, + { + "_path": "lib/python3.10/turtledemo/__pycache__/peace.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "f8ce4e071ce4b2e5544da5fbf13ab190d4e0099815e74ab41f5430da311d4702", + "sha256_in_prefix": "f8ce4e071ce4b2e5544da5fbf13ab190d4e0099815e74ab41f5430da311d4702", + "size_in_bytes": 1381 + }, + { + "_path": "lib/python3.10/turtledemo/__pycache__/penrose.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "d0f1740dfa60caa9f41ab44ff0f6ed7e8348372db1d23aaf71b5b149fcbb0cd8", + "sha256_in_prefix": "d0f1740dfa60caa9f41ab44ff0f6ed7e8348372db1d23aaf71b5b149fcbb0cd8", + "size_in_bytes": 4608 + }, + { + "_path": "lib/python3.10/turtledemo/__pycache__/planet_and_moon.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "313a1a6ff1eabbf62899065267c37556b1e2e300f2fa8e30c374b80796d6e609", + "sha256_in_prefix": "313a1a6ff1eabbf62899065267c37556b1e2e300f2fa8e30c374b80796d6e609", + "size_in_bytes": 3759 + }, + { + "_path": "lib/python3.10/turtledemo/__pycache__/rosette.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "84a514014b2441d5bd9db010576c761f03cd12b0de62b3616d4c54e687ba1a62", + "sha256_in_prefix": "84a514014b2441d5bd9db010576c761f03cd12b0de62b3616d4c54e687ba1a62", + "size_in_bytes": 1993 + }, + { + "_path": "lib/python3.10/turtledemo/__pycache__/round_dance.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "4550dad336b65c3aea3fc0da981417be523ba1397f612aaaff2e0eab3ebb40c3", + "sha256_in_prefix": "4550dad336b65c3aea3fc0da981417be523ba1397f612aaaff2e0eab3ebb40c3", + "size_in_bytes": 2162 + }, + { + "_path": "lib/python3.10/turtledemo/__pycache__/sorting_animate.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c42331c8ea9ad7efefca84a742862773cdebdb31acccd4d158e473bdae1b9eb8", + "sha256_in_prefix": "c42331c8ea9ad7efefca84a742862773cdebdb31acccd4d158e473bdae1b9eb8", + "size_in_bytes": 6585 + }, + { + "_path": "lib/python3.10/turtledemo/__pycache__/tree.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "3c47d6dec4d05f262453b8139287e4d4532146bb4d4c9cdd4385f58a1018704c", + "sha256_in_prefix": "3c47d6dec4d05f262453b8139287e4d4532146bb4d4c9cdd4385f58a1018704c", + "size_in_bytes": 2002 + }, + { + "_path": "lib/python3.10/turtledemo/__pycache__/two_canvases.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "79ed92226a838a41f9e0198b82c6431c4a2a74657476851b0c50d93bb7daed72", + "sha256_in_prefix": "79ed92226a838a41f9e0198b82c6431c4a2a74657476851b0c50d93bb7daed72", + "size_in_bytes": 1527 + }, + { + "_path": "lib/python3.10/turtledemo/__pycache__/yinyang.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "098f188487e7432cb012185554a7525f098c4db8e76d9aa6ecb3f69759d2163b", + "sha256_in_prefix": "098f188487e7432cb012185554a7525f098c4db8e76d9aa6ecb3f69759d2163b", + "size_in_bytes": 1330 + }, + { + "_path": "lib/python3.10/turtledemo/bytedesign.py", + "path_type": "hardlink", + "sha256": "6deeee99e0ddb4ed29a648f95d4d33e9f3292c21dbecec301337c22a605a280f", + "sha256_in_prefix": "6deeee99e0ddb4ed29a648f95d4d33e9f3292c21dbecec301337c22a605a280f", + "size_in_bytes": 4248 + }, + { + "_path": "lib/python3.10/turtledemo/chaos.py", + "path_type": "hardlink", + "sha256": "bc8a3a9b77e90446fb7060ff68ee008ffd6b23b366052207ec225cc163b4dae5", + "sha256_in_prefix": "bc8a3a9b77e90446fb7060ff68ee008ffd6b23b366052207ec225cc163b4dae5", + "size_in_bytes": 951 + }, + { + "_path": "lib/python3.10/turtledemo/clock.py", + "path_type": "hardlink", + "sha256": "8728b6e1f7e81e8c9fbc5797588d1766e6be15d353e0f29c38f3e75d28084fcd", + "sha256_in_prefix": "8728b6e1f7e81e8c9fbc5797588d1766e6be15d353e0f29c38f3e75d28084fcd", + "size_in_bytes": 3180 + }, + { + "_path": "lib/python3.10/turtledemo/colormixer.py", + "path_type": "hardlink", + "sha256": "bbb065830edb37fd53b1c004118853176fd8da32ee532cb0d363960880920374", + "sha256_in_prefix": "bbb065830edb37fd53b1c004118853176fd8da32ee532cb0d363960880920374", + "size_in_bytes": 1339 + }, + { + "_path": "lib/python3.10/turtledemo/forest.py", + "path_type": "hardlink", + "sha256": "68cd81b7da35ca49d9066cc2cba24768cddbf90797dbd619a559cf899cde926b", + "sha256_in_prefix": "68cd81b7da35ca49d9066cc2cba24768cddbf90797dbd619a559cf899cde926b", + "size_in_bytes": 2966 + }, + { + "_path": "lib/python3.10/turtledemo/fractalcurves.py", + "path_type": "hardlink", + "sha256": "29fadf34c5eabda4649848d052fa2ed3ae829e55bc3ac5933f2aedf3fb04b320", + "sha256_in_prefix": "29fadf34c5eabda4649848d052fa2ed3ae829e55bc3ac5933f2aedf3fb04b320", + "size_in_bytes": 3473 + }, + { + "_path": "lib/python3.10/turtledemo/lindenmayer.py", + "path_type": "hardlink", + "sha256": "4b597f52c1cb35ae8ed540d1db2dab52276c7874febd7a659ee50f26be26f61e", + "sha256_in_prefix": "4b597f52c1cb35ae8ed540d1db2dab52276c7874febd7a659ee50f26be26f61e", + "size_in_bytes": 2434 + }, + { + "_path": "lib/python3.10/turtledemo/minimal_hanoi.py", + "path_type": "hardlink", + "sha256": "0e458a6257fb5a4ecd2785962850fa87924b23d4ead8aebb70aab38904ff8ef5", + "sha256_in_prefix": "0e458a6257fb5a4ecd2785962850fa87924b23d4ead8aebb70aab38904ff8ef5", + "size_in_bytes": 2051 + }, + { + "_path": "lib/python3.10/turtledemo/nim.py", + "path_type": "hardlink", + "sha256": "939d1ee904a7b00579bb44719b0286e7524bf560c7ffff6d482064b41b09fdb3", + "sha256_in_prefix": "939d1ee904a7b00579bb44719b0286e7524bf560c7ffff6d482064b41b09fdb3", + "size_in_bytes": 6513 + }, + { + "_path": "lib/python3.10/turtledemo/paint.py", + "path_type": "hardlink", + "sha256": "81aa22d0da1d934cb47edfef1883f9fe8ef864c56d484f79f9ec4b46457d047e", + "sha256_in_prefix": "81aa22d0da1d934cb47edfef1883f9fe8ef864c56d484f79f9ec4b46457d047e", + "size_in_bytes": 1291 + }, + { + "_path": "lib/python3.10/turtledemo/peace.py", + "path_type": "hardlink", + "sha256": "b260b857164684b3065ad760fec0245ab6505c220814fb179a3d080f2bba0814", + "sha256_in_prefix": "b260b857164684b3065ad760fec0245ab6505c220814fb179a3d080f2bba0814", + "size_in_bytes": 1066 + }, + { + "_path": "lib/python3.10/turtledemo/penrose.py", + "path_type": "hardlink", + "sha256": "14aeb10db966bfd4ec923a19eb96892eb2aa2723c0962c0824fe2ca9f30e300a", + "sha256_in_prefix": "14aeb10db966bfd4ec923a19eb96892eb2aa2723c0962c0824fe2ca9f30e300a", + "size_in_bytes": 3380 + }, + { + "_path": "lib/python3.10/turtledemo/planet_and_moon.py", + "path_type": "hardlink", + "sha256": "cd2c5344b67dbe781cf4c7f0f1eb1b97e6d8a5bf50329bdaa4e42e7d390ea609", + "sha256_in_prefix": "cd2c5344b67dbe781cf4c7f0f1eb1b97e6d8a5bf50329bdaa4e42e7d390ea609", + "size_in_bytes": 2825 + }, + { + "_path": "lib/python3.10/turtledemo/rosette.py", + "path_type": "hardlink", + "sha256": "61dfd5bb932cc5a0c3bb9caa8ed74889a19a8d3ee3cb6707ea8f63595ec350b0", + "sha256_in_prefix": "61dfd5bb932cc5a0c3bb9caa8ed74889a19a8d3ee3cb6707ea8f63595ec350b0", + "size_in_bytes": 1361 + }, + { + "_path": "lib/python3.10/turtledemo/round_dance.py", + "path_type": "hardlink", + "sha256": "4ecaac02e68f11ec1a406a6ce8a4b17e4f8af74f76157e0776360d0dd041f276", + "sha256_in_prefix": "4ecaac02e68f11ec1a406a6ce8a4b17e4f8af74f76157e0776360d0dd041f276", + "size_in_bytes": 1804 + }, + { + "_path": "lib/python3.10/turtledemo/sorting_animate.py", + "path_type": "hardlink", + "sha256": "a82a7608d3620cd8a956d3335bddbc2e30320486645de5d2ec26f481b0a74254", + "sha256_in_prefix": "a82a7608d3620cd8a956d3335bddbc2e30320486645de5d2ec26f481b0a74254", + "size_in_bytes": 5052 + }, + { + "_path": "lib/python3.10/turtledemo/tree.py", + "path_type": "hardlink", + "sha256": "3318448046c83c176f95a97c33b5cd82e0076bee038d72810bef3dac1085e590", + "sha256_in_prefix": "3318448046c83c176f95a97c33b5cd82e0076bee038d72810bef3dac1085e590", + "size_in_bytes": 1401 + }, + { + "_path": "lib/python3.10/turtledemo/turtle.cfg", + "path_type": "hardlink", + "sha256": "de66698dc4f083792df6aaed1e5d94e879852d72f1f24ac09c8fb4cd144c6c88", + "sha256_in_prefix": "de66698dc4f083792df6aaed1e5d94e879852d72f1f24ac09c8fb4cd144c6c88", + "size_in_bytes": 160 + }, + { + "_path": "lib/python3.10/turtledemo/two_canvases.py", + "path_type": "hardlink", + "sha256": "3300593114fb9286af9360cc9d871a40e5dcbea4aedc24b832607d1dd71c7b96", + "sha256_in_prefix": "3300593114fb9286af9360cc9d871a40e5dcbea4aedc24b832607d1dd71c7b96", + "size_in_bytes": 1119 + }, + { + "_path": "lib/python3.10/turtledemo/yinyang.py", + "path_type": "hardlink", + "sha256": "0737a80b939aafcf3d8a1bf60b63e781979c749337d02b6c216680893f9fffc5", + "sha256_in_prefix": "0737a80b939aafcf3d8a1bf60b63e781979c749337d02b6c216680893f9fffc5", + "size_in_bytes": 821 + }, + { + "_path": "lib/python3.10/types.py", + "path_type": "hardlink", + "sha256": "5e6c3b3380332249908d7907bc4c1102c0bf14076248c8244d03314f6b2e2078", + "sha256_in_prefix": "5e6c3b3380332249908d7907bc4c1102c0bf14076248c8244d03314f6b2e2078", + "size_in_bytes": 10117 + }, + { + "_path": "lib/python3.10/typing.py", + "path_type": "hardlink", + "sha256": "ec7b7f73fc92827c78a7d2aff90cffe070530cad6c693460165c26f76d195f41", + "sha256_in_prefix": "ec7b7f73fc92827c78a7d2aff90cffe070530cad6c693460165c26f76d195f41", + "size_in_bytes": 92557 + }, + { + "_path": "lib/python3.10/unittest/__init__.py", + "path_type": "hardlink", + "sha256": "07bdf1fff20e4121ba61cfb64ea3c404d54ac56b053475a3a105907f48685210", + "sha256_in_prefix": "07bdf1fff20e4121ba61cfb64ea3c404d54ac56b053475a3a105907f48685210", + "size_in_bytes": 3761 + }, + { + "_path": "lib/python3.10/unittest/__main__.py", + "path_type": "hardlink", + "sha256": "ff6b9a100d32001715b40d61bc4d613623b139edb1fdc3566427b83c331caae3", + "sha256_in_prefix": "ff6b9a100d32001715b40d61bc4d613623b139edb1fdc3566427b83c331caae3", + "size_in_bytes": 472 + }, + { + "_path": "lib/python3.10/unittest/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "1e81239a8469ffae3e0ca9224b94b2d4d4772a1be429785a021fe204588e6cdd", + "sha256_in_prefix": "1e81239a8469ffae3e0ca9224b94b2d4d4772a1be429785a021fe204588e6cdd", + "size_in_bytes": 3390 + }, + { + "_path": "lib/python3.10/unittest/__pycache__/__main__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "69b975a2e4b27a340db7d6086c73a93cf2dddd7fa592cbf6fd2dd0b486d9dee6", + "sha256_in_prefix": "69b975a2e4b27a340db7d6086c73a93cf2dddd7fa592cbf6fd2dd0b486d9dee6", + "size_in_bytes": 656 + }, + { + "_path": "lib/python3.10/unittest/__pycache__/_log.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "b2064e407714b4c584aa78f75ea1f60f9235d3be32e2e7543f450c3cef50ad15", + "sha256_in_prefix": "b2064e407714b4c584aa78f75ea1f60f9235d3be32e2e7543f450c3cef50ad15", + "size_in_bytes": 2942 + }, + { + "_path": "lib/python3.10/unittest/__pycache__/async_case.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "4ef0c1501c3645ba2f89f26c89debcf262a1399f712ea6e0c3ae8be9c3dc8be1", + "sha256_in_prefix": "4ef0c1501c3645ba2f89f26c89debcf262a1399f712ea6e0c3ae8be9c3dc8be1", + "size_in_bytes": 5000 + }, + { + "_path": "lib/python3.10/unittest/__pycache__/case.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "795f797e8f54152d806495ad7cf1581b4e5e4fc33833bd7d374d9f57174fafca", + "sha256_in_prefix": "795f797e8f54152d806495ad7cf1581b4e5e4fc33833bd7d374d9f57174fafca", + "size_in_bytes": 48744 + }, + { + "_path": "lib/python3.10/unittest/__pycache__/loader.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "9bf15935c0ac6ba47892654c1e7dfa39449c9c810f90b848bcaa139d56a9be8b", + "sha256_in_prefix": "9bf15935c0ac6ba47892654c1e7dfa39449c9c810f90b848bcaa139d56a9be8b", + "size_in_bytes": 14678 + }, + { + "_path": "lib/python3.10/unittest/__pycache__/main.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "75fb0c9c461077458253878ec8dac30447c7d58d0f3b5ed406572c197971e40c", + "sha256_in_prefix": "75fb0c9c461077458253878ec8dac30447c7d58d0f3b5ed406572c197971e40c", + "size_in_bytes": 7810 + }, + { + "_path": "lib/python3.10/unittest/__pycache__/mock.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "faf619ffb7ac3a3eadbbe78bc4fba92ca12a6dafb96b886d9cecb09f89e30cf5", + "sha256_in_prefix": "faf619ffb7ac3a3eadbbe78bc4fba92ca12a6dafb96b886d9cecb09f89e30cf5", + "size_in_bytes": 80067 + }, + { + "_path": "lib/python3.10/unittest/__pycache__/result.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "f109f418bc60141795ff57725a33afc80695daaaa2c171267b171aeef5e00bf7", + "sha256_in_prefix": "f109f418bc60141795ff57725a33afc80695daaaa2c171267b171aeef5e00bf7", + "size_in_bytes": 8293 + }, + { + "_path": "lib/python3.10/unittest/__pycache__/runner.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "7493fe20fb38898395199141f685ccfae7e7d74a1e61d932b63e232a00251dde", + "sha256_in_prefix": "7493fe20fb38898395199141f685ccfae7e7d74a1e61d932b63e232a00251dde", + "size_in_bytes": 7206 + }, + { + "_path": "lib/python3.10/unittest/__pycache__/signals.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "9cbb6fada9c0b8acb6af5cf14326bf230f6a13196deaa5dd9c46628be7de97fc", + "sha256_in_prefix": "9cbb6fada9c0b8acb6af5cf14326bf230f6a13196deaa5dd9c46628be7de97fc", + "size_in_bytes": 2507 + }, + { + "_path": "lib/python3.10/unittest/__pycache__/suite.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "e4904f96ef301edc6e38be93a89707478045c80e13031c54c36ccbf76040840c", + "sha256_in_prefix": "e4904f96ef301edc6e38be93a89707478045c80e13031c54c36ccbf76040840c", + "size_in_bytes": 10522 + }, + { + "_path": "lib/python3.10/unittest/__pycache__/util.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "cbc94cb876ab8b897f21567c4b8807523d1a3100fc65ef780dd345f17647cc39", + "sha256_in_prefix": "cbc94cb876ab8b897f21567c4b8807523d1a3100fc65ef780dd345f17647cc39", + "size_in_bytes": 4794 + }, + { + "_path": "lib/python3.10/unittest/_log.py", + "path_type": "hardlink", + "sha256": "905672317ab26c656c600defce25d477728068f597f00a7f94e22e8128c323b9", + "sha256_in_prefix": "905672317ab26c656c600defce25d477728068f597f00a7f94e22e8128c323b9", + "size_in_bytes": 2746 + }, + { + "_path": "lib/python3.10/unittest/async_case.py", + "path_type": "hardlink", + "sha256": "2507108536605136aeba050554dc3c6c269b18d3aa9aa22e120af19681b56031", + "sha256_in_prefix": "2507108536605136aeba050554dc3c6c269b18d3aa9aa22e120af19681b56031", + "size_in_bytes": 6368 + }, + { + "_path": "lib/python3.10/unittest/case.py", + "path_type": "hardlink", + "sha256": "9fa2e873ba608253b6e3d2158e36baf02433a46e68071b76b5e961a7accec2d2", + "sha256_in_prefix": "9fa2e873ba608253b6e3d2158e36baf02433a46e68071b76b5e961a7accec2d2", + "size_in_bytes": 57680 + }, + { + "_path": "lib/python3.10/unittest/loader.py", + "path_type": "hardlink", + "sha256": "4b8d7dbfe68bc38f50e6b3952fda338e1cf9de43f299ab910cfef31c219e0342", + "sha256_in_prefix": "4b8d7dbfe68bc38f50e6b3952fda338e1cf9de43f299ab910cfef31c219e0342", + "size_in_bytes": 22702 + }, + { + "_path": "lib/python3.10/unittest/main.py", + "path_type": "hardlink", + "sha256": "360d56268ce4d561681faccf0206dc2164830de7a6dcd135f655ae5fdbdc59cf", + "sha256_in_prefix": "360d56268ce4d561681faccf0206dc2164830de7a6dcd135f655ae5fdbdc59cf", + "size_in_bytes": 11256 + }, + { + "_path": "lib/python3.10/unittest/mock.py", + "path_type": "hardlink", + "sha256": "199d3774b59a89dbe34409b4bdcefcbfab419c5c5a987f3ab91b748da34afae6", + "sha256_in_prefix": "199d3774b59a89dbe34409b4bdcefcbfab419c5c5a987f3ab91b748da34afae6", + "size_in_bytes": 103283 + }, + { + "_path": "lib/python3.10/unittest/result.py", + "path_type": "hardlink", + "sha256": "eb3f6ed6a6d339b8113479f6878f1946bf082b8818a89daf85f0b63a5be1f9c1", + "sha256_in_prefix": "eb3f6ed6a6d339b8113479f6878f1946bf082b8818a89daf85f0b63a5be1f9c1", + "size_in_bytes": 8518 + }, + { + "_path": "lib/python3.10/unittest/runner.py", + "path_type": "hardlink", + "sha256": "7ab57b963cd64f210d5a074b15e8dae9b4d1699da980dd523362d3f88e966847", + "sha256_in_prefix": "7ab57b963cd64f210d5a074b15e8dae9b4d1699da980dd523362d3f88e966847", + "size_in_bytes": 8051 + }, + { + "_path": "lib/python3.10/unittest/signals.py", + "path_type": "hardlink", + "sha256": "f8286e818ca56e10e03745bc056cdfd31147678f9a1dc8cb6b0fe96ef9a4362a", + "sha256_in_prefix": "f8286e818ca56e10e03745bc056cdfd31147678f9a1dc8cb6b0fe96ef9a4362a", + "size_in_bytes": 2403 + }, + { + "_path": "lib/python3.10/unittest/suite.py", + "path_type": "hardlink", + "sha256": "ed2da92bc9f97c53403ee2d3d12cc53b16a96e85d596ebc887b5a93458f3f6bc", + "sha256_in_prefix": "ed2da92bc9f97c53403ee2d3d12cc53b16a96e85d596ebc887b5a93458f3f6bc", + "size_in_bytes": 13512 + }, + { + "_path": "lib/python3.10/unittest/util.py", + "path_type": "hardlink", + "sha256": "fdcc640c3505d16deab9c32eae7c3f5f67c3b5e81c563dc6698fa7fcf403854d", + "sha256_in_prefix": "fdcc640c3505d16deab9c32eae7c3f5f67c3b5e81c563dc6698fa7fcf403854d", + "size_in_bytes": 5215 + }, + { + "_path": "lib/python3.10/urllib/__init__.py", + "path_type": "hardlink", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size_in_bytes": 0 + }, + { + "_path": "lib/python3.10/urllib/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "77287392188c40197b344ff8c2bf4fef1fae48b354577c4e9906923c54c90bbd", + "sha256_in_prefix": "77287392188c40197b344ff8c2bf4fef1fae48b354577c4e9906923c54c90bbd", + "size_in_bytes": 385 + }, + { + "_path": "lib/python3.10/urllib/__pycache__/error.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "f4b3a0e789a01ee1a41edecd9382d916af18ca550e40e64dc8cbcb5d276226d8", + "sha256_in_prefix": "f4b3a0e789a01ee1a41edecd9382d916af18ca550e40e64dc8cbcb5d276226d8", + "size_in_bytes": 3107 + }, + { + "_path": "lib/python3.10/urllib/__pycache__/parse.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "6f07a27a9bf32b77b9e25fdd45e3ea423611d2ee85540b4fa7048093baace4d7", + "sha256_in_prefix": "6f07a27a9bf32b77b9e25fdd45e3ea423611d2ee85540b4fa7048093baace4d7", + "size_in_bytes": 34350 + }, + { + "_path": "lib/python3.10/urllib/__pycache__/request.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "ec6cf70df9c6a4c278f103fcd9e83966ec7e6483aa1397adc372e2dd1e17da20", + "sha256_in_prefix": "ec6cf70df9c6a4c278f103fcd9e83966ec7e6483aa1397adc372e2dd1e17da20", + "size_in_bytes": 71837 + }, + { + "_path": "lib/python3.10/urllib/__pycache__/response.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "8552626d03c462a15c6ffe319315013dee0f2210b6b2b310b4671444f37f7f2c", + "sha256_in_prefix": "8552626d03c462a15c6ffe319315013dee0f2210b6b2b310b4671444f37f7f2c", + "size_in_bytes": 3721 + }, + { + "_path": "lib/python3.10/urllib/__pycache__/robotparser.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "b77f6982870d809e6b4fdbc4dbee19b3e4ead558c70a25e38bfca6c539ac5818", + "sha256_in_prefix": "b77f6982870d809e6b4fdbc4dbee19b3e4ead558c70a25e38bfca6c539ac5818", + "size_in_bytes": 7586 + }, + { + "_path": "lib/python3.10/urllib/error.py", + "path_type": "hardlink", + "sha256": "d12b3cc66af3f42a8ebe63e1c91d24f92c6237b6a93a3702938dffabd812d77b", + "sha256_in_prefix": "d12b3cc66af3f42a8ebe63e1c91d24f92c6237b6a93a3702938dffabd812d77b", + "size_in_bytes": 2415 + }, + { + "_path": "lib/python3.10/urllib/parse.py", + "path_type": "hardlink", + "sha256": "90d563f67191c87a494017b4410899906634bf7edad8bc8e6608ea51b5d90a38", + "sha256_in_prefix": "90d563f67191c87a494017b4410899906634bf7edad8bc8e6608ea51b5d90a38", + "size_in_bytes": 43022 + }, + { + "_path": "lib/python3.10/urllib/request.py", + "path_type": "hardlink", + "sha256": "ba6cee0f5b8a7ef7673e21beea1c2d62b9ac69cc8d92c68e3d115c6395a491d9", + "sha256_in_prefix": "ba6cee0f5b8a7ef7673e21beea1c2d62b9ac69cc8d92c68e3d115c6395a491d9", + "size_in_bytes": 101742 + }, + { + "_path": "lib/python3.10/urllib/response.py", + "path_type": "hardlink", + "sha256": "7e6c3b6d7a95f0d74f5968f51a87adae8a51bf42390cdfec98c7a99203e7bb76", + "sha256_in_prefix": "7e6c3b6d7a95f0d74f5968f51a87adae8a51bf42390cdfec98c7a99203e7bb76", + "size_in_bytes": 2361 + }, + { + "_path": "lib/python3.10/urllib/robotparser.py", + "path_type": "hardlink", + "sha256": "389b811835f9a3ba72b192c3487b0266fa31f6e571b7a83ceb2a34792dc0d9fc", + "sha256_in_prefix": "389b811835f9a3ba72b192c3487b0266fa31f6e571b7a83ceb2a34792dc0d9fc", + "size_in_bytes": 9424 + }, + { + "_path": "lib/python3.10/uu.py", + "path_type": "hardlink", + "sha256": "11c44d6915c8c76cbd33e1989d90f3846c041abea1148f230d3ff7144fb69837", + "sha256_in_prefix": "11c44d6915c8c76cbd33e1989d90f3846c041abea1148f230d3ff7144fb69837", + "size_in_bytes": 7301 + }, + { + "_path": "lib/python3.10/uuid.py", + "path_type": "hardlink", + "sha256": "75bdfdbbb57c7a50e0252997621308be79a535ceb1eb6ba01a462b7e7ffdf19d", + "sha256_in_prefix": "75bdfdbbb57c7a50e0252997621308be79a535ceb1eb6ba01a462b7e7ffdf19d", + "size_in_bytes": 27500 + }, + { + "_path": "lib/python3.10/venv/__init__.py", + "path_type": "hardlink", + "sha256": "90abffc2b81a7ab70ba0a26b38b35d842eb997843c4f7d70471b50eec193ac84", + "sha256_in_prefix": "90abffc2b81a7ab70ba0a26b38b35d842eb997843c4f7d70471b50eec193ac84", + "size_in_bytes": 23997 + }, + { + "_path": "lib/python3.10/venv/__main__.py", + "path_type": "hardlink", + "sha256": "722537c68c0622f8293d39bb6ab1288f3637d8dc45d6f9aae96e49af8145ca36", + "sha256_in_prefix": "722537c68c0622f8293d39bb6ab1288f3637d8dc45d6f9aae96e49af8145ca36", + "size_in_bytes": 145 + }, + { + "_path": "lib/python3.10/venv/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "cc0442ea77c369f921d99f6511c5a8a1ad20479ab7b7a0acb099c5ba1ac3e35c", + "sha256_in_prefix": "cc0442ea77c369f921d99f6511c5a8a1ad20479ab7b7a0acb099c5ba1ac3e35c", + "size_in_bytes": 16435 + }, + { + "_path": "lib/python3.10/venv/__pycache__/__main__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "d030872ceea0839a46eb44917380e0025ba90288cc43a68c55a4bf50187f2886", + "sha256_in_prefix": "d030872ceea0839a46eb44917380e0025ba90288cc43a68c55a4bf50187f2886", + "size_in_bytes": 592 + }, + { + "_path": "lib/python3.10/venv/scripts/common/Activate.ps1", + "path_type": "hardlink", + "sha256": "3795a060dea7d621320d6d841deb37591fadf7f5592c5cb2286f9867af0e91df", + "sha256_in_prefix": "3795a060dea7d621320d6d841deb37591fadf7f5592c5cb2286f9867af0e91df", + "size_in_bytes": 9033 + }, + { + "_path": "lib/python3.10/venv/scripts/common/activate", + "path_type": "hardlink", + "sha256": "5581945e7f30bcd0dbd2dc472a7e8b16bf137bbbed565707e97b9c5616793ea7", + "sha256_in_prefix": "5581945e7f30bcd0dbd2dc472a7e8b16bf137bbbed565707e97b9c5616793ea7", + "size_in_bytes": 2009 + }, + { + "_path": "lib/python3.10/venv/scripts/posix/activate.csh", + "path_type": "hardlink", + "sha256": "540b1d850e88ba3f184ebad24cd967b5a0c6e1c7dc27ca599d8466829e0b2846", + "sha256_in_prefix": "540b1d850e88ba3f184ebad24cd967b5a0c6e1c7dc27ca599d8466829e0b2846", + "size_in_bytes": 935 + }, + { + "_path": "lib/python3.10/venv/scripts/posix/activate.fish", + "path_type": "hardlink", + "sha256": "3ce0db624d9fb550f4267d7501fd3fd4fba090952220a331d09ff2ba646b8a6e", + "sha256_in_prefix": "3ce0db624d9fb550f4267d7501fd3fd4fba090952220a331d09ff2ba646b8a6e", + "size_in_bytes": 2215 + }, + { + "_path": "lib/python3.10/warnings.py", + "path_type": "hardlink", + "sha256": "b8e7748e4c67eb65cea5d3b3bd888d245771c0ebe63117f747189a55a9b622db", + "sha256_in_prefix": "b8e7748e4c67eb65cea5d3b3bd888d245771c0ebe63117f747189a55a9b622db", + "size_in_bytes": 19688 + }, + { + "_path": "lib/python3.10/wave.py", + "path_type": "hardlink", + "sha256": "2d6ddc0c5e408bb993274ad4f7806252158fec7c569e5a78a50a06ecf02e681d", + "sha256_in_prefix": "2d6ddc0c5e408bb993274ad4f7806252158fec7c569e5a78a50a06ecf02e681d", + "size_in_bytes": 18004 + }, + { + "_path": "lib/python3.10/weakref.py", + "path_type": "hardlink", + "sha256": "dd8e03473ee5667c1a2caa43ede07797652bcb4035fabb60d60af10bb23a0886", + "sha256_in_prefix": "dd8e03473ee5667c1a2caa43ede07797652bcb4035fabb60d60af10bb23a0886", + "size_in_bytes": 21560 + }, + { + "_path": "lib/python3.10/webbrowser.py", + "path_type": "hardlink", + "sha256": "92c5336973260f37727fb59c1f2efdf230c8d3da8be61b5803c709860aec1fc0", + "sha256_in_prefix": "92c5336973260f37727fb59c1f2efdf230c8d3da8be61b5803c709860aec1fc0", + "size_in_bytes": 24245 + }, + { + "_path": "lib/python3.10/wsgiref/__init__.py", + "path_type": "hardlink", + "sha256": "db2259a74988dc73a209cdf7aaa3b79ab6f213384287a8bd288ad141a935e236", + "sha256_in_prefix": "db2259a74988dc73a209cdf7aaa3b79ab6f213384287a8bd288ad141a935e236", + "size_in_bytes": 587 + }, + { + "_path": "lib/python3.10/wsgiref/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "4e7bcf7ad004c92380313a0e76466e0bccd729b616a297078566cee06ae827a8", + "sha256_in_prefix": "4e7bcf7ad004c92380313a0e76466e0bccd729b616a297078566cee06ae827a8", + "size_in_bytes": 981 + }, + { + "_path": "lib/python3.10/wsgiref/__pycache__/handlers.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "77b9c3ed158f69ec3d7b4f6e9209decfd7407b0ae6a8a5857225e0dd7ce8c87a", + "sha256_in_prefix": "77b9c3ed158f69ec3d7b4f6e9209decfd7407b0ae6a8a5857225e0dd7ce8c87a", + "size_in_bytes": 16652 + }, + { + "_path": "lib/python3.10/wsgiref/__pycache__/headers.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "670ba19b8fd1b5de477db9141ed6b2905b320d3fd9fd2d2c178167cba61330e8", + "sha256_in_prefix": "670ba19b8fd1b5de477db9141ed6b2905b320d3fd9fd2d2c178167cba61330e8", + "size_in_bytes": 7969 + }, + { + "_path": "lib/python3.10/wsgiref/__pycache__/simple_server.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "69076370dd26acd1609fd57bbc20cdd1d22a50ad76c4a84aac8609c07be75b6b", + "sha256_in_prefix": "69076370dd26acd1609fd57bbc20cdd1d22a50ad76c4a84aac8609c07be75b6b", + "size_in_bytes": 5560 + }, + { + "_path": "lib/python3.10/wsgiref/__pycache__/util.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "0c208e6f0ad4d74e8f3d36ff31a136e01157d41c95959e3ebc07ef5a315e0b35", + "sha256_in_prefix": "0c208e6f0ad4d74e8f3d36ff31a136e01157d41c95959e3ebc07ef5a315e0b35", + "size_in_bytes": 5661 + }, + { + "_path": "lib/python3.10/wsgiref/__pycache__/validate.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "db743c4de2c242bcd00a60a0b3835238f6e52fe53d861af96e1c818214e71e43", + "sha256_in_prefix": "db743c4de2c242bcd00a60a0b3835238f6e52fe53d861af96e1c818214e71e43", + "size_in_bytes": 14848 + }, + { + "_path": "lib/python3.10/wsgiref/handlers.py", + "path_type": "hardlink", + "sha256": "2b4afb6eb7db05f7c6d1785853cfd45f870fcf65997a7bc5419c36d1dba67191", + "sha256_in_prefix": "2b4afb6eb7db05f7c6d1785853cfd45f870fcf65997a7bc5419c36d1dba67191", + "size_in_bytes": 21669 + }, + { + "_path": "lib/python3.10/wsgiref/headers.py", + "path_type": "hardlink", + "sha256": "0fbf95a47d8e4c0d831fd52312ec43076cbf503c190269876f170a5cf5585fb9", + "sha256_in_prefix": "0fbf95a47d8e4c0d831fd52312ec43076cbf503c190269876f170a5cf5585fb9", + "size_in_bytes": 6766 + }, + { + "_path": "lib/python3.10/wsgiref/simple_server.py", + "path_type": "hardlink", + "sha256": "d435cad48b5f63c0356e1ac70755e6e35eb94b02f9844b813e5762199110bc2b", + "sha256_in_prefix": "d435cad48b5f63c0356e1ac70755e6e35eb94b02f9844b813e5762199110bc2b", + "size_in_bytes": 5171 + }, + { + "_path": "lib/python3.10/wsgiref/util.py", + "path_type": "hardlink", + "sha256": "dcb02730111ea1afdfb7520b37feecce28eb56e2c98fe9fc5a3778547e73ce6e", + "sha256_in_prefix": "dcb02730111ea1afdfb7520b37feecce28eb56e2c98fe9fc5a3778547e73ce6e", + "size_in_bytes": 5851 + }, + { + "_path": "lib/python3.10/wsgiref/validate.py", + "path_type": "hardlink", + "sha256": "622c6a2c69db3b10a8c124b5b06fcdf538bfe03f18f31667b78416123b777308", + "sha256_in_prefix": "622c6a2c69db3b10a8c124b5b06fcdf538bfe03f18f31667b78416123b777308", + "size_in_bytes": 15097 + }, + { + "_path": "lib/python3.10/xdrlib.py", + "path_type": "hardlink", + "sha256": "5bae885a7da49c1fdca1136bf5aece233f0b8f4a6948da3969072c26de395e83", + "sha256_in_prefix": "5bae885a7da49c1fdca1136bf5aece233f0b8f4a6948da3969072c26de395e83", + "size_in_bytes": 5913 + }, + { + "_path": "lib/python3.10/xml/__init__.py", + "path_type": "hardlink", + "sha256": "34296f728e7fe68cccb97a9f6edbf3bf3a686f44044c744fe85f207a92ed4811", + "sha256_in_prefix": "34296f728e7fe68cccb97a9f6edbf3bf3a686f44044c744fe85f207a92ed4811", + "size_in_bytes": 557 + }, + { + "_path": "lib/python3.10/xml/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "7b11b02011cad70638536a57aea129fdd36eb494fb14ad8d4cbd52dfa361c120", + "sha256_in_prefix": "7b11b02011cad70638536a57aea129fdd36eb494fb14ad8d4cbd52dfa361c120", + "size_in_bytes": 947 + }, + { + "_path": "lib/python3.10/xml/dom/NodeFilter.py", + "path_type": "hardlink", + "sha256": "9bfacbbb64e239a75591a7260b3ed86748eeb4366e6c40f3542753e79bace9a7", + "sha256_in_prefix": "9bfacbbb64e239a75591a7260b3ed86748eeb4366e6c40f3542753e79bace9a7", + "size_in_bytes": 936 + }, + { + "_path": "lib/python3.10/xml/dom/__init__.py", + "path_type": "hardlink", + "sha256": "b415a6f3d3663c3ac332ee4a0f4213eadad9281508dc97410e258a03633b063a", + "sha256_in_prefix": "b415a6f3d3663c3ac332ee4a0f4213eadad9281508dc97410e258a03633b063a", + "size_in_bytes": 4019 + }, + { + "_path": "lib/python3.10/xml/dom/__pycache__/NodeFilter.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "d2cabc626f4d9d8e9ee2edb2352b9d5a6642fd85ebb2a82f0be4671ef92ae35f", + "sha256_in_prefix": "d2cabc626f4d9d8e9ee2edb2352b9d5a6642fd85ebb2a82f0be4671ef92ae35f", + "size_in_bytes": 1222 + }, + { + "_path": "lib/python3.10/xml/dom/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "4b731a50972cb0a93b5de7c14fc8b4a3f879af115ccdbe4f315bdf7925a5ae4c", + "sha256_in_prefix": "4b731a50972cb0a93b5de7c14fc8b4a3f879af115ccdbe4f315bdf7925a5ae4c", + "size_in_bytes": 5531 + }, + { + "_path": "lib/python3.10/xml/dom/__pycache__/domreg.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c67b27a1ef588ae85438089f2ada96882a3e2baeedb173b0b09589cd2756063b", + "sha256_in_prefix": "c67b27a1ef588ae85438089f2ada96882a3e2baeedb173b0b09589cd2756063b", + "size_in_bytes": 3113 + }, + { + "_path": "lib/python3.10/xml/dom/__pycache__/expatbuilder.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "0c7c5ee05ddcf6ac1b4cb20440f15408c41808d97867fad05402447817640594", + "sha256_in_prefix": "0c7c5ee05ddcf6ac1b4cb20440f15408c41808d97867fad05402447817640594", + "size_in_bytes": 27563 + }, + { + "_path": "lib/python3.10/xml/dom/__pycache__/minicompat.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "972b635645488515c89f85b3e7d15e08c6a6991cdc21efcc338d45f8dfabce26", + "sha256_in_prefix": "972b635645488515c89f85b3e7d15e08c6a6991cdc21efcc338d45f8dfabce26", + "size_in_bytes": 2944 + }, + { + "_path": "lib/python3.10/xml/dom/__pycache__/minidom.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "ae6df4de725f175263c56ddef3e5455198a67dfc79bfce75e2c073ffb9d5b68a", + "sha256_in_prefix": "ae6df4de725f175263c56ddef3e5455198a67dfc79bfce75e2c073ffb9d5b68a", + "size_in_bytes": 55583 + }, + { + "_path": "lib/python3.10/xml/dom/__pycache__/pulldom.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "de146de88f51d06c3d05a0a5fdd4ca0e93cd7b5e2dee5259f6c4c2e0fa7d30e5", + "sha256_in_prefix": "de146de88f51d06c3d05a0a5fdd4ca0e93cd7b5e2dee5259f6c4c2e0fa7d30e5", + "size_in_bytes": 10808 + }, + { + "_path": "lib/python3.10/xml/dom/__pycache__/xmlbuilder.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "ea4deaf47ae575633e90960fa3eda4fb31c403b7834ab48d05e36cb37f94b1be", + "sha256_in_prefix": "ea4deaf47ae575633e90960fa3eda4fb31c403b7834ab48d05e36cb37f94b1be", + "size_in_bytes": 12555 + }, + { + "_path": "lib/python3.10/xml/dom/domreg.py", + "path_type": "hardlink", + "sha256": "826b02a803930834b96b1086cbee7db1d21c684f65dd3073706dc7bb5ba1a3e8", + "sha256_in_prefix": "826b02a803930834b96b1086cbee7db1d21c684f65dd3073706dc7bb5ba1a3e8", + "size_in_bytes": 3451 + }, + { + "_path": "lib/python3.10/xml/dom/expatbuilder.py", + "path_type": "hardlink", + "sha256": "40ebc018d1f1d7f16121f2dec0cede039fea8a89bf18862d7ed3489adb934be8", + "sha256_in_prefix": "40ebc018d1f1d7f16121f2dec0cede039fea8a89bf18862d7ed3489adb934be8", + "size_in_bytes": 35767 + }, + { + "_path": "lib/python3.10/xml/dom/minicompat.py", + "path_type": "hardlink", + "sha256": "42974c4c67803dfe80b016ff8aeea0d1e5c751703ab3aec5be765f4e534367be", + "sha256_in_prefix": "42974c4c67803dfe80b016ff8aeea0d1e5c751703ab3aec5be765f4e534367be", + "size_in_bytes": 3367 + }, + { + "_path": "lib/python3.10/xml/dom/minidom.py", + "path_type": "hardlink", + "sha256": "af4ee09b06efc54e7fe58032d8338c4bc8578094946d03a200740deab25d97cb", + "sha256_in_prefix": "af4ee09b06efc54e7fe58032d8338c4bc8578094946d03a200740deab25d97cb", + "size_in_bytes": 68140 + }, + { + "_path": "lib/python3.10/xml/dom/pulldom.py", + "path_type": "hardlink", + "sha256": "99dd807c260c3bfa754c0515d390f6041c8f040355f4c628fd4f89a5641bee21", + "sha256_in_prefix": "99dd807c260c3bfa754c0515d390f6041c8f040355f4c628fd4f89a5641bee21", + "size_in_bytes": 11997 + }, + { + "_path": "lib/python3.10/xml/dom/xmlbuilder.py", + "path_type": "hardlink", + "sha256": "d4f33a8f018755626b64557953a91c6bba21ff613da46f7558a2874aa5d08ebf", + "sha256_in_prefix": "d4f33a8f018755626b64557953a91c6bba21ff613da46f7558a2874aa5d08ebf", + "size_in_bytes": 12387 + }, + { + "_path": "lib/python3.10/xml/etree/ElementInclude.py", + "path_type": "hardlink", + "sha256": "97b513db52e9d8382d446e283583e3adf20aae86fb93d4764565ac08250399c0", + "sha256_in_prefix": "97b513db52e9d8382d446e283583e3adf20aae86fb93d4764565ac08250399c0", + "size_in_bytes": 6882 + }, + { + "_path": "lib/python3.10/xml/etree/ElementPath.py", + "path_type": "hardlink", + "sha256": "b98742c79365ce62259074a29940b7817b22af237869192a0f2647fbd6cd5384", + "sha256_in_prefix": "b98742c79365ce62259074a29940b7817b22af237869192a0f2647fbd6cd5384", + "size_in_bytes": 13951 + }, + { + "_path": "lib/python3.10/xml/etree/ElementTree.py", + "path_type": "hardlink", + "sha256": "407440bbbc7041cba4ef5a846ff35378841d540cab3f0adea6cdd1468599fcc6", + "sha256_in_prefix": "407440bbbc7041cba4ef5a846ff35378841d540cab3f0adea6cdd1468599fcc6", + "size_in_bytes": 74316 + }, + { + "_path": "lib/python3.10/xml/etree/__init__.py", + "path_type": "hardlink", + "sha256": "91950edfb196c105d93886f8af7ea3c0a79e06a6b63be3e5a4ea09804e8672a6", + "sha256_in_prefix": "91950edfb196c105d93886f8af7ea3c0a79e06a6b63be3e5a4ea09804e8672a6", + "size_in_bytes": 1605 + }, + { + "_path": "lib/python3.10/xml/etree/__pycache__/ElementInclude.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "168a321fcb81db046cd92cff619f8593d2a9f09f8190da96b909370e9e956add", + "sha256_in_prefix": "168a321fcb81db046cd92cff619f8593d2a9f09f8190da96b909370e9e956add", + "size_in_bytes": 2430 + }, + { + "_path": "lib/python3.10/xml/etree/__pycache__/ElementPath.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "5f58bbb69ef4ee38acea697024d4c5f100e4e7c68b0aa79859c7af3e4128cf75", + "sha256_in_prefix": "5f58bbb69ef4ee38acea697024d4c5f100e4e7c68b0aa79859c7af3e4128cf75", + "size_in_bytes": 9286 + }, + { + "_path": "lib/python3.10/xml/etree/__pycache__/ElementTree.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "f991514ed0056226007516016317bbefa07749005bb50711c18d5864ec189d9d", + "sha256_in_prefix": "f991514ed0056226007516016317bbefa07749005bb50711c18d5864ec189d9d", + "size_in_bytes": 56696 + }, + { + "_path": "lib/python3.10/xml/etree/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "7d27ab6338a4cb0a97baab2e31e62eabccdc148dab55ea3e64e2b53fb1037ab4", + "sha256_in_prefix": "7d27ab6338a4cb0a97baab2e31e62eabccdc148dab55ea3e64e2b53fb1037ab4", + "size_in_bytes": 388 + }, + { + "_path": "lib/python3.10/xml/etree/__pycache__/cElementTree.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "f4fafd9088e21bb9774ec5aa13d3273b41b9e4c6fa9af8274bc56e69eec7827e", + "sha256_in_prefix": "f4fafd9088e21bb9774ec5aa13d3273b41b9e4c6fa9af8274bc56e69eec7827e", + "size_in_bytes": 430 + }, + { + "_path": "lib/python3.10/xml/etree/cElementTree.py", + "path_type": "hardlink", + "sha256": "d0f57acab07fe4f9c116c3392d85946bac8e78608f409cea70005f16ea019b57", + "sha256_in_prefix": "d0f57acab07fe4f9c116c3392d85946bac8e78608f409cea70005f16ea019b57", + "size_in_bytes": 82 + }, + { + "_path": "lib/python3.10/xml/parsers/__init__.py", + "path_type": "hardlink", + "sha256": "b88497adc30d5d5eda7789c25a2206ee9270c932d584d7ac42680325651da45c", + "sha256_in_prefix": "b88497adc30d5d5eda7789c25a2206ee9270c932d584d7ac42680325651da45c", + "size_in_bytes": 167 + }, + { + "_path": "lib/python3.10/xml/parsers/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "54108cb53ecb110d72956d88c02c670aca0b1dc1e56d7fdde8e27fded2d82176", + "sha256_in_prefix": "54108cb53ecb110d72956d88c02c670aca0b1dc1e56d7fdde8e27fded2d82176", + "size_in_bytes": 562 + }, + { + "_path": "lib/python3.10/xml/parsers/__pycache__/expat.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "6c3f3f2478e8ef0b28d451706a821ad6e080ca8a9e5680f6f942ce4f02717ba6", + "sha256_in_prefix": "6c3f3f2478e8ef0b28d451706a821ad6e080ca8a9e5680f6f942ce4f02717ba6", + "size_in_bytes": 591 + }, + { + "_path": "lib/python3.10/xml/parsers/expat.py", + "path_type": "hardlink", + "sha256": "64e1947747c2874117a7458bba1f07c86620cc0ed9a4a4116d262878e4a2aa09", + "sha256_in_prefix": "64e1947747c2874117a7458bba1f07c86620cc0ed9a4a4116d262878e4a2aa09", + "size_in_bytes": 248 + }, + { + "_path": "lib/python3.10/xml/sax/__init__.py", + "path_type": "hardlink", + "sha256": "4cf987c524aaa6ca2030a59a13a98ea3eae6cd3051099d1dd462d557e7bc7e77", + "sha256_in_prefix": "4cf987c524aaa6ca2030a59a13a98ea3eae6cd3051099d1dd462d557e7bc7e77", + "size_in_bytes": 3642 + }, + { + "_path": "lib/python3.10/xml/sax/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "cbbbc90968d4e02ac334d9ee319c8bcd6365a73ed79f43673bfb4ad7b8a5e073", + "sha256_in_prefix": "cbbbc90968d4e02ac334d9ee319c8bcd6365a73ed79f43673bfb4ad7b8a5e073", + "size_in_bytes": 3459 + }, + { + "_path": "lib/python3.10/xml/sax/__pycache__/_exceptions.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "0f6266a09e9519f9a76981b94cf41bfb65e18dbd6f33895d27f4647095d994ef", + "sha256_in_prefix": "0f6266a09e9519f9a76981b94cf41bfb65e18dbd6f33895d27f4647095d994ef", + "size_in_bytes": 5628 + }, + { + "_path": "lib/python3.10/xml/sax/__pycache__/expatreader.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c97c6344eea4c40a15d9281351dc271c505f4c2a0f5ea45208ef148d205edcbf", + "sha256_in_prefix": "c97c6344eea4c40a15d9281351dc271c505f4c2a0f5ea45208ef148d205edcbf", + "size_in_bytes": 13198 + }, + { + "_path": "lib/python3.10/xml/sax/__pycache__/handler.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "51df251c330bf7cbb99dfed588f561c38b68782f2002bae9886c419cfea65b28", + "sha256_in_prefix": "51df251c330bf7cbb99dfed588f561c38b68782f2002bae9886c419cfea65b28", + "size_in_bytes": 14798 + }, + { + "_path": "lib/python3.10/xml/sax/__pycache__/saxutils.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "2f18428d3c0822e6ae1f4a1f7c670580507b39e14c7fc1e842e0436307f548aa", + "sha256_in_prefix": "2f18428d3c0822e6ae1f4a1f7c670580507b39e14c7fc1e842e0436307f548aa", + "size_in_bytes": 12900 + }, + { + "_path": "lib/python3.10/xml/sax/__pycache__/xmlreader.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "2f63260405c6175bfee2f84bd718522a3a9d6d8a17b36025e237f36f816bb7b1", + "sha256_in_prefix": "2f63260405c6175bfee2f84bd718522a3a9d6d8a17b36025e237f36f816bb7b1", + "size_in_bytes": 16641 + }, + { + "_path": "lib/python3.10/xml/sax/_exceptions.py", + "path_type": "hardlink", + "sha256": "cfa45778e457731e0988d9ceef29cf9eeef916f22d7bd53f4cb08c7a2b8b2ce2", + "sha256_in_prefix": "cfa45778e457731e0988d9ceef29cf9eeef916f22d7bd53f4cb08c7a2b8b2ce2", + "size_in_bytes": 4785 + }, + { + "_path": "lib/python3.10/xml/sax/expatreader.py", + "path_type": "hardlink", + "sha256": "4ee774e2d0a3efe1cd1a1afdb3778f6a95523c79bc940ddfd40c19592ba7be21", + "sha256_in_prefix": "4ee774e2d0a3efe1cd1a1afdb3778f6a95523c79bc940ddfd40c19592ba7be21", + "size_in_bytes": 16211 + }, + { + "_path": "lib/python3.10/xml/sax/handler.py", + "path_type": "hardlink", + "sha256": "64c7aae49f1dd382a7b9012610307bfa1d43a14a5dc09a5c8da30903f6805c3d", + "sha256_in_prefix": "64c7aae49f1dd382a7b9012610307bfa1d43a14a5dc09a5c8da30903f6805c3d", + "size_in_bytes": 15617 + }, + { + "_path": "lib/python3.10/xml/sax/saxutils.py", + "path_type": "hardlink", + "sha256": "3fe2cdb6386e0c4d42d37c657bbecb78b69c57aedb1610dbd8bf4043944130ab", + "sha256_in_prefix": "3fe2cdb6386e0c4d42d37c657bbecb78b69c57aedb1610dbd8bf4043944130ab", + "size_in_bytes": 12255 + }, + { + "_path": "lib/python3.10/xml/sax/xmlreader.py", + "path_type": "hardlink", + "sha256": "922a6e2995952366b366c13736d715d77fa1868ee453fdabe35043059357768f", + "sha256_in_prefix": "922a6e2995952366b366c13736d715d77fa1868ee453fdabe35043059357768f", + "size_in_bytes": 12684 + }, + { + "_path": "lib/python3.10/xmlrpc/__init__.py", + "path_type": "hardlink", + "sha256": "87ad5c8954dd56fbbca04517bf87477ff4dce575170c7dd1281d7ef1f4214ac8", + "sha256_in_prefix": "87ad5c8954dd56fbbca04517bf87477ff4dce575170c7dd1281d7ef1f4214ac8", + "size_in_bytes": 38 + }, + { + "_path": "lib/python3.10/xmlrpc/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "a426add6e9d9a1be4e65d000a0572871f639f6a87cf37873807fe7e70c46d0e0", + "sha256_in_prefix": "a426add6e9d9a1be4e65d000a0572871f639f6a87cf37873807fe7e70c46d0e0", + "size_in_bytes": 385 + }, + { + "_path": "lib/python3.10/xmlrpc/__pycache__/client.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "a97e5b356bd253204402a17e1d19169c0761879b2e0f9f7a355c752858fcf349", + "sha256_in_prefix": "a97e5b356bd253204402a17e1d19169c0761879b2e0f9f7a355c752858fcf349", + "size_in_bytes": 34642 + }, + { + "_path": "lib/python3.10/xmlrpc/__pycache__/server.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "d407d27b3918ea32e4b2723a820d8802a1b988663afd0ef3884cce4addeb90a7", + "sha256_in_prefix": "d407d27b3918ea32e4b2723a820d8802a1b988663afd0ef3884cce4addeb90a7", + "size_in_bytes": 29670 + }, + { + "_path": "lib/python3.10/xmlrpc/client.py", + "path_type": "hardlink", + "sha256": "2e6d11a76a1d1f360655e251466ec192843a6bdac1e97bd88dcd358b3045adcd", + "sha256_in_prefix": "2e6d11a76a1d1f360655e251466ec192843a6bdac1e97bd88dcd358b3045adcd", + "size_in_bytes": 49391 + }, + { + "_path": "lib/python3.10/xmlrpc/server.py", + "path_type": "hardlink", + "sha256": "7a0f492dccca9cc8027800815be42053c3a9bd74569d48b7113696e5c3f699aa", + "sha256_in_prefix": "7a0f492dccca9cc8027800815be42053c3a9bd74569d48b7113696e5c3f699aa", + "size_in_bytes": 36672 + }, + { + "_path": "lib/python3.10/zipapp.py", + "path_type": "hardlink", + "sha256": "776078e89fd7dadbce41678f8bacd3b493135e6d610911c867489415420de383", + "sha256_in_prefix": "776078e89fd7dadbce41678f8bacd3b493135e6d610911c867489415420de383", + "size_in_bytes": 7535 + }, + { + "_path": "lib/python3.10/zipfile.py", + "path_type": "hardlink", + "sha256": "99de6f49c7a86de134b4afb5fae694a51b11b2c197a7c4794e9b14ce874d128c", + "sha256_in_prefix": "99de6f49c7a86de134b4afb5fae694a51b11b2c197a7c4794e9b14ce874d128c", + "size_in_bytes": 90056 + }, + { + "_path": "lib/python3.10/zipimport.py", + "path_type": "hardlink", + "sha256": "b85d7c16a559c7ca846659c09d014df509c9eaa5807eafc83615e5f32fa28233", + "sha256_in_prefix": "b85d7c16a559c7ca846659c09d014df509c9eaa5807eafc83615e5f32fa28233", + "size_in_bytes": 30891 + }, + { + "_path": "lib/python3.10/zoneinfo/__init__.py", + "path_type": "hardlink", + "sha256": "ac7fb403e4371d07482ef2fda81dbcf6879484e9fc41d4be42c156d7e54c68a8", + "sha256_in_prefix": "ac7fb403e4371d07482ef2fda81dbcf6879484e9fc41d4be42c156d7e54c68a8", + "size_in_bytes": 703 + }, + { + "_path": "lib/python3.10/zoneinfo/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "7cbdb663cfd654fa4a563b1aeeb7696f2fd28ce7c1078f4ae3edf3495582bdf6", + "sha256_in_prefix": "7cbdb663cfd654fa4a563b1aeeb7696f2fd28ce7c1078f4ae3edf3495582bdf6", + "size_in_bytes": 1064 + }, + { + "_path": "lib/python3.10/zoneinfo/__pycache__/_common.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "35ab32961a747269cc03ca62e5a7a44429e65c52ec52f8ddca2cc6f29275182f", + "sha256_in_prefix": "35ab32961a747269cc03ca62e5a7a44429e65c52ec52f8ddca2cc6f29275182f", + "size_in_bytes": 3367 + }, + { + "_path": "lib/python3.10/zoneinfo/__pycache__/_tzpath.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "8b4cdefe9e8064620990091717c6a70255af7298625773ee03565b049a4999e3", + "sha256_in_prefix": "8b4cdefe9e8064620990091717c6a70255af7298625773ee03565b049a4999e3", + "size_in_bytes": 4328 + }, + { + "_path": "lib/python3.10/zoneinfo/__pycache__/_zoneinfo.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c46d1659118479354693551f21e99a396b6f9997992e7bd509bd8d6f330d15d2", + "sha256_in_prefix": "c46d1659118479354693551f21e99a396b6f9997992e7bd509bd8d6f330d15d2", + "size_in_bytes": 15690 + }, + { + "_path": "lib/python3.10/zoneinfo/_common.py", + "path_type": "hardlink", + "sha256": "f05e4665baa1b3a20c4c9f9eee4e90477040cafbe5c48d1bd91b04846a7b49b1", + "sha256_in_prefix": "f05e4665baa1b3a20c4c9f9eee4e90477040cafbe5c48d1bd91b04846a7b49b1", + "size_in_bytes": 5285 + }, + { + "_path": "lib/python3.10/zoneinfo/_tzpath.py", + "path_type": "hardlink", + "sha256": "3896a3dfd0d7d6e1812d071952590e5365c9b41938a777f596a7ad0eef2d3704", + "sha256_in_prefix": "3896a3dfd0d7d6e1812d071952590e5365c9b41938a777f596a7ad0eef2d3704", + "size_in_bytes": 5081 + }, + { + "_path": "lib/python3.10/zoneinfo/_zoneinfo.py", + "path_type": "hardlink", + "sha256": "98e19a55b4fc33dc5cec78127908d67b5e09e39472d259c4272b98e82fede24d", + "sha256_in_prefix": "98e19a55b4fc33dc5cec78127908d67b5e09e39472d259c4272b98e82fede24d", + "size_in_bytes": 24315 + }, + { + "_path": "share/man/man1/python3.1", + "path_type": "softlink", + "sha256": "f6537764619d8297b0d47485d388c24bbf8623b95e2cdf44f81bfb223a34fbcf", + "size_in_bytes": 18926 + }, + { + "_path": "share/man/man1/python3.10.1", + "path_type": "hardlink", + "sha256": "f6537764619d8297b0d47485d388c24bbf8623b95e2cdf44f81bfb223a34fbcf", + "sha256_in_prefix": "f6537764619d8297b0d47485d388c24bbf8623b95e2cdf44f81bfb223a34fbcf", + "size_in_bytes": 18926 + } + ], + "paths_version": 1 + }, + "requested_spec": "python=3.10", + "sha256": "818e45d7409870f5bc4e1c7fe75ab4b7b66e4a069ec908b493646446d1d706c6", + "size": 13600220, + "subdir": "osx-arm64", + "timestamp": 1715024921000, + "url": "https://repo.anaconda.com/pkgs/main/osx-arm64/python-3.10.14-hb885b13_1.conda", + "version": "3.10.14" +} \ No newline at end of file diff --git a/crates/pet-conda/tests/unix/anaconda3-2023.03/envs/myenv/conda-meta/readline-8.2-h1a28f6b_0.json b/crates/pet-conda/tests/unix/anaconda3-2023.03/envs/myenv/conda-meta/readline-8.2-h1a28f6b_0.json new file mode 100644 index 00000000..9801c49a --- /dev/null +++ b/crates/pet-conda/tests/unix/anaconda3-2023.03/envs/myenv/conda-meta/readline-8.2-h1a28f6b_0.json @@ -0,0 +1,241 @@ +{ + "build": "h1a28f6b_0", + "build_number": 0, + "channel": "https://repo.anaconda.com/pkgs/main/osx-arm64", + "constrains": [], + "depends": [ + "ncurses >=6.3,<7.0a0" + ], + "extracted_package_dir": "/Users/donjayamanne/.pyenv/versions/miniconda3-latest/pkgs/readline-8.2-h1a28f6b_0", + "files": [ + "include/readline/chardefs.h", + "include/readline/history.h", + "include/readline/keymaps.h", + "include/readline/readline.h", + "include/readline/rlconf.h", + "include/readline/rlstdc.h", + "include/readline/rltypedefs.h", + "include/readline/tilde.h", + "lib/libhistory.8.2.dylib", + "lib/libhistory.8.dylib", + "lib/libhistory.a", + "lib/libhistory.dylib", + "lib/libreadline.8.2.dylib", + "lib/libreadline.8.dylib", + "lib/libreadline.a", + "lib/libreadline.dylib", + "lib/pkgconfig/history.pc", + "lib/pkgconfig/readline.pc", + "share/doc/readline/CHANGES", + "share/doc/readline/INSTALL", + "share/doc/readline/README", + "share/info/history.info", + "share/info/readline.info", + "share/info/rluserman.info", + "share/man/man3/history.3", + "share/man/man3/readline.3" + ], + "fn": "readline-8.2-h1a28f6b_0.conda", + "license": "GPL-3.0-only", + "link": { + "source": "/Users/donjayamanne/.pyenv/versions/miniconda3-latest/pkgs/readline-8.2-h1a28f6b_0", + "type": 1 + }, + "md5": "8e3d8eb62e32065d41fad9a83a901254", + "name": "readline", + "package_tarball_full_path": "/Users/donjayamanne/.pyenv/versions/miniconda3-latest/pkgs/readline-8.2-h1a28f6b_0.conda", + "paths_data": { + "paths": [ + { + "_path": "include/readline/chardefs.h", + "path_type": "hardlink", + "sha256": "928fdcd4204b361a8a922085f12497181606981a70ae52c67d39118ae5fab640", + "sha256_in_prefix": "928fdcd4204b361a8a922085f12497181606981a70ae52c67d39118ae5fab640", + "size_in_bytes": 4694 + }, + { + "_path": "include/readline/history.h", + "path_type": "hardlink", + "sha256": "f33fed4d7598d513fdf223eea7853fde5452da0d7fd5b951865aef5553caf02b", + "sha256_in_prefix": "f33fed4d7598d513fdf223eea7853fde5452da0d7fd5b951865aef5553caf02b", + "size_in_bytes": 10663 + }, + { + "_path": "include/readline/keymaps.h", + "path_type": "hardlink", + "sha256": "4c42c3c5d2bb3aba10c7e7f27dd79841f30857fde61c6c85bf67f4f2ac1befc4", + "sha256_in_prefix": "4c42c3c5d2bb3aba10c7e7f27dd79841f30857fde61c6c85bf67f4f2ac1befc4", + "size_in_bytes": 3201 + }, + { + "_path": "include/readline/readline.h", + "path_type": "hardlink", + "sha256": "5c4d149f5609cd5771f2d1bd4c1557e7b7822cf4dbd415041490cee2c018b58d", + "sha256_in_prefix": "5c4d149f5609cd5771f2d1bd4c1557e7b7822cf4dbd415041490cee2c018b58d", + "size_in_bytes": 38147 + }, + { + "_path": "include/readline/rlconf.h", + "path_type": "hardlink", + "sha256": "b599f6bc28df4c0cb0143c5747233aeadc191b3c4f8bb9128509c4c68e946da6", + "sha256_in_prefix": "b599f6bc28df4c0cb0143c5747233aeadc191b3c4f8bb9128509c4c68e946da6", + "size_in_bytes": 2829 + }, + { + "_path": "include/readline/rlstdc.h", + "path_type": "hardlink", + "sha256": "77c9d0203d571a576ec2aabbfbdfbdd18802d6fcfe6e890d33fbab3536f3317a", + "sha256_in_prefix": "77c9d0203d571a576ec2aabbfbdfbdd18802d6fcfe6e890d33fbab3536f3317a", + "size_in_bytes": 1835 + }, + { + "_path": "include/readline/rltypedefs.h", + "path_type": "hardlink", + "sha256": "ed7e4063f9b73fa0071b2e202c4f939189fc883917aa931c5192d3652fac0914", + "sha256_in_prefix": "ed7e4063f9b73fa0071b2e202c4f939189fc883917aa931c5192d3652fac0914", + "size_in_bytes": 3021 + }, + { + "_path": "include/readline/tilde.h", + "path_type": "hardlink", + "sha256": "76ea2566b9045468f1ae1a0a97e62d765edcd642a2d1f12a62a6af1b4dfe9729", + "sha256_in_prefix": "76ea2566b9045468f1ae1a0a97e62d765edcd642a2d1f12a62a6af1b4dfe9729", + "size_in_bytes": 2652 + }, + { + "_path": "lib/libhistory.8.2.dylib", + "path_type": "hardlink", + "sha256": "15f6f72faef490146b924f955e37bbf3619868152c411a3b638e6b3430c3ec6c", + "sha256_in_prefix": "15f6f72faef490146b924f955e37bbf3619868152c411a3b638e6b3430c3ec6c", + "size_in_bytes": 91184 + }, + { + "_path": "lib/libhistory.8.dylib", + "path_type": "softlink", + "sha256": "15f6f72faef490146b924f955e37bbf3619868152c411a3b638e6b3430c3ec6c", + "size_in_bytes": 91184 + }, + { + "_path": "lib/libhistory.a", + "path_type": "hardlink", + "sha256": "b4b8dac3e00c95649b6d95ec0effcebe4be304fd26afe4fb4e91b34a914b98fb", + "sha256_in_prefix": "b4b8dac3e00c95649b6d95ec0effcebe4be304fd26afe4fb4e91b34a914b98fb", + "size_in_bytes": 48392 + }, + { + "_path": "lib/libhistory.dylib", + "path_type": "softlink", + "sha256": "15f6f72faef490146b924f955e37bbf3619868152c411a3b638e6b3430c3ec6c", + "size_in_bytes": 91184 + }, + { + "_path": "lib/libreadline.8.2.dylib", + "path_type": "hardlink", + "sha256": "e994597a907fe4a242e2c39cca51b1c930cf8630437bcfdaac47231a3b7e5aea", + "sha256_in_prefix": "e994597a907fe4a242e2c39cca51b1c930cf8630437bcfdaac47231a3b7e5aea", + "size_in_bytes": 327920 + }, + { + "_path": "lib/libreadline.8.dylib", + "path_type": "softlink", + "sha256": "e994597a907fe4a242e2c39cca51b1c930cf8630437bcfdaac47231a3b7e5aea", + "size_in_bytes": 327920 + }, + { + "_path": "lib/libreadline.a", + "path_type": "hardlink", + "sha256": "58cdb2216372f692335409eb0994b11489bc3b5c5a301090c45bca2aef767a75", + "sha256_in_prefix": "58cdb2216372f692335409eb0994b11489bc3b5c5a301090c45bca2aef767a75", + "size_in_bytes": 509560 + }, + { + "_path": "lib/libreadline.dylib", + "path_type": "softlink", + "sha256": "e994597a907fe4a242e2c39cca51b1c930cf8630437bcfdaac47231a3b7e5aea", + "size_in_bytes": 327920 + }, + { + "_path": "lib/pkgconfig/history.pc", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_37p5hcjlng/croot/readline_1666648022400/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_place", + "sha256": "f16a55a7917f79312fd55749e52537768004308b7c68070e3a1244931edb44b3", + "sha256_in_prefix": "8a3fd22fc0ee8455ed9dded37683daaee8f14b7cf33327ea0b923ad7d13818e8", + "size_in_bytes": 548 + }, + { + "_path": "lib/pkgconfig/readline.pc", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_37p5hcjlng/croot/readline_1666648022400/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_place", + "sha256": "f671e78857f21c5f4e040c5e8e6159129a8d2b8f6ef80fe233a42608fbb721c2", + "sha256_in_prefix": "a19eaa6d4fc9aa6499055db3678139be84839d9e2cb8631eadab55d1f725b6f1", + "size_in_bytes": 564 + }, + { + "_path": "share/doc/readline/CHANGES", + "path_type": "hardlink", + "sha256": "f526ca246cec4c4fa535a792c04735fb7b06d318d9b4f61f6a0f64152fa39a43", + "sha256_in_prefix": "f526ca246cec4c4fa535a792c04735fb7b06d318d9b4f61f6a0f64152fa39a43", + "size_in_bytes": 81365 + }, + { + "_path": "share/doc/readline/INSTALL", + "path_type": "hardlink", + "sha256": "b7bbbc2908a61f0594277fb03b1a11c18f9ffbd8737a804f9a886454d0894967", + "sha256_in_prefix": "b7bbbc2908a61f0594277fb03b1a11c18f9ffbd8737a804f9a886454d0894967", + "size_in_bytes": 13357 + }, + { + "_path": "share/doc/readline/README", + "path_type": "hardlink", + "sha256": "680abe0d4e5866d49304863c1b5ef6f96055942da178f061a41a0dce9e3d89a9", + "sha256_in_prefix": "680abe0d4e5866d49304863c1b5ef6f96055942da178f061a41a0dce9e3d89a9", + "size_in_bytes": 8029 + }, + { + "_path": "share/info/history.info", + "path_type": "hardlink", + "sha256": "8b5ada1697abc91d4ebd07b70c383e34acab67d33c84855ec11f3a5e44a0711f", + "sha256_in_prefix": "8b5ada1697abc91d4ebd07b70c383e34acab67d33c84855ec11f3a5e44a0711f", + "size_in_bytes": 63497 + }, + { + "_path": "share/info/readline.info", + "path_type": "hardlink", + "sha256": "fe2b54b34a356a3fe82aa61f76c43e3a8a1ebe9173ba8b5640fe091b9331a5bc", + "sha256_in_prefix": "fe2b54b34a356a3fe82aa61f76c43e3a8a1ebe9173ba8b5640fe091b9331a5bc", + "size_in_bytes": 243177 + }, + { + "_path": "share/info/rluserman.info", + "path_type": "hardlink", + "sha256": "6d64db954627199edad6bf6cea65a026455a9dd72a342c3ce7e071d482ab4bf0", + "sha256_in_prefix": "6d64db954627199edad6bf6cea65a026455a9dd72a342c3ce7e071d482ab4bf0", + "size_in_bytes": 93405 + }, + { + "_path": "share/man/man3/history.3", + "path_type": "hardlink", + "sha256": "a8a01fea0adaac18e6aca4c71004d5dc61cdff363df44b76e2dc54ec721bafb8", + "sha256_in_prefix": "a8a01fea0adaac18e6aca4c71004d5dc61cdff363df44b76e2dc54ec721bafb8", + "size_in_bytes": 23204 + }, + { + "_path": "share/man/man3/readline.3", + "path_type": "hardlink", + "sha256": "dee2f232395d0381454b9d90eceed03c5027a5f43f32e6c514d56c2d12170965", + "sha256_in_prefix": "dee2f232395d0381454b9d90eceed03c5027a5f43f32e6c514d56c2d12170965", + "size_in_bytes": 52342 + } + ], + "paths_version": 1 + }, + "requested_spec": "None", + "sha256": "0399187fd09fc52bfac1b67b3cdef33faa76a75213ff932d9fcb079238dd8584", + "size": 361268, + "subdir": "osx-arm64", + "timestamp": 1666648067000, + "url": "https://repo.anaconda.com/pkgs/main/osx-arm64/readline-8.2-h1a28f6b_0.conda", + "version": "8.2" +} \ No newline at end of file diff --git a/crates/pet-conda/tests/unix/anaconda3-2023.03/envs/without_python/conda-meta/history b/crates/pet-conda/tests/unix/anaconda3-2023.03/envs/without_python/conda-meta/history new file mode 100644 index 00000000..2db66a21 --- /dev/null +++ b/crates/pet-conda/tests/unix/anaconda3-2023.03/envs/without_python/conda-meta/history @@ -0,0 +1,3 @@ +==> 2024-02-29 08:48:22 <== +# cmd: /Users/donjayamanne/miniconda3/bin/conda create -n conda7 -y +# conda version: 23.11.0 diff --git a/crates/pet-conda/tests/unix/user_home_with_environments_txt/.conda/environments.txt b/crates/pet-conda/tests/unix/user_home_with_environments_txt/.conda/environments.txt new file mode 100644 index 00000000..ff4a7e6e --- /dev/null +++ b/crates/pet-conda/tests/unix/user_home_with_environments_txt/.conda/environments.txt @@ -0,0 +1,22 @@ +/Users/username/miniconda3 +/Users/username/miniconda3/envs/xyz +/Users/username/miniconda3/envs/conda1 +/Users/username/miniconda3/envs/conda2 +/Users/username/miniconda3/envs/conda3 +/Users/username/miniconda3/envs/conda4 +/Users/username/miniconda3/envs/conda5 +/Users/username/miniconda3/envs/conda6 +/Users/username/miniconda3/envs/conda7 +/Users/username/miniconda3/envs/conda8 +/Users/username/.pyenv/versions/miniconda3-latest +/Users/username/.pyenv/versions/miniconda3-latest/envs/myenv +/Users/username/.pyenv/versions/miniforge3-4.10.1-1 +/Users/username/.pyenv/versions/anaconda3-2023.03 +/Users/username/miniforge3/envs/sample1 +/Users/username/temp/conda_work_folder +/Users/username/temp/conda_work_folder_3.12 +/Users/username/temp/conda_work_folder__no_python +/Users/username/temp/conda_work_folder_from_root +/Users/username/temp/sample-conda-envs-folder/hello_world +/Users/username/temp/sample-conda-envs-folder2/another +/Users/username/temp/sample-conda-envs-folder2/xyz diff --git a/crates/pet-conda/tests/utils_test.rs b/crates/pet-conda/tests/utils_test.rs new file mode 100644 index 00000000..927a0269 --- /dev/null +++ b/crates/pet-conda/tests/utils_test.rs @@ -0,0 +1,53 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +mod common; +use pet_conda::utils; +use std::path::PathBuf; + +use common::resolve_test_path; + +#[test] +fn is_conda_install() { + let path: PathBuf = resolve_test_path(&["unix", "anaconda3-2023.03"]).into(); + assert!(utils::is_conda_install(&path)); + + let path: PathBuf = resolve_test_path(&["unix", "anaconda3-2023.03-without-history"]).into(); + assert!(utils::is_conda_install(&path)); +} + +#[test] +fn is_not_conda_install() { + let path: PathBuf = resolve_test_path(&["unix", "some bogus directory"]).into(); + assert_eq!(utils::is_conda_install(&path), false); + + // Conda env is not an install location. + let path: PathBuf = + resolve_test_path(&["unix", "anaconda3-2023.03", "envs", "env_python_3"]).into(); + assert_eq!(utils::is_conda_install(&path), false); +} + +#[test] +fn is_conda_env() { + let path: PathBuf = resolve_test_path(&["unix", "anaconda3-2023.03"]).into(); + assert!(utils::is_conda_env(&path)); + + let path: PathBuf = resolve_test_path(&["unix", "anaconda3-2023.03-without-history"]).into(); + assert!(utils::is_conda_env(&path)); + + let path: PathBuf = + resolve_test_path(&["unix", "anaconda3-2023.03", "envs", "env_python_3"]).into(); + assert!(utils::is_conda_env(&path)); +} + +#[test] +fn is_not_conda_env() { + let path: PathBuf = resolve_test_path(&["unix", "some bogus directory"]).into(); + assert_eq!(utils::is_conda_env(&path), false); + + let path: PathBuf = resolve_test_path(&["unix", "anaconda3-2023.03"]).into(); + assert!(utils::is_conda_env(&path)); + + let path: PathBuf = resolve_test_path(&["unix", "anaconda3-2023.03-without-history"]).into(); + assert!(utils::is_conda_env(&path)); +} diff --git a/crates/pet-core/Cargo.toml b/crates/pet-core/Cargo.toml new file mode 100644 index 00000000..403664b1 --- /dev/null +++ b/crates/pet-core/Cargo.toml @@ -0,0 +1,7 @@ +[package] +name = "pet-core" +version = "0.1.0" +edition = "2021" + +[dependencies] +serde = { version = "1.0.152", features = ["derive"] } diff --git a/crates/pet-core/src/arch.rs b/crates/pet-core/src/arch.rs new file mode 100644 index 00000000..11c943cc --- /dev/null +++ b/crates/pet-core/src/arch.rs @@ -0,0 +1,12 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +use serde::{Deserialize, Serialize}; + +#[derive(Serialize, Deserialize, Clone)] +#[serde(rename_all = "camelCase")] +#[derive(Debug, PartialEq)] +pub enum Architecture { + X64, + X86, +} diff --git a/crates/pet-core/src/lib.rs b/crates/pet-core/src/lib.rs new file mode 100644 index 00000000..3d21012b --- /dev/null +++ b/crates/pet-core/src/lib.rs @@ -0,0 +1,7 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +pub mod arch; +pub mod manager; +pub mod os_environment; +pub mod python_environment; diff --git a/crates/pet-core/src/manager.rs b/crates/pet-core/src/manager.rs new file mode 100644 index 00000000..08800204 --- /dev/null +++ b/crates/pet-core/src/manager.rs @@ -0,0 +1,32 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +use serde::{Deserialize, Serialize}; +use std::path::PathBuf; + +#[derive(Serialize, Deserialize, Copy, Clone)] +#[serde(rename_all = "camelCase")] +#[derive(Debug)] +pub enum EnvManagerType { + Conda, + Pyenv, +} + +#[derive(Serialize, Deserialize, Clone)] +#[serde(rename_all = "camelCase")] +#[derive(Debug)] +pub struct EnvManager { + pub executable: PathBuf, + pub version: Option, + pub tool: EnvManagerType, +} + +impl EnvManager { + pub fn new(executable_path: PathBuf, tool: EnvManagerType, version: Option) -> Self { + Self { + executable: executable_path, + version, + tool, + } + } +} diff --git a/crates/pet-core/src/os_environment.rs b/crates/pet-core/src/os_environment.rs new file mode 100644 index 00000000..56d45bf5 --- /dev/null +++ b/crates/pet-core/src/os_environment.rs @@ -0,0 +1,113 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +use std::{env, path::PathBuf}; + +pub trait Environment { + fn get_user_home(&self) -> Option; + /** + * Only used in tests, this is the root `/`. + */ + #[allow(dead_code)] + fn get_root(&self) -> Option; + fn get_env_var(&self, key: String) -> Option; + fn get_know_global_search_locations(&self) -> Vec; +} + +pub struct EnvironmentApi {} +impl EnvironmentApi { + pub fn new() -> Self { + EnvironmentApi {} + } +} + +#[cfg(windows)] +impl Environment for EnvironmentApi { + fn get_user_home(&self) -> Option { + get_user_home() + } + fn get_root(&self) -> Option { + None + } + fn get_env_var(&self, key: String) -> Option { + get_env_var(key) + } + fn get_know_global_search_locations(&self) -> Vec { + vec![] + } +} + +#[cfg(unix)] +impl Environment for EnvironmentApi { + fn get_user_home(&self) -> Option { + get_user_home() + } + fn get_root(&self) -> Option { + None + } + fn get_env_var(&self, key: String) -> Option { + get_env_var(key) + } + fn get_know_global_search_locations(&self) -> Vec { + let mut paths = env::split_paths(&self.get_env_var("PATH".to_string()).unwrap_or_default()) + .collect::>(); + + vec![ + PathBuf::from("/bin"), + PathBuf::from("/etc"), + PathBuf::from("/lib"), + PathBuf::from("/lib/x86_64-linux-gnu"), + PathBuf::from("/lib64"), + PathBuf::from("/sbin"), + PathBuf::from("/snap/bin"), + PathBuf::from("/usr/bin"), + PathBuf::from("/usr/games"), + PathBuf::from("/usr/include"), + PathBuf::from("/usr/lib"), + PathBuf::from("/usr/lib/x86_64-linux-gnu"), + PathBuf::from("/usr/lib64"), + PathBuf::from("/usr/libexec"), + PathBuf::from("/usr/local"), + PathBuf::from("/usr/local/bin"), + PathBuf::from("/usr/local/etc"), + PathBuf::from("/usr/local/games"), + PathBuf::from("/usr/local/lib"), + PathBuf::from("/usr/local/sbin"), + PathBuf::from("/usr/sbin"), + PathBuf::from("/usr/share"), + PathBuf::from("/home/bin"), + PathBuf::from("/home/sbin"), + PathBuf::from("/opt"), + PathBuf::from("/opt/bin"), + PathBuf::from("/opt/sbin"), + ] + .iter() + .for_each(|p| { + if !paths.contains(p) { + paths.push(p.clone()); + } + }); + + if let Some(home) = self.get_user_home() { + // PathBuf::from("~/.local/bin"), + paths.push(home.join(".local").join("bin")); + } + + paths + } +} + +fn get_user_home() -> Option { + let home = env::var("HOME").or_else(|_| env::var("USERPROFILE")); + match home { + Ok(home) => Some(PathBuf::from(home)), + Err(_) => None, + } +} + +fn get_env_var(key: String) -> Option { + match env::var(key) { + Ok(path) => Some(path), + Err(_) => None, + } +} diff --git a/crates/pet-core/src/python_environment.rs b/crates/pet-core/src/python_environment.rs new file mode 100644 index 00000000..d69bb2e9 --- /dev/null +++ b/crates/pet-core/src/python_environment.rs @@ -0,0 +1,188 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +use std::path::PathBuf; + +use serde::{Deserialize, Serialize}; + +use crate::{arch::Architecture, manager::EnvManager}; + +#[derive(Serialize, Deserialize, Clone)] +#[serde(rename_all = "camelCase")] +#[derive(Debug)] +pub enum PythonEnvironmentCategory { + Conda, + Homebrew, + Pyenv, + PyenvVirtualEnv, + Pipenv, + System, + Unknown, + Venv, + VirtualEnv, + VirtualEnvWrapper, + WindowsStore, + WindowsRegistry, +} + +#[derive(Serialize, Deserialize, Clone)] +#[serde(rename_all = "camelCase")] +#[derive(Debug)] +// Python environment. +// Any item that has information is known to be accurate, if an item is missing it is unknown. +pub struct PythonEnvironment { + // Display name as provided by the tool, Windows Store & Windows Registry have display names defined in registry. + pub display_name: Option, + // The name of the environment. Primarily applies to conda environments. + pub name: Option, + // Python executable, can be empty in the case of conda envs that do not have Python installed in them. + pub executable: Option, + pub category: PythonEnvironmentCategory, + pub version: Option, + // SysPrefix for the environment. + pub prefix: Option, + pub manager: Option, + /** + * The project path for the Pipenv, VirtualEnvWrapper, Hatch environment & the like. + * Basically this is the folder that a particular environment is associated with. + */ + pub project: Option, + // Architecture of the environment. + // E.g. its possible to have a 32bit python in a 64bit OS. + pub arch: Option, + // Some of the known symlinks for the environment. + // E.g. in the case of Homebrew there are a number of symlinks that are created. + pub symlinks: Option>, +} + +impl Default for PythonEnvironment { + fn default() -> Self { + Self { + display_name: None, + name: None, + executable: None, + // Sometimes we might not know the env type. + // Lets never default these to System/Global or others as thats not true. + // Not knowing does not mean it is a system env. + category: PythonEnvironmentCategory::Unknown, + version: None, + prefix: None, + manager: None, + project: None, + arch: None, + symlinks: None, + } + } +} + +impl PythonEnvironment { + pub fn new( + executable: Option, + category: PythonEnvironmentCategory, + prefix: Option, + manager: Option, + version: Option, + ) -> Self { + Self { + executable, + category, + version, + prefix, + manager, + ..Default::default() + } + } +} + +#[derive(Serialize, Deserialize, Clone)] +#[serde(rename_all = "camelCase")] +#[derive(Debug)] +pub struct PythonEnvironmentBuilder { + display_name: Option, + name: Option, + executable: Option, + category: PythonEnvironmentCategory, + version: Option, + prefix: Option, + manager: Option, + project: Option, + arch: Option, + symlinks: Option>, +} + +impl PythonEnvironmentBuilder { + pub fn new(category: PythonEnvironmentCategory) -> Self { + Self { + category, + display_name: None, + name: None, + executable: None, + version: None, + prefix: None, + manager: None, + project: None, + arch: None, + symlinks: None, + } + } + + pub fn display_name(mut self, display_name: String) -> Self { + self.display_name = Some(display_name); + self + } + + pub fn name(mut self, name: String) -> Self { + self.name = Some(name); + self + } + + pub fn executable(mut self, executable: PathBuf) -> Self { + self.executable = Some(executable); + self + } + + pub fn version(mut self, version: String) -> Self { + self.version = Some(version); + self + } + + pub fn prefix(mut self, prefix: PathBuf) -> Self { + self.prefix = Some(prefix); + self + } + + pub fn manager(mut self, manager: EnvManager) -> Self { + self.manager = Some(manager); + self + } + + pub fn project(mut self, project: PathBuf) -> Self { + self.project = Some(project); + self + } + + pub fn arch(mut self, arch: Architecture) -> Self { + self.arch = Some(arch); + self + } + + pub fn symlinks(mut self, symlinks: Vec) -> Self { + self.symlinks = Some(symlinks); + self + } + + pub fn build(self) -> PythonEnvironment { + PythonEnvironment { + display_name: self.display_name, + name: self.name, + executable: self.executable, + category: self.category, + version: self.version, + prefix: self.prefix, + manager: self.manager, + project: self.project, + arch: self.arch, + symlinks: self.symlinks, + } + } +} diff --git a/crates/pet-env-var-path/Cargo.toml b/crates/pet-env-var-path/Cargo.toml new file mode 100644 index 00000000..25438d95 --- /dev/null +++ b/crates/pet-env-var-path/Cargo.toml @@ -0,0 +1,6 @@ +[package] +name = "pet-env-var-path" +version = "0.1.0" +edition = "2021" + +[dependencies] diff --git a/crates/pet-env-var-path/src/lib.rs b/crates/pet-env-var-path/src/lib.rs new file mode 100644 index 00000000..7d12d9af --- /dev/null +++ b/crates/pet-env-var-path/src/lib.rs @@ -0,0 +1,14 @@ +pub fn add(left: usize, right: usize) -> usize { + left + right +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn it_works() { + let result = add(2, 2); + assert_eq!(result, 4); + } +} diff --git a/crates/pet-hatch/Cargo.toml b/crates/pet-hatch/Cargo.toml new file mode 100644 index 00000000..01246f89 --- /dev/null +++ b/crates/pet-hatch/Cargo.toml @@ -0,0 +1,6 @@ +[package] +name = "pet-hatch" +version = "0.1.0" +edition = "2021" + +[dependencies] diff --git a/crates/pet-hatch/src/lib.rs b/crates/pet-hatch/src/lib.rs new file mode 100644 index 00000000..7d12d9af --- /dev/null +++ b/crates/pet-hatch/src/lib.rs @@ -0,0 +1,14 @@ +pub fn add(left: usize, right: usize) -> usize { + left + right +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn it_works() { + let result = add(2, 2); + assert_eq!(result, 4); + } +} diff --git a/crates/pet-homebrew/Cargo.toml b/crates/pet-homebrew/Cargo.toml new file mode 100644 index 00000000..82181b23 --- /dev/null +++ b/crates/pet-homebrew/Cargo.toml @@ -0,0 +1,6 @@ +[package] +name = "pet-homebrew" +version = "0.1.0" +edition = "2021" + +[dependencies] diff --git a/crates/pet-homebrew/src/lib.rs b/crates/pet-homebrew/src/lib.rs new file mode 100644 index 00000000..7d12d9af --- /dev/null +++ b/crates/pet-homebrew/src/lib.rs @@ -0,0 +1,14 @@ +pub fn add(left: usize, right: usize) -> usize { + left + right +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn it_works() { + let result = add(2, 2); + assert_eq!(result, 4); + } +} diff --git a/crates/pet-jsonrpc/Cargo.toml b/crates/pet-jsonrpc/Cargo.toml new file mode 100644 index 00000000..6a5a1049 --- /dev/null +++ b/crates/pet-jsonrpc/Cargo.toml @@ -0,0 +1,6 @@ +[package] +name = "pet-jsonrpc" +version = "0.1.0" +edition = "2021" + +[dependencies] diff --git a/crates/pet-jsonrpc/src/lib.rs b/crates/pet-jsonrpc/src/lib.rs new file mode 100644 index 00000000..7d12d9af --- /dev/null +++ b/crates/pet-jsonrpc/src/lib.rs @@ -0,0 +1,14 @@ +pub fn add(left: usize, right: usize) -> usize { + left + right +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn it_works() { + let result = add(2, 2); + assert_eq!(result, 4); + } +} diff --git a/crates/pet-pipenv/Cargo.toml b/crates/pet-pipenv/Cargo.toml new file mode 100644 index 00000000..1a03f785 --- /dev/null +++ b/crates/pet-pipenv/Cargo.toml @@ -0,0 +1,6 @@ +[package] +name = "pet-pipenv" +version = "0.1.0" +edition = "2021" + +[dependencies] diff --git a/crates/pet-pipenv/src/lib.rs b/crates/pet-pipenv/src/lib.rs new file mode 100644 index 00000000..7d12d9af --- /dev/null +++ b/crates/pet-pipenv/src/lib.rs @@ -0,0 +1,14 @@ +pub fn add(left: usize, right: usize) -> usize { + left + right +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn it_works() { + let result = add(2, 2); + assert_eq!(result, 4); + } +} diff --git a/crates/pet-poetry/Cargo.toml b/crates/pet-poetry/Cargo.toml new file mode 100644 index 00000000..06cc7b6d --- /dev/null +++ b/crates/pet-poetry/Cargo.toml @@ -0,0 +1,6 @@ +[package] +name = "pet-poetry" +version = "0.1.0" +edition = "2021" + +[dependencies] diff --git a/crates/pet-poetry/src/lib.rs b/crates/pet-poetry/src/lib.rs new file mode 100644 index 00000000..7d12d9af --- /dev/null +++ b/crates/pet-poetry/src/lib.rs @@ -0,0 +1,14 @@ +pub fn add(left: usize, right: usize) -> usize { + left + right +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn it_works() { + let result = add(2, 2); + assert_eq!(result, 4); + } +} diff --git a/crates/pet-pyenv/Cargo.toml b/crates/pet-pyenv/Cargo.toml new file mode 100644 index 00000000..94cd626b --- /dev/null +++ b/crates/pet-pyenv/Cargo.toml @@ -0,0 +1,6 @@ +[package] +name = "pet-pyenv" +version = "0.1.0" +edition = "2021" + +[dependencies] diff --git a/crates/pet-pyenv/src/lib.rs b/crates/pet-pyenv/src/lib.rs new file mode 100644 index 00000000..7d12d9af --- /dev/null +++ b/crates/pet-pyenv/src/lib.rs @@ -0,0 +1,14 @@ +pub fn add(left: usize, right: usize) -> usize { + left + right +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn it_works() { + let result = add(2, 2); + assert_eq!(result, 4); + } +} diff --git a/crates/pet-utils/Cargo.toml b/crates/pet-utils/Cargo.toml new file mode 100644 index 00000000..434626e7 --- /dev/null +++ b/crates/pet-utils/Cargo.toml @@ -0,0 +1,9 @@ +[package] +name = "pet-utils" +version = "0.1.0" +edition = "2021" + +[dependencies] +serde = { version = "1.0.152", features = ["derive"] } +lazy_static = "1.4.0" +regex = "1.10.4" diff --git a/crates/pet-utils/src/env.rs b/crates/pet-utils/src/env.rs new file mode 100644 index 00000000..56ec2f78 --- /dev/null +++ b/crates/pet-utils/src/env.rs @@ -0,0 +1,21 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +use std::path::PathBuf; + +#[derive(Debug)] +pub struct PythonEnv { + pub executable: PathBuf, + pub prefix: Option, + pub version: Option, +} + +impl PythonEnv { + pub fn new(executable: PathBuf, prefix: Option, version: Option) -> Self { + Self { + executable, + prefix, + version, + } + } +} diff --git a/crates/pet-utils/src/executable.rs b/crates/pet-utils/src/executable.rs new file mode 100644 index 00000000..a43f3348 --- /dev/null +++ b/crates/pet-utils/src/executable.rs @@ -0,0 +1,222 @@ +// Copyright (c) Microsoft Corporation. All rights reserved. +// Licensed under the MIT License. + +use lazy_static::lazy_static; +use regex::Regex; +use std::{ + fs, + path::{Path, PathBuf}, +}; + +lazy_static! { + static ref WINDOWS_EXE: Regex = + Regex::new(r"python(\d+\.?)*.exe").expect("error parsing Windows executable regex"); + static ref UNIX_EXE: Regex = + Regex::new(r"python(\d+\.?)*$").expect("error parsing Unix executable regex"); +} + +#[cfg(windows)] +pub fn find_executable(env_path: &Path) -> Option { + for path in vec![ + env_path.join("Scripts").join("python.exe"), + env_path.join("Scripts").join("python3.exe"), + env_path.join("python.exe"), + env_path.join("python3.exe"), + ] { + // Should parallelize this + // This is legacy logic, need to see where and why this is used before changing it. + if fs::metadata(&path).is_ok() { + return Some(path); + } + } + None +} + +#[cfg(unix)] +pub fn find_executable(env_path: &Path) -> Option { + use std::fs; + + for path in vec![ + env_path.join("bin").join("python"), + env_path.join("bin").join("python3"), + env_path.join("python"), + env_path.join("python3"), + ] { + // Should parallelize this + // This is legacy logic, need to see where and why this is used before changing it. + if fs::metadata(&path).is_ok() { + return Some(path); + } + } + None +} + +pub fn find_executables(env_path: &Path) -> Vec { + let mut python_executables = vec![]; + let bin = if cfg!(windows) { "Scripts" } else { "bin" }; + let mut env_path = env_path.to_path_buf(); + if env_path.join(bin).metadata().is_ok() { + env_path = env_path.join(bin); + } + + // If we have python.exe or python3.exe, then enumerator files in this directory + // We might have others like python 3.10 and python 3.11 + // If we do not find python or python3, then do not enumerate, as its very expensive. + // This fn gets called from a number of places, e.g. to look scan all folders that are in PATH variable, + // & a few others, and scanning all of those dirs is every expensive. + let python_exe = if cfg!(windows) { + "python.exe" + } else { + "python" + }; + let python3_exe = if cfg!(windows) { + "python3.exe" + } else { + "python3" + }; + + if env_path.join(python_exe).metadata().is_ok() || env_path.join(python3_exe).metadata().is_ok() + { + // Enumerate this directory and get all `python` & `pythonX.X` files. + if let Ok(entries) = fs::read_dir(env_path) { + for entry in entries.filter_map(Result::ok) { + let file = entry.path(); + if let Some(metadata) = fs::metadata(&file).ok() { + if is_python_executable_name(&file) && metadata.is_file() { + python_executables.push(file); + } + } + } + } + } + + python_executables +} + +fn is_python_executable_name(exe: &Path) -> bool { + let name = exe + .file_name() + .unwrap_or_default() + .to_str() + .unwrap_or_default() + .to_lowercase(); + if !name.starts_with("python") { + return false; + } + // Regex to match pythonX.X.exe + if cfg!(windows) { + WINDOWS_EXE.is_match(&name) + } else { + UNIX_EXE.is_match(&name) + } +} + +// Resolves symlinks to the real file. +// If the real file == exe, then it is not a symlink. +pub fn resolve_symlink(exe: &Path) -> Option { + let name = exe.file_name()?.to_string_lossy(); + // TODO: What is -config and -build? + if !name.starts_with("python") || name.ends_with("-config") || name.ends_with("-build") { + return None; + } + + // If the file == symlink, then it is not a symlink. + // We already have the resolved file, no need to return that again. + if let Some(real_file) = fs::read_link(&exe).ok() { + if real_file == exe { + None + } else { + Some(real_file) + } + } else { + None + } +} + +// Given a list of executables, return the one with the shortest path. +// The shortest path is the most likely to be most user friendly. +pub fn get_shortest_executable(exes: &Option>) -> Option { + // Ensure the executable always points to the shorted path. + if let Some(mut exes) = exes.clone() { + exes.sort_by(|a, b| { + a.to_str() + .unwrap_or_default() + .len() + .cmp(&b.to_str().unwrap_or_default().len()) + }); + if exes.is_empty() { + return None; + } + Some(exes[0].clone()) + } else { + None + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn is_python_executable_test() { + #[cfg(unix)] + assert!(is_python_executable_name(PathBuf::from("python").as_path())); + #[cfg(unix)] + assert!(is_python_executable_name( + PathBuf::from("python3").as_path() + )); + #[cfg(unix)] + assert!(is_python_executable_name( + PathBuf::from("python3.1").as_path() + )); + #[cfg(unix)] + assert!(is_python_executable_name( + PathBuf::from("python3.10").as_path() + )); + #[cfg(unix)] + assert!(is_python_executable_name( + PathBuf::from("python4.10").as_path() + )); + + #[cfg(windows)] + assert!(is_python_executable_name( + PathBuf::from("python.exe").as_path() + )); + #[cfg(windows)] + assert!(is_python_executable_name( + PathBuf::from("python3.exe").as_path() + )); + #[cfg(windows)] + assert!(is_python_executable_name( + PathBuf::from("python3.1.exe").as_path() + )); + #[cfg(windows)] + assert!(is_python_executable_name( + PathBuf::from("python3.10.exe").as_path() + )); + #[cfg(windows)] + assert!(is_python_executable_name( + PathBuf::from("python4.10.exe").as_path() + )); + } + #[test] + fn is_not_python_executable_test() { + #[cfg(unix)] + assert!(!is_python_executable_name( + PathBuf::from("pythonw").as_path() + )); + #[cfg(unix)] + assert!(!is_python_executable_name( + PathBuf::from("pythonw3").as_path() + )); + + #[cfg(windows)] + assert!(!is_python_executable_name( + PathBuf::from("pythonw.exe").as_path() + )); + #[cfg(windows)] + assert!(!is_python_executable_name( + PathBuf::from("pythonw3.exe").as_path() + )); + } +} diff --git a/crates/pet-utils/src/headers.rs b/crates/pet-utils/src/headers.rs new file mode 100644 index 00000000..54dcc732 --- /dev/null +++ b/crates/pet-utils/src/headers.rs @@ -0,0 +1,50 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +use lazy_static::lazy_static; +use regex::Regex; +use std::{ + fs, + path::{Path, PathBuf}, +}; + +lazy_static! { + static ref VERSION: Regex = Regex::new(r#"#define\s+PY_VERSION\s+"((\d+\.?)*)"#) + .expect("error parsing Version regex for partchlevel.h"); +} + +#[derive(Debug)] +pub struct Headers { + pub version: String, +} + +impl Headers { + pub fn get_version(path: &Path) -> Option { + get_version(&path.to_path_buf()) + } +} + +// Get the python version from the `/include/patchlevel.h` file +// On windows the path is `/Headers/patchlevel.h` +// The lines we are looking for are: +// /* Version as a string */ +// #define PY_VERSION "3.10.2" +// /*--end constants--*/ +pub fn get_version(path: &PathBuf) -> Option { + let mut path = path.clone(); + let bin = if cfg!(windows) { "Scripts" } else { "bin" }; + if path.ends_with(bin) { + path.pop(); + } + let headers_path = if cfg!(windows) { "Headers" } else { "include" }; + let patchlevel_h = path.join(headers_path).join("patchlevel.h"); + let contents = fs::read_to_string(&patchlevel_h).ok()?; + for line in contents.lines() { + if let Some(captures) = VERSION.captures(line) { + if let Some(value) = captures.get(1) { + return Some(value.as_str().to_string()); + } + } + } + None +} diff --git a/crates/pet-utils/src/lib.rs b/crates/pet-utils/src/lib.rs new file mode 100644 index 00000000..ce9e01ec --- /dev/null +++ b/crates/pet-utils/src/lib.rs @@ -0,0 +1,8 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +pub mod env; +pub mod executable; +mod headers; +mod pyvenv_cfg; +pub mod sys_prefix; diff --git a/crates/pet-utils/src/pyvenv_cfg.rs b/crates/pet-utils/src/pyvenv_cfg.rs new file mode 100644 index 00000000..f5135a3f --- /dev/null +++ b/crates/pet-utils/src/pyvenv_cfg.rs @@ -0,0 +1,92 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +use lazy_static::lazy_static; +use regex::Regex; +use std::{ + fs, + path::{Path, PathBuf}, +}; + +lazy_static! { + static ref VERSION: Regex = Regex::new(r"^version\s*=\s*(\d+\.\d+\.\d+)$") + .expect("error parsing Version regex for pyenv_cfg"); + static ref VERSION_INFO: Regex = Regex::new(r"^version_info\s*=\s*(\d+\.\d+\.\d+.*)$") + .expect("error parsing Version_info regex for pyenv_cfg"); +} + +const PYVENV_CONFIG_FILE: &str = "pyvenv.cfg"; + +#[derive(Debug)] +pub struct PyEnvCfg { + pub version: String, +} + +impl PyEnvCfg { + fn new(version: String) -> Self { + Self { version } + } + pub fn find(path: &Path) -> Option { + if let Some(file) = find(&path.to_path_buf()) { + parse(&file) + } else { + None + } + } +} + +fn find(path: &PathBuf) -> Option { + // env + // |__ pyvenv.cfg <--- check if this file exists + // |__ bin or Scripts + // |__ python <--- interpreterPath + + // Check if the pyvenv.cfg file is in the current directory. + // Possible the passed value is the `env`` directory. + let cfg = path.join(PYVENV_CONFIG_FILE); + if fs::metadata(&cfg).is_ok() { + return Some(cfg); + } + + let bin = if cfg!(windows) { "Scripts" } else { "bin" }; + if path.ends_with(bin) { + let cfg = path.parent()?.join(PYVENV_CONFIG_FILE); + if fs::metadata(&cfg).is_ok() { + return Some(cfg); + } + } + // let cfg = path.parent()?.join(PYVENV_CONFIG_FILE); + // println!("{:?}", cfg); + // if fs::metadata(&cfg).is_ok() { + // return Some(cfg); + // } + + // // Check if the pyvenv.cfg file is in the parent directory. + // // Possible the passed value is the `bin` directory. + // let cfg = path.parent()?.parent()?.join(PYVENV_CONFIG_FILE); + // if fs::metadata(&cfg).is_ok() { + // return Some(cfg); + // } + + None +} + +fn parse(file: &Path) -> Option { + let contents = fs::read_to_string(&file).ok()?; + for line in contents.lines() { + if !line.contains("version") { + continue; + } + if let Some(captures) = VERSION.captures(line) { + if let Some(value) = captures.get(1) { + return Some(PyEnvCfg::new(value.as_str().to_string())); + } + } + if let Some(captures) = VERSION_INFO.captures(line) { + if let Some(value) = captures.get(1) { + return Some(PyEnvCfg::new(value.as_str().to_string())); + } + } + } + None +} diff --git a/crates/pet-utils/src/sys_prefix.rs b/crates/pet-utils/src/sys_prefix.rs new file mode 100644 index 00000000..a0ea4e3d --- /dev/null +++ b/crates/pet-utils/src/sys_prefix.rs @@ -0,0 +1,17 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +use super::headers::Headers; +use super::pyvenv_cfg::PyEnvCfg; +use std::path::Path; + +pub struct SysPrefix {} + +impl SysPrefix { + pub fn get_version(path: &Path) -> Option { + if let Some(cfg) = PyEnvCfg::find(path) { + return Some(cfg.version); + } + Headers::get_version(path) + } +} diff --git a/crates/pet-utils/tests/common.rs b/crates/pet-utils/tests/common.rs new file mode 100644 index 00000000..462e6fb1 --- /dev/null +++ b/crates/pet-utils/tests/common.rs @@ -0,0 +1,166 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +use std::path::PathBuf; + +#[allow(dead_code)] +pub fn resolve_test_path(paths: &[&str]) -> PathBuf { + let mut root = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("tests"); + + paths.iter().for_each(|p| root.push(p)); + + root +} + +// #[allow(dead_code)] +// pub fn resolve_test_paths(paths: &[&str]) -> PathBuf { +// let mut root = PathBuf::from(env!("CARGO_MANIFEST_DIR")); + +// paths.iter().for_each(|p| root.push(p)); + +// root +// } + +// #[allow(dead_code)] +// pub fn join_test_paths(paths: &[&str]) -> PathBuf { +// let path: PathBuf = paths.iter().map(|p| p.to_string()).collect(); +// path +// } + +// #[allow(dead_code)] +// pub trait TestMessages { +// fn get_messages(&self) -> Vec; +// } + +// #[allow(dead_code)] +// pub struct TestEnvironment { +// vars: HashMap, +// home: Option, +// root: Option, +// globals_locations: Vec, +// } +// #[allow(dead_code)] +// pub fn create_test_environment( +// vars: HashMap, +// home: Option, +// globals_locations: Vec, +// root: Option, +// ) -> TestEnvironment { +// impl Environment for TestEnvironment { +// fn get_env_var(&self, key: String) -> Option { +// self.vars.get(&key).cloned() +// } +// fn get_root(&self) -> Option { +// self.root.clone() +// } +// fn get_user_home(&self) -> Option { +// self.home.clone() +// } +// fn get_know_global_search_locations(&self) -> Vec { +// self.globals_locations.clone() +// } +// } +// TestEnvironment { +// vars, +// home, +// root, +// globals_locations, +// } +// } + +// fn compare_json(expected: &Value, actual: &Value) -> bool { +// if expected == actual { +// return true; +// } + +// if expected.is_object() { +// if expected.as_object().is_none() && actual.as_object().is_none() { +// return true; +// } + +// if expected.as_object().is_none() && actual.as_object().is_some() { +// return false; +// } +// if expected.as_object().is_some() && actual.as_object().is_none() { +// return false; +// } + +// let expected = expected.as_object().unwrap(); +// let actual = actual.as_object().unwrap(); + +// for (key, value) in expected.iter() { +// if !actual.contains_key(key) { +// return false; +// } +// if !compare_json(value, actual.get(key).unwrap()) { +// return false; +// } +// } +// return true; +// } + +// if expected.is_array() { +// let expected = expected.as_array().unwrap(); +// let actual = actual.as_array().unwrap(); + +// if expected.len() != actual.len() { +// return false; +// } + +// for (i, value) in expected.iter().enumerate() { +// if !compare_json(value, actual.get(i).unwrap()) { +// return false; +// } +// } +// return true; +// } + +// false +// } + +// #[allow(dead_code)] +// pub fn assert_messages(expected_json: &[Value], actual_json: &[Value]) { +// let mut expected_json = expected_json.to_vec(); +// assert_eq!( +// expected_json.len(), +// actual_json.len(), +// "Incorrect number of messages" +// ); + +// if expected_json.len() == 0 { +// return; +// } + +// // Ignore the order of the json items when comparing. +// println!("==========="); +// for (index, actual) in actual_json.iter().enumerate() { +// println!("{}. Actual: {}", index, actual); +// let mut valid_index: Option = None; +// for (i, expected) in expected_json.iter().enumerate() { +// if !compare_json(expected, &actual) { +// println!("{}. Not equal: {}", i, expected); +// continue; +// } + +// // Ensure we verify using standard assert_eq!, just in case the code is faulty.. +// valid_index = Some(i); +// assert_eq!(expected, actual); +// } +// if let Some(index) = valid_index { +// // This is to ensure we don't compare the same item twice. +// expected_json.remove(index); +// } else { +// println!("NOT FOUND"); +// println!("NOT FOUND"); +// println!("NOT FOUND"); +// println!("NOT FOUND"); +// println!("NOT FOUND"); +// println!("NOT FOUND"); +// println!("NOT FOUND"); +// println!("NOT FOUND"); +// println!("NOT FOUND"); +// // Use traditional assert so we can see the fully output in the test results. +// assert_eq!(&expected_json[0], actual); +// } +// } +// } diff --git a/crates/pet-utils/tests/executable_test.rs b/crates/pet-utils/tests/executable_test.rs new file mode 100644 index 00000000..6a771a86 --- /dev/null +++ b/crates/pet-utils/tests/executable_test.rs @@ -0,0 +1,49 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +mod common; +use pet_utils::executable; +use std::path::PathBuf; + +use common::resolve_test_path; + +#[test] +fn find_executables() { + // .venv + let path: PathBuf = resolve_test_path(&["unix", "executables", ".venv"]).into(); + let mut executables = executable::find_executables(&path.clone()); + executables.sort(); + + assert_eq!( + executables, + vec![ + resolve_test_path(&["unix", "executables", ".venv", "bin", "python"]), + resolve_test_path(&["unix", "executables", ".venv", "bin", "python3"]), + ] + ); + + // Python3.9.9 + let path: PathBuf = resolve_test_path(&["unix", "executables", "python3.9.9"]).into(); + let mut executables = executable::find_executables(&path.clone()); + executables.sort(); + + assert_eq!( + executables, + vec![ + resolve_test_path(&["unix", "executables", "python3.9.9", "bin", "python3"]), + resolve_test_path(&["unix", "executables", "python3.9.9", "bin", "python3.9.9"]), + ] + ); + + // Conda without Python. + let path: PathBuf = resolve_test_path(&["unix", "executables", "conda_without_python"]).into(); + let executables = executable::find_executables(&path.clone()); + + assert_eq!(executables.len(), 0); + + // Bogus dir + let path: PathBuf = resolve_test_path(&["unix_bogus_dir"]).into(); + let executables = executable::find_executables(&path.clone()); + + assert_eq!(executables.len(), 0); +} diff --git a/crates/pet-utils/tests/sys_prefix_test.rs b/crates/pet-utils/tests/sys_prefix_test.rs new file mode 100644 index 00000000..183e939c --- /dev/null +++ b/crates/pet-utils/tests/sys_prefix_test.rs @@ -0,0 +1,72 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +mod common; +use pet_utils::sys_prefix::SysPrefix; +use std::path::PathBuf; + +use common::resolve_test_path; + +#[test] +fn version_from_sys_prefix() { + let path: PathBuf = resolve_test_path(&["unix", "pyvenv_cfg", ".venv"]).into(); + let version = SysPrefix::get_version(&path).unwrap(); + assert_eq!(version, "3.12.1"); + + let path: PathBuf = resolve_test_path(&["unix", "pyvenv_cfg", ".venv", "bin"]).into(); + let version = SysPrefix::get_version(&path).unwrap(); + assert_eq!(version, "3.12.1"); +} + +#[test] +fn version_from_sys_prefix_using_version_info_format() { + let path: PathBuf = resolve_test_path(&["unix", "pyvenv_cfg", "hatch_env"]).into(); + let version = SysPrefix::get_version(&path).unwrap(); + assert_eq!(version, "3.9.6.final.0"); + + let path: PathBuf = resolve_test_path(&["unix", "pyvenv_cfg", "hatch_env", "bin"]).into(); + let version = SysPrefix::get_version(&path).unwrap(); + assert_eq!(version, "3.9.6.final.0"); +} + +#[test] +fn no_version_without_pyvenv_cfg_and_without_headers() { + let path: PathBuf = + resolve_test_path(&["unix", "pyvenv_cfg", "python3.9.9_without_headers"]).into(); + let version = SysPrefix::get_version(&path); + assert!(version.is_none()); + + let path: PathBuf = + resolve_test_path(&["unix", "pyvenv_cfg", "python3.9.9_without_headers", "bin"]).into(); + let version = SysPrefix::get_version(&path); + assert!(version.is_none()); + + let path: PathBuf = resolve_test_path(&[ + "unix", + "pyvenv_cfg", + "python3.9.9_without_headers", + "bin", + "python", + ]) + .into(); + let version = SysPrefix::get_version(&path); + assert!(version.is_none()); +} + +#[test] +fn no_version_for_invalid_paths() { + let path: PathBuf = resolve_test_path(&["unix_1234"]).into(); + let version = SysPrefix::get_version(&path); + assert!(version.is_none()); +} + +#[test] +fn version_from_header_files() { + let path: PathBuf = resolve_test_path(&["unix", "headers", "python3.9.9"]).into(); + let version = SysPrefix::get_version(&path).unwrap(); + assert_eq!(version, "3.9.9"); + + let path: PathBuf = resolve_test_path(&["unix", "headers", "python3.9.9", "bin"]).into(); + let version = SysPrefix::get_version(&path).unwrap(); + assert_eq!(version, "3.9.9"); +} diff --git a/crates/pet-utils/tests/unix/executables/.venv/bin/python b/crates/pet-utils/tests/unix/executables/.venv/bin/python new file mode 100644 index 00000000..e69de29b diff --git a/crates/pet-utils/tests/unix/executables/.venv/bin/python3 b/crates/pet-utils/tests/unix/executables/.venv/bin/python3 new file mode 100644 index 00000000..e69de29b diff --git a/crates/pet-utils/tests/unix/executables/.venv/pyvenv.cfg b/crates/pet-utils/tests/unix/executables/.venv/pyvenv.cfg new file mode 100644 index 00000000..860b12e2 --- /dev/null +++ b/crates/pet-utils/tests/unix/executables/.venv/pyvenv.cfg @@ -0,0 +1,5 @@ +home = /Users/donjayamanne/.pyenv/versions/3.12.1/bin +include-system-site-packages = false +version = 3.12.1 +executable = /Users/donjayamanne/.pyenv/versions/3.12.1/bin/python3.12 +command = /Users/donjayamanne/.pyenv/versions/3.12.1/bin/python -m venv /Users/donjayamanne/demo/.venv diff --git a/crates/pet-utils/tests/unix/executables/conda_without_python/conda-meta/history b/crates/pet-utils/tests/unix/executables/conda_without_python/conda-meta/history new file mode 100644 index 00000000..2db66a21 --- /dev/null +++ b/crates/pet-utils/tests/unix/executables/conda_without_python/conda-meta/history @@ -0,0 +1,3 @@ +==> 2024-02-29 08:48:22 <== +# cmd: /Users/donjayamanne/miniconda3/bin/conda create -n conda7 -y +# conda version: 23.11.0 diff --git a/crates/pet-utils/tests/unix/executables/python3.9.9/bin/python3 b/crates/pet-utils/tests/unix/executables/python3.9.9/bin/python3 new file mode 100644 index 00000000..e69de29b diff --git a/crates/pet-utils/tests/unix/executables/python3.9.9/bin/python3.9.9 b/crates/pet-utils/tests/unix/executables/python3.9.9/bin/python3.9.9 new file mode 100644 index 00000000..e69de29b diff --git a/crates/pet-utils/tests/unix/executables/python3.9.9/include/patchlevel.h b/crates/pet-utils/tests/unix/executables/python3.9.9/include/patchlevel.h new file mode 100644 index 00000000..293e51a2 --- /dev/null +++ b/crates/pet-utils/tests/unix/executables/python3.9.9/include/patchlevel.h @@ -0,0 +1,35 @@ + +/* Python version identification scheme. + + When the major or minor version changes, the VERSION variable in + configure.ac must also be changed. + + There is also (independent) API version information in modsupport.h. +*/ + +/* Values for PY_RELEASE_LEVEL */ +#define PY_RELEASE_LEVEL_ALPHA 0xA +#define PY_RELEASE_LEVEL_BETA 0xB +#define PY_RELEASE_LEVEL_GAMMA 0xC /* For release candidates */ +#define PY_RELEASE_LEVEL_FINAL 0xF /* Serial should be 0 here */ + /* Higher for patch releases */ + +/* Version parsed out into numeric values */ +/*--start constants--*/ +#define PY_MAJOR_VERSION 3 +#define PY_MINOR_VERSION 9 +#define PY_MICRO_VERSION 9 +#define PY_RELEASE_LEVEL PY_RELEASE_LEVEL_FINAL +#define PY_RELEASE_SERIAL 0 + +/* Version as a string */ +#define PY_VERSION "3.9.9" +/*--end constants--*/ + +/* Version as a single 4-byte hex number, e.g. 0x010502B2 == 1.5.2b2. + Use this for numeric comparisons, e.g. #if PY_VERSION_HEX >= ... */ +#define PY_VERSION_HEX ((PY_MAJOR_VERSION << 24) | \ + (PY_MINOR_VERSION << 16) | \ + (PY_MICRO_VERSION << 8) | \ + (PY_RELEASE_LEVEL << 4) | \ + (PY_RELEASE_SERIAL << 0)) diff --git a/crates/pet-utils/tests/unix/headers/python3.9.9/bin/python3 b/crates/pet-utils/tests/unix/headers/python3.9.9/bin/python3 new file mode 100644 index 00000000..e69de29b diff --git a/crates/pet-utils/tests/unix/headers/python3.9.9/bin/python3.9.9 b/crates/pet-utils/tests/unix/headers/python3.9.9/bin/python3.9.9 new file mode 100644 index 00000000..e69de29b diff --git a/crates/pet-utils/tests/unix/headers/python3.9.9/include/patchlevel.h b/crates/pet-utils/tests/unix/headers/python3.9.9/include/patchlevel.h new file mode 100644 index 00000000..293e51a2 --- /dev/null +++ b/crates/pet-utils/tests/unix/headers/python3.9.9/include/patchlevel.h @@ -0,0 +1,35 @@ + +/* Python version identification scheme. + + When the major or minor version changes, the VERSION variable in + configure.ac must also be changed. + + There is also (independent) API version information in modsupport.h. +*/ + +/* Values for PY_RELEASE_LEVEL */ +#define PY_RELEASE_LEVEL_ALPHA 0xA +#define PY_RELEASE_LEVEL_BETA 0xB +#define PY_RELEASE_LEVEL_GAMMA 0xC /* For release candidates */ +#define PY_RELEASE_LEVEL_FINAL 0xF /* Serial should be 0 here */ + /* Higher for patch releases */ + +/* Version parsed out into numeric values */ +/*--start constants--*/ +#define PY_MAJOR_VERSION 3 +#define PY_MINOR_VERSION 9 +#define PY_MICRO_VERSION 9 +#define PY_RELEASE_LEVEL PY_RELEASE_LEVEL_FINAL +#define PY_RELEASE_SERIAL 0 + +/* Version as a string */ +#define PY_VERSION "3.9.9" +/*--end constants--*/ + +/* Version as a single 4-byte hex number, e.g. 0x010502B2 == 1.5.2b2. + Use this for numeric comparisons, e.g. #if PY_VERSION_HEX >= ... */ +#define PY_VERSION_HEX ((PY_MAJOR_VERSION << 24) | \ + (PY_MINOR_VERSION << 16) | \ + (PY_MICRO_VERSION << 8) | \ + (PY_RELEASE_LEVEL << 4) | \ + (PY_RELEASE_SERIAL << 0)) diff --git a/crates/pet-utils/tests/unix/pyvenv_cfg/.venv/bin/python b/crates/pet-utils/tests/unix/pyvenv_cfg/.venv/bin/python new file mode 100644 index 00000000..e69de29b diff --git a/crates/pet-utils/tests/unix/pyvenv_cfg/.venv/bin/python3 b/crates/pet-utils/tests/unix/pyvenv_cfg/.venv/bin/python3 new file mode 100644 index 00000000..e69de29b diff --git a/crates/pet-utils/tests/unix/pyvenv_cfg/.venv/pyvenv.cfg b/crates/pet-utils/tests/unix/pyvenv_cfg/.venv/pyvenv.cfg new file mode 100644 index 00000000..860b12e2 --- /dev/null +++ b/crates/pet-utils/tests/unix/pyvenv_cfg/.venv/pyvenv.cfg @@ -0,0 +1,5 @@ +home = /Users/donjayamanne/.pyenv/versions/3.12.1/bin +include-system-site-packages = false +version = 3.12.1 +executable = /Users/donjayamanne/.pyenv/versions/3.12.1/bin/python3.12 +command = /Users/donjayamanne/.pyenv/versions/3.12.1/bin/python -m venv /Users/donjayamanne/demo/.venv diff --git a/crates/pet-utils/tests/unix/pyvenv_cfg/hatch_env/bin/python b/crates/pet-utils/tests/unix/pyvenv_cfg/hatch_env/bin/python new file mode 100644 index 00000000..e69de29b diff --git a/crates/pet-utils/tests/unix/pyvenv_cfg/hatch_env/pyvenv.cfg b/crates/pet-utils/tests/unix/pyvenv_cfg/hatch_env/pyvenv.cfg new file mode 100644 index 00000000..37728792 --- /dev/null +++ b/crates/pet-utils/tests/unix/pyvenv_cfg/hatch_env/pyvenv.cfg @@ -0,0 +1,8 @@ +home = /Library/Developer/CommandLineTools/usr/bin +implementation = CPython +version_info = 3.9.6.final.0 +virtualenv = 20.26.2 +include-system-site-packages = false +base-prefix = /Library/Developer/CommandLineTools/Library/Frameworks/Python3.framework/Versions/3.9 +base-exec-prefix = /Library/Developer/CommandLineTools/Library/Frameworks/Python3.framework/Versions/3.9 +base-executable = /Library/Developer/CommandLineTools/Library/Frameworks/Python3.framework/Versions/3.9/bin/python3.9 diff --git a/crates/pet-utils/tests/unix/pyvenv_cfg/python3.9.9_without_headers/bin/python b/crates/pet-utils/tests/unix/pyvenv_cfg/python3.9.9_without_headers/bin/python new file mode 100644 index 00000000..e69de29b diff --git a/crates/pet-venv/Cargo.toml b/crates/pet-venv/Cargo.toml new file mode 100644 index 00000000..9c2e9ba6 --- /dev/null +++ b/crates/pet-venv/Cargo.toml @@ -0,0 +1,6 @@ +[package] +name = "pet-venv" +version = "0.1.0" +edition = "2021" + +[dependencies] diff --git a/crates/pet-venv/src/lib.rs b/crates/pet-venv/src/lib.rs new file mode 100644 index 00000000..7d12d9af --- /dev/null +++ b/crates/pet-venv/src/lib.rs @@ -0,0 +1,14 @@ +pub fn add(left: usize, right: usize) -> usize { + left + right +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn it_works() { + let result = add(2, 2); + assert_eq!(result, 4); + } +} diff --git a/crates/pet-virtualenv/Cargo.toml b/crates/pet-virtualenv/Cargo.toml new file mode 100644 index 00000000..55e4b143 --- /dev/null +++ b/crates/pet-virtualenv/Cargo.toml @@ -0,0 +1,6 @@ +[package] +name = "pet-virtualenv" +version = "0.1.0" +edition = "2021" + +[dependencies] diff --git a/crates/pet-virtualenv/src/lib.rs b/crates/pet-virtualenv/src/lib.rs new file mode 100644 index 00000000..7d12d9af --- /dev/null +++ b/crates/pet-virtualenv/src/lib.rs @@ -0,0 +1,14 @@ +pub fn add(left: usize, right: usize) -> usize { + left + right +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn it_works() { + let result = add(2, 2); + assert_eq!(result, 4); + } +} diff --git a/crates/pet-virtualenvwrapper/Cargo.toml b/crates/pet-virtualenvwrapper/Cargo.toml new file mode 100644 index 00000000..d99cc6ae --- /dev/null +++ b/crates/pet-virtualenvwrapper/Cargo.toml @@ -0,0 +1,6 @@ +[package] +name = "pet-virtualenvwrapper" +version = "0.1.0" +edition = "2021" + +[dependencies] diff --git a/crates/pet-virtualenvwrapper/src/lib.rs b/crates/pet-virtualenvwrapper/src/lib.rs new file mode 100644 index 00000000..7d12d9af --- /dev/null +++ b/crates/pet-virtualenvwrapper/src/lib.rs @@ -0,0 +1,14 @@ +pub fn add(left: usize, right: usize) -> usize { + left + right +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn it_works() { + let result = add(2, 2); + assert_eq!(result, 4); + } +} diff --git a/crates/pet-windows-registry/Cargo.toml b/crates/pet-windows-registry/Cargo.toml new file mode 100644 index 00000000..742871df --- /dev/null +++ b/crates/pet-windows-registry/Cargo.toml @@ -0,0 +1,6 @@ +[package] +name = "pet-windows-registry" +version = "0.1.0" +edition = "2021" + +[dependencies] diff --git a/crates/pet-windows-registry/src/lib.rs b/crates/pet-windows-registry/src/lib.rs new file mode 100644 index 00000000..7d12d9af --- /dev/null +++ b/crates/pet-windows-registry/src/lib.rs @@ -0,0 +1,14 @@ +pub fn add(left: usize, right: usize) -> usize { + left + right +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn it_works() { + let result = add(2, 2); + assert_eq!(result, 4); + } +} diff --git a/crates/pet-windows-store/Cargo.toml b/crates/pet-windows-store/Cargo.toml new file mode 100644 index 00000000..079b0e09 --- /dev/null +++ b/crates/pet-windows-store/Cargo.toml @@ -0,0 +1,6 @@ +[package] +name = "pet-windows-store" +version = "0.1.0" +edition = "2021" + +[dependencies] diff --git a/crates/pet-windows-store/src/lib.rs b/crates/pet-windows-store/src/lib.rs new file mode 100644 index 00000000..7d12d9af --- /dev/null +++ b/crates/pet-windows-store/src/lib.rs @@ -0,0 +1,14 @@ +pub fn add(left: usize, right: usize) -> usize { + left + right +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn it_works() { + let result = add(2, 2); + assert_eq!(result, 4); + } +} diff --git a/crates/pet/Cargo.toml b/crates/pet/Cargo.toml new file mode 100644 index 00000000..9d8b5a92 --- /dev/null +++ b/crates/pet/Cargo.toml @@ -0,0 +1,6 @@ +[package] +name = "pet" +version = "0.1.0" +edition = "2021" + +[dependencies] diff --git a/crates/pet/src/lib.rs b/crates/pet/src/lib.rs new file mode 100644 index 00000000..e69de29b diff --git a/crates/pet/src/main.rs b/crates/pet/src/main.rs new file mode 100644 index 00000000..e7a11a96 --- /dev/null +++ b/crates/pet/src/main.rs @@ -0,0 +1,3 @@ +fn main() { + println!("Hello, world!"); +} From 905f4f72b4bce6ff92658589e5ea04b9cb6d7279 Mon Sep 17 00:00:00 2001 From: Don Jayamanne Date: Mon, 3 Jun 2024 23:39:37 +1000 Subject: [PATCH 2/3] More changes --- crates/pet-conda/Cargo.toml | 1 + crates/pet-conda/src/conda_rc.rs | 52 +- crates/pet-conda/src/environment_locations.rs | 103 +- crates/pet-conda/src/environments.rs | 122 +- crates/pet-conda/src/lib.rs | 3 +- crates/pet-conda/src/manager.rs | 18 +- crates/pet-conda/src/package.rs | 100 +- crates/pet-conda/src/utils.rs | 23 +- crates/pet-conda/tests/common.rs | 52 +- crates/pet-conda/tests/conda_rc_test.rs | 92 + .../tests/environment_locations_test.rs | 19 +- crates/pet-conda/tests/environments_test.rs | 74 + crates/pet-conda/tests/package_test.rs | 6 + .../conda_envs/user_home/miniconda3/bin/conda | 0 .../user_home/miniconda3/bin/python | 0 .../user_home/miniconda3/bin/python3 | 0 .../user_home/miniconda3/bin/python3.1 | 0 .../user_home/miniconda3/bin/python3.10 | 0 .../conda-23.1.0-py310hca03da5_0.json | 575 + .../conda-build-3.23.3-py310hca03da5_0.json | 292 + .../user_home/miniconda3/conda-meta/history | 428 + .../pytest-7.1.2-py310hca03da5_0.json | 209 + .../conda-meta/python-3.10.9-hc0d8a6c_1.json | 2222 +++ .../python-dateutil-2.8.2-pyhd3eb1b0_0.json | 159 + ...fastjsonschema-2.16.2-py310hca03da5_0.json | 66 + .../user_home/miniconda3/condabin/conda | 0 .../miniconda3/envs/env_python_3/bin/conda | 0 .../miniconda3/envs/env_python_3/bin/python | 0 .../miniconda3/envs/env_python_3/bin/python3 | 0 .../envs/env_python_3/bin/python3.1 | 0 .../envs/env_python_3/bin/python3.12 | 0 .../envs/env_python_3/conda-meta/history | 62 + .../pygments-2.17.2-pyhd8ed1ab_0.json | 4285 ++++ .../python-3.12.2-hdf0ec26_0_cpython.json | 15444 +++++++++++++++ .../python-dateutil-2.8.2-pyhd8ed1ab_0.json | 350 + .../conda-meta/python_abi-3.12-4_cp312.json | 31 + .../miniconda3/envs/myenv/bin/python | 0 .../miniconda3/envs/myenv/bin/python3 | 0 .../miniconda3/envs/myenv/bin/python3.1 | 0 .../miniconda3/envs/myenv/bin/python3.10 | 0 .../miniconda3/envs/myenv/conda-meta/history | 19 + .../conda-meta/pip-24.0-py310hca03da5_0.json | 8143 ++++++++ .../conda-meta/python-3.10.14-hb885b13_1.json | 16514 ++++++++++++++++ .../conda-meta/readline-8.2-h1a28f6b_0.json | 241 + .../envs/without_python/conda-meta/history | 3 + .../tests/unix/conda_rc/user_home/.condarc | 3 + .../user_home/.condarc | 3 + .../conda_root_variable_path/.condarc | 3 + .../conda_rc_root/root/etc/conda/.condarc | 3 + .../unix/conda_rc_root/user_home/.condarc | 3 + crates/pet-conda/tests/utils_test.rs | 7 +- crates/pet-core/src/python_environment.rs | 32 +- 52 files changed, 49528 insertions(+), 234 deletions(-) create mode 100644 crates/pet-conda/tests/conda_rc_test.rs create mode 100644 crates/pet-conda/tests/environments_test.rs create mode 100644 crates/pet-conda/tests/unix/conda_envs/user_home/miniconda3/bin/conda create mode 100644 crates/pet-conda/tests/unix/conda_envs/user_home/miniconda3/bin/python create mode 100644 crates/pet-conda/tests/unix/conda_envs/user_home/miniconda3/bin/python3 create mode 100644 crates/pet-conda/tests/unix/conda_envs/user_home/miniconda3/bin/python3.1 create mode 100644 crates/pet-conda/tests/unix/conda_envs/user_home/miniconda3/bin/python3.10 create mode 100644 crates/pet-conda/tests/unix/conda_envs/user_home/miniconda3/conda-meta/conda-23.1.0-py310hca03da5_0.json create mode 100644 crates/pet-conda/tests/unix/conda_envs/user_home/miniconda3/conda-meta/conda-build-3.23.3-py310hca03da5_0.json create mode 100644 crates/pet-conda/tests/unix/conda_envs/user_home/miniconda3/conda-meta/history create mode 100644 crates/pet-conda/tests/unix/conda_envs/user_home/miniconda3/conda-meta/pytest-7.1.2-py310hca03da5_0.json create mode 100644 crates/pet-conda/tests/unix/conda_envs/user_home/miniconda3/conda-meta/python-3.10.9-hc0d8a6c_1.json create mode 100644 crates/pet-conda/tests/unix/conda_envs/user_home/miniconda3/conda-meta/python-dateutil-2.8.2-pyhd3eb1b0_0.json create mode 100644 crates/pet-conda/tests/unix/conda_envs/user_home/miniconda3/conda-meta/python-fastjsonschema-2.16.2-py310hca03da5_0.json create mode 100644 crates/pet-conda/tests/unix/conda_envs/user_home/miniconda3/condabin/conda create mode 100644 crates/pet-conda/tests/unix/conda_envs/user_home/miniconda3/envs/env_python_3/bin/conda create mode 100644 crates/pet-conda/tests/unix/conda_envs/user_home/miniconda3/envs/env_python_3/bin/python create mode 100644 crates/pet-conda/tests/unix/conda_envs/user_home/miniconda3/envs/env_python_3/bin/python3 create mode 100644 crates/pet-conda/tests/unix/conda_envs/user_home/miniconda3/envs/env_python_3/bin/python3.1 create mode 100644 crates/pet-conda/tests/unix/conda_envs/user_home/miniconda3/envs/env_python_3/bin/python3.12 create mode 100644 crates/pet-conda/tests/unix/conda_envs/user_home/miniconda3/envs/env_python_3/conda-meta/history create mode 100644 crates/pet-conda/tests/unix/conda_envs/user_home/miniconda3/envs/env_python_3/conda-meta/pygments-2.17.2-pyhd8ed1ab_0.json create mode 100644 crates/pet-conda/tests/unix/conda_envs/user_home/miniconda3/envs/env_python_3/conda-meta/python-3.12.2-hdf0ec26_0_cpython.json create mode 100644 crates/pet-conda/tests/unix/conda_envs/user_home/miniconda3/envs/env_python_3/conda-meta/python-dateutil-2.8.2-pyhd8ed1ab_0.json create mode 100644 crates/pet-conda/tests/unix/conda_envs/user_home/miniconda3/envs/env_python_3/conda-meta/python_abi-3.12-4_cp312.json create mode 100644 crates/pet-conda/tests/unix/conda_envs/user_home/miniconda3/envs/myenv/bin/python create mode 100644 crates/pet-conda/tests/unix/conda_envs/user_home/miniconda3/envs/myenv/bin/python3 create mode 100644 crates/pet-conda/tests/unix/conda_envs/user_home/miniconda3/envs/myenv/bin/python3.1 create mode 100644 crates/pet-conda/tests/unix/conda_envs/user_home/miniconda3/envs/myenv/bin/python3.10 create mode 100644 crates/pet-conda/tests/unix/conda_envs/user_home/miniconda3/envs/myenv/conda-meta/history create mode 100644 crates/pet-conda/tests/unix/conda_envs/user_home/miniconda3/envs/myenv/conda-meta/pip-24.0-py310hca03da5_0.json create mode 100644 crates/pet-conda/tests/unix/conda_envs/user_home/miniconda3/envs/myenv/conda-meta/python-3.10.14-hb885b13_1.json create mode 100644 crates/pet-conda/tests/unix/conda_envs/user_home/miniconda3/envs/myenv/conda-meta/readline-8.2-h1a28f6b_0.json create mode 100644 crates/pet-conda/tests/unix/conda_envs/user_home/miniconda3/envs/without_python/conda-meta/history create mode 100644 crates/pet-conda/tests/unix/conda_rc/user_home/.condarc create mode 100644 crates/pet-conda/tests/unix/conda_rc_conda_root_var/user_home/.condarc create mode 100644 crates/pet-conda/tests/unix/conda_rc_conda_root_var/user_home/conda_root_variable_path/.condarc create mode 100644 crates/pet-conda/tests/unix/conda_rc_root/root/etc/conda/.condarc create mode 100644 crates/pet-conda/tests/unix/conda_rc_root/user_home/.condarc diff --git a/crates/pet-conda/Cargo.toml b/crates/pet-conda/Cargo.toml index 6b1a06aa..aefc3235 100644 --- a/crates/pet-conda/Cargo.toml +++ b/crates/pet-conda/Cargo.toml @@ -8,5 +8,6 @@ serde = { version = "1.0.152", features = ["derive"] } serde_json = "1.0.93" lazy_static = "1.4.0" pet-core = { path = "../pet-core" } +pet-utils = { path = "../pet-utils" } log = "0.4.21" regex = "1.10.4" diff --git a/crates/pet-conda/src/conda_rc.rs b/crates/pet-conda/src/conda_rc.rs index 9a426194..4e7f6689 100644 --- a/crates/pet-conda/src/conda_rc.rs +++ b/crates/pet-conda/src/conda_rc.rs @@ -1,8 +1,8 @@ // Copyright (c) Microsoft Corporation. All rights reserved. // Licensed under the MIT License. +use crate::utils::CondaEnvironmentVariables; use log::trace; -use pet_core::os_environment::Environment; use std::{fs, path::PathBuf}; #[derive(Debug)] @@ -10,8 +10,14 @@ pub struct Condarc { pub env_dirs: Vec, } +impl Condarc { + pub fn from(environment: &CondaEnvironmentVariables) -> Option { + get_conda_conda_rc(environment) + } +} + #[cfg(windows)] -fn get_conda_rc_search_paths(environment: &dyn Environment) -> Vec { +fn get_conda_rc_search_paths(environment: &CondaEnvironmentVariables) -> Vec { let mut search_paths: Vec = vec![ "C:\\ProgramData\\conda\\.condarc", "C:\\ProgramData\\conda\\condarc", @@ -21,14 +27,14 @@ fn get_conda_rc_search_paths(environment: &dyn Environment) -> Vec { .map(|p| PathBuf::from(p)) .collect(); - if let Some(conda_root) = environment.get_env_var("CONDA_ROOT".to_string()) { + if let Some(ref conda_root) = environment.conda_root { search_paths.append(&mut vec![ PathBuf::from(conda_root.clone()).join(".condarc"), PathBuf::from(conda_root.clone()).join("condarc"), PathBuf::from(conda_root.clone()).join(".condarc.d"), ]); } - if let Some(home) = environment.get_user_home() { + if let Some(ref home) = environment.home { search_paths.append(&mut vec![ home.join(".config").join("conda").join(".condarc"), home.join(".config").join("conda").join("condarc"), @@ -39,35 +45,37 @@ fn get_conda_rc_search_paths(environment: &dyn Environment) -> Vec { home.join(".condarc"), ]); } - if let Some(conda_prefix) = environment.get_env_var("CONDA_PREFIX".to_string()) { + if let Some(ref conda_prefix) = environment.conda_prefix { search_paths.append(&mut vec![ PathBuf::from(conda_prefix.clone()).join(".condarc"), PathBuf::from(conda_prefix.clone()).join("condarc"), PathBuf::from(conda_prefix.clone()).join(".condarc.d"), ]); } - if let Some(condarc) = environment.get_env_var("CONDARC".to_string()) { + if let Some(ref condarc) = environment.condarc { search_paths.append(&mut vec![PathBuf::from(condarc)]); } search_paths } + #[cfg(unix)] -fn get_conda_rc_search_paths(environment: &dyn Environment) -> Vec { +fn get_conda_rc_search_paths(environment: &CondaEnvironmentVariables) -> Vec { let mut search_paths: Vec = vec![ "/etc/conda/.condarc", "/etc/conda/condarc", - "/etc/conda/condarc.d/", + "/etc/conda/condarc.d", "/var/lib/conda/.condarc", "/var/lib/conda/condarc", - "/var/lib/conda/condarc.d/", + "/var/lib/conda/condarc.d", ] .iter() .map(|p| PathBuf::from(p)) .map(|p| { // This only applies in tests. // We need this, as the root folder cannot be mocked. - if let Some(root) = environment.get_root() { + if let Some(ref root) = environment.root { + // Strip the first `/` (this path is only for testing purposes) root.join(p.to_string_lossy()[1..].to_string()) } else { p @@ -75,21 +83,21 @@ fn get_conda_rc_search_paths(environment: &dyn Environment) -> Vec { }) .collect(); - if let Some(conda_root) = environment.get_env_var("CONDA_ROOT".to_string()) { + if let Some(ref conda_root) = environment.conda_root { search_paths.append(&mut vec![ PathBuf::from(conda_root.clone()).join(".condarc"), PathBuf::from(conda_root.clone()).join("condarc"), PathBuf::from(conda_root.clone()).join(".condarc.d"), ]); } - if let Some(xdg_config_home) = environment.get_env_var("XDG_CONFIG_HOME".to_string()) { + if let Some(ref xdg_config_home) = environment.xdg_config_home { search_paths.append(&mut vec![ PathBuf::from(xdg_config_home.clone()).join(".condarc"), PathBuf::from(xdg_config_home.clone()).join("condarc"), PathBuf::from(xdg_config_home.clone()).join(".condarc.d"), ]); } - if let Some(home) = environment.get_user_home() { + if let Some(ref home) = environment.home { search_paths.append(&mut vec![ home.join(".config").join("conda").join(".condarc"), home.join(".config").join("conda").join("condarc"), @@ -100,14 +108,14 @@ fn get_conda_rc_search_paths(environment: &dyn Environment) -> Vec { home.join(".condarc"), ]); } - if let Some(conda_prefix) = environment.get_env_var("CONDA_PREFIX".to_string()) { + if let Some(ref conda_prefix) = environment.conda_prefix { search_paths.append(&mut vec![ PathBuf::from(conda_prefix.clone()).join(".condarc"), PathBuf::from(conda_prefix.clone()).join("condarc"), PathBuf::from(conda_prefix.clone()).join(".condarc.d"), ]); } - if let Some(condarc) = environment.get_env_var("CONDARC".to_string()) { + if let Some(ref condarc) = environment.condarc { search_paths.append(&mut vec![PathBuf::from(condarc)]); } @@ -121,10 +129,14 @@ fn get_conda_rc_search_paths(environment: &dyn Environment) -> Vec { * TODO: Search for the .condarc file in the following locations: * https://conda.io/projects/conda/en/latest/user-guide/configuration/use-condarc.html#searching-for-condarc */ -pub fn get_conda_conda_rc(environment: &dyn Environment) -> Option { +fn get_conda_conda_rc(environment: &CondaEnvironmentVariables) -> Option { let conda_rc = get_conda_rc_search_paths(environment) .into_iter() - .find(|p| p.exists())?; + .find(|p: &PathBuf| p.exists())?; + parse_conda_rc(&conda_rc) +} + +fn parse_conda_rc(conda_rc: &PathBuf) -> Option { let mut start_consuming_values = false; trace!("conda_rc: {:?}", conda_rc); let reader = fs::read_to_string(conda_rc).ok()?; @@ -137,10 +149,8 @@ pub fn get_conda_conda_rc(environment: &dyn Environment) -> Option { if start_consuming_values { if line.trim().starts_with("-") { if let Some(env_dir) = line.splitn(2, '-').nth(1) { - let env_dir = PathBuf::from(env_dir.trim()).join("envs"); - if fs::metadata(&env_dir).is_ok() { - env_dirs.push(env_dir); - } + // Directories in conda-rc are where `envs` are stored. + env_dirs.push(PathBuf::from(env_dir.trim()).join("envs")); } continue; } else { diff --git a/crates/pet-conda/src/environment_locations.rs b/crates/pet-conda/src/environment_locations.rs index 9e740ce1..46859615 100644 --- a/crates/pet-conda/src/environment_locations.rs +++ b/crates/pet-conda/src/environment_locations.rs @@ -2,28 +2,17 @@ // Licensed under the MIT License. use crate::{ - conda_rc::get_conda_conda_rc, - utils::{is_conda_env, is_conda_install}, + conda_rc::Condarc, + utils::{is_conda_env, is_conda_install, CondaEnvironmentVariables}, }; use log::trace; -use pet_core::os_environment::Environment; use std::{ fs, path::{Path, PathBuf}, + thread, }; -// use super::conda_rc::get_conda_conda_rc; -// use crate::{ -// conda::{is_conda_env_location, is_conda_install_location}, -// known::Environment, -// }; -// use log::trace; -// use std::{ -// collections::HashSet, -// path::{Path, PathBuf}, -// }; - -pub fn get_conda_environment_paths(environment: &dyn Environment) -> Vec { +pub fn get_conda_environment_paths(environment: &CondaEnvironmentVariables) -> Vec { let mut env_paths = get_conda_envs_from_environment_txt(environment) .iter() .map(|e| PathBuf::from(e)) @@ -38,16 +27,26 @@ pub fn get_conda_environment_paths(environment: &dyn Environment) -> Vec Vec/.conda/envs * /AppData/Local/conda/conda/envs */ -pub fn get_conda_environment_paths_from_conda_rc(environment: &dyn Environment) -> Vec { - if let Some(paths) = get_conda_conda_rc(environment) { - paths.env_dirs +pub fn get_conda_environment_paths_from_conda_rc( + environment: &CondaEnvironmentVariables, +) -> Vec { + if let Some(conda_rc) = Condarc::from(environment) { + conda_rc.env_dirs } else { vec![] } } -pub fn get_conda_environment_paths_from_known_paths(environment: &dyn Environment) -> Vec { +pub fn get_conda_environment_paths_from_known_paths( + environment: &CondaEnvironmentVariables, +) -> Vec { let mut env_paths: Vec = vec![]; - if let Some(home) = environment.get_user_home() { + if let Some(ref home) = environment.home { let known_conda_paths = [ PathBuf::from(".conda").join("envs"), PathBuf::from("AppData") @@ -92,7 +95,7 @@ pub fn get_conda_environment_paths_from_known_paths(environment: &dyn Environmen return env_paths; } -pub fn get_environments_in_conda_dir(conda_dir: &Path) -> Vec { +pub fn get_environments(conda_dir: &Path) -> Vec { let mut envs: Vec = vec![]; if is_conda_install(conda_dir) { @@ -114,9 +117,11 @@ pub fn get_environments_in_conda_dir(conda_dir: &Path) -> Vec { envs } -pub fn get_conda_envs_from_environment_txt(environment: &dyn Environment) -> Vec { +pub fn get_conda_envs_from_environment_txt( + environment: &CondaEnvironmentVariables, +) -> Vec { let mut envs: Vec = vec![]; - if let Some(home) = environment.get_user_home() { + if let Some(ref home) = environment.home { let home = Path::new(&home); let environment_txt = home.join(".conda").join("environments.txt"); if let Ok(reader) = fs::read_to_string(environment_txt.clone()) { @@ -131,13 +136,11 @@ pub fn get_conda_envs_from_environment_txt(environment: &dyn Environment) -> Vec } #[cfg(windows)] -pub fn get_known_conda_install_locations(environment: &dyn Environment) -> Vec { - let user_profile = environment.get_env_var("USERPROFILE".to_string()).unwrap(); - let program_data = environment.get_env_var("PROGRAMDATA".to_string()).unwrap(); - let all_user_profile = environment - .get_env_var("ALLUSERSPROFILE".to_string()) - .unwrap(); - let home_drive = environment.get_env_var("HOMEDRIVE".to_string()).unwrap(); +pub fn get_known_conda_install_locations(environment: &CondaEnvironmentVariables) -> Vec { + let user_profile = environment.userprofile.clone().unwrap_or_default(); + let program_data = environment.programdata.clone().unwrap_or_default(); + let all_user_profile = environment.allusersprofile.clone().unwrap_or_default(); + let home_drive = environment.homedrive.clone().unwrap_or_default(); let mut known_paths = vec![ Path::new(&user_profile).join("Anaconda3"), Path::new(&program_data).join("Anaconda3"), @@ -150,7 +153,7 @@ pub fn get_known_conda_install_locations(environment: &dyn Environment) -> Vec

Vec

Vec { +pub fn get_known_conda_install_locations(environment: &CondaEnvironmentVariables) -> Vec { let mut known_paths = vec![ PathBuf::from("/opt/anaconda3"), PathBuf::from("/opt/miniconda3"), @@ -175,23 +178,23 @@ pub fn get_known_conda_install_locations(environment: &dyn Environment) -> Vec

Vec { - let user_profile = environment.get_env_var("USERPROFILE".to_string()).unwrap(); - let program_data = environment.get_env_var("PROGRAMDATA".to_string()).unwrap(); - let all_user_profile = environment - .get_env_var("ALLUSERSPROFILE".to_string()) - .unwrap(); - let home_drive = environment.get_env_var("HOMEDRIVE".to_string()).unwrap(); +pub fn get_known_conda_locations(environment: &CondaEnvironmentVariables) -> Vec { + let user_profile = environment.userprofile.clone().unwrap_or_default(); + let program_data = environment.programdata.clone().unwrap_or_default(); + let all_user_profile = environment.allusersprofile.clone().unwrap_or_default(); + let home_drive = environment.homedrive.clone().unwrap_or_default(); let mut known_paths = vec![ Path::new(&user_profile).join("Anaconda3\\Scripts"), Path::new(&program_data).join("Anaconda3\\Scripts"), @@ -202,12 +205,12 @@ pub fn get_known_conda_locations(environment: &dyn Environment) -> Vec Path::new(&all_user_profile).join("Miniconda3\\Scripts"), Path::new(&home_drive).join("Miniconda3\\Scripts"), ]; - known_paths.append(&mut environment.get_know_global_search_locations()); + known_paths.append(&mut environment.known_global_search_locations.clone()); known_paths } #[cfg(unix)] -pub fn get_known_conda_locations(environment: &dyn Environment) -> Vec { +pub fn get_known_conda_locations(environment: &CondaEnvironmentVariables) -> Vec { let mut known_paths = vec![ PathBuf::from("/opt/anaconda3/bin"), PathBuf::from("/opt/miniconda3/bin"), @@ -220,10 +223,10 @@ pub fn get_known_conda_locations(environment: &dyn Environment) -> Vec PathBuf::from("/anaconda3/bin"), PathBuf::from("/miniconda3/bin"), ]; - if let Some(home) = environment.get_user_home() { + if let Some(ref home) = environment.home { known_paths.push(PathBuf::from(home.clone()).join("anaconda3/bin")); known_paths.push(PathBuf::from(home).join("miniconda3/bin")); } - known_paths.append(&mut environment.get_know_global_search_locations()); + known_paths.append(&mut environment.known_global_search_locations.clone()); known_paths } diff --git a/crates/pet-conda/src/environments.rs b/crates/pet-conda/src/environments.rs index 9d12ef0d..b4291e10 100644 --- a/crates/pet-conda/src/environments.rs +++ b/crates/pet-conda/src/environments.rs @@ -1,37 +1,44 @@ // Copyright (c) Microsoft Corporation. All rights reserved. // Licensed under the MIT License. -use super::{is_conda_env_location, is_conda_install_location, utils::get_conda_package_info}; use crate::{ - messaging::{ - Architecture, EnvManager, PythonEnvironment, PythonEnvironmentBuilder, - PythonEnvironmentCategory, - }, - utils::find_python_binary_path, + manager::CondaManager, + package::{CondaPackageInfo, Package}, + utils::{is_conda_env, is_conda_install}, }; -use std::path::PathBuf; +use pet_core::{ + arch::Architecture, + manager::EnvManager, + python_environment::{PythonEnvironment, PythonEnvironmentBuilder, PythonEnvironmentCategory}, +}; +use pet_utils::executable::find_executable; +use std::path::{Path, PathBuf}; #[derive(Debug, Clone)] pub struct CondaEnvironment { - pub env_path: PathBuf, - pub python_executable_path: Option, + pub prefix: PathBuf, + pub executable: Option, pub version: Option, - pub conda_install_folder: Option, + pub conda_dir: Option, pub arch: Option, } impl CondaEnvironment { + pub fn from(path: &Path, manager: &Option) -> Option { + get_conda_environment_info(&path.into(), manager) + } + pub fn to_python_environment( &self, conda_manager: EnvManager, - conda_manager_dir: &PathBuf, + conda_dir: &PathBuf, ) -> PythonEnvironment { #[allow(unused_assignments)] let mut name: Option = None; - if is_conda_install_location(&self.env_path) { + if is_conda_install(&self.prefix) { name = Some("base".to_string()); } else { - name = match self.env_path.file_name() { + name = match self.prefix.file_name() { Some(name) => Some(name.to_str().unwrap_or_default().to_string()), None => None, }; @@ -39,59 +46,64 @@ impl CondaEnvironment { // if the conda install folder is parent of the env folder, then we can use named activation. // E.g. conda env is = /envs/ // Then we can use `/bin/conda activate -n ` - if !self.env_path.starts_with(&conda_manager_dir) { + if !self.prefix.starts_with(&conda_dir) { name = None; } // This is a root env. let builder = PythonEnvironmentBuilder::new(PythonEnvironmentCategory::Conda) - .python_executable_path(self.python_executable_path.clone()) + .executable(self.executable.clone()) .version(self.version.clone()) - .env_path(Some(self.env_path.clone())) + .prefix(Some(self.prefix.clone())) .arch(self.arch.clone()) - .env_manager(Some(conda_manager.clone())) - .python_run_command(get_activation_command(self, &conda_manager, name.clone())); + .name(name.clone()) + .manager(Some(conda_manager.clone())); - if let Some(name) = name { - builder.name(name).build() - } else { - builder.build() - } + builder.build() } } -pub fn get_conda_environment_info(env_path: &PathBuf) -> Option { - if is_conda_env_location(env_path) { - let conda_install_folder = get_conda_installation_used_to_create_conda_env(env_path); - let env_path = env_path.clone(); - if let Some(python_binary) = find_python_binary_path(&env_path) { - if let Some(package_info) = get_conda_package_info(&env_path, "python") { - return Some(CondaEnvironment { - env_path, - python_executable_path: Some(python_binary), - version: Some(package_info.version), - conda_install_folder, - arch: package_info.arch, - }); - } else { - return Some(CondaEnvironment { - env_path, - python_executable_path: Some(python_binary), - version: None, - conda_install_folder, - arch: None, - }); - } +fn get_conda_environment_info( + env_path: &PathBuf, + manager: &Option, +) -> Option { + if !is_conda_env(env_path) { + // Not a conda environment (neither root nor a separate env). + return None; + } + // If we know the conda install folder, then we can use it. + let conda_install_folder = match manager { + Some(manager) => Some(manager.conda_dir.clone()), + None => get_conda_installation_used_to_create_conda_env(env_path), + }; + let env_path = env_path.clone(); + if let Some(python_binary) = find_executable(&env_path) { + if let Some(package_info) = CondaPackageInfo::from(&env_path, &Package::Python) { + return Some(CondaEnvironment { + prefix: env_path, + executable: Some(python_binary), + version: Some(package_info.version), + conda_dir: conda_install_folder, + arch: package_info.arch, + }); } else { + // No python in this environment. return Some(CondaEnvironment { - env_path, - python_executable_path: None, + prefix: env_path, + executable: Some(python_binary), version: None, - conda_install_folder, + conda_dir: conda_install_folder, arch: None, }); } + } else { + // No python in this environment. + return Some(CondaEnvironment { + prefix: env_path, + executable: None, + version: None, + conda_dir: conda_install_folder, + arch: None, + }); } - - None } /** @@ -104,13 +116,13 @@ pub fn get_conda_environment_info(env_path: &PathBuf) -> Option Option { // Possible the env_path is the root conda install folder. - if is_conda_install_location(env_path) { + if is_conda_install(env_path) { return Some(env_path.to_path_buf()); } // If this environment is in a folder named `envs`, then the parent directory of `envs` is the root conda install folder. if let Some(parent) = env_path.ancestors().nth(2) { - if is_conda_install_location(parent) { + if is_conda_install(parent) { return Some(parent.to_path_buf()); } } @@ -150,10 +162,10 @@ pub fn get_activation_command( manager: &EnvManager, name: Option, ) -> Option> { - if env.python_executable_path.is_none() { + if env.executable.is_none() { return None; } - let conda_exe = manager.executable_path.to_str().unwrap().to_string(); + let conda_exe = manager.executable.to_str().unwrap_or_default().to_string(); if let Some(name) = name { Some(vec![ conda_exe, @@ -167,7 +179,7 @@ pub fn get_activation_command( conda_exe, "run".to_string(), "-p".to_string(), - env.env_path.to_str().unwrap().to_string(), + env.prefix.to_str().unwrap().to_string(), "python".to_string(), ]) } diff --git a/crates/pet-conda/src/lib.rs b/crates/pet-conda/src/lib.rs index 76b1dab8..f535d0ce 100644 --- a/crates/pet-conda/src/lib.rs +++ b/crates/pet-conda/src/lib.rs @@ -3,8 +3,9 @@ pub mod conda_rc; pub mod environment_locations; -pub mod package; +pub mod environments; pub mod manager; +pub mod package; pub mod utils; pub fn add(left: usize, right: usize) -> usize { diff --git a/crates/pet-conda/src/manager.rs b/crates/pet-conda/src/manager.rs index 9a4ff150..5078cf95 100644 --- a/crates/pet-conda/src/manager.rs +++ b/crates/pet-conda/src/manager.rs @@ -1,15 +1,17 @@ // Copyright (c) Microsoft Corporation. All rights reserved. // Licensed under the MIT License. +use crate::{ + environment_locations::get_known_conda_locations, package::CondaPackageInfo, + utils::CondaEnvironmentVariables, +}; use log::warn; -use pet_core::{manager::EnvManager, manager::EnvManagerType, os_environment::Environment}; +use pet_core::{manager::EnvManager, manager::EnvManagerType}; use std::{ env, path::{Path, PathBuf}, }; -use crate::{environment_locations::get_known_conda_locations, package::CondaPackageInfo}; - fn get_conda_executable(path: &Path) -> Option { #[cfg(windows)] let relative_path_to_conda_exe = vec![ @@ -42,8 +44,8 @@ fn get_conda_bin_names() -> Vec<&'static str> { } /// Find the conda binary on the PATH environment variable -pub fn find_conda_binary_on_path(environment: &dyn Environment) -> Option { - let paths = environment.get_env_var("PATH".to_string())?; +pub fn find_conda_binary_on_path(environment: &CondaEnvironmentVariables) -> Option { + let paths = environment.path.clone()?; for path in env::split_paths(&paths) { for bin in get_conda_bin_names() { let conda_path = path.join(bin); @@ -58,7 +60,9 @@ pub fn find_conda_binary_on_path(environment: &dyn Environment) -> Option Option { +fn find_conda_binary_in_known_locations( + environment: &CondaEnvironmentVariables, +) -> Option { let conda_bin_names = get_conda_bin_names(); let known_locations = get_known_conda_locations(environment); for location in known_locations { @@ -75,7 +79,7 @@ fn find_conda_binary_in_known_locations(environment: &dyn Environment) -> Option } /// Find the conda binary on the system -pub fn find_conda_binary(environment: &dyn Environment) -> Option { +pub fn find_conda_binary(environment: &CondaEnvironmentVariables) -> Option { let conda_binary_on_path = find_conda_binary_on_path(environment); match conda_binary_on_path { Some(conda_binary_on_path) => Some(conda_binary_on_path), diff --git a/crates/pet-conda/src/package.rs b/crates/pet-conda/src/package.rs index a2dc26a7..2feaba86 100644 --- a/crates/pet-conda/src/package.rs +++ b/crates/pet-conda/src/package.rs @@ -10,9 +10,18 @@ use std::fs::read_to_string; use std::path::{Path, PathBuf}; lazy_static! { - static ref PYTHON_VERSION: Regex = Regex::new("^python-((\\d+\\.*)*)-.*.json$") + // Sample => python-3.12.2-hdf0ec26_0_cpython.json + static ref PYTHON_VERSION: Regex = Regex::new("^python-([\\d+\\.*]*)-.*.json$") .expect("error parsing Version regex for Python Package Version in conda"); - static ref CONDA_VERSION: Regex = Regex::new("^conda-((\\d+\\.*)*)-.*.json$") + // Sample => conda-23.1.0-py310hca03da5_0.json + static ref CONDA_VERSION: Regex = Regex::new("^conda-([\\d+\\.*]*)-.*.json$") + .expect("error parsing Version regex for Conda Package Version in conda"); + // Sample => +defaults::python-3.10.9-hc0d8a6c_1 + // Sample => +conda-forge/osx-arm64::python-3.12.2-hdf0ec26_0_cpython + static ref PYTHON_VERSION_IN_HISTORY: Regex = Regex::new(".*python-([\\d+\\.*]*)-(.*)") + .expect("error parsing Version regex for Python Package Version in conda"); + // Sample => +defaults::conda-23.1.0-py310hca03da5_0 + static ref CONDA_VERSION_IN_HISTORY: Regex = Regex::new(".*conda-([\\d+\\.*]*)-(.*)") .expect("error parsing Version regex for Conda Package Version in conda"); } @@ -69,7 +78,7 @@ fn get_conda_package_info(path: &Path, name: &Package) -> Option Option = None; - // Sample contents - // { - // "build": "h966fe2a_2", - // "build_number": 2, - // "channel": "https://repo.anaconda.com/pkgs/main/win-64", - // "constrains": [], - // } - // 32bit channel is https://repo.anaconda.com/pkgs/main/win-32/ - // 64bit channel is "channel": "https://repo.anaconda.com/pkgs/main/osx-arm64", - if let Some(contents) = read_to_string(&package_path).ok() { - if let Some(js) = - serde_json::from_str::(&contents).ok() - { - if let Some(channel) = js.channel { - if channel.ends_with("64") { - arch = Some(Architecture::X64); - } else if channel.ends_with("32") { - arch = Some(Architecture::X86); + let regex = get_package_version_history_regex(&name); + if let Some(captures) = regex.captures(&line) { + if let Some(version) = captures.get(1) { + if let Some(hash) = captures.get(2) { + let package_path = format!( + "{}-{}-{}.json", + name.to_name(), + version.as_str(), + hash.as_str() + ); + let package_path = path.join(package_path); + let mut arch: Option = None; + // Sample contents + // { + // "build": "h966fe2a_2", + // "build_number": 2, + // "channel": "https://repo.anaconda.com/pkgs/main/win-64", + // "constrains": [], + // } + // 32bit channel is https://repo.anaconda.com/pkgs/main/win-32/ + // 64bit channel is "channel": "https://repo.anaconda.com/pkgs/main/osx-arm64", + if let Some(contents) = read_to_string(&package_path).ok() { + if let Some(js) = + serde_json::from_str::(&contents).ok() + { + if let Some(channel) = js.channel { + if channel.ends_with("64") { + arch = Some(Architecture::X64); + } else if channel.ends_with("32") { + arch = Some(Architecture::X86); + } + } + if let Some(version) = js.version { + return Some(CondaPackageInfo { + package: name.clone(), + path: package_path, + version, + arch, + }); + } else { + warn!( + "Unable to find version for package {} in {:?}", + name, package_path + ); + } } } - if let Some(version) = js.version { - return Some(CondaPackageInfo { - package: name.clone(), - path: package_path, - version, - arch, - }); - } else { - warn!( - "Unable to find version for package {} in {:?}", - name, package_path - ); - } } } } @@ -180,3 +200,9 @@ fn get_package_version_regex(package: &Package) -> &Regex { Package::Python => &PYTHON_VERSION, } } +fn get_package_version_history_regex(package: &Package) -> &Regex { + match package { + Package::Conda => &CONDA_VERSION_IN_HISTORY, + Package::Python => &PYTHON_VERSION_IN_HISTORY, + } +} diff --git a/crates/pet-conda/src/utils.rs b/crates/pet-conda/src/utils.rs index 4f824258..302c5986 100644 --- a/crates/pet-conda/src/utils.rs +++ b/crates/pet-conda/src/utils.rs @@ -1,7 +1,10 @@ // Copyright (c) Microsoft Corporation. All rights reserved. // Licensed under the MIT License. -use std::{fs, path::Path}; +use std::{ + fs, + path::{Path, PathBuf}, +}; // conda-meta must exist as this contains a mandatory `history` file. pub fn is_conda_install(path: &Path) -> bool { @@ -17,3 +20,21 @@ pub fn is_conda_env(path: &Path) -> bool { false } } + +#[derive(Debug, Clone)] +// NOTE: Do not implt Default trait, as we do not want to ever forget to set the values. +// Lets be explicit, this way we never miss a value (in Windows or Unix). +pub struct CondaEnvironmentVariables { + pub home: Option, + pub root: Option, + pub path: Option, + pub userprofile: Option, + pub allusersprofile: Option, + pub programdata: Option, + pub homedrive: Option, + pub conda_root: Option, + pub conda_prefix: Option, + pub condarc: Option, + pub xdg_config_home: Option, + pub known_global_search_locations: Vec, +} diff --git a/crates/pet-conda/tests/common.rs b/crates/pet-conda/tests/common.rs index d9804384..0a81f4b6 100644 --- a/crates/pet-conda/tests/common.rs +++ b/crates/pet-conda/tests/common.rs @@ -1,9 +1,8 @@ // Copyright (c) Microsoft Corporation. // Licensed under the MIT License. -use std::{collections::HashMap, path::PathBuf}; - -use pet_core::os_environment::Environment; +use pet_conda::utils::CondaEnvironmentVariables; +use std::path::PathBuf; #[allow(dead_code)] pub fn resolve_test_path(paths: &[&str]) -> PathBuf { @@ -15,38 +14,19 @@ pub fn resolve_test_path(paths: &[&str]) -> PathBuf { } #[allow(dead_code)] -#[derive(Debug)] -pub struct TestEnvironment { - vars: HashMap, - home: Option, - root: Option, - globals_locations: Vec, -} -#[allow(dead_code)] -pub fn create_test_environment( - root: Option, - home: Option, - vars: HashMap, - globals_locations: Vec, -) -> TestEnvironment { - impl Environment for TestEnvironment { - fn get_env_var(&self, key: String) -> Option { - self.vars.get(&key).cloned() - } - fn get_root(&self) -> Option { - self.root.clone() - } - fn get_user_home(&self) -> Option { - self.home.clone() - } - fn get_know_global_search_locations(&self) -> Vec { - self.globals_locations.clone() - } - } - TestEnvironment { - vars, - home, - root, - globals_locations, +pub fn create_env_variables(home: PathBuf, root: PathBuf) -> CondaEnvironmentVariables { + CondaEnvironmentVariables { + home: Some(home), + root: Some(root), + allusersprofile: None, + conda_prefix: None, + conda_root: None, + condarc: None, + homedrive: None, + known_global_search_locations: vec![], + path: None, + programdata: None, + userprofile: None, + xdg_config_home: None, } } diff --git a/crates/pet-conda/tests/conda_rc_test.rs b/crates/pet-conda/tests/conda_rc_test.rs new file mode 100644 index 00000000..5b9d6a11 --- /dev/null +++ b/crates/pet-conda/tests/conda_rc_test.rs @@ -0,0 +1,92 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +mod common; +use common::resolve_test_path; +use pet_conda::conda_rc::Condarc; +use std::path::PathBuf; + +#[cfg(unix)] +#[test] +fn no_conda_rc() { + use common::create_env_variables; + + let root = resolve_test_path(&["unix", "root_empty"]); + let home = resolve_test_path(&["unix", "user_home_with_environments_txt"]); + let env = create_env_variables(home, root); + + let conda_rc = Condarc::from(&env); + + assert!(conda_rc.is_none()); +} + +#[cfg(unix)] +#[test] +fn finds_conda_rc() { + use common::create_env_variables; + + let root = resolve_test_path(&["unix", "conda_rc", "root"]); + let home = resolve_test_path(&["unix", "conda_rc", "user_home"]); + let env = create_env_variables(home, root); + + let conda_rc = Condarc::from(&env).unwrap(); + + assert_eq!( + conda_rc.env_dirs, + vec![ + PathBuf::from("/Users/donjayamanne/temp/sample-conda-envs-folder2/envs"), + PathBuf::from("/Users/donjayamanne/temp/sample-conda-envs-folder/envs") + ] + ); +} + +#[cfg(unix)] +#[test] +fn finds_conda_rc_from_conda_root_env_variable() { + use common::create_env_variables; + + let root = resolve_test_path(&["unix", "conda_rc_conda_root_var", "root"]); + let home = resolve_test_path(&["unix", "conda_rc_conda_root_var", "user_home"]); + let mut env = create_env_variables(home, root); + env.conda_root = Some( + resolve_test_path(&[ + "unix", + "conda_rc_conda_root_var", + "user_home", + "conda_root_variable_path", + ]) + .to_str() + .unwrap_or_default() + .to_string(), + ); + + let conda_rc = Condarc::from(&env).unwrap(); + + assert_eq!( + conda_rc.env_dirs, + vec![ + PathBuf::from("/Users/donjayamanne/sample-conda-envs-folder2-from_conda_root/envs"), + PathBuf::from("/Users/donjayamanne/sample-conda-envs-folder-from_conda_root/envs") + ] + ); +} + +#[cfg(unix)] +#[test] +fn finds_conda_rc_from_root() { + use common::create_env_variables; + + let root = resolve_test_path(&["unix", "conda_rc_root", "root"]); + let home = resolve_test_path(&["unix", "conda_rc_root", "user_home"]); + let env = create_env_variables(home, root); + + let conda_rc = Condarc::from(&env).unwrap(); + + assert_eq!( + conda_rc.env_dirs, + vec![ + PathBuf::from("/Users/donjayamanne/root-folder2/envs"), + PathBuf::from("/Users/donjayamanne/root-folder/envs") + ] + ); +} diff --git a/crates/pet-conda/tests/environment_locations_test.rs b/crates/pet-conda/tests/environment_locations_test.rs index 8218d5a6..f1f64050 100644 --- a/crates/pet-conda/tests/environment_locations_test.rs +++ b/crates/pet-conda/tests/environment_locations_test.rs @@ -2,17 +2,18 @@ // Licensed under the MIT License. mod common; -use common::{create_test_environment, resolve_test_path}; +use common::{create_env_variables, resolve_test_path}; use pet_conda::environment_locations::{ - get_conda_envs_from_environment_txt, get_environments_in_conda_dir, get_known_conda_locations, + get_conda_envs_from_environment_txt, get_environments, get_known_conda_locations, }; -use std::{collections::HashMap, path::PathBuf}; +use std::path::PathBuf; +#[cfg(unix)] #[test] fn read_environment_txt() { let root = resolve_test_path(&["unix", "root_empty"]).into(); let home = resolve_test_path(&["unix", "user_home_with_environments_txt"]).into(); - let env = create_test_environment(root, home, HashMap::new(), vec![]); + let env = create_env_variables(home, root); let mut environments = get_conda_envs_from_environment_txt(&env); environments.sort(); @@ -49,22 +50,24 @@ fn read_environment_txt() { assert_eq!(environments, expected); } +#[cfg(unix)] #[test] fn non_existent_envrionments_txt() { let root = resolve_test_path(&["unix", "root_empty"]).into(); let home = resolve_test_path(&["unix", "bogus directory"]).into(); - let env = create_test_environment(root, home, HashMap::new(), vec![]); + let env = create_env_variables(home, root); let environments = get_conda_envs_from_environment_txt(&env); assert_eq!(environments.len(), 0); } +#[cfg(unix)] #[test] fn known_install_locations() { let root = resolve_test_path(&["unix", "root_empty"]).into(); let home = resolve_test_path(&["unix", "user_home"]).into(); - let env = create_test_environment(root, home, HashMap::new(), vec![]); + let env = create_env_variables(home, root); let mut locations = get_known_conda_locations(&env); locations.sort(); @@ -96,11 +99,12 @@ fn known_install_locations() { assert_eq!(locations, expected); } +#[cfg(unix)] #[test] fn list_conda_envs_in_install_location() { let path = resolve_test_path(&["unix", "anaconda3-2023.03"]); - let mut locations = get_environments_in_conda_dir(&path); + let mut locations = get_environments(&path); locations.sort(); assert_eq!( @@ -117,7 +121,6 @@ fn list_conda_envs_in_install_location() { // #[test] // fn get_conda_environment_paths_test() { // let now = SystemTime::now(); - // let env = EnvironmentApi {}; // let envs = get_conda_environment_paths(&env); // println!("{:?}", envs); diff --git a/crates/pet-conda/tests/environments_test.rs b/crates/pet-conda/tests/environments_test.rs new file mode 100644 index 00000000..c1d8bb13 --- /dev/null +++ b/crates/pet-conda/tests/environments_test.rs @@ -0,0 +1,74 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +mod common; +use common::resolve_test_path; +use pet_conda::environments::CondaEnvironment; +use pet_core::arch::Architecture; + +#[cfg(unix)] +#[test] +fn resolve_root_conda_env() { + let path = resolve_test_path(&["unix", "anaconda3-2023.03"]); + + let env = CondaEnvironment::from(&path, &None).unwrap(); + + assert_eq!(env.prefix, path.clone()); + assert_eq!(env.arch, Some(Architecture::X64)); + assert_eq!(env.conda_dir, Some(path.clone())); + assert_eq!( + env.executable, + Some(path.clone().join("bin").join("python")) + ); + assert_eq!(env.version, Some("3.10.9".into())); +} + +#[cfg(unix)] +#[test] +fn resolve_root_conda_env_without_history_file() { + let path = resolve_test_path(&["unix", "anaconda3-2023.03-without-history"]); + + let env = CondaEnvironment::from(&path, &None).unwrap(); + + assert_eq!(env.prefix, path.clone()); + assert_eq!(env.arch, Some(Architecture::X64)); + assert_eq!(env.conda_dir, Some(path.clone())); + assert_eq!( + env.executable, + Some(path.clone().join("bin").join("python")) + ); + assert_eq!(env.version, Some("3.10.9".into())); +} + +#[cfg(unix)] +#[test] +fn resolve_conda_env() { + let conda_dir = resolve_test_path(&["unix", "anaconda3-2023.03"]); + let path = resolve_test_path(&["unix", "anaconda3-2023.03", "envs", "env_python_3"]); + + let env = CondaEnvironment::from(&path, &None).unwrap(); + + assert_eq!(env.prefix, path.clone()); + assert_eq!(env.arch, Some(Architecture::X64)); + assert_eq!(env.conda_dir, Some(conda_dir.clone())); + assert_eq!( + env.executable, + Some(path.clone().join("bin").join("python")) + ); + assert_eq!(env.version, Some("3.12.2".into())); +} + +#[cfg(unix)] +#[test] +fn resolve_conda_env_without_python() { + let conda_dir = resolve_test_path(&["unix", "anaconda3-2023.03"]); + let path = resolve_test_path(&["unix", "anaconda3-2023.03", "envs", "without_python"]); + + let env = CondaEnvironment::from(&path, &None).unwrap(); + + assert_eq!(env.prefix, path.clone()); + assert_eq!(env.arch, None); + assert_eq!(env.conda_dir, Some(conda_dir.clone())); + assert_eq!(env.executable, None); + assert_eq!(env.version, None); +} diff --git a/crates/pet-conda/tests/package_test.rs b/crates/pet-conda/tests/package_test.rs index 25a65cfc..828c07a9 100644 --- a/crates/pet-conda/tests/package_test.rs +++ b/crates/pet-conda/tests/package_test.rs @@ -7,6 +7,7 @@ use std::path::PathBuf; use common::resolve_test_path; +#[cfg(unix)] #[test] fn empty_result_for_bogus_paths() { let path: PathBuf = resolve_test_path(&["unix", "bogus_path"]).into(); @@ -15,6 +16,7 @@ fn empty_result_for_bogus_paths() { assert!(pkg.is_none()); } +#[cfg(unix)] #[test] fn get_conda_package_info() { let path: PathBuf = resolve_test_path(&["unix", "anaconda3-2023.03"]).into(); @@ -33,6 +35,7 @@ fn get_conda_package_info() { ); } +#[cfg(unix)] #[test] fn get_python_package_info() { let path: PathBuf = resolve_test_path(&["unix", "anaconda3-2023.03"]).into(); @@ -50,6 +53,8 @@ fn get_python_package_info() { ]) ); } + +#[cfg(unix)] #[test] fn get_conda_package_info_without_history() { let path: PathBuf = resolve_test_path(&["unix", "anaconda3-2023.03-without-history"]).into(); @@ -68,6 +73,7 @@ fn get_conda_package_info_without_history() { ); } +#[cfg(unix)] #[test] fn get_python_package_info_without_history() { let path: PathBuf = resolve_test_path(&["unix", "anaconda3-2023.03-without-history"]).into(); diff --git a/crates/pet-conda/tests/unix/conda_envs/user_home/miniconda3/bin/conda b/crates/pet-conda/tests/unix/conda_envs/user_home/miniconda3/bin/conda new file mode 100644 index 00000000..e69de29b diff --git a/crates/pet-conda/tests/unix/conda_envs/user_home/miniconda3/bin/python b/crates/pet-conda/tests/unix/conda_envs/user_home/miniconda3/bin/python new file mode 100644 index 00000000..e69de29b diff --git a/crates/pet-conda/tests/unix/conda_envs/user_home/miniconda3/bin/python3 b/crates/pet-conda/tests/unix/conda_envs/user_home/miniconda3/bin/python3 new file mode 100644 index 00000000..e69de29b diff --git a/crates/pet-conda/tests/unix/conda_envs/user_home/miniconda3/bin/python3.1 b/crates/pet-conda/tests/unix/conda_envs/user_home/miniconda3/bin/python3.1 new file mode 100644 index 00000000..e69de29b diff --git a/crates/pet-conda/tests/unix/conda_envs/user_home/miniconda3/bin/python3.10 b/crates/pet-conda/tests/unix/conda_envs/user_home/miniconda3/bin/python3.10 new file mode 100644 index 00000000..e69de29b diff --git a/crates/pet-conda/tests/unix/conda_envs/user_home/miniconda3/conda-meta/conda-23.1.0-py310hca03da5_0.json b/crates/pet-conda/tests/unix/conda_envs/user_home/miniconda3/conda-meta/conda-23.1.0-py310hca03da5_0.json new file mode 100644 index 00000000..0ab7e321 --- /dev/null +++ b/crates/pet-conda/tests/unix/conda_envs/user_home/miniconda3/conda-meta/conda-23.1.0-py310hca03da5_0.json @@ -0,0 +1,575 @@ +{ + "build": "py310hca03da5_0", + "build_number": 0, + "channel": "https://repo.anaconda.com/pkgs/main/osx-arm64", + "constrains": [ + "conda-content-trust >=0.1.1", + "cytoolz >=0.8.1", + "conda-env >=2.6", + "conda-libmamba-solver >=22.12.0", + "conda-build >=3" + ], + "depends": [ + "conda-package-handling >=1.3.0", + "pluggy >=1.0.0", + "pycosat >=0.6.3", + "pyopenssl >=16.2.0", + "python >=3.10,<3.11.0a0", + "requests >=2.20.1,<3", + "ruamel.yaml >=0.11.14,<0.18", + "setuptools >=31.0.1", + "toolz >=0.8.1", + "tqdm >=4" + ], + "extracted_package_dir": "/Users/donjayamanne/.pyenv/versions/anaconda3-2023.03/pkgs/conda-23.1.0-py310hca03da5_0", + "features": "", + "files": [ + "bin/activate", + "bin/conda", + "bin/conda-env", + "bin/deactivate", + "condabin/conda", + "etc/fish/conf.d/conda.fish", + "etc/profile.d/conda.csh", + "etc/profile.d/conda.sh", + "lib/python3.10/site-packages/conda-23.1.0-py3.10.egg-info/PKG-INFO", + "lib/python3.10/site-packages/conda-23.1.0-py3.10.egg-info/SOURCES.txt", + "lib/python3.10/site-packages/conda-23.1.0-py3.10.egg-info/dependency_links.txt", + "lib/python3.10/site-packages/conda-23.1.0-py3.10.egg-info/entry_points.txt", + "lib/python3.10/site-packages/conda-23.1.0-py3.10.egg-info/not-zip-safe", + "lib/python3.10/site-packages/conda-23.1.0-py3.10.egg-info/requires.txt", + "lib/python3.10/site-packages/conda-23.1.0-py3.10.egg-info/top_level.txt", + "lib/python3.10/site-packages/conda/.version", + "lib/python3.10/site-packages/conda/__init__.py", + "lib/python3.10/site-packages/conda/__main__.py", + "lib/python3.10/site-packages/conda/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/conda/__pycache__/__main__.cpython-310.pyc", + "lib/python3.10/site-packages/conda/__pycache__/activate.cpython-310.pyc", + "lib/python3.10/site-packages/conda/__pycache__/api.cpython-310.pyc", + "lib/python3.10/site-packages/conda/__pycache__/exceptions.cpython-310.pyc", + "lib/python3.10/site-packages/conda/__pycache__/exports.cpython-310.pyc", + "lib/python3.10/site-packages/conda/__pycache__/history.cpython-310.pyc", + "lib/python3.10/site-packages/conda/__pycache__/instructions.cpython-310.pyc", + "lib/python3.10/site-packages/conda/__pycache__/lock.cpython-310.pyc", + "lib/python3.10/site-packages/conda/__pycache__/misc.cpython-310.pyc", + "lib/python3.10/site-packages/conda/__pycache__/plan.cpython-310.pyc", + "lib/python3.10/site-packages/conda/__pycache__/resolve.cpython-310.pyc", + "lib/python3.10/site-packages/conda/__pycache__/utils.cpython-310.pyc", + "lib/python3.10/site-packages/conda/_vendor/__init__.py", + "lib/python3.10/site-packages/conda/_vendor/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/conda/_vendor/__pycache__/appdirs.cpython-310.pyc", + "lib/python3.10/site-packages/conda/_vendor/__pycache__/distro.cpython-310.pyc", + "lib/python3.10/site-packages/conda/_vendor/appdirs.py", + "lib/python3.10/site-packages/conda/_vendor/boltons/LICENSE", + "lib/python3.10/site-packages/conda/_vendor/boltons/__init__.py", + "lib/python3.10/site-packages/conda/_vendor/boltons/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/conda/_vendor/boltons/__pycache__/setutils.cpython-310.pyc", + "lib/python3.10/site-packages/conda/_vendor/boltons/__pycache__/timeutils.cpython-310.pyc", + "lib/python3.10/site-packages/conda/_vendor/boltons/setutils.py", + "lib/python3.10/site-packages/conda/_vendor/boltons/timeutils.py", + "lib/python3.10/site-packages/conda/_vendor/cpuinfo/__init__.py", + "lib/python3.10/site-packages/conda/_vendor/cpuinfo/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/conda/_vendor/cpuinfo/__pycache__/cpuinfo.cpython-310.pyc", + "lib/python3.10/site-packages/conda/_vendor/cpuinfo/cpuinfo.py", + "lib/python3.10/site-packages/conda/_vendor/distro.py", + "lib/python3.10/site-packages/conda/_vendor/frozendict/__init__.py", + "lib/python3.10/site-packages/conda/_vendor/frozendict/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/conda/_vendor/toolz/__init__.py", + "lib/python3.10/site-packages/conda/_vendor/toolz/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/conda/_vendor/toolz/__pycache__/compatibility.cpython-310.pyc", + "lib/python3.10/site-packages/conda/_vendor/toolz/__pycache__/dicttoolz.cpython-310.pyc", + "lib/python3.10/site-packages/conda/_vendor/toolz/__pycache__/itertoolz.cpython-310.pyc", + "lib/python3.10/site-packages/conda/_vendor/toolz/__pycache__/recipes.cpython-310.pyc", + "lib/python3.10/site-packages/conda/_vendor/toolz/__pycache__/utils.cpython-310.pyc", + "lib/python3.10/site-packages/conda/_vendor/toolz/compatibility.py", + "lib/python3.10/site-packages/conda/_vendor/toolz/dicttoolz.py", + "lib/python3.10/site-packages/conda/_vendor/toolz/itertoolz.py", + "lib/python3.10/site-packages/conda/_vendor/toolz/recipes.py", + "lib/python3.10/site-packages/conda/_vendor/toolz/utils.py", + "lib/python3.10/site-packages/conda/_vendor/tqdm/__init__.py", + "lib/python3.10/site-packages/conda/_vendor/tqdm/__main__.py", + "lib/python3.10/site-packages/conda/_vendor/tqdm/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/conda/_vendor/tqdm/__pycache__/__main__.cpython-310.pyc", + "lib/python3.10/site-packages/conda/_vendor/tqdm/__pycache__/_main.cpython-310.pyc", + "lib/python3.10/site-packages/conda/_vendor/tqdm/__pycache__/_monitor.cpython-310.pyc", + "lib/python3.10/site-packages/conda/_vendor/tqdm/__pycache__/_tqdm.cpython-310.pyc", + "lib/python3.10/site-packages/conda/_vendor/tqdm/__pycache__/_utils.cpython-310.pyc", + "lib/python3.10/site-packages/conda/_vendor/tqdm/__pycache__/asyncio.cpython-310.pyc", + "lib/python3.10/site-packages/conda/_vendor/tqdm/__pycache__/auto.cpython-310.pyc", + "lib/python3.10/site-packages/conda/_vendor/tqdm/__pycache__/cli.cpython-310.pyc", + "lib/python3.10/site-packages/conda/_vendor/tqdm/__pycache__/std.cpython-310.pyc", + "lib/python3.10/site-packages/conda/_vendor/tqdm/__pycache__/utils.cpython-310.pyc", + "lib/python3.10/site-packages/conda/_vendor/tqdm/__pycache__/version.cpython-310.pyc", + "lib/python3.10/site-packages/conda/_vendor/tqdm/_main.py", + "lib/python3.10/site-packages/conda/_vendor/tqdm/_monitor.py", + "lib/python3.10/site-packages/conda/_vendor/tqdm/_tqdm.py", + "lib/python3.10/site-packages/conda/_vendor/tqdm/_utils.py", + "lib/python3.10/site-packages/conda/_vendor/tqdm/asyncio.py", + "lib/python3.10/site-packages/conda/_vendor/tqdm/auto.py", + "lib/python3.10/site-packages/conda/_vendor/tqdm/cli.py", + "lib/python3.10/site-packages/conda/_vendor/tqdm/std.py", + "lib/python3.10/site-packages/conda/_vendor/tqdm/utils.py", + "lib/python3.10/site-packages/conda/_vendor/tqdm/version.py", + "lib/python3.10/site-packages/conda/activate.py", + "lib/python3.10/site-packages/conda/api.py", + "lib/python3.10/site-packages/conda/auxlib/LICENSE", + "lib/python3.10/site-packages/conda/auxlib/__init__.py", + "lib/python3.10/site-packages/conda/auxlib/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/conda/auxlib/__pycache__/collection.cpython-310.pyc", + "lib/python3.10/site-packages/conda/auxlib/__pycache__/compat.cpython-310.pyc", + "lib/python3.10/site-packages/conda/auxlib/__pycache__/decorators.cpython-310.pyc", + "lib/python3.10/site-packages/conda/auxlib/__pycache__/entity.cpython-310.pyc", + "lib/python3.10/site-packages/conda/auxlib/__pycache__/exceptions.cpython-310.pyc", + "lib/python3.10/site-packages/conda/auxlib/__pycache__/ish.cpython-310.pyc", + "lib/python3.10/site-packages/conda/auxlib/__pycache__/logz.cpython-310.pyc", + "lib/python3.10/site-packages/conda/auxlib/__pycache__/packaging.cpython-310.pyc", + "lib/python3.10/site-packages/conda/auxlib/__pycache__/type_coercion.cpython-310.pyc", + "lib/python3.10/site-packages/conda/auxlib/collection.py", + "lib/python3.10/site-packages/conda/auxlib/compat.py", + "lib/python3.10/site-packages/conda/auxlib/decorators.py", + "lib/python3.10/site-packages/conda/auxlib/entity.py", + "lib/python3.10/site-packages/conda/auxlib/exceptions.py", + "lib/python3.10/site-packages/conda/auxlib/ish.py", + "lib/python3.10/site-packages/conda/auxlib/logz.py", + "lib/python3.10/site-packages/conda/auxlib/packaging.py", + "lib/python3.10/site-packages/conda/auxlib/type_coercion.py", + "lib/python3.10/site-packages/conda/base/__init__.py", + "lib/python3.10/site-packages/conda/base/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/conda/base/__pycache__/constants.cpython-310.pyc", + "lib/python3.10/site-packages/conda/base/__pycache__/context.cpython-310.pyc", + "lib/python3.10/site-packages/conda/base/__pycache__/exceptions.cpython-310.pyc", + "lib/python3.10/site-packages/conda/base/constants.py", + "lib/python3.10/site-packages/conda/base/context.py", + "lib/python3.10/site-packages/conda/base/exceptions.py", + "lib/python3.10/site-packages/conda/cli/__init__.py", + "lib/python3.10/site-packages/conda/cli/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/conda/cli/__pycache__/common.cpython-310.pyc", + "lib/python3.10/site-packages/conda/cli/__pycache__/conda_argparse.cpython-310.pyc", + "lib/python3.10/site-packages/conda/cli/__pycache__/find_commands.cpython-310.pyc", + "lib/python3.10/site-packages/conda/cli/__pycache__/install.cpython-310.pyc", + "lib/python3.10/site-packages/conda/cli/__pycache__/main.cpython-310.pyc", + "lib/python3.10/site-packages/conda/cli/__pycache__/main_clean.cpython-310.pyc", + "lib/python3.10/site-packages/conda/cli/__pycache__/main_compare.cpython-310.pyc", + "lib/python3.10/site-packages/conda/cli/__pycache__/main_config.cpython-310.pyc", + "lib/python3.10/site-packages/conda/cli/__pycache__/main_create.cpython-310.pyc", + "lib/python3.10/site-packages/conda/cli/__pycache__/main_info.cpython-310.pyc", + "lib/python3.10/site-packages/conda/cli/__pycache__/main_init.cpython-310.pyc", + "lib/python3.10/site-packages/conda/cli/__pycache__/main_install.cpython-310.pyc", + "lib/python3.10/site-packages/conda/cli/__pycache__/main_list.cpython-310.pyc", + "lib/python3.10/site-packages/conda/cli/__pycache__/main_notices.cpython-310.pyc", + "lib/python3.10/site-packages/conda/cli/__pycache__/main_package.cpython-310.pyc", + "lib/python3.10/site-packages/conda/cli/__pycache__/main_pip.cpython-310.pyc", + "lib/python3.10/site-packages/conda/cli/__pycache__/main_remove.cpython-310.pyc", + "lib/python3.10/site-packages/conda/cli/__pycache__/main_rename.cpython-310.pyc", + "lib/python3.10/site-packages/conda/cli/__pycache__/main_run.cpython-310.pyc", + "lib/python3.10/site-packages/conda/cli/__pycache__/main_search.cpython-310.pyc", + "lib/python3.10/site-packages/conda/cli/__pycache__/main_update.cpython-310.pyc", + "lib/python3.10/site-packages/conda/cli/__pycache__/python_api.cpython-310.pyc", + "lib/python3.10/site-packages/conda/cli/common.py", + "lib/python3.10/site-packages/conda/cli/conda_argparse.py", + "lib/python3.10/site-packages/conda/cli/find_commands.py", + "lib/python3.10/site-packages/conda/cli/install.py", + "lib/python3.10/site-packages/conda/cli/main.py", + "lib/python3.10/site-packages/conda/cli/main_clean.py", + "lib/python3.10/site-packages/conda/cli/main_compare.py", + "lib/python3.10/site-packages/conda/cli/main_config.py", + "lib/python3.10/site-packages/conda/cli/main_create.py", + "lib/python3.10/site-packages/conda/cli/main_info.py", + "lib/python3.10/site-packages/conda/cli/main_init.py", + "lib/python3.10/site-packages/conda/cli/main_install.py", + "lib/python3.10/site-packages/conda/cli/main_list.py", + "lib/python3.10/site-packages/conda/cli/main_notices.py", + "lib/python3.10/site-packages/conda/cli/main_package.py", + "lib/python3.10/site-packages/conda/cli/main_pip.py", + "lib/python3.10/site-packages/conda/cli/main_remove.py", + "lib/python3.10/site-packages/conda/cli/main_rename.py", + "lib/python3.10/site-packages/conda/cli/main_run.py", + "lib/python3.10/site-packages/conda/cli/main_search.py", + "lib/python3.10/site-packages/conda/cli/main_update.py", + "lib/python3.10/site-packages/conda/cli/python_api.py", + "lib/python3.10/site-packages/conda/common/__init__.py", + "lib/python3.10/site-packages/conda/common/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/conda/common/__pycache__/_logic.cpython-310.pyc", + "lib/python3.10/site-packages/conda/common/__pycache__/compat.cpython-310.pyc", + "lib/python3.10/site-packages/conda/common/__pycache__/configuration.cpython-310.pyc", + "lib/python3.10/site-packages/conda/common/__pycache__/constants.cpython-310.pyc", + "lib/python3.10/site-packages/conda/common/__pycache__/cuda.cpython-310.pyc", + "lib/python3.10/site-packages/conda/common/__pycache__/decorators.cpython-310.pyc", + "lib/python3.10/site-packages/conda/common/__pycache__/disk.cpython-310.pyc", + "lib/python3.10/site-packages/conda/common/__pycache__/io.cpython-310.pyc", + "lib/python3.10/site-packages/conda/common/__pycache__/iterators.cpython-310.pyc", + "lib/python3.10/site-packages/conda/common/__pycache__/logic.cpython-310.pyc", + "lib/python3.10/site-packages/conda/common/__pycache__/path.cpython-310.pyc", + "lib/python3.10/site-packages/conda/common/__pycache__/serialize.cpython-310.pyc", + "lib/python3.10/site-packages/conda/common/__pycache__/signals.cpython-310.pyc", + "lib/python3.10/site-packages/conda/common/__pycache__/toposort.cpython-310.pyc", + "lib/python3.10/site-packages/conda/common/__pycache__/url.cpython-310.pyc", + "lib/python3.10/site-packages/conda/common/_logic.py", + "lib/python3.10/site-packages/conda/common/_os/__init__.py", + "lib/python3.10/site-packages/conda/common/_os/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/conda/common/_os/__pycache__/linux.cpython-310.pyc", + "lib/python3.10/site-packages/conda/common/_os/__pycache__/unix.cpython-310.pyc", + "lib/python3.10/site-packages/conda/common/_os/__pycache__/windows.cpython-310.pyc", + "lib/python3.10/site-packages/conda/common/_os/linux.py", + "lib/python3.10/site-packages/conda/common/_os/unix.py", + "lib/python3.10/site-packages/conda/common/_os/windows.py", + "lib/python3.10/site-packages/conda/common/compat.py", + "lib/python3.10/site-packages/conda/common/configuration.py", + "lib/python3.10/site-packages/conda/common/constants.py", + "lib/python3.10/site-packages/conda/common/cuda.py", + "lib/python3.10/site-packages/conda/common/decorators.py", + "lib/python3.10/site-packages/conda/common/disk.py", + "lib/python3.10/site-packages/conda/common/io.py", + "lib/python3.10/site-packages/conda/common/iterators.py", + "lib/python3.10/site-packages/conda/common/logic.py", + "lib/python3.10/site-packages/conda/common/path.py", + "lib/python3.10/site-packages/conda/common/pkg_formats/__init__.py", + "lib/python3.10/site-packages/conda/common/pkg_formats/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/conda/common/pkg_formats/__pycache__/python.cpython-310.pyc", + "lib/python3.10/site-packages/conda/common/pkg_formats/python.py", + "lib/python3.10/site-packages/conda/common/serialize.py", + "lib/python3.10/site-packages/conda/common/signals.py", + "lib/python3.10/site-packages/conda/common/toposort.py", + "lib/python3.10/site-packages/conda/common/url.py", + "lib/python3.10/site-packages/conda/core/__init__.py", + "lib/python3.10/site-packages/conda/core/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/conda/core/__pycache__/envs_manager.cpython-310.pyc", + "lib/python3.10/site-packages/conda/core/__pycache__/index.cpython-310.pyc", + "lib/python3.10/site-packages/conda/core/__pycache__/initialize.cpython-310.pyc", + "lib/python3.10/site-packages/conda/core/__pycache__/link.cpython-310.pyc", + "lib/python3.10/site-packages/conda/core/__pycache__/package_cache.cpython-310.pyc", + "lib/python3.10/site-packages/conda/core/__pycache__/package_cache_data.cpython-310.pyc", + "lib/python3.10/site-packages/conda/core/__pycache__/path_actions.cpython-310.pyc", + "lib/python3.10/site-packages/conda/core/__pycache__/portability.cpython-310.pyc", + "lib/python3.10/site-packages/conda/core/__pycache__/prefix_data.cpython-310.pyc", + "lib/python3.10/site-packages/conda/core/__pycache__/solve.cpython-310.pyc", + "lib/python3.10/site-packages/conda/core/__pycache__/subdir_data.cpython-310.pyc", + "lib/python3.10/site-packages/conda/core/envs_manager.py", + "lib/python3.10/site-packages/conda/core/index.py", + "lib/python3.10/site-packages/conda/core/initialize.py", + "lib/python3.10/site-packages/conda/core/link.py", + "lib/python3.10/site-packages/conda/core/package_cache.py", + "lib/python3.10/site-packages/conda/core/package_cache_data.py", + "lib/python3.10/site-packages/conda/core/path_actions.py", + "lib/python3.10/site-packages/conda/core/portability.py", + "lib/python3.10/site-packages/conda/core/prefix_data.py", + "lib/python3.10/site-packages/conda/core/solve.py", + "lib/python3.10/site-packages/conda/core/subdir_data.py", + "lib/python3.10/site-packages/conda/exceptions.py", + "lib/python3.10/site-packages/conda/exports.py", + "lib/python3.10/site-packages/conda/gateways/__init__.py", + "lib/python3.10/site-packages/conda/gateways/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/conda/gateways/__pycache__/anaconda_client.cpython-310.pyc", + "lib/python3.10/site-packages/conda/gateways/__pycache__/logging.cpython-310.pyc", + "lib/python3.10/site-packages/conda/gateways/__pycache__/subprocess.cpython-310.pyc", + "lib/python3.10/site-packages/conda/gateways/anaconda_client.py", + "lib/python3.10/site-packages/conda/gateways/connection/__init__.py", + "lib/python3.10/site-packages/conda/gateways/connection/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/conda/gateways/connection/__pycache__/download.cpython-310.pyc", + "lib/python3.10/site-packages/conda/gateways/connection/__pycache__/session.cpython-310.pyc", + "lib/python3.10/site-packages/conda/gateways/connection/adapters/__init__.py", + "lib/python3.10/site-packages/conda/gateways/connection/adapters/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/conda/gateways/connection/adapters/__pycache__/ftp.cpython-310.pyc", + "lib/python3.10/site-packages/conda/gateways/connection/adapters/__pycache__/localfs.cpython-310.pyc", + "lib/python3.10/site-packages/conda/gateways/connection/adapters/__pycache__/s3.cpython-310.pyc", + "lib/python3.10/site-packages/conda/gateways/connection/adapters/ftp.py", + "lib/python3.10/site-packages/conda/gateways/connection/adapters/localfs.py", + "lib/python3.10/site-packages/conda/gateways/connection/adapters/s3.py", + "lib/python3.10/site-packages/conda/gateways/connection/download.py", + "lib/python3.10/site-packages/conda/gateways/connection/session.py", + "lib/python3.10/site-packages/conda/gateways/disk/__init__.py", + "lib/python3.10/site-packages/conda/gateways/disk/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/conda/gateways/disk/__pycache__/create.cpython-310.pyc", + "lib/python3.10/site-packages/conda/gateways/disk/__pycache__/delete.cpython-310.pyc", + "lib/python3.10/site-packages/conda/gateways/disk/__pycache__/link.cpython-310.pyc", + "lib/python3.10/site-packages/conda/gateways/disk/__pycache__/permissions.cpython-310.pyc", + "lib/python3.10/site-packages/conda/gateways/disk/__pycache__/read.cpython-310.pyc", + "lib/python3.10/site-packages/conda/gateways/disk/__pycache__/test.cpython-310.pyc", + "lib/python3.10/site-packages/conda/gateways/disk/__pycache__/update.cpython-310.pyc", + "lib/python3.10/site-packages/conda/gateways/disk/create.py", + "lib/python3.10/site-packages/conda/gateways/disk/delete.py", + "lib/python3.10/site-packages/conda/gateways/disk/link.py", + "lib/python3.10/site-packages/conda/gateways/disk/permissions.py", + "lib/python3.10/site-packages/conda/gateways/disk/read.py", + "lib/python3.10/site-packages/conda/gateways/disk/test.py", + "lib/python3.10/site-packages/conda/gateways/disk/update.py", + "lib/python3.10/site-packages/conda/gateways/logging.py", + "lib/python3.10/site-packages/conda/gateways/repodata/__init__.py", + "lib/python3.10/site-packages/conda/gateways/repodata/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/conda/gateways/subprocess.py", + "lib/python3.10/site-packages/conda/history.py", + "lib/python3.10/site-packages/conda/instructions.py", + "lib/python3.10/site-packages/conda/lock.py", + "lib/python3.10/site-packages/conda/misc.py", + "lib/python3.10/site-packages/conda/models/__init__.py", + "lib/python3.10/site-packages/conda/models/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/conda/models/__pycache__/channel.cpython-310.pyc", + "lib/python3.10/site-packages/conda/models/__pycache__/dist.cpython-310.pyc", + "lib/python3.10/site-packages/conda/models/__pycache__/enums.cpython-310.pyc", + "lib/python3.10/site-packages/conda/models/__pycache__/leased_path_entry.cpython-310.pyc", + "lib/python3.10/site-packages/conda/models/__pycache__/match_spec.cpython-310.pyc", + "lib/python3.10/site-packages/conda/models/__pycache__/package_info.cpython-310.pyc", + "lib/python3.10/site-packages/conda/models/__pycache__/prefix_graph.cpython-310.pyc", + "lib/python3.10/site-packages/conda/models/__pycache__/records.cpython-310.pyc", + "lib/python3.10/site-packages/conda/models/__pycache__/version.cpython-310.pyc", + "lib/python3.10/site-packages/conda/models/channel.py", + "lib/python3.10/site-packages/conda/models/dist.py", + "lib/python3.10/site-packages/conda/models/enums.py", + "lib/python3.10/site-packages/conda/models/leased_path_entry.py", + "lib/python3.10/site-packages/conda/models/match_spec.py", + "lib/python3.10/site-packages/conda/models/package_info.py", + "lib/python3.10/site-packages/conda/models/prefix_graph.py", + "lib/python3.10/site-packages/conda/models/records.py", + "lib/python3.10/site-packages/conda/models/version.py", + "lib/python3.10/site-packages/conda/notices/__init__.py", + "lib/python3.10/site-packages/conda/notices/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/conda/notices/__pycache__/cache.cpython-310.pyc", + "lib/python3.10/site-packages/conda/notices/__pycache__/core.cpython-310.pyc", + "lib/python3.10/site-packages/conda/notices/__pycache__/fetch.cpython-310.pyc", + "lib/python3.10/site-packages/conda/notices/__pycache__/types.cpython-310.pyc", + "lib/python3.10/site-packages/conda/notices/__pycache__/views.cpython-310.pyc", + "lib/python3.10/site-packages/conda/notices/cache.py", + "lib/python3.10/site-packages/conda/notices/core.py", + "lib/python3.10/site-packages/conda/notices/fetch.py", + "lib/python3.10/site-packages/conda/notices/types.py", + "lib/python3.10/site-packages/conda/notices/views.py", + "lib/python3.10/site-packages/conda/plan.py", + "lib/python3.10/site-packages/conda/plugins/__init__.py", + "lib/python3.10/site-packages/conda/plugins/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/conda/plugins/__pycache__/hookspec.cpython-310.pyc", + "lib/python3.10/site-packages/conda/plugins/__pycache__/manager.cpython-310.pyc", + "lib/python3.10/site-packages/conda/plugins/__pycache__/solvers.cpython-310.pyc", + "lib/python3.10/site-packages/conda/plugins/__pycache__/types.cpython-310.pyc", + "lib/python3.10/site-packages/conda/plugins/hookspec.py", + "lib/python3.10/site-packages/conda/plugins/manager.py", + "lib/python3.10/site-packages/conda/plugins/solvers.py", + "lib/python3.10/site-packages/conda/plugins/types.py", + "lib/python3.10/site-packages/conda/plugins/virtual_packages/__init__.py", + "lib/python3.10/site-packages/conda/plugins/virtual_packages/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/conda/plugins/virtual_packages/__pycache__/archspec.cpython-310.pyc", + "lib/python3.10/site-packages/conda/plugins/virtual_packages/__pycache__/cuda.cpython-310.pyc", + "lib/python3.10/site-packages/conda/plugins/virtual_packages/__pycache__/linux.cpython-310.pyc", + "lib/python3.10/site-packages/conda/plugins/virtual_packages/__pycache__/osx.cpython-310.pyc", + "lib/python3.10/site-packages/conda/plugins/virtual_packages/__pycache__/windows.cpython-310.pyc", + "lib/python3.10/site-packages/conda/plugins/virtual_packages/archspec.py", + "lib/python3.10/site-packages/conda/plugins/virtual_packages/cuda.py", + "lib/python3.10/site-packages/conda/plugins/virtual_packages/linux.py", + "lib/python3.10/site-packages/conda/plugins/virtual_packages/osx.py", + "lib/python3.10/site-packages/conda/plugins/virtual_packages/windows.py", + "lib/python3.10/site-packages/conda/resolve.py", + "lib/python3.10/site-packages/conda/shell/Library/bin/conda.bat", + "lib/python3.10/site-packages/conda/shell/Scripts/activate.bat", + "lib/python3.10/site-packages/conda/shell/bin/activate", + "lib/python3.10/site-packages/conda/shell/bin/conda", + "lib/python3.10/site-packages/conda/shell/bin/deactivate", + "lib/python3.10/site-packages/conda/shell/cli-32.exe", + "lib/python3.10/site-packages/conda/shell/cli-64.exe", + "lib/python3.10/site-packages/conda/shell/conda.xsh", + "lib/python3.10/site-packages/conda/shell/conda_icon.ico", + "lib/python3.10/site-packages/conda/shell/condabin/Conda.psm1", + "lib/python3.10/site-packages/conda/shell/condabin/_conda_activate.bat", + "lib/python3.10/site-packages/conda/shell/condabin/activate.bat", + "lib/python3.10/site-packages/conda/shell/condabin/conda-hook.ps1", + "lib/python3.10/site-packages/conda/shell/condabin/conda.bat", + "lib/python3.10/site-packages/conda/shell/condabin/conda_auto_activate.bat", + "lib/python3.10/site-packages/conda/shell/condabin/conda_hook.bat", + "lib/python3.10/site-packages/conda/shell/condabin/deactivate.bat", + "lib/python3.10/site-packages/conda/shell/condabin/rename_tmp.bat", + "lib/python3.10/site-packages/conda/shell/etc/fish/conf.d/conda.fish", + "lib/python3.10/site-packages/conda/shell/etc/profile.d/conda.csh", + "lib/python3.10/site-packages/conda/shell/etc/profile.d/conda.sh", + "lib/python3.10/site-packages/conda/testing/__init__.py", + "lib/python3.10/site-packages/conda/testing/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/conda/testing/__pycache__/cases.cpython-310.pyc", + "lib/python3.10/site-packages/conda/testing/__pycache__/fixtures.cpython-310.pyc", + "lib/python3.10/site-packages/conda/testing/__pycache__/helpers.cpython-310.pyc", + "lib/python3.10/site-packages/conda/testing/__pycache__/integration.cpython-310.pyc", + "lib/python3.10/site-packages/conda/testing/__pycache__/solver_helpers.cpython-310.pyc", + "lib/python3.10/site-packages/conda/testing/cases.py", + "lib/python3.10/site-packages/conda/testing/fixtures.py", + "lib/python3.10/site-packages/conda/testing/gateways/__init__.py", + "lib/python3.10/site-packages/conda/testing/gateways/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/conda/testing/gateways/__pycache__/fixtures.cpython-310.pyc", + "lib/python3.10/site-packages/conda/testing/gateways/fixtures.py", + "lib/python3.10/site-packages/conda/testing/helpers.py", + "lib/python3.10/site-packages/conda/testing/integration.py", + "lib/python3.10/site-packages/conda/testing/notices/__init__.py", + "lib/python3.10/site-packages/conda/testing/notices/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/conda/testing/notices/__pycache__/fixtures.cpython-310.pyc", + "lib/python3.10/site-packages/conda/testing/notices/__pycache__/helpers.cpython-310.pyc", + "lib/python3.10/site-packages/conda/testing/notices/fixtures.py", + "lib/python3.10/site-packages/conda/testing/notices/helpers.py", + "lib/python3.10/site-packages/conda/testing/solver_helpers.py", + "lib/python3.10/site-packages/conda/trust/__init__.py", + "lib/python3.10/site-packages/conda/trust/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/conda/trust/__pycache__/constants.cpython-310.pyc", + "lib/python3.10/site-packages/conda/trust/__pycache__/signature_verification.cpython-310.pyc", + "lib/python3.10/site-packages/conda/trust/constants.py", + "lib/python3.10/site-packages/conda/trust/signature_verification.py", + "lib/python3.10/site-packages/conda/utils.py", + "lib/python3.10/site-packages/conda_env/__init__.py", + "lib/python3.10/site-packages/conda_env/__main__.py", + "lib/python3.10/site-packages/conda_env/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/conda_env/__pycache__/__main__.cpython-310.pyc", + "lib/python3.10/site-packages/conda_env/__pycache__/env.cpython-310.pyc", + "lib/python3.10/site-packages/conda_env/__pycache__/pip_util.cpython-310.pyc", + "lib/python3.10/site-packages/conda_env/cli/__init__.py", + "lib/python3.10/site-packages/conda_env/cli/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/conda_env/cli/__pycache__/common.cpython-310.pyc", + "lib/python3.10/site-packages/conda_env/cli/__pycache__/main.cpython-310.pyc", + "lib/python3.10/site-packages/conda_env/cli/__pycache__/main_config.cpython-310.pyc", + "lib/python3.10/site-packages/conda_env/cli/__pycache__/main_create.cpython-310.pyc", + "lib/python3.10/site-packages/conda_env/cli/__pycache__/main_export.cpython-310.pyc", + "lib/python3.10/site-packages/conda_env/cli/__pycache__/main_list.cpython-310.pyc", + "lib/python3.10/site-packages/conda_env/cli/__pycache__/main_remove.cpython-310.pyc", + "lib/python3.10/site-packages/conda_env/cli/__pycache__/main_update.cpython-310.pyc", + "lib/python3.10/site-packages/conda_env/cli/__pycache__/main_vars.cpython-310.pyc", + "lib/python3.10/site-packages/conda_env/cli/common.py", + "lib/python3.10/site-packages/conda_env/cli/main.py", + "lib/python3.10/site-packages/conda_env/cli/main_config.py", + "lib/python3.10/site-packages/conda_env/cli/main_create.py", + "lib/python3.10/site-packages/conda_env/cli/main_export.py", + "lib/python3.10/site-packages/conda_env/cli/main_list.py", + "lib/python3.10/site-packages/conda_env/cli/main_remove.py", + "lib/python3.10/site-packages/conda_env/cli/main_update.py", + "lib/python3.10/site-packages/conda_env/cli/main_vars.py", + "lib/python3.10/site-packages/conda_env/env.py", + "lib/python3.10/site-packages/conda_env/installers/__init__.py", + "lib/python3.10/site-packages/conda_env/installers/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/conda_env/installers/__pycache__/base.cpython-310.pyc", + "lib/python3.10/site-packages/conda_env/installers/__pycache__/conda.cpython-310.pyc", + "lib/python3.10/site-packages/conda_env/installers/__pycache__/pip.cpython-310.pyc", + "lib/python3.10/site-packages/conda_env/installers/base.py", + "lib/python3.10/site-packages/conda_env/installers/conda.py", + "lib/python3.10/site-packages/conda_env/installers/pip.py", + "lib/python3.10/site-packages/conda_env/pip_util.py", + "lib/python3.10/site-packages/conda_env/specs/__init__.py", + "lib/python3.10/site-packages/conda_env/specs/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/conda_env/specs/__pycache__/binstar.cpython-310.pyc", + "lib/python3.10/site-packages/conda_env/specs/__pycache__/notebook.cpython-310.pyc", + "lib/python3.10/site-packages/conda_env/specs/__pycache__/requirements.cpython-310.pyc", + "lib/python3.10/site-packages/conda_env/specs/__pycache__/yaml_file.cpython-310.pyc", + "lib/python3.10/site-packages/conda_env/specs/binstar.py", + "lib/python3.10/site-packages/conda_env/specs/notebook.py", + "lib/python3.10/site-packages/conda_env/specs/requirements.py", + "lib/python3.10/site-packages/conda_env/specs/yaml_file.py", + "lib/python3.10/site-packages/xontrib/conda.xsh", + "shell/condabin/Conda.psm1", + "shell/condabin/conda-hook.ps1" + ], + "fn": "conda-23.1.0-py310hca03da5_0.conda", + "legacy_bz2_md5": "7c4f77c5ec509dcd5003dd693a2e3c9e", + "legacy_bz2_size": 990313, + "license": "BSD-3-Clause", + "license_family": "BSD", + "link": { + "source": "/Users/donjayamanne/.pyenv/versions/anaconda3-2023.03/pkgs/conda-23.1.0-py310hca03da5_0", + "type": 1 + }, + "md5": "00c5c7f9e827401bd66aaceb9c5ee4a8", + "name": "conda", + "package_tarball_full_path": "/Users/donjayamanne/.pyenv/versions/anaconda3-2023.03/pkgs/conda-23.1.0-py310hca03da5_0.conda", + "paths_data": { + "paths": [ + { + "_path": "bin/activate", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_f1vw_br1qm/croot/conda_1674574636144/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehol", + "sha256": "e276f622f70beeb3a1f25d5af51b76b6b715cad3f21e28eb79225be88d499ba4", + "sha256_in_prefix": "e0338158197b194a1452aecb186cbe38971f797192ece162d6ec574e8e8e6cda", + "size_in_bytes": 429 + }, + { + "_path": "bin/conda", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_f1vw_br1qm/croot/conda_1674574636144/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehol", + "sha256": "ab080152682efca803dac53cfbcfd102f3a33b06a057c492b0aa22c8a9cc739a", + "sha256_in_prefix": "3dccd282d2586f801bfd4fafe2a59cc97a9c05ad8202f6d9bc1ae2ead6c65b41", + "size_in_bytes": 756 + }, + { + "_path": "bin/conda-env", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_f1vw_br1qm/croot/conda_1674574636144/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehol", + "sha256": "64737294f79d62e8a522b03df355826194122f144f8f44f93cb9fca41a33e417", + "sha256_in_prefix": "0cfb694efceb4ad75fe1ed8250683eceb4004b7606bb8c261f77f5264ed2d658", + "size_in_bytes": 393 + }, + { + "_path": "bin/deactivate", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_f1vw_br1qm/croot/conda_1674574636144/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehol", + "sha256": "4970c998fe3718638b1fa504ebb608ecacfc0682f61229941a55ba2161bd20b3", + "sha256_in_prefix": "b619c825c6d1c76f630d01aca010cc78f099af9fa432bd4c010063c26483f59f", + "size_in_bytes": 517 + }, + { + "_path": "condabin/conda", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_f1vw_br1qm/croot/conda_1674574636144/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehol", + "sha256": "ab080152682efca803dac53cfbcfd102f3a33b06a057c492b0aa22c8a9cc739a", + "sha256_in_prefix": "3dccd282d2586f801bfd4fafe2a59cc97a9c05ad8202f6d9bc1ae2ead6c65b41", + "size_in_bytes": 756 + }, + { + "_path": "etc/fish/conf.d/conda.fish", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_f1vw_br1qm/croot/conda_1674574636144/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehol", + "sha256": "6ffed84ed6c728ac8cc324c82a944916bfa93974bd0f3431e48003687bb12883", + "sha256_in_prefix": "79df3672c7b2e72f58a8eeddad177ed7e1d738fca3c6d491951a09fd5787a7a2", + "size_in_bytes": 4880 + }, + { + "_path": "etc/profile.d/conda.csh", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_f1vw_br1qm/croot/conda_1674574636144/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehol", + "sha256": "5ffc2c88ff64d8f8a41f95135efe3012eceffd7e1144bdea20ac0365591d6bf9", + "sha256_in_prefix": "f4dd7bd7acb551cb41afe7775c963d7ab5759647464e953edc17f97b9d84c3bd", + "size_in_bytes": 3164 + }, + { + "_path": "etc/profile.d/conda.sh", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_f1vw_br1qm/croot/conda_1674574636144/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehol", + "sha256": "6d751a99d1dc5de6c41244a213890b583cff3a217ea3acac2b975d01bb971d9a", + "sha256_in_prefix": "18d5fc38f1808824dd557f0b12c0855f7981734de89176b391ea6faa9fa20592", + "size_in_bytes": 2553 + }, + { + "_path": "lib/python3.10/site-packages/xontrib/conda.xsh", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_f1vw_br1qm/croot/conda_1674574636144/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehol", + "sha256": "f4d511a3b380dfc1a015a1bb6f6201f157fdd5b025a3d0bcdc694555b78c8ca6", + "sha256_in_prefix": "7aa4186c00138a4c108e83f46d500a2d33c6d7f40386684d914f0a5c1b94657a", + "size_in_bytes": 7418 + }, + { + "_path": "shell/condabin/conda-hook.ps1", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_f1vw_br1qm/croot/conda_1674574636144/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehol", + "sha256": "d247c979ac45cb449f8988993c8fadea7b68dc32114a17d48619f8f671fea4ae", + "sha256_in_prefix": "bb43432a1dfe9936d54b4cb55e03e623e4e0046e926497ffef077cb83464a6ce", + "size_in_bytes": 1047 + } + ], + "paths_version": 1 + }, + "requested_spec": "defaults/osx-arm64::conda==23.1.0=py310hca03da5_0[md5=00c5c7f9e827401bd66aaceb9c5ee4a8]", + "sha256": "125ed5a84b2874b42430763e4543e23e0496aac8e8e09522594ace150eb6aacf", + "size": 982226, + "subdir": "osx-arm64", + "timestamp": 1674574815058, + "track_features": "", + "url": "https://repo.anaconda.com/pkgs/main/osx-arm64/conda-23.1.0-py310hca03da5_0.conda", + "version": "23.1.0" +} \ No newline at end of file diff --git a/crates/pet-conda/tests/unix/conda_envs/user_home/miniconda3/conda-meta/conda-build-3.23.3-py310hca03da5_0.json b/crates/pet-conda/tests/unix/conda_envs/user_home/miniconda3/conda-meta/conda-build-3.23.3-py310hca03da5_0.json new file mode 100644 index 00000000..f0f3640b --- /dev/null +++ b/crates/pet-conda/tests/unix/conda_envs/user_home/miniconda3/conda-meta/conda-build-3.23.3-py310hca03da5_0.json @@ -0,0 +1,292 @@ +{ + "build": "py310hca03da5_0", + "build_number": 0, + "channel": "https://repo.anaconda.com/pkgs/main/osx-arm64", + "constrains": [ + "conda-verify >=3.1.0" + ], + "depends": [ + "beautifulsoup4", + "cctools", + "chardet", + "conda >=4.13", + "conda-package-handling >=1.3", + "filelock", + "glob2 >=0.6", + "jinja2 !=3.0.0", + "patch >=2.6", + "pkginfo", + "psutil", + "py-lief", + "python >=3.10,<3.11.0a0", + "python-libarchive-c", + "pytz", + "pyyaml", + "requests", + "setuptools", + "six", + "toml", + "tqdm" + ], + "extracted_package_dir": "/Users/donjayamanne/.pyenv/versions/anaconda3-2023.03/pkgs/conda-build-3.23.3-py310hca03da5_0", + "features": "", + "files": [ + "bin/conda-build", + "bin/conda-convert", + "bin/conda-debug", + "bin/conda-develop", + "bin/conda-index", + "bin/conda-inspect", + "bin/conda-metapackage", + "bin/conda-render", + "bin/conda-skeleton", + "lib/python3.10/site-packages/conda_build-3.23.3-py3.10.egg-info/PKG-INFO", + "lib/python3.10/site-packages/conda_build-3.23.3-py3.10.egg-info/SOURCES.txt", + "lib/python3.10/site-packages/conda_build-3.23.3-py3.10.egg-info/dependency_links.txt", + "lib/python3.10/site-packages/conda_build-3.23.3-py3.10.egg-info/entry_points.txt", + "lib/python3.10/site-packages/conda_build-3.23.3-py3.10.egg-info/not-zip-safe", + "lib/python3.10/site-packages/conda_build-3.23.3-py3.10.egg-info/requires.txt", + "lib/python3.10/site-packages/conda_build-3.23.3-py3.10.egg-info/top_level.txt", + "lib/python3.10/site-packages/conda_build/__init__.py", + "lib/python3.10/site-packages/conda_build/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/__pycache__/_link.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/__pycache__/_load_setup_py_data.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/__pycache__/_version.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/__pycache__/api.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/__pycache__/bdist_conda.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/__pycache__/build.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/__pycache__/conda_interface.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/__pycache__/config.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/__pycache__/convert.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/__pycache__/create_test.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/__pycache__/develop.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/__pycache__/environ.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/__pycache__/exceptions.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/__pycache__/features.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/__pycache__/index.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/__pycache__/inspect_pkg.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/__pycache__/jinja_context.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/__pycache__/license_family.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/__pycache__/metadata.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/__pycache__/metapackage.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/__pycache__/noarch_python.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/__pycache__/post.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/__pycache__/render.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/__pycache__/source.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/__pycache__/tarcheck.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/__pycache__/utils.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/__pycache__/variants.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/__pycache__/windows.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/_link.py", + "lib/python3.10/site-packages/conda_build/_load_setup_py_data.py", + "lib/python3.10/site-packages/conda_build/_version.py", + "lib/python3.10/site-packages/conda_build/api.py", + "lib/python3.10/site-packages/conda_build/bdist_conda.py", + "lib/python3.10/site-packages/conda_build/build.py", + "lib/python3.10/site-packages/conda_build/cli-32.exe", + "lib/python3.10/site-packages/conda_build/cli-64.exe", + "lib/python3.10/site-packages/conda_build/cli/__init__.py", + "lib/python3.10/site-packages/conda_build/cli/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/cli/__pycache__/actions.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/cli/__pycache__/main_build.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/cli/__pycache__/main_convert.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/cli/__pycache__/main_debug.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/cli/__pycache__/main_develop.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/cli/__pycache__/main_index.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/cli/__pycache__/main_inspect.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/cli/__pycache__/main_metapackage.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/cli/__pycache__/main_render.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/cli/__pycache__/main_skeleton.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/cli/__pycache__/validators.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/cli/actions.py", + "lib/python3.10/site-packages/conda_build/cli/main_build.py", + "lib/python3.10/site-packages/conda_build/cli/main_convert.py", + "lib/python3.10/site-packages/conda_build/cli/main_debug.py", + "lib/python3.10/site-packages/conda_build/cli/main_develop.py", + "lib/python3.10/site-packages/conda_build/cli/main_index.py", + "lib/python3.10/site-packages/conda_build/cli/main_inspect.py", + "lib/python3.10/site-packages/conda_build/cli/main_metapackage.py", + "lib/python3.10/site-packages/conda_build/cli/main_render.py", + "lib/python3.10/site-packages/conda_build/cli/main_skeleton.py", + "lib/python3.10/site-packages/conda_build/cli/validators.py", + "lib/python3.10/site-packages/conda_build/conda_interface.py", + "lib/python3.10/site-packages/conda_build/config.py", + "lib/python3.10/site-packages/conda_build/convert.py", + "lib/python3.10/site-packages/conda_build/create_test.py", + "lib/python3.10/site-packages/conda_build/develop.py", + "lib/python3.10/site-packages/conda_build/environ.py", + "lib/python3.10/site-packages/conda_build/exceptions.py", + "lib/python3.10/site-packages/conda_build/features.py", + "lib/python3.10/site-packages/conda_build/index.py", + "lib/python3.10/site-packages/conda_build/inspect_pkg.py", + "lib/python3.10/site-packages/conda_build/jinja_context.py", + "lib/python3.10/site-packages/conda_build/license_family.py", + "lib/python3.10/site-packages/conda_build/metadata.py", + "lib/python3.10/site-packages/conda_build/metapackage.py", + "lib/python3.10/site-packages/conda_build/noarch_python.py", + "lib/python3.10/site-packages/conda_build/os_utils/__init__.py", + "lib/python3.10/site-packages/conda_build/os_utils/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/os_utils/__pycache__/elf.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/os_utils/__pycache__/external.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/os_utils/__pycache__/ldd.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/os_utils/__pycache__/liefldd.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/os_utils/__pycache__/macho.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/os_utils/__pycache__/pyldd.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/os_utils/elf.py", + "lib/python3.10/site-packages/conda_build/os_utils/external.py", + "lib/python3.10/site-packages/conda_build/os_utils/ldd.py", + "lib/python3.10/site-packages/conda_build/os_utils/liefldd.py", + "lib/python3.10/site-packages/conda_build/os_utils/macho.py", + "lib/python3.10/site-packages/conda_build/os_utils/pyldd.py", + "lib/python3.10/site-packages/conda_build/post.py", + "lib/python3.10/site-packages/conda_build/render.py", + "lib/python3.10/site-packages/conda_build/skeletons/__init__.py", + "lib/python3.10/site-packages/conda_build/skeletons/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/skeletons/__pycache__/_example_skeleton.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/skeletons/__pycache__/cpan.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/skeletons/__pycache__/cran.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/skeletons/__pycache__/luarocks.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/skeletons/__pycache__/pypi.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/skeletons/__pycache__/rpm.cpython-310.pyc", + "lib/python3.10/site-packages/conda_build/skeletons/_example_skeleton.py", + "lib/python3.10/site-packages/conda_build/skeletons/cpan.py", + "lib/python3.10/site-packages/conda_build/skeletons/cran.py", + "lib/python3.10/site-packages/conda_build/skeletons/luarocks.py", + "lib/python3.10/site-packages/conda_build/skeletons/pypi.py", + "lib/python3.10/site-packages/conda_build/skeletons/rpm.py", + "lib/python3.10/site-packages/conda_build/source.py", + "lib/python3.10/site-packages/conda_build/tarcheck.py", + "lib/python3.10/site-packages/conda_build/templates/channeldata-index.html.j2", + "lib/python3.10/site-packages/conda_build/templates/npm.yaml", + "lib/python3.10/site-packages/conda_build/templates/rss.xml.j2", + "lib/python3.10/site-packages/conda_build/templates/setuptools.yaml", + "lib/python3.10/site-packages/conda_build/templates/subdir-index.html.j2", + "lib/python3.10/site-packages/conda_build/utils.py", + "lib/python3.10/site-packages/conda_build/variants.py", + "lib/python3.10/site-packages/conda_build/windows.py" + ], + "fn": "conda-build-3.23.3-py310hca03da5_0.conda", + "legacy_bz2_md5": "8ea35d4f734cdef277a94cf74d22d3ae", + "legacy_bz2_size": 576512, + "license": "BSD-3-Clause", + "license_family": "BSD", + "link": { + "source": "/Users/donjayamanne/.pyenv/versions/anaconda3-2023.03/pkgs/conda-build-3.23.3-py310hca03da5_0", + "type": 1 + }, + "md5": "4a6b06f0a14b98c819cd4b0e09c740e8", + "name": "conda-build", + "package_tarball_full_path": "/Users/donjayamanne/.pyenv/versions/anaconda3-2023.03/pkgs/conda-build-3.23.3-py310hca03da5_0.conda", + "paths_data": { + "paths": [ + { + "_path": "bin/conda-build", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_e9c9oqsgk0/croot/conda-build_1670407343391/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_pl", + "sha256": "bcb2e024326726eba4acd5a19f0a630864fdf5ba060f2e18f15ac7ebc480d110", + "sha256_in_prefix": "0e3157ec917846a3847fb675ea632a2ac8c36673f3be8a1c04f37fc0181733ee", + "size_in_bytes": 479 + }, + { + "_path": "bin/conda-convert", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_e9c9oqsgk0/croot/conda-build_1670407343391/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_pl", + "sha256": "d410d34b34ad6f68b7a1500ed6b63fc27561ce130dee75b39dbe411b5fb3a2af", + "sha256_in_prefix": "f14a90cb7a116bd45a2994c040c6957cac360f762e9c334af427cb8241770367", + "size_in_bytes": 481 + }, + { + "_path": "bin/conda-debug", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_e9c9oqsgk0/croot/conda-build_1670407343391/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_pl", + "sha256": "bd4dffebd208180e99ac73f86ce8ceb5f4bea5c2c71a95bbe687de2560ab9b08", + "sha256_in_prefix": "13a281bc24e2d7aaca30eb00307b6eb44563c677274ab3e07b0649c663ca419a", + "size_in_bytes": 479 + }, + { + "_path": "bin/conda-develop", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_e9c9oqsgk0/croot/conda-build_1670407343391/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_pl", + "sha256": "231799f45acb8119dfdb95f42f23e906fe70fbb144b303d9614fedeece77773f", + "sha256_in_prefix": "cbd4fccc2791cf5100694976d0cae72da508f8ad6e68b20c28c88f80dcca4993", + "size_in_bytes": 481 + }, + { + "_path": "bin/conda-index", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_e9c9oqsgk0/croot/conda-build_1670407343391/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_pl", + "sha256": "6864da7e624f38d401fb0583f0d8d90745c0364dc395ccb5a2f1376d2665dc0a", + "sha256_in_prefix": "82530863ef858181f6916b8119d958756f6369340725ec0c431566d9d069fd7d", + "size_in_bytes": 479 + }, + { + "_path": "bin/conda-inspect", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_e9c9oqsgk0/croot/conda-build_1670407343391/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_pl", + "sha256": "e6ac49718570dba57e082b1cada990916ad9c842428c1e4feb0ab2a8991b779a", + "sha256_in_prefix": "de395fada71e3b91388f77e58595c0ea5c312f3d9723f1166f53d02ee0cea7aa", + "size_in_bytes": 481 + }, + { + "_path": "bin/conda-metapackage", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_e9c9oqsgk0/croot/conda-build_1670407343391/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_pl", + "sha256": "cdb36b8e4952467f37afa6bff264785ce30283b4514930ff476007deeaf40c82", + "sha256_in_prefix": "39f4482e3f3cced297044aca946716cb0ba028d790fa2c0bb0750f18ade242a3", + "size_in_bytes": 485 + }, + { + "_path": "bin/conda-render", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_e9c9oqsgk0/croot/conda-build_1670407343391/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_pl", + "sha256": "1ce235e5b9079264b8e537cda0b4f2de978a7023a42b3e610cc25d187b2c0b5e", + "sha256_in_prefix": "fe22b853f463bc1e376ea2408b47a1b136bed9b7920df95f9a9c85cf01ee9d25", + "size_in_bytes": 480 + }, + { + "_path": "bin/conda-skeleton", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_e9c9oqsgk0/croot/conda-build_1670407343391/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_pl", + "sha256": "67dc5e0c39f5c60c3b0137e288e63f888b555238a61306bb9a543d07eb9055d6", + "sha256_in_prefix": "ad8ad61d3334dc35a06b7892e9ff74a3bff15e1a826dae1c12a7e0e14a03286c", + "size_in_bytes": 482 + }, + { + "_path": "lib/python3.10/site-packages/conda_build/build.py", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/opt/anaconda1anaconda2anaconda3", + "sha256": "80484c779970d54fc4770770d4fd7e8c3746bf9dca507422b0de9ac6318de577", + "sha256_in_prefix": "15b2555eafdddbbec1056215f7b7ad63ddb83119c7505fc58058f946b430898c", + "size_in_bytes": 165970 + }, + { + "_path": "lib/python3.10/site-packages/conda_build/convert.py", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/opt/anaconda1anaconda2anaconda3", + "sha256": "de70a8ed59cdfb67e8f929d6cb3152c87a2be8d57dd9c93e9facb8c35ee1ae3a", + "sha256_in_prefix": "2a64800bf62f67f4666563f7c4779390fd0e80382227e883e40646910fcf8a41", + "size_in_bytes": 32246 + } + ], + "paths_version": 1 + }, + "requested_spec": "defaults/osx-arm64::conda-build==3.23.3=py310hca03da5_0[md5=4a6b06f0a14b98c819cd4b0e09c740e8]", + "sha256": "5f67c17b8cda432f379e620df27dd0dee0dd028158a1e08ad7dfb5dd4a13a020", + "size": 594922, + "subdir": "osx-arm64", + "timestamp": 1670407406866, + "track_features": "", + "url": "https://repo.anaconda.com/pkgs/main/osx-arm64/conda-build-3.23.3-py310hca03da5_0.conda", + "version": "3.23.3" +} \ No newline at end of file diff --git a/crates/pet-conda/tests/unix/conda_envs/user_home/miniconda3/conda-meta/history b/crates/pet-conda/tests/unix/conda_envs/user_home/miniconda3/conda-meta/history new file mode 100644 index 00000000..59f60f91 --- /dev/null +++ b/crates/pet-conda/tests/unix/conda_envs/user_home/miniconda3/conda-meta/history @@ -0,0 +1,428 @@ +==> 2023-03-09 04:25:49 <== +# cmd: constructor /var/folders/24/8k48jl6d249_n_qfxwsl6xvm0000gn/T/tmp.3zs0BaU4sl/Anaconda3/ --output-dir /var/folders/24/8k48jl6d249_n_qfxwsl6xvm0000gn/T/tmp.3zs0BaU4sl --conda-exe /var/folders/24/8k48jl6d249_n_qfxwsl6xvm0000gn/T/tmp.3zs0BaU4sl/conda_exe/standalone_conda/conda.exe --platform osx-arm64 ++defaults::blas-1.0-openblas ++defaults::bzip2-1.0.8-h620ffc9_4 ++defaults::c-ares-1.18.1-h1a28f6b_0 ++defaults::ca-certificates-2023.01.10-hca03da5_0 ++defaults::giflib-5.2.1-h80987f9_3 ++defaults::jpeg-9e-h80987f9_1 ++defaults::jxrlib-1.1-h1a28f6b_2 ++defaults::ldid-2.1.2-h64d1936_2 ++defaults::libbrotlicommon-1.0.9-h1a28f6b_7 ++defaults::libcxx-14.0.6-h848a8c0_0 ++defaults::libdeflate-1.17-h80987f9_0 ++defaults::libev-4.33-h1a28f6b_1 ++defaults::libffi-3.4.2-hca03da5_6 ++defaults::libiconv-1.16-h1a28f6b_2 ++defaults::libsodium-1.0.18-h1a28f6b_0 ++defaults::libuv-1.44.2-h80987f9_0 ++defaults::libwebp-base-1.2.4-h80987f9_1 ++defaults::llvm-openmp-14.0.6-hc6e5704_0 ++defaults::lzo-2.10-h1a28f6b_2 ++defaults::ncurses-6.4-h313beb8_0 ++defaults::oniguruma-6.9.7.1-h1a28f6b_0 ++defaults::patch-2.7.6-h1a28f6b_1001 ++defaults::tzdata-2022g-h04d1e81_0 ++defaults::xz-5.2.10-h80987f9_1 ++defaults::yaml-0.2.5-h1a28f6b_0 ++defaults::zlib-1.2.13-h5a0b063_0 ++defaults::charls-2.2.0-hc377ac9_0 ++defaults::gmp-6.2.1-hc377ac9_3 ++defaults::icu-68.1-hc377ac9_0 ++defaults::jq-1.6-h1a28f6b_1 ++defaults::lerc-3.0-hc377ac9_0 ++defaults::libaec-1.0.4-hc377ac9_1 ++defaults::libbrotlidec-1.0.9-h1a28f6b_7 ++defaults::libbrotlienc-1.0.9-h1a28f6b_7 ++defaults::libedit-3.1.20221030-h80987f9_0 ++defaults::libgfortran5-11.3.0-h009349e_28 ++defaults::liblief-0.12.3-h313beb8_0 ++defaults::libllvm11-11.1.0-h12f7ac0_6 ++defaults::libllvm12-12.0.0-h12f7ac0_4 ++defaults::libllvm14-14.0.6-h7ec7a93_1 ++defaults::libpng-1.6.39-h80987f9_0 ++defaults::libprotobuf-3.20.3-h514c7bf_0 ++defaults::libspatialindex-1.9.3-hc377ac9_0 ++defaults::libzopfli-1.0.3-hc377ac9_0 ++defaults::lz4-c-1.9.4-h313beb8_0 ++defaults::ninja-base-1.10.2-h525c30c_5 ++defaults::nspr-4.33-hc377ac9_0 ++defaults::openssl-1.1.1t-h1a28f6b_0 ++defaults::pcre-8.45-hc377ac9_0 ++defaults::readline-8.2-h1a28f6b_0 ++defaults::sleef-3.5.1-hf27765b_1 ++defaults::snappy-1.1.9-hc377ac9_0 ++defaults::tapi-1100.0.11-h8754e6a_1 ++defaults::tbb-2021.7.0-h48ca7d4_0 ++defaults::tk-8.6.12-hb8d0fd4_0 ++defaults::zeromq-4.3.4-hc377ac9_0 ++defaults::zfp-0.5.5-hc377ac9_6 ++defaults::brotli-bin-1.0.9-h1a28f6b_7 ++defaults::freetype-2.12.1-h1192e45_0 ++defaults::krb5-1.19.4-h8380606_0 ++defaults::ld64_osx-arm64-530-h001ce53_25 ++defaults::libclang-12.0.0-default_hc321e17_4 ++defaults::libgfortran-5.0.0-11_3_0_hca03da5_28 ++defaults::libnghttp2-1.46.0-h95c9599_0 ++defaults::libssh2-1.10.0-hf27765b_0 ++defaults::libxml2-2.9.14-h8c5e841_0 ++defaults::mpfr-4.0.2-h695f6f0_1 ++defaults::sqlite-3.40.1-h7a7dc30_0 ++defaults::unixodbc-2.3.11-h1a28f6b_0 ++defaults::zstd-1.5.2-h8574219_0 ++defaults::blosc-1.21.3-h313beb8_0 ++defaults::brotli-1.0.9-h1a28f6b_7 ++defaults::cctools_osx-arm64-949.0.1-h332cad3_25 ++defaults::gettext-0.21.0-h826f4ad_0 ++defaults::ld64-530-hb29bf3f_25 ++defaults::libarchive-3.6.2-h3d4dd14_0 ++defaults::libcurl-7.87.0-h0f1d93c_0 ++defaults::libopenblas-0.3.21-h269037a_0 ++defaults::libpq-12.9-h65cfe13_3 ++defaults::libtiff-4.5.0-h313beb8_2 ++defaults::libxslt-1.1.35-h9833966_0 ++defaults::mpc-1.1.0-h8c48613_1 ++defaults::nss-3.74-h142855e_0 ++defaults::python-3.10.9-hc0d8a6c_1 ++defaults::alabaster-0.7.12-pyhd3eb1b0_0 ++defaults::appdirs-1.4.4-pyhd3eb1b0_0 ++defaults::appnope-0.1.2-py310hca03da5_1001 ++defaults::appscript-1.1.2-py310h1a28f6b_0 ++defaults::atomicwrites-1.4.0-py_0 ++defaults::attrs-22.1.0-py310hca03da5_0 ++defaults::backcall-0.2.0-pyhd3eb1b0_0 ++defaults::backports-1.1-pyhd3eb1b0_0 ++defaults::brunsli-0.1-hc377ac9_1 ++defaults::cctools-949.0.1-hc179dcd_25 ++defaults::certifi-2022.12.7-py310hca03da5_0 ++defaults::cfitsio-3.470-h7f6438f_7 ++defaults::chardet-4.0.0-py310hca03da5_1003 ++defaults::charset-normalizer-2.0.4-pyhd3eb1b0_0 ++defaults::click-8.0.4-py310hca03da5_0 ++defaults::cloudpickle-2.0.0-pyhd3eb1b0_0 ++defaults::colorama-0.4.6-py310hca03da5_0 ++defaults::constantly-15.1.0-py310hca03da5_0 ++defaults::cssselect-1.1.0-pyhd3eb1b0_0 ++defaults::curl-7.87.0-h80987f9_0 ++defaults::cycler-0.11.0-pyhd3eb1b0_0 ++defaults::debugpy-1.5.1-py310hc377ac9_0 ++defaults::decorator-5.1.1-pyhd3eb1b0_0 ++defaults::defusedxml-0.7.1-pyhd3eb1b0_0 ++defaults::diff-match-patch-20200713-pyhd3eb1b0_0 ++defaults::dill-0.3.6-py310hca03da5_0 ++defaults::docstring-to-markdown-0.11-py310hca03da5_0 ++defaults::docutils-0.18.1-py310hca03da5_3 ++defaults::entrypoints-0.4-py310hca03da5_0 ++defaults::et_xmlfile-1.1.0-py310hca03da5_0 ++defaults::executing-0.8.3-pyhd3eb1b0_0 ++defaults::filelock-3.9.0-py310hca03da5_0 ++defaults::flit-core-3.6.0-pyhd3eb1b0_0 ++defaults::fsspec-2022.11.0-py310hca03da5_0 ++defaults::future-0.18.3-py310hca03da5_0 ++defaults::glib-2.69.1-h514c7bf_2 ++defaults::glob2-0.7-pyhd3eb1b0_0 ++defaults::gmpy2-2.1.2-py310h8c48613_0 ++defaults::greenlet-2.0.1-py310h313beb8_0 ++defaults::hdf5-1.12.1-h160e8cb_2 ++defaults::heapdict-1.0.1-pyhd3eb1b0_0 ++defaults::idna-3.4-py310hca03da5_0 ++defaults::imagesize-1.4.1-py310hca03da5_0 ++defaults::incremental-21.3.0-pyhd3eb1b0_0 ++defaults::inflection-0.5.1-py310hca03da5_0 ++defaults::iniconfig-1.1.1-pyhd3eb1b0_0 ++defaults::ipython_genutils-0.2.0-pyhd3eb1b0_1 ++defaults::isort-5.9.3-pyhd3eb1b0_0 ++defaults::itemadapter-0.3.0-pyhd3eb1b0_0 ++defaults::itsdangerous-2.0.1-pyhd3eb1b0_0 ++defaults::jellyfish-0.9.0-py310h1a28f6b_0 ++defaults::jmespath-0.10.0-pyhd3eb1b0_0 ++defaults::joblib-1.1.1-py310hca03da5_0 ++defaults::json5-0.9.6-pyhd3eb1b0_0 ++defaults::kiwisolver-1.4.4-py310h313beb8_0 ++defaults::lazy-object-proxy-1.6.0-py310h1a28f6b_0 ++defaults::lcms2-2.12-hba8e193_0 ++defaults::libwebp-1.2.4-ha3663a8_1 ++defaults::llvmlite-0.39.1-py310h98b2900_0 ++defaults::locket-1.0.0-py310hca03da5_0 ++defaults::lxml-4.9.1-py310h2fae87d_0 ++defaults::lz4-3.1.3-py310h1a28f6b_0 ++defaults::markdown-3.4.1-py310hca03da5_0 ++defaults::markupsafe-2.1.1-py310h1a28f6b_0 ++defaults::mccabe-0.7.0-pyhd3eb1b0_0 ++defaults::mistune-0.8.4-py310h1a28f6b_1000 ++defaults::mock-4.0.3-pyhd3eb1b0_0 ++defaults::mpmath-1.2.1-py310hca03da5_0 ++defaults::msgpack-python-1.0.3-py310h525c30c_0 ++defaults::munkres-1.1.4-py_0 ++defaults::mypy_extensions-0.4.3-py310hca03da5_1 ++defaults::nest-asyncio-1.5.6-py310hca03da5_0 ++defaults::networkx-2.8.4-py310hca03da5_0 ++defaults::ninja-1.10.2-hca03da5_5 ++defaults::numpy-base-1.23.5-py310haf87e8b_0 ++defaults::openjpeg-2.3.0-h7a6adac_2 ++defaults::packaging-22.0-py310hca03da5_0 ++defaults::pandocfilters-1.5.0-pyhd3eb1b0_0 ++defaults::param-1.12.3-py310hca03da5_0 ++defaults::parso-0.8.3-pyhd3eb1b0_0 ++defaults::pathlib-1.0.1-pyhd3eb1b0_1 ++defaults::pathspec-0.10.3-py310hca03da5_0 ++defaults::pep8-1.7.1-py310hca03da5_1 ++defaults::pickleshare-0.7.5-pyhd3eb1b0_1003 ++defaults::pkginfo-1.8.3-py310hca03da5_0 ++defaults::platformdirs-2.5.2-py310hca03da5_0 ++defaults::pluggy-1.0.0-py310hca03da5_1 ++defaults::ply-3.11-py310hca03da5_0 ++defaults::poyo-0.5.0-pyhd3eb1b0_0 ++defaults::prometheus_client-0.14.1-py310hca03da5_0 ++defaults::psutil-5.9.0-py310h1a28f6b_0 ++defaults::ptyprocess-0.7.0-pyhd3eb1b0_2 ++defaults::pure_eval-0.2.2-pyhd3eb1b0_0 ++defaults::py-1.11.0-pyhd3eb1b0_0 ++defaults::py-lief-0.12.3-py310h313beb8_0 ++defaults::pyasn1-0.4.8-pyhd3eb1b0_0 ++defaults::pycodestyle-2.10.0-py310hca03da5_0 ++defaults::pycosat-0.6.4-py310h1a28f6b_0 ++defaults::pycparser-2.21-pyhd3eb1b0_0 ++defaults::pycurl-7.45.1-py310hf27765b_0 ++defaults::pydispatcher-2.0.5-py310hca03da5_2 ++defaults::pyflakes-3.0.1-py310hca03da5_0 ++defaults::pygments-2.11.2-pyhd3eb1b0_0 ++defaults::pyjwt-2.4.0-py310hca03da5_0 ++defaults::pylint-venv-2.3.0-py310hca03da5_0 ++defaults::pyobjc-core-9.0-py310h3eb5a62_1 ++defaults::pyodbc-4.0.34-py310hc377ac9_0 ++defaults::pyparsing-3.0.9-py310hca03da5_0 ++defaults::pyrsistent-0.18.0-py310h1a28f6b_0 ++defaults::pysocks-1.7.1-py310hca03da5_0 ++defaults::python-fastjsonschema-2.16.2-py310hca03da5_0 ++defaults::python-libarchive-c-2.9-pyhd3eb1b0_1 ++defaults::python-snappy-0.6.1-py310h313beb8_0 ++defaults::python.app-3-py310h1a28f6b_0 ++defaults::pytz-2022.7-py310hca03da5_0 ++defaults::pyyaml-6.0-py310h80987f9_1 ++defaults::pyzmq-23.2.0-py310hc377ac9_0 ++defaults::qdarkstyle-3.0.2-pyhd3eb1b0_0 ++defaults::queuelib-1.5.0-py310hca03da5_0 ++defaults::regex-2022.7.9-py310h1a28f6b_0 ++defaults::rtree-1.0.1-py310hca03da5_0 ++defaults::ruamel.yaml.clib-0.2.6-py310h1a28f6b_1 ++defaults::send2trash-1.8.0-pyhd3eb1b0_1 ++defaults::six-1.16.0-pyhd3eb1b0_1 ++defaults::smart_open-5.2.1-py310hca03da5_0 ++defaults::sniffio-1.2.0-py310hca03da5_1 ++defaults::snowballstemmer-2.2.0-pyhd3eb1b0_0 ++defaults::sortedcontainers-2.4.0-pyhd3eb1b0_0 ++defaults::soupsieve-2.3.2.post1-py310hca03da5_0 ++defaults::sphinxcontrib-applehelp-1.0.2-pyhd3eb1b0_0 ++defaults::sphinxcontrib-devhelp-1.0.2-pyhd3eb1b0_0 ++defaults::sphinxcontrib-htmlhelp-2.0.0-pyhd3eb1b0_0 ++defaults::sphinxcontrib-jsmath-1.0.1-pyhd3eb1b0_0 ++defaults::sphinxcontrib-qthelp-1.0.3-pyhd3eb1b0_0 ++defaults::sphinxcontrib-serializinghtml-1.1.5-pyhd3eb1b0_0 ++defaults::tabulate-0.8.10-py310hca03da5_0 ++defaults::tbb4py-2021.7.0-py310h48ca7d4_0 ++defaults::tblib-1.7.0-pyhd3eb1b0_0 ++defaults::tenacity-8.0.1-py310hca03da5_1 ++defaults::text-unidecode-1.3-pyhd3eb1b0_0 ++defaults::textdistance-4.2.1-pyhd3eb1b0_0 ++defaults::threadpoolctl-2.2.0-pyh0d69192_0 ++defaults::tokenizers-0.11.4-py310h5c5695e_1 ++defaults::toml-0.10.2-pyhd3eb1b0_0 ++defaults::tomli-2.0.1-py310hca03da5_0 ++defaults::tomlkit-0.11.1-py310hca03da5_0 ++defaults::toolz-0.12.0-py310hca03da5_0 ++defaults::tornado-6.1-py310h1a28f6b_0 ++defaults::tqdm-4.64.1-py310hca03da5_0 ++defaults::traitlets-5.7.1-py310hca03da5_0 ++defaults::ujson-5.4.0-py310hc377ac9_0 ++defaults::unidecode-1.2.0-pyhd3eb1b0_0 ++defaults::wcwidth-0.2.5-pyhd3eb1b0_0 ++defaults::webencodings-0.5.1-py310hca03da5_1 ++defaults::whatthepatch-1.0.2-py310hca03da5_0 ++defaults::wheel-0.38.4-py310hca03da5_0 ++defaults::wrapt-1.14.1-py310h1a28f6b_0 ++defaults::wurlitzer-3.0.2-py310hca03da5_0 ++defaults::yapf-0.31.0-pyhd3eb1b0_0 ++defaults::zipp-3.11.0-py310hca03da5_0 ++defaults::zope-1.0-py310hca03da5_1 ++defaults::anyio-3.5.0-py310hca03da5_0 ++defaults::asttokens-2.0.5-pyhd3eb1b0_0 ++defaults::automat-20.2.0-py_0 ++defaults::autopep8-1.6.0-pyhd3eb1b0_1 ++defaults::babel-2.11.0-py310hca03da5_0 ++defaults::backports.weakref-1.0.post1-py_1 ++defaults::beautifulsoup4-4.11.1-py310hca03da5_0 ++defaults::binaryornot-0.4.4-pyhd3eb1b0_1 ++defaults::black-22.6.0-py310hca03da5_0 ++defaults::bleach-4.1.0-pyhd3eb1b0_0 ++defaults::cffi-1.15.1-py310h80987f9_3 ++defaults::comm-0.1.2-py310hca03da5_0 ++defaults::cytoolz-0.12.0-py310h1a28f6b_0 ++defaults::flake8-6.0.0-py310hca03da5_0 ++defaults::fonttools-4.25.0-pyhd3eb1b0_0 ++defaults::gstreamer-1.14.1-h80987f9_1 ++defaults::hyperlink-21.0.0-pyhd3eb1b0_0 ++defaults::importlib-metadata-4.11.3-py310hca03da5_0 ++defaults::intervaltree-3.1.0-pyhd3eb1b0_0 ++defaults::jedi-0.18.1-py310hca03da5_1 ++defaults::jinja2-3.1.2-py310hca03da5_0 ++defaults::jsonschema-4.17.3-py310hca03da5_0 ++defaults::jupyter_core-5.2.0-py310hca03da5_0 ++defaults::jupyterlab_pygments-0.1.2-py_0 ++defaults::matplotlib-inline-0.1.6-py310hca03da5_0 ++defaults::multipledispatch-0.6.0-py310hca03da5_0 ++defaults::nltk-3.7-pyhd3eb1b0_0 ++defaults::numpy-1.23.5-py310hb93e574_0 ++defaults::openpyxl-3.0.10-py310h1a28f6b_0 ++defaults::partd-1.2.0-pyhd3eb1b0_1 ++defaults::pexpect-4.8.0-pyhd3eb1b0_3 ++defaults::pillow-9.4.0-py310h313beb8_0 ++defaults::plotly-5.9.0-py310hca03da5_0 ++defaults::prompt-toolkit-3.0.36-py310hca03da5_0 ++defaults::protego-0.1.16-py_0 ++defaults::pyasn1-modules-0.2.8-py_0 ++defaults::pydocstyle-6.3.0-py310hca03da5_0 ++defaults::pyhamcrest-2.0.2-pyhd3eb1b0_2 ++defaults::pyobjc-framework-cocoa-9.0-py310hb094c41_0 ++defaults::pytest-7.1.2-py310hca03da5_0 ++defaults::python-dateutil-2.8.2-pyhd3eb1b0_0 ++defaults::python-lsp-jsonrpc-1.0.0-pyhd3eb1b0_0 ++defaults::python-slugify-5.0.2-pyhd3eb1b0_0 ++defaults::pytoolconfig-1.2.5-py310hca03da5_1 ++defaults::pyviz_comms-2.0.2-pyhd3eb1b0_0 ++defaults::qtpy-2.2.0-py310hca03da5_0 ++defaults::ruamel.yaml-0.17.21-py310h1a28f6b_0 ++defaults::ruamel_yaml-0.17.21-py310h1a28f6b_0 ++defaults::setuptools-65.6.3-py310hca03da5_0 ++defaults::sip-6.6.2-py310hc377ac9_0 ++defaults::sqlalchemy-1.4.39-py310h1a28f6b_0 ++defaults::sympy-1.11.1-py310hca03da5_0 ++defaults::terminado-0.17.1-py310hca03da5_0 ++defaults::three-merge-0.1.1-pyhd3eb1b0_0 ++defaults::tinycss2-1.2.1-py310hca03da5_0 ++defaults::typing_extensions-4.4.0-py310hca03da5_0 ++defaults::w3lib-1.21.0-pyhd3eb1b0_0 ++defaults::watchdog-2.1.6-py310h1a28f6b_0 ++defaults::websocket-client-0.58.0-py310hca03da5_4 ++defaults::werkzeug-2.2.2-py310hca03da5_0 ++defaults::xlwings-0.29.1-py310hca03da5_0 ++defaults::zict-2.1.0-py310hca03da5_0 ++defaults::argon2-cffi-bindings-21.2.0-py310h1a28f6b_0 ++defaults::arrow-1.2.3-py310hca03da5_1 ++defaults::backports.functools_lru_cache-1.6.4-pyhd3eb1b0_0 ++defaults::backports.tempfile-1.0-pyhd3eb1b0_1 ++defaults::bokeh-2.4.3-py310hca03da5_0 ++defaults::bottleneck-1.3.5-py310h96f19d2_0 ++defaults::brotlipy-0.7.0-py310h1a28f6b_1002 ++defaults::clyent-1.2.2-py310hca03da5_1 ++defaults::conda-pack-0.6.0-pyhd3eb1b0_0 ++defaults::contourpy-1.0.5-py310h525c30c_0 ++defaults::cryptography-39.0.1-py310h834c97f_0 ++defaults::dask-core-2022.7.0-py310hca03da5_0 ++defaults::datashape-0.5.4-py310hca03da5_1 ++defaults::flask-2.2.2-py310hca03da5_0 ++defaults::gst-plugins-base-1.14.1-h313beb8_1 ++defaults::h5py-3.7.0-py310h181c318_0 ++defaults::imagecodecs-2021.8.26-py310h48bc37f_2 ++defaults::imageio-2.26.0-py310hca03da5_0 ++defaults::importlib_metadata-4.11.3-hd3eb1b0_0 ++defaults::jupyter_client-7.3.4-py310hca03da5_0 ++defaults::nbformat-5.7.0-py310hca03da5_0 ++defaults::numba-0.56.4-py310h46d7db6_0 ++defaults::numexpr-2.8.4-py310hecc3335_0 ++defaults::parsel-1.6.0-py310hca03da5_0 ++defaults::patsy-0.5.3-py310hca03da5_0 ++defaults::pip-22.3.1-py310hca03da5_0 ++defaults::pyerfa-2.0.0-py310h1a28f6b_0 ++defaults::pyobjc-framework-fsevents-9.0-py310hca03da5_0 ++defaults::pyqt5-sip-12.11.0-py310hc377ac9_0 ++defaults::pywavelets-1.4.1-py310h80987f9_0 ++defaults::qstylizer-0.2.2-py310hca03da5_0 ++defaults::qtawesome-1.2.2-py310hca03da5_0 ++defaults::rope-1.7.0-py310hca03da5_0 ++defaults::stack_data-0.2.0-pyhd3eb1b0_0 ++defaults::typing-extensions-4.4.0-py310hca03da5_0 ++defaults::zope.interface-5.4.0-py310h1a28f6b_0 ++defaults::zstandard-0.19.0-py310h80987f9_0 ++defaults::argon2-cffi-21.3.0-pyhd3eb1b0_0 ++defaults::astroid-2.14.2-py310hca03da5_0 ++defaults::astropy-5.1-py310h96f19d2_0 ++defaults::bcrypt-3.2.0-py310h1a28f6b_1 ++defaults::conda-content-trust-0.1.3-py310hca03da5_0 ++defaults::conda-package-streaming-0.7.0-py310hca03da5_0 ++defaults::ipython-8.10.0-py310hca03da5_0 ++defaults::itemloaders-1.0.4-pyhd3eb1b0_1 ++defaults::jinja2-time-0.2.0-pyhd3eb1b0_3 ++defaults::keyring-23.4.0-py310hca03da5_0 ++defaults::matplotlib-base-3.7.0-py310h46d7db6_0 ++defaults::nbclient-0.5.13-py310hca03da5_0 ++defaults::pandas-1.5.3-py310h46d7db6_0 ++defaults::pyobjc-framework-coreservices-9.0-py310hdd8dd1f_0 ++defaults::pyopenssl-23.0.0-py310hca03da5_0 ++defaults::pytables-3.7.0-py310ha5d4e50_1 ++defaults::pytorch-1.12.1-cpu_py310h8370978_1 ++defaults::qt-main-5.15.2-ha2d02b5_7 ++defaults::service_identity-18.1.0-pyhd3eb1b0_1 ++defaults::tifffile-2021.7.2-pyhd3eb1b0_2 ++defaults::applaunchservices-0.3.0-py310hca03da5_0 ++defaults::conda-package-handling-2.0.2-py310hca03da5_0 ++defaults::ipykernel-6.19.2-py310h33ce5c2_0 ++defaults::matplotlib-3.7.0-py310hca03da5_0 ++defaults::nbconvert-6.5.4-py310hca03da5_0 ++defaults::pylint-2.16.2-py310hca03da5_0 ++defaults::qt-webengine-5.15.9-h2903aaf_4 ++defaults::seaborn-0.12.2-py310hca03da5_0 ++defaults::twisted-22.2.0-py310h1a28f6b_1 ++defaults::urllib3-1.26.14-py310hca03da5_0 ++defaults::xarray-2022.11.0-py310hca03da5_0 ++defaults::conda-verify-3.4.2-py_1 ++defaults::distributed-2022.7.0-py310hca03da5_0 ++defaults::jupyter_server-1.23.4-py310hca03da5_0 ++defaults::python-lsp-server-1.7.1-py310hca03da5_0 ++defaults::qtwebkit-5.212-h0f11f3c_4 ++defaults::requests-2.28.1-py310hca03da5_0 ++defaults::spyder-kernels-2.4.1-py310hca03da5_0 ++defaults::anaconda-client-1.11.1-py310hca03da5_0 ++defaults::conda-23.1.0-py310hca03da5_0 ++defaults::cookiecutter-1.7.3-pyhd3eb1b0_0 ++defaults::dask-2022.7.0-py310hca03da5_0 ++defaults::huggingface_hub-0.10.1-py310hca03da5_0 ++defaults::jupyterlab_server-2.19.0-py310hca03da5_0 ++defaults::notebook-shim-0.2.2-py310hca03da5_0 ++defaults::pooch-1.4.0-pyhd3eb1b0_0 ++defaults::pyct-0.5.0-py310hca03da5_0 ++defaults::pyls-spyder-0.4.0-pyhd3eb1b0_0 ++defaults::pyqt-5.15.7-py310hc377ac9_0 ++defaults::python-lsp-black-1.2.1-py310hca03da5_0 ++defaults::requests-file-1.5.1-pyhd3eb1b0_0 ++defaults::sphinx-5.0.2-py310hca03da5_0 ++defaults::anaconda-project-0.11.1-py310hca03da5_0 ++defaults::colorcet-3.0.1-py310hca03da5_0 ++defaults::conda-build-3.23.3-py310hca03da5_0 ++defaults::conda-repo-cli-1.0.27-py310hca03da5_0 ++defaults::conda-token-0.4.0-pyhd3eb1b0_0 ++defaults::intake-0.6.7-py310hca03da5_0 ++defaults::navigator-updater-0.3.0-py310hca03da5_0 ++defaults::nbclassic-0.5.2-py310hca03da5_0 ++defaults::numpydoc-1.5.0-py310hca03da5_0 ++defaults::panel-0.14.3-py310hca03da5_0 ++defaults::pyqtwebengine-5.15.7-py310hc377ac9_0 ++defaults::qtconsole-5.4.0-py310hca03da5_0 ++defaults::scipy-1.10.0-py310h20cbe94_1 ++defaults::tldextract-3.2.0-pyhd3eb1b0_0 ++defaults::transformers-4.24.0-py310hca03da5_0 ++defaults::anaconda-navigator-2.4.0-py310hca03da5_0 ++defaults::datashader-0.14.4-py310hca03da5_0 ++defaults::gensim-4.3.0-py310h46d7db6_0 ++defaults::notebook-6.5.2-py310hca03da5_0 ++defaults::scikit-image-0.19.3-py310h313beb8_1 ++defaults::scikit-learn-1.2.1-py310h313beb8_0 ++defaults::scrapy-2.8.0-py310hca03da5_0 ++defaults::spyder-5.4.1-py310hca03da5_0 ++defaults::statsmodels-0.13.5-py310hbda83bc_1 ++defaults::holoviews-1.15.4-py310hca03da5_0 ++defaults::imbalanced-learn-0.10.1-py310hca03da5_0 ++defaults::jupyterlab-3.5.3-py310hca03da5_0 ++defaults::hvplot-0.8.2-py310hca03da5_0 +# update specs: ['anaconda==2023.03', 'python=3.10', 'setuptools', 'pip', 'wheel', 'anaconda-client', 'anaconda-project', 'anaconda-navigator', 'conda', 'conda-build', 'conda-content-trust', 'conda-pack', 'conda-package-handling', 'conda-package-streaming', 'conda-token', 'conda-verify', 'python.app'] + diff --git a/crates/pet-conda/tests/unix/conda_envs/user_home/miniconda3/conda-meta/pytest-7.1.2-py310hca03da5_0.json b/crates/pet-conda/tests/unix/conda_envs/user_home/miniconda3/conda-meta/pytest-7.1.2-py310hca03da5_0.json new file mode 100644 index 00000000..eeac4446 --- /dev/null +++ b/crates/pet-conda/tests/unix/conda_envs/user_home/miniconda3/conda-meta/pytest-7.1.2-py310hca03da5_0.json @@ -0,0 +1,209 @@ +{ + "build": "py310hca03da5_0", + "build_number": 0, + "channel": "https://repo.anaconda.com/pkgs/main/osx-arm64", + "constrains": [ + "pytest-faulthandler >=2" + ], + "depends": [ + "attrs >=19.2.0", + "iniconfig", + "packaging", + "pluggy >=0.12,<2.0", + "py >=1.8.2", + "python >=3.10,<3.11.0a0", + "tomli >=1.0.0" + ], + "extracted_package_dir": "/Users/donjayamanne/.pyenv/versions/anaconda3-2023.03/pkgs/pytest-7.1.2-py310hca03da5_0", + "features": "", + "files": [ + "bin/py.test", + "bin/pytest", + "lib/python3.10/site-packages/_pytest/__init__.py", + "lib/python3.10/site-packages/_pytest/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/_argcomplete.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/_version.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/cacheprovider.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/capture.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/compat.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/debugging.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/deprecated.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/doctest.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/faulthandler.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/fixtures.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/freeze_support.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/helpconfig.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/hookspec.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/junitxml.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/legacypath.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/logging.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/main.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/monkeypatch.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/nodes.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/nose.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/outcomes.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/pastebin.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/pathlib.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/pytester.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/pytester_assertions.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/python.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/python_api.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/python_path.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/recwarn.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/reports.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/runner.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/scope.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/setuponly.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/setupplan.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/skipping.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/stash.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/stepwise.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/terminal.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/threadexception.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/timing.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/tmpdir.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/unittest.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/unraisableexception.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/warning_types.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/__pycache__/warnings.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/_argcomplete.py", + "lib/python3.10/site-packages/_pytest/_code/__init__.py", + "lib/python3.10/site-packages/_pytest/_code/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/_code/__pycache__/code.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/_code/__pycache__/source.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/_code/code.py", + "lib/python3.10/site-packages/_pytest/_code/source.py", + "lib/python3.10/site-packages/_pytest/_io/__init__.py", + "lib/python3.10/site-packages/_pytest/_io/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/_io/__pycache__/saferepr.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/_io/__pycache__/terminalwriter.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/_io/__pycache__/wcwidth.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/_io/saferepr.py", + "lib/python3.10/site-packages/_pytest/_io/terminalwriter.py", + "lib/python3.10/site-packages/_pytest/_io/wcwidth.py", + "lib/python3.10/site-packages/_pytest/_version.py", + "lib/python3.10/site-packages/_pytest/assertion/__init__.py", + "lib/python3.10/site-packages/_pytest/assertion/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/assertion/__pycache__/rewrite.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/assertion/__pycache__/truncate.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/assertion/__pycache__/util.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/assertion/rewrite.py", + "lib/python3.10/site-packages/_pytest/assertion/truncate.py", + "lib/python3.10/site-packages/_pytest/assertion/util.py", + "lib/python3.10/site-packages/_pytest/cacheprovider.py", + "lib/python3.10/site-packages/_pytest/capture.py", + "lib/python3.10/site-packages/_pytest/compat.py", + "lib/python3.10/site-packages/_pytest/config/__init__.py", + "lib/python3.10/site-packages/_pytest/config/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/config/__pycache__/argparsing.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/config/__pycache__/compat.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/config/__pycache__/exceptions.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/config/__pycache__/findpaths.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/config/argparsing.py", + "lib/python3.10/site-packages/_pytest/config/compat.py", + "lib/python3.10/site-packages/_pytest/config/exceptions.py", + "lib/python3.10/site-packages/_pytest/config/findpaths.py", + "lib/python3.10/site-packages/_pytest/debugging.py", + "lib/python3.10/site-packages/_pytest/deprecated.py", + "lib/python3.10/site-packages/_pytest/doctest.py", + "lib/python3.10/site-packages/_pytest/faulthandler.py", + "lib/python3.10/site-packages/_pytest/fixtures.py", + "lib/python3.10/site-packages/_pytest/freeze_support.py", + "lib/python3.10/site-packages/_pytest/helpconfig.py", + "lib/python3.10/site-packages/_pytest/hookspec.py", + "lib/python3.10/site-packages/_pytest/junitxml.py", + "lib/python3.10/site-packages/_pytest/legacypath.py", + "lib/python3.10/site-packages/_pytest/logging.py", + "lib/python3.10/site-packages/_pytest/main.py", + "lib/python3.10/site-packages/_pytest/mark/__init__.py", + "lib/python3.10/site-packages/_pytest/mark/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/mark/__pycache__/expression.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/mark/__pycache__/structures.cpython-310.pyc", + "lib/python3.10/site-packages/_pytest/mark/expression.py", + "lib/python3.10/site-packages/_pytest/mark/structures.py", + "lib/python3.10/site-packages/_pytest/monkeypatch.py", + "lib/python3.10/site-packages/_pytest/nodes.py", + "lib/python3.10/site-packages/_pytest/nose.py", + "lib/python3.10/site-packages/_pytest/outcomes.py", + "lib/python3.10/site-packages/_pytest/pastebin.py", + "lib/python3.10/site-packages/_pytest/pathlib.py", + "lib/python3.10/site-packages/_pytest/py.typed", + "lib/python3.10/site-packages/_pytest/pytester.py", + "lib/python3.10/site-packages/_pytest/pytester_assertions.py", + "lib/python3.10/site-packages/_pytest/python.py", + "lib/python3.10/site-packages/_pytest/python_api.py", + "lib/python3.10/site-packages/_pytest/python_path.py", + "lib/python3.10/site-packages/_pytest/recwarn.py", + "lib/python3.10/site-packages/_pytest/reports.py", + "lib/python3.10/site-packages/_pytest/runner.py", + "lib/python3.10/site-packages/_pytest/scope.py", + "lib/python3.10/site-packages/_pytest/setuponly.py", + "lib/python3.10/site-packages/_pytest/setupplan.py", + "lib/python3.10/site-packages/_pytest/skipping.py", + "lib/python3.10/site-packages/_pytest/stash.py", + "lib/python3.10/site-packages/_pytest/stepwise.py", + "lib/python3.10/site-packages/_pytest/terminal.py", + "lib/python3.10/site-packages/_pytest/threadexception.py", + "lib/python3.10/site-packages/_pytest/timing.py", + "lib/python3.10/site-packages/_pytest/tmpdir.py", + "lib/python3.10/site-packages/_pytest/unittest.py", + "lib/python3.10/site-packages/_pytest/unraisableexception.py", + "lib/python3.10/site-packages/_pytest/warning_types.py", + "lib/python3.10/site-packages/_pytest/warnings.py", + "lib/python3.10/site-packages/pytest-7.1.2-py3.10.egg-info/PKG-INFO", + "lib/python3.10/site-packages/pytest-7.1.2-py3.10.egg-info/SOURCES.txt", + "lib/python3.10/site-packages/pytest-7.1.2-py3.10.egg-info/dependency_links.txt", + "lib/python3.10/site-packages/pytest-7.1.2-py3.10.egg-info/entry_points.txt", + "lib/python3.10/site-packages/pytest-7.1.2-py3.10.egg-info/not-zip-safe", + "lib/python3.10/site-packages/pytest-7.1.2-py3.10.egg-info/requires.txt", + "lib/python3.10/site-packages/pytest-7.1.2-py3.10.egg-info/top_level.txt", + "lib/python3.10/site-packages/pytest/__init__.py", + "lib/python3.10/site-packages/pytest/__main__.py", + "lib/python3.10/site-packages/pytest/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/pytest/__pycache__/__main__.cpython-310.pyc", + "lib/python3.10/site-packages/pytest/py.typed" + ], + "fn": "pytest-7.1.2-py310hca03da5_0.conda", + "legacy_bz2_md5": "d5f7cb91582e7a1e1d0302b6691f4ff2", + "legacy_bz2_size": 475724, + "license": "MIT", + "license_family": "MIT", + "link": { + "source": "/Users/donjayamanne/.pyenv/versions/anaconda3-2023.03/pkgs/pytest-7.1.2-py310hca03da5_0", + "type": 1 + }, + "md5": "3d4ffcd5ce4a0f875ed0a577c35dd924", + "name": "pytest", + "package_tarball_full_path": "/Users/donjayamanne/.pyenv/versions/anaconda3-2023.03/pkgs/pytest-7.1.2-py310hca03da5_0.conda", + "paths_data": { + "paths": [ + { + "_path": "bin/py.test", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_bb79cf71-3b0d-4f6e-b127-6cd6f42cd0b3zuaib3yw/croots/recipe/pytest_1654684981069/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_place", + "sha256": "25a4084929551abe44daf94ad6db601477697c2e7fe7754bfa51e927f61a2a82", + "sha256_in_prefix": "74ca4d1facd6ae350af7bf80a69703271ebb7bf74053924e86a222e5d96d1f9e", + "size_in_bytes": 475 + }, + { + "_path": "bin/pytest", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_bb79cf71-3b0d-4f6e-b127-6cd6f42cd0b3zuaib3yw/croots/recipe/pytest_1654684981069/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_place", + "sha256": "25a4084929551abe44daf94ad6db601477697c2e7fe7754bfa51e927f61a2a82", + "sha256_in_prefix": "74ca4d1facd6ae350af7bf80a69703271ebb7bf74053924e86a222e5d96d1f9e", + "size_in_bytes": 475 + } + ], + "paths_version": 1 + }, + "requested_spec": "defaults/osx-arm64::pytest==7.1.2=py310hca03da5_0[md5=3d4ffcd5ce4a0f875ed0a577c35dd924]", + "sha256": "6d9d80df16880009035d6aeca466be48c7511e3dc366469459f3400928ef6c87", + "size": 458308, + "subdir": "osx-arm64", + "timestamp": 1654685008490, + "track_features": "", + "url": "https://repo.anaconda.com/pkgs/main/osx-arm64/pytest-7.1.2-py310hca03da5_0.conda", + "version": "7.1.2" +} \ No newline at end of file diff --git a/crates/pet-conda/tests/unix/conda_envs/user_home/miniconda3/conda-meta/python-3.10.9-hc0d8a6c_1.json b/crates/pet-conda/tests/unix/conda_envs/user_home/miniconda3/conda-meta/python-3.10.9-hc0d8a6c_1.json new file mode 100644 index 00000000..54078722 --- /dev/null +++ b/crates/pet-conda/tests/unix/conda_envs/user_home/miniconda3/conda-meta/python-3.10.9-hc0d8a6c_1.json @@ -0,0 +1,2222 @@ +{ + "build": "hc0d8a6c_1", + "build_number": 1, + "channel": "https://repo.anaconda.com/pkgs/main/osx-arm64", + "constrains": [], + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "libffi >=3.4,<3.5", + "libffi >=3.4,<4.0a0", + "ncurses >=6.4,<7.0a0", + "openssl >=1.1.1t,<1.1.2a", + "readline >=8.1.2,<9.0a0", + "sqlite >=3.40.1,<4.0a0", + "tk >=8.6.12,<8.7.0a0", + "tzdata", + "xz >=5.2.10,<6.0a0", + "zlib >=1.2.13,<1.3.0a0", + "pip" + ], + "extracted_package_dir": "/Users/donjayamanne/.pyenv/versions/anaconda3-2023.03/pkgs/python-3.10.9-hc0d8a6c_1", + "features": "", + "files": [ + "bin/2to3", + "bin/2to3-3.10", + "bin/idle3", + "bin/idle3.10", + "bin/pydoc", + "bin/pydoc3", + "bin/pydoc3.10", + "bin/python", + "bin/python3", + "bin/python3-config", + "bin/python3.1", + "bin/python3.10", + "bin/python3.10-config", + "include/python3.10/Python.h", + "include/python3.10/abstract.h", + "include/python3.10/bltinmodule.h", + "include/python3.10/boolobject.h", + "include/python3.10/bytearrayobject.h", + "include/python3.10/bytesobject.h", + "include/python3.10/cellobject.h", + "include/python3.10/ceval.h", + "include/python3.10/classobject.h", + "include/python3.10/code.h", + "include/python3.10/codecs.h", + "include/python3.10/compile.h", + "include/python3.10/complexobject.h", + "include/python3.10/context.h", + "include/python3.10/cpython/abstract.h", + "include/python3.10/cpython/bytearrayobject.h", + "include/python3.10/cpython/bytesobject.h", + "include/python3.10/cpython/ceval.h", + "include/python3.10/cpython/code.h", + "include/python3.10/cpython/compile.h", + "include/python3.10/cpython/dictobject.h", + "include/python3.10/cpython/fileobject.h", + "include/python3.10/cpython/fileutils.h", + "include/python3.10/cpython/frameobject.h", + "include/python3.10/cpython/import.h", + "include/python3.10/cpython/initconfig.h", + "include/python3.10/cpython/interpreteridobject.h", + "include/python3.10/cpython/listobject.h", + "include/python3.10/cpython/methodobject.h", + "include/python3.10/cpython/object.h", + "include/python3.10/cpython/objimpl.h", + "include/python3.10/cpython/odictobject.h", + "include/python3.10/cpython/picklebufobject.h", + "include/python3.10/cpython/pyctype.h", + "include/python3.10/cpython/pydebug.h", + "include/python3.10/cpython/pyerrors.h", + "include/python3.10/cpython/pyfpe.h", + "include/python3.10/cpython/pylifecycle.h", + "include/python3.10/cpython/pymem.h", + "include/python3.10/cpython/pystate.h", + "include/python3.10/cpython/pythonrun.h", + "include/python3.10/cpython/pytime.h", + "include/python3.10/cpython/sysmodule.h", + "include/python3.10/cpython/traceback.h", + "include/python3.10/cpython/tupleobject.h", + "include/python3.10/cpython/unicodeobject.h", + "include/python3.10/datetime.h", + "include/python3.10/descrobject.h", + "include/python3.10/dictobject.h", + "include/python3.10/dynamic_annotations.h", + "include/python3.10/enumobject.h", + "include/python3.10/errcode.h", + "include/python3.10/eval.h", + "include/python3.10/exports.h", + "include/python3.10/fileobject.h", + "include/python3.10/fileutils.h", + "include/python3.10/floatobject.h", + "include/python3.10/frameobject.h", + "include/python3.10/funcobject.h", + "include/python3.10/genericaliasobject.h", + "include/python3.10/genobject.h", + "include/python3.10/import.h", + "include/python3.10/internal/pycore_abstract.h", + "include/python3.10/internal/pycore_accu.h", + "include/python3.10/internal/pycore_asdl.h", + "include/python3.10/internal/pycore_ast.h", + "include/python3.10/internal/pycore_ast_state.h", + "include/python3.10/internal/pycore_atomic.h", + "include/python3.10/internal/pycore_atomic_funcs.h", + "include/python3.10/internal/pycore_bitutils.h", + "include/python3.10/internal/pycore_blocks_output_buffer.h", + "include/python3.10/internal/pycore_bytes_methods.h", + "include/python3.10/internal/pycore_call.h", + "include/python3.10/internal/pycore_ceval.h", + "include/python3.10/internal/pycore_code.h", + "include/python3.10/internal/pycore_compile.h", + "include/python3.10/internal/pycore_condvar.h", + "include/python3.10/internal/pycore_context.h", + "include/python3.10/internal/pycore_dtoa.h", + "include/python3.10/internal/pycore_fileutils.h", + "include/python3.10/internal/pycore_format.h", + "include/python3.10/internal/pycore_gc.h", + "include/python3.10/internal/pycore_getopt.h", + "include/python3.10/internal/pycore_gil.h", + "include/python3.10/internal/pycore_hamt.h", + "include/python3.10/internal/pycore_hashtable.h", + "include/python3.10/internal/pycore_import.h", + "include/python3.10/internal/pycore_initconfig.h", + "include/python3.10/internal/pycore_interp.h", + "include/python3.10/internal/pycore_list.h", + "include/python3.10/internal/pycore_long.h", + "include/python3.10/internal/pycore_moduleobject.h", + "include/python3.10/internal/pycore_object.h", + "include/python3.10/internal/pycore_parser.h", + "include/python3.10/internal/pycore_pathconfig.h", + "include/python3.10/internal/pycore_pyarena.h", + "include/python3.10/internal/pycore_pyerrors.h", + "include/python3.10/internal/pycore_pyhash.h", + "include/python3.10/internal/pycore_pylifecycle.h", + "include/python3.10/internal/pycore_pymem.h", + "include/python3.10/internal/pycore_pystate.h", + "include/python3.10/internal/pycore_runtime.h", + "include/python3.10/internal/pycore_structseq.h", + "include/python3.10/internal/pycore_symtable.h", + "include/python3.10/internal/pycore_sysmodule.h", + "include/python3.10/internal/pycore_traceback.h", + "include/python3.10/internal/pycore_tuple.h", + "include/python3.10/internal/pycore_ucnhash.h", + "include/python3.10/internal/pycore_unionobject.h", + "include/python3.10/internal/pycore_warnings.h", + "include/python3.10/interpreteridobject.h", + "include/python3.10/intrcheck.h", + "include/python3.10/iterobject.h", + "include/python3.10/listobject.h", + "include/python3.10/longintrepr.h", + "include/python3.10/longobject.h", + "include/python3.10/marshal.h", + "include/python3.10/memoryobject.h", + "include/python3.10/methodobject.h", + "include/python3.10/modsupport.h", + "include/python3.10/moduleobject.h", + "include/python3.10/namespaceobject.h", + "include/python3.10/object.h", + "include/python3.10/objimpl.h", + "include/python3.10/opcode.h", + "include/python3.10/osdefs.h", + "include/python3.10/osmodule.h", + "include/python3.10/patchlevel.h", + "include/python3.10/py_curses.h", + "include/python3.10/pycapsule.h", + "include/python3.10/pyconfig.h", + "include/python3.10/pydtrace.h", + "include/python3.10/pyerrors.h", + "include/python3.10/pyexpat.h", + "include/python3.10/pyframe.h", + "include/python3.10/pyhash.h", + "include/python3.10/pylifecycle.h", + "include/python3.10/pymacconfig.h", + "include/python3.10/pymacro.h", + "include/python3.10/pymath.h", + "include/python3.10/pymem.h", + "include/python3.10/pyport.h", + "include/python3.10/pystate.h", + "include/python3.10/pystrcmp.h", + "include/python3.10/pystrhex.h", + "include/python3.10/pystrtod.h", + "include/python3.10/pythonrun.h", + "include/python3.10/pythread.h", + "include/python3.10/rangeobject.h", + "include/python3.10/setobject.h", + "include/python3.10/sliceobject.h", + "include/python3.10/structmember.h", + "include/python3.10/structseq.h", + "include/python3.10/sysmodule.h", + "include/python3.10/token.h", + "include/python3.10/traceback.h", + "include/python3.10/tracemalloc.h", + "include/python3.10/tupleobject.h", + "include/python3.10/typeslots.h", + "include/python3.10/unicodeobject.h", + "include/python3.10/warnings.h", + "include/python3.10/weakrefobject.h", + "lib/libpython3.10.dylib", + "lib/pkgconfig/python-3.10-embed.pc", + "lib/pkgconfig/python-3.10.pc", + "lib/pkgconfig/python3-embed.pc", + "lib/pkgconfig/python3.pc", + "lib/python3.1", + "lib/python3.10/LICENSE.txt", + "lib/python3.10/__future__.py", + "lib/python3.10/__phello__.foo.py", + "lib/python3.10/__pycache__/__future__.cpython-310.pyc", + "lib/python3.10/__pycache__/__phello__.foo.cpython-310.pyc", + "lib/python3.10/__pycache__/_aix_support.cpython-310.pyc", + "lib/python3.10/__pycache__/_bootsubprocess.cpython-310.pyc", + "lib/python3.10/__pycache__/_collections_abc.cpython-310.pyc", + "lib/python3.10/__pycache__/_compat_pickle.cpython-310.pyc", + "lib/python3.10/__pycache__/_compression.cpython-310.pyc", + "lib/python3.10/__pycache__/_markupbase.cpython-310.pyc", + "lib/python3.10/__pycache__/_osx_support.cpython-310.pyc", + "lib/python3.10/__pycache__/_py_abc.cpython-310.pyc", + "lib/python3.10/__pycache__/_pydecimal.cpython-310.pyc", + "lib/python3.10/__pycache__/_pyio.cpython-310.pyc", + "lib/python3.10/__pycache__/_sitebuiltins.cpython-310.pyc", + "lib/python3.10/__pycache__/_strptime.cpython-310.pyc", + "lib/python3.10/__pycache__/_sysconfigdata__darwin_darwin.cpython-310.pyc", + "lib/python3.10/__pycache__/_sysconfigdata_arm64_apple_darwin20_0_0.cpython-310.pyc", + "lib/python3.10/__pycache__/_threading_local.cpython-310.pyc", + "lib/python3.10/__pycache__/_weakrefset.cpython-310.pyc", + "lib/python3.10/__pycache__/abc.cpython-310.pyc", + "lib/python3.10/__pycache__/aifc.cpython-310.pyc", + "lib/python3.10/__pycache__/antigravity.cpython-310.pyc", + "lib/python3.10/__pycache__/argparse.cpython-310.pyc", + "lib/python3.10/__pycache__/ast.cpython-310.pyc", + "lib/python3.10/__pycache__/asynchat.cpython-310.pyc", + "lib/python3.10/__pycache__/asyncore.cpython-310.pyc", + "lib/python3.10/__pycache__/base64.cpython-310.pyc", + "lib/python3.10/__pycache__/bdb.cpython-310.pyc", + "lib/python3.10/__pycache__/binhex.cpython-310.pyc", + "lib/python3.10/__pycache__/bisect.cpython-310.pyc", + "lib/python3.10/__pycache__/bz2.cpython-310.pyc", + "lib/python3.10/__pycache__/cProfile.cpython-310.pyc", + "lib/python3.10/__pycache__/calendar.cpython-310.pyc", + "lib/python3.10/__pycache__/cgi.cpython-310.pyc", + "lib/python3.10/__pycache__/cgitb.cpython-310.pyc", + "lib/python3.10/__pycache__/chunk.cpython-310.pyc", + "lib/python3.10/__pycache__/cmd.cpython-310.pyc", + "lib/python3.10/__pycache__/code.cpython-310.pyc", + "lib/python3.10/__pycache__/codecs.cpython-310.pyc", + "lib/python3.10/__pycache__/codeop.cpython-310.pyc", + "lib/python3.10/__pycache__/colorsys.cpython-310.pyc", + "lib/python3.10/__pycache__/compileall.cpython-310.pyc", + "lib/python3.10/__pycache__/configparser.cpython-310.pyc", + "lib/python3.10/__pycache__/contextlib.cpython-310.pyc", + "lib/python3.10/__pycache__/contextvars.cpython-310.pyc", + "lib/python3.10/__pycache__/copy.cpython-310.pyc", + "lib/python3.10/__pycache__/copyreg.cpython-310.pyc", + "lib/python3.10/__pycache__/crypt.cpython-310.pyc", + "lib/python3.10/__pycache__/csv.cpython-310.pyc", + "lib/python3.10/__pycache__/dataclasses.cpython-310.pyc", + "lib/python3.10/__pycache__/datetime.cpython-310.pyc", + "lib/python3.10/__pycache__/decimal.cpython-310.pyc", + "lib/python3.10/__pycache__/difflib.cpython-310.pyc", + "lib/python3.10/__pycache__/dis.cpython-310.pyc", + "lib/python3.10/__pycache__/doctest.cpython-310.pyc", + "lib/python3.10/__pycache__/enum.cpython-310.pyc", + "lib/python3.10/__pycache__/filecmp.cpython-310.pyc", + "lib/python3.10/__pycache__/fileinput.cpython-310.pyc", + "lib/python3.10/__pycache__/fnmatch.cpython-310.pyc", + "lib/python3.10/__pycache__/fractions.cpython-310.pyc", + "lib/python3.10/__pycache__/ftplib.cpython-310.pyc", + "lib/python3.10/__pycache__/functools.cpython-310.pyc", + "lib/python3.10/__pycache__/genericpath.cpython-310.pyc", + "lib/python3.10/__pycache__/getopt.cpython-310.pyc", + "lib/python3.10/__pycache__/getpass.cpython-310.pyc", + "lib/python3.10/__pycache__/gettext.cpython-310.pyc", + "lib/python3.10/__pycache__/glob.cpython-310.pyc", + "lib/python3.10/__pycache__/graphlib.cpython-310.pyc", + "lib/python3.10/__pycache__/gzip.cpython-310.pyc", + "lib/python3.10/__pycache__/hashlib.cpython-310.pyc", + "lib/python3.10/__pycache__/heapq.cpython-310.pyc", + "lib/python3.10/__pycache__/hmac.cpython-310.pyc", + "lib/python3.10/__pycache__/imaplib.cpython-310.pyc", + "lib/python3.10/__pycache__/imghdr.cpython-310.pyc", + "lib/python3.10/__pycache__/imp.cpython-310.pyc", + "lib/python3.10/__pycache__/inspect.cpython-310.pyc", + "lib/python3.10/__pycache__/io.cpython-310.pyc", + "lib/python3.10/__pycache__/ipaddress.cpython-310.pyc", + "lib/python3.10/__pycache__/keyword.cpython-310.pyc", + "lib/python3.10/__pycache__/linecache.cpython-310.pyc", + "lib/python3.10/__pycache__/locale.cpython-310.pyc", + "lib/python3.10/__pycache__/lzma.cpython-310.pyc", + "lib/python3.10/__pycache__/mailbox.cpython-310.pyc", + "lib/python3.10/__pycache__/mailcap.cpython-310.pyc", + "lib/python3.10/__pycache__/mimetypes.cpython-310.pyc", + "lib/python3.10/__pycache__/modulefinder.cpython-310.pyc", + "lib/python3.10/__pycache__/netrc.cpython-310.pyc", + "lib/python3.10/__pycache__/nntplib.cpython-310.pyc", + "lib/python3.10/__pycache__/ntpath.cpython-310.pyc", + "lib/python3.10/__pycache__/nturl2path.cpython-310.pyc", + "lib/python3.10/__pycache__/numbers.cpython-310.pyc", + "lib/python3.10/__pycache__/opcode.cpython-310.pyc", + "lib/python3.10/__pycache__/operator.cpython-310.pyc", + "lib/python3.10/__pycache__/optparse.cpython-310.pyc", + "lib/python3.10/__pycache__/os.cpython-310.pyc", + "lib/python3.10/__pycache__/pathlib.cpython-310.pyc", + "lib/python3.10/__pycache__/pdb.cpython-310.pyc", + "lib/python3.10/__pycache__/pickle.cpython-310.pyc", + "lib/python3.10/__pycache__/pickletools.cpython-310.pyc", + "lib/python3.10/__pycache__/pipes.cpython-310.pyc", + "lib/python3.10/__pycache__/pkgutil.cpython-310.pyc", + "lib/python3.10/__pycache__/platform.cpython-310.pyc", + "lib/python3.10/__pycache__/plistlib.cpython-310.pyc", + "lib/python3.10/__pycache__/poplib.cpython-310.pyc", + "lib/python3.10/__pycache__/posixpath.cpython-310.pyc", + "lib/python3.10/__pycache__/pprint.cpython-310.pyc", + "lib/python3.10/__pycache__/profile.cpython-310.pyc", + "lib/python3.10/__pycache__/pstats.cpython-310.pyc", + "lib/python3.10/__pycache__/pty.cpython-310.pyc", + "lib/python3.10/__pycache__/py_compile.cpython-310.pyc", + "lib/python3.10/__pycache__/pyclbr.cpython-310.pyc", + "lib/python3.10/__pycache__/pydoc.cpython-310.pyc", + "lib/python3.10/__pycache__/queue.cpython-310.pyc", + "lib/python3.10/__pycache__/quopri.cpython-310.pyc", + "lib/python3.10/__pycache__/random.cpython-310.pyc", + "lib/python3.10/__pycache__/re.cpython-310.pyc", + "lib/python3.10/__pycache__/reprlib.cpython-310.pyc", + "lib/python3.10/__pycache__/rlcompleter.cpython-310.pyc", + "lib/python3.10/__pycache__/runpy.cpython-310.pyc", + "lib/python3.10/__pycache__/sched.cpython-310.pyc", + "lib/python3.10/__pycache__/secrets.cpython-310.pyc", + "lib/python3.10/__pycache__/selectors.cpython-310.pyc", + "lib/python3.10/__pycache__/shelve.cpython-310.pyc", + "lib/python3.10/__pycache__/shlex.cpython-310.pyc", + "lib/python3.10/__pycache__/shutil.cpython-310.pyc", + "lib/python3.10/__pycache__/signal.cpython-310.pyc", + "lib/python3.10/__pycache__/site.cpython-310.pyc", + "lib/python3.10/__pycache__/smtpd.cpython-310.pyc", + "lib/python3.10/__pycache__/smtplib.cpython-310.pyc", + "lib/python3.10/__pycache__/sndhdr.cpython-310.pyc", + "lib/python3.10/__pycache__/socket.cpython-310.pyc", + "lib/python3.10/__pycache__/socketserver.cpython-310.pyc", + "lib/python3.10/__pycache__/sre_compile.cpython-310.pyc", + "lib/python3.10/__pycache__/sre_constants.cpython-310.pyc", + "lib/python3.10/__pycache__/sre_parse.cpython-310.pyc", + "lib/python3.10/__pycache__/ssl.cpython-310.pyc", + "lib/python3.10/__pycache__/stat.cpython-310.pyc", + "lib/python3.10/__pycache__/statistics.cpython-310.pyc", + "lib/python3.10/__pycache__/string.cpython-310.pyc", + "lib/python3.10/__pycache__/stringprep.cpython-310.pyc", + "lib/python3.10/__pycache__/struct.cpython-310.pyc", + "lib/python3.10/__pycache__/subprocess.cpython-310.pyc", + "lib/python3.10/__pycache__/sunau.cpython-310.pyc", + "lib/python3.10/__pycache__/symtable.cpython-310.pyc", + "lib/python3.10/__pycache__/sysconfig.cpython-310.pyc", + "lib/python3.10/__pycache__/tabnanny.cpython-310.pyc", + "lib/python3.10/__pycache__/tarfile.cpython-310.pyc", + "lib/python3.10/__pycache__/telnetlib.cpython-310.pyc", + "lib/python3.10/__pycache__/tempfile.cpython-310.pyc", + "lib/python3.10/__pycache__/textwrap.cpython-310.pyc", + "lib/python3.10/__pycache__/this.cpython-310.pyc", + "lib/python3.10/__pycache__/threading.cpython-310.pyc", + "lib/python3.10/__pycache__/timeit.cpython-310.pyc", + "lib/python3.10/__pycache__/token.cpython-310.pyc", + "lib/python3.10/__pycache__/tokenize.cpython-310.pyc", + "lib/python3.10/__pycache__/trace.cpython-310.pyc", + "lib/python3.10/__pycache__/traceback.cpython-310.pyc", + "lib/python3.10/__pycache__/tracemalloc.cpython-310.pyc", + "lib/python3.10/__pycache__/tty.cpython-310.pyc", + "lib/python3.10/__pycache__/turtle.cpython-310.pyc", + "lib/python3.10/__pycache__/types.cpython-310.pyc", + "lib/python3.10/__pycache__/typing.cpython-310.pyc", + "lib/python3.10/__pycache__/uu.cpython-310.pyc", + "lib/python3.10/__pycache__/uuid.cpython-310.pyc", + "lib/python3.10/__pycache__/warnings.cpython-310.pyc", + "lib/python3.10/__pycache__/wave.cpython-310.pyc", + "lib/python3.10/__pycache__/weakref.cpython-310.pyc", + "lib/python3.10/__pycache__/webbrowser.cpython-310.pyc", + "lib/python3.10/__pycache__/xdrlib.cpython-310.pyc", + "lib/python3.10/__pycache__/zipapp.cpython-310.pyc", + "lib/python3.10/__pycache__/zipfile.cpython-310.pyc", + "lib/python3.10/__pycache__/zipimport.cpython-310.pyc", + "lib/python3.10/_aix_support.py", + "lib/python3.10/_bootsubprocess.py", + "lib/python3.10/_collections_abc.py", + "lib/python3.10/_compat_pickle.py", + "lib/python3.10/_compression.py", + "lib/python3.10/_markupbase.py", + "lib/python3.10/_osx_support.py", + "lib/python3.10/_py_abc.py", + "lib/python3.10/_pydecimal.py", + "lib/python3.10/_pyio.py", + "lib/python3.10/_sitebuiltins.py", + "lib/python3.10/_strptime.py", + "lib/python3.10/_sysconfigdata__darwin_darwin.py", + "lib/python3.10/_sysconfigdata__darwin_darwin.py.orig", + "lib/python3.10/_sysconfigdata_arm64_apple_darwin20_0_0.py", + "lib/python3.10/_threading_local.py", + "lib/python3.10/_weakrefset.py", + "lib/python3.10/abc.py", + "lib/python3.10/aifc.py", + "lib/python3.10/antigravity.py", + "lib/python3.10/argparse.py", + "lib/python3.10/ast.py", + "lib/python3.10/asynchat.py", + "lib/python3.10/asyncio/__init__.py", + "lib/python3.10/asyncio/__main__.py", + "lib/python3.10/asyncio/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/__main__.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/base_events.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/base_futures.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/base_subprocess.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/base_tasks.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/constants.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/coroutines.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/events.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/exceptions.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/format_helpers.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/futures.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/locks.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/log.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/mixins.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/proactor_events.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/protocols.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/queues.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/runners.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/selector_events.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/sslproto.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/staggered.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/streams.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/subprocess.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/tasks.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/threads.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/transports.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/trsock.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/unix_events.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/windows_events.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/windows_utils.cpython-310.pyc", + "lib/python3.10/asyncio/base_events.py", + "lib/python3.10/asyncio/base_futures.py", + "lib/python3.10/asyncio/base_subprocess.py", + "lib/python3.10/asyncio/base_tasks.py", + "lib/python3.10/asyncio/constants.py", + "lib/python3.10/asyncio/coroutines.py", + "lib/python3.10/asyncio/events.py", + "lib/python3.10/asyncio/exceptions.py", + "lib/python3.10/asyncio/format_helpers.py", + "lib/python3.10/asyncio/futures.py", + "lib/python3.10/asyncio/locks.py", + "lib/python3.10/asyncio/log.py", + "lib/python3.10/asyncio/mixins.py", + "lib/python3.10/asyncio/proactor_events.py", + "lib/python3.10/asyncio/protocols.py", + "lib/python3.10/asyncio/queues.py", + "lib/python3.10/asyncio/runners.py", + "lib/python3.10/asyncio/selector_events.py", + "lib/python3.10/asyncio/sslproto.py", + "lib/python3.10/asyncio/staggered.py", + "lib/python3.10/asyncio/streams.py", + "lib/python3.10/asyncio/subprocess.py", + "lib/python3.10/asyncio/tasks.py", + "lib/python3.10/asyncio/threads.py", + "lib/python3.10/asyncio/transports.py", + "lib/python3.10/asyncio/trsock.py", + "lib/python3.10/asyncio/unix_events.py", + "lib/python3.10/asyncio/windows_events.py", + "lib/python3.10/asyncio/windows_utils.py", + "lib/python3.10/asyncore.py", + "lib/python3.10/base64.py", + "lib/python3.10/bdb.py", + "lib/python3.10/binhex.py", + "lib/python3.10/bisect.py", + "lib/python3.10/bz2.py", + "lib/python3.10/cProfile.py", + "lib/python3.10/calendar.py", + "lib/python3.10/cgi.py", + "lib/python3.10/cgitb.py", + "lib/python3.10/chunk.py", + "lib/python3.10/cmd.py", + "lib/python3.10/code.py", + "lib/python3.10/codecs.py", + "lib/python3.10/codeop.py", + "lib/python3.10/collections/__init__.py", + "lib/python3.10/collections/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/collections/__pycache__/abc.cpython-310.pyc", + "lib/python3.10/collections/abc.py", + "lib/python3.10/colorsys.py", + "lib/python3.10/compileall.py", + "lib/python3.10/concurrent/__init__.py", + "lib/python3.10/concurrent/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/concurrent/futures/__init__.py", + "lib/python3.10/concurrent/futures/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/concurrent/futures/__pycache__/_base.cpython-310.pyc", + "lib/python3.10/concurrent/futures/__pycache__/process.cpython-310.pyc", + "lib/python3.10/concurrent/futures/__pycache__/thread.cpython-310.pyc", + "lib/python3.10/concurrent/futures/_base.py", + "lib/python3.10/concurrent/futures/process.py", + "lib/python3.10/concurrent/futures/thread.py", + "lib/python3.10/config-3.10-darwin/Makefile", + "lib/python3.10/config-3.10-darwin/Setup", + "lib/python3.10/config-3.10-darwin/Setup.local", + "lib/python3.10/config-3.10-darwin/__pycache__/python-config.cpython-310.pyc", + "lib/python3.10/config-3.10-darwin/config.c", + "lib/python3.10/config-3.10-darwin/config.c.in", + "lib/python3.10/config-3.10-darwin/install-sh", + "lib/python3.10/config-3.10-darwin/makesetup", + "lib/python3.10/config-3.10-darwin/python-config.py", + "lib/python3.10/config-3.10-darwin/python.o", + "lib/python3.10/configparser.py", + "lib/python3.10/contextlib.py", + "lib/python3.10/contextvars.py", + "lib/python3.10/copy.py", + "lib/python3.10/copyreg.py", + "lib/python3.10/crypt.py", + "lib/python3.10/csv.py", + "lib/python3.10/ctypes/__init__.py", + "lib/python3.10/ctypes/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/ctypes/__pycache__/_aix.cpython-310.pyc", + "lib/python3.10/ctypes/__pycache__/_endian.cpython-310.pyc", + "lib/python3.10/ctypes/__pycache__/util.cpython-310.pyc", + "lib/python3.10/ctypes/__pycache__/wintypes.cpython-310.pyc", + "lib/python3.10/ctypes/_aix.py", + "lib/python3.10/ctypes/_endian.py", + "lib/python3.10/ctypes/macholib/README.ctypes", + "lib/python3.10/ctypes/macholib/__init__.py", + "lib/python3.10/ctypes/macholib/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/ctypes/macholib/__pycache__/dyld.cpython-310.pyc", + "lib/python3.10/ctypes/macholib/__pycache__/dylib.cpython-310.pyc", + "lib/python3.10/ctypes/macholib/__pycache__/framework.cpython-310.pyc", + "lib/python3.10/ctypes/macholib/dyld.py", + "lib/python3.10/ctypes/macholib/dylib.py", + "lib/python3.10/ctypes/macholib/fetch_macholib", + "lib/python3.10/ctypes/macholib/fetch_macholib.bat", + "lib/python3.10/ctypes/macholib/framework.py", + "lib/python3.10/ctypes/util.py", + "lib/python3.10/ctypes/wintypes.py", + "lib/python3.10/curses/__init__.py", + "lib/python3.10/curses/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/curses/__pycache__/ascii.cpython-310.pyc", + "lib/python3.10/curses/__pycache__/has_key.cpython-310.pyc", + "lib/python3.10/curses/__pycache__/panel.cpython-310.pyc", + "lib/python3.10/curses/__pycache__/textpad.cpython-310.pyc", + "lib/python3.10/curses/ascii.py", + "lib/python3.10/curses/has_key.py", + "lib/python3.10/curses/panel.py", + "lib/python3.10/curses/textpad.py", + "lib/python3.10/dataclasses.py", + "lib/python3.10/datetime.py", + "lib/python3.10/dbm/__init__.py", + "lib/python3.10/dbm/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/dbm/__pycache__/dumb.cpython-310.pyc", + "lib/python3.10/dbm/__pycache__/gnu.cpython-310.pyc", + "lib/python3.10/dbm/__pycache__/ndbm.cpython-310.pyc", + "lib/python3.10/dbm/dumb.py", + "lib/python3.10/dbm/gnu.py", + "lib/python3.10/dbm/ndbm.py", + "lib/python3.10/decimal.py", + "lib/python3.10/difflib.py", + "lib/python3.10/dis.py", + "lib/python3.10/distutils/README", + "lib/python3.10/distutils/__init__.py", + "lib/python3.10/distutils/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/_msvccompiler.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/archive_util.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/bcppcompiler.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/ccompiler.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/cmd.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/config.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/core.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/cygwinccompiler.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/debug.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/dep_util.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/dir_util.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/dist.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/errors.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/extension.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/fancy_getopt.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/file_util.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/filelist.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/log.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/msvc9compiler.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/msvccompiler.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/spawn.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/sysconfig.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/text_file.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/unixccompiler.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/util.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/version.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/versionpredicate.cpython-310.pyc", + "lib/python3.10/distutils/_msvccompiler.py", + "lib/python3.10/distutils/archive_util.py", + "lib/python3.10/distutils/bcppcompiler.py", + "lib/python3.10/distutils/ccompiler.py", + "lib/python3.10/distutils/cmd.py", + "lib/python3.10/distutils/command/__init__.py", + "lib/python3.10/distutils/command/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/distutils/command/__pycache__/bdist.cpython-310.pyc", + "lib/python3.10/distutils/command/__pycache__/bdist_dumb.cpython-310.pyc", + "lib/python3.10/distutils/command/__pycache__/bdist_msi.cpython-310.pyc", + "lib/python3.10/distutils/command/__pycache__/bdist_rpm.cpython-310.pyc", + "lib/python3.10/distutils/command/__pycache__/build.cpython-310.pyc", + "lib/python3.10/distutils/command/__pycache__/build_clib.cpython-310.pyc", + "lib/python3.10/distutils/command/__pycache__/build_ext.cpython-310.pyc", + "lib/python3.10/distutils/command/__pycache__/build_py.cpython-310.pyc", + "lib/python3.10/distutils/command/__pycache__/build_scripts.cpython-310.pyc", + "lib/python3.10/distutils/command/__pycache__/check.cpython-310.pyc", + "lib/python3.10/distutils/command/__pycache__/clean.cpython-310.pyc", + "lib/python3.10/distutils/command/__pycache__/config.cpython-310.pyc", + "lib/python3.10/distutils/command/__pycache__/install.cpython-310.pyc", + "lib/python3.10/distutils/command/__pycache__/install_data.cpython-310.pyc", + "lib/python3.10/distutils/command/__pycache__/install_egg_info.cpython-310.pyc", + "lib/python3.10/distutils/command/__pycache__/install_headers.cpython-310.pyc", + "lib/python3.10/distutils/command/__pycache__/install_lib.cpython-310.pyc", + "lib/python3.10/distutils/command/__pycache__/install_scripts.cpython-310.pyc", + "lib/python3.10/distutils/command/__pycache__/register.cpython-310.pyc", + "lib/python3.10/distutils/command/__pycache__/sdist.cpython-310.pyc", + "lib/python3.10/distutils/command/__pycache__/upload.cpython-310.pyc", + "lib/python3.10/distutils/command/bdist.py", + "lib/python3.10/distutils/command/bdist_dumb.py", + "lib/python3.10/distutils/command/bdist_msi.py", + "lib/python3.10/distutils/command/bdist_rpm.py", + "lib/python3.10/distutils/command/build.py", + "lib/python3.10/distutils/command/build_clib.py", + "lib/python3.10/distutils/command/build_ext.py", + "lib/python3.10/distutils/command/build_py.py", + "lib/python3.10/distutils/command/build_scripts.py", + "lib/python3.10/distutils/command/check.py", + "lib/python3.10/distutils/command/clean.py", + "lib/python3.10/distutils/command/command_template", + "lib/python3.10/distutils/command/config.py", + "lib/python3.10/distutils/command/install.py", + "lib/python3.10/distutils/command/install_data.py", + "lib/python3.10/distutils/command/install_egg_info.py", + "lib/python3.10/distutils/command/install_headers.py", + "lib/python3.10/distutils/command/install_lib.py", + "lib/python3.10/distutils/command/install_scripts.py", + "lib/python3.10/distutils/command/register.py", + "lib/python3.10/distutils/command/sdist.py", + "lib/python3.10/distutils/command/upload.py", + "lib/python3.10/distutils/config.py", + "lib/python3.10/distutils/core.py", + "lib/python3.10/distutils/cygwinccompiler.py", + "lib/python3.10/distutils/debug.py", + "lib/python3.10/distutils/dep_util.py", + "lib/python3.10/distutils/dir_util.py", + "lib/python3.10/distutils/dist.py", + "lib/python3.10/distutils/errors.py", + "lib/python3.10/distutils/extension.py", + "lib/python3.10/distutils/fancy_getopt.py", + "lib/python3.10/distutils/file_util.py", + "lib/python3.10/distutils/filelist.py", + "lib/python3.10/distutils/log.py", + "lib/python3.10/distutils/msvc9compiler.py", + "lib/python3.10/distutils/msvccompiler.py", + "lib/python3.10/distutils/spawn.py", + "lib/python3.10/distutils/sysconfig.py", + "lib/python3.10/distutils/tests/Setup.sample", + "lib/python3.10/distutils/tests/__init__.py", + "lib/python3.10/distutils/tests/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/support.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_archive_util.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_bdist.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_bdist_dumb.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_bdist_msi.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_bdist_rpm.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_build.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_build_clib.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_build_ext.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_build_py.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_build_scripts.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_check.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_clean.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_cmd.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_config.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_config_cmd.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_core.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_cygwinccompiler.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_dep_util.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_dir_util.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_dist.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_extension.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_file_util.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_filelist.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_install.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_install_data.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_install_headers.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_install_lib.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_install_scripts.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_log.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_msvc9compiler.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_msvccompiler.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_register.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_sdist.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_spawn.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_sysconfig.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_text_file.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_unixccompiler.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_upload.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_util.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_version.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_versionpredicate.cpython-310.pyc", + "lib/python3.10/distutils/tests/includetest.rst", + "lib/python3.10/distutils/tests/support.py", + "lib/python3.10/distutils/tests/test_archive_util.py", + "lib/python3.10/distutils/tests/test_bdist.py", + "lib/python3.10/distutils/tests/test_bdist_dumb.py", + "lib/python3.10/distutils/tests/test_bdist_msi.py", + "lib/python3.10/distutils/tests/test_bdist_rpm.py", + "lib/python3.10/distutils/tests/test_build.py", + "lib/python3.10/distutils/tests/test_build_clib.py", + "lib/python3.10/distutils/tests/test_build_ext.py", + "lib/python3.10/distutils/tests/test_build_py.py", + "lib/python3.10/distutils/tests/test_build_scripts.py", + "lib/python3.10/distutils/tests/test_check.py", + "lib/python3.10/distutils/tests/test_clean.py", + "lib/python3.10/distutils/tests/test_cmd.py", + "lib/python3.10/distutils/tests/test_config.py", + "lib/python3.10/distutils/tests/test_config_cmd.py", + "lib/python3.10/distutils/tests/test_core.py", + "lib/python3.10/distutils/tests/test_cygwinccompiler.py", + "lib/python3.10/distutils/tests/test_dep_util.py", + "lib/python3.10/distutils/tests/test_dir_util.py", + "lib/python3.10/distutils/tests/test_dist.py", + "lib/python3.10/distutils/tests/test_extension.py", + "lib/python3.10/distutils/tests/test_file_util.py", + "lib/python3.10/distutils/tests/test_filelist.py", + "lib/python3.10/distutils/tests/test_install.py", + "lib/python3.10/distutils/tests/test_install_data.py", + "lib/python3.10/distutils/tests/test_install_headers.py", + "lib/python3.10/distutils/tests/test_install_lib.py", + "lib/python3.10/distutils/tests/test_install_scripts.py", + "lib/python3.10/distutils/tests/test_log.py", + "lib/python3.10/distutils/tests/test_msvc9compiler.py", + "lib/python3.10/distutils/tests/test_msvccompiler.py", + "lib/python3.10/distutils/tests/test_register.py", + "lib/python3.10/distutils/tests/test_sdist.py", + "lib/python3.10/distutils/tests/test_spawn.py", + "lib/python3.10/distutils/tests/test_sysconfig.py", + "lib/python3.10/distutils/tests/test_text_file.py", + "lib/python3.10/distutils/tests/test_unixccompiler.py", + "lib/python3.10/distutils/tests/test_upload.py", + "lib/python3.10/distutils/tests/test_util.py", + "lib/python3.10/distutils/tests/test_version.py", + "lib/python3.10/distutils/tests/test_versionpredicate.py", + "lib/python3.10/distutils/tests/xxmodule.c", + "lib/python3.10/distutils/text_file.py", + "lib/python3.10/distutils/unixccompiler.py", + "lib/python3.10/distutils/util.py", + "lib/python3.10/distutils/version.py", + "lib/python3.10/distutils/versionpredicate.py", + "lib/python3.10/doctest.py", + "lib/python3.10/email/__init__.py", + "lib/python3.10/email/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/email/__pycache__/_encoded_words.cpython-310.pyc", + "lib/python3.10/email/__pycache__/_header_value_parser.cpython-310.pyc", + "lib/python3.10/email/__pycache__/_parseaddr.cpython-310.pyc", + "lib/python3.10/email/__pycache__/_policybase.cpython-310.pyc", + "lib/python3.10/email/__pycache__/base64mime.cpython-310.pyc", + "lib/python3.10/email/__pycache__/charset.cpython-310.pyc", + "lib/python3.10/email/__pycache__/contentmanager.cpython-310.pyc", + "lib/python3.10/email/__pycache__/encoders.cpython-310.pyc", + "lib/python3.10/email/__pycache__/errors.cpython-310.pyc", + "lib/python3.10/email/__pycache__/feedparser.cpython-310.pyc", + "lib/python3.10/email/__pycache__/generator.cpython-310.pyc", + "lib/python3.10/email/__pycache__/header.cpython-310.pyc", + "lib/python3.10/email/__pycache__/headerregistry.cpython-310.pyc", + "lib/python3.10/email/__pycache__/iterators.cpython-310.pyc", + "lib/python3.10/email/__pycache__/message.cpython-310.pyc", + "lib/python3.10/email/__pycache__/parser.cpython-310.pyc", + "lib/python3.10/email/__pycache__/policy.cpython-310.pyc", + "lib/python3.10/email/__pycache__/quoprimime.cpython-310.pyc", + "lib/python3.10/email/__pycache__/utils.cpython-310.pyc", + "lib/python3.10/email/_encoded_words.py", + "lib/python3.10/email/_header_value_parser.py", + "lib/python3.10/email/_parseaddr.py", + "lib/python3.10/email/_policybase.py", + "lib/python3.10/email/architecture.rst", + "lib/python3.10/email/base64mime.py", + "lib/python3.10/email/charset.py", + "lib/python3.10/email/contentmanager.py", + "lib/python3.10/email/encoders.py", + "lib/python3.10/email/errors.py", + "lib/python3.10/email/feedparser.py", + "lib/python3.10/email/generator.py", + "lib/python3.10/email/header.py", + "lib/python3.10/email/headerregistry.py", + "lib/python3.10/email/iterators.py", + "lib/python3.10/email/message.py", + "lib/python3.10/email/mime/__init__.py", + "lib/python3.10/email/mime/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/email/mime/__pycache__/application.cpython-310.pyc", + "lib/python3.10/email/mime/__pycache__/audio.cpython-310.pyc", + "lib/python3.10/email/mime/__pycache__/base.cpython-310.pyc", + "lib/python3.10/email/mime/__pycache__/image.cpython-310.pyc", + "lib/python3.10/email/mime/__pycache__/message.cpython-310.pyc", + "lib/python3.10/email/mime/__pycache__/multipart.cpython-310.pyc", + "lib/python3.10/email/mime/__pycache__/nonmultipart.cpython-310.pyc", + "lib/python3.10/email/mime/__pycache__/text.cpython-310.pyc", + "lib/python3.10/email/mime/application.py", + "lib/python3.10/email/mime/audio.py", + "lib/python3.10/email/mime/base.py", + "lib/python3.10/email/mime/image.py", + "lib/python3.10/email/mime/message.py", + "lib/python3.10/email/mime/multipart.py", + "lib/python3.10/email/mime/nonmultipart.py", + "lib/python3.10/email/mime/text.py", + "lib/python3.10/email/parser.py", + "lib/python3.10/email/policy.py", + "lib/python3.10/email/quoprimime.py", + "lib/python3.10/email/utils.py", + "lib/python3.10/encodings/__init__.py", + "lib/python3.10/encodings/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/aliases.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/ascii.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/base64_codec.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/big5.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/big5hkscs.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/bz2_codec.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/charmap.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp037.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp1006.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp1026.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp1125.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp1140.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp1250.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp1251.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp1252.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp1253.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp1254.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp1255.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp1256.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp1257.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp1258.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp273.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp424.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp437.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp500.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp720.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp737.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp775.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp850.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp852.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp855.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp856.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp857.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp858.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp860.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp861.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp862.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp863.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp864.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp865.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp866.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp869.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp874.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp875.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp932.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp949.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp950.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/euc_jis_2004.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/euc_jisx0213.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/euc_jp.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/euc_kr.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/gb18030.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/gb2312.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/gbk.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/hex_codec.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/hp_roman8.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/hz.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/idna.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/iso2022_jp.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/iso2022_jp_1.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/iso2022_jp_2.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/iso2022_jp_2004.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/iso2022_jp_3.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/iso2022_jp_ext.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/iso2022_kr.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/iso8859_1.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/iso8859_10.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/iso8859_11.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/iso8859_13.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/iso8859_14.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/iso8859_15.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/iso8859_16.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/iso8859_2.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/iso8859_3.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/iso8859_4.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/iso8859_5.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/iso8859_6.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/iso8859_7.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/iso8859_8.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/iso8859_9.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/johab.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/koi8_r.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/koi8_t.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/koi8_u.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/kz1048.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/latin_1.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/mac_arabic.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/mac_croatian.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/mac_cyrillic.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/mac_farsi.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/mac_greek.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/mac_iceland.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/mac_latin2.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/mac_roman.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/mac_romanian.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/mac_turkish.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/mbcs.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/oem.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/palmos.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/ptcp154.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/punycode.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/quopri_codec.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/raw_unicode_escape.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/rot_13.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/shift_jis.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/shift_jis_2004.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/shift_jisx0213.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/tis_620.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/undefined.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/unicode_escape.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/utf_16.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/utf_16_be.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/utf_16_le.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/utf_32.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/utf_32_be.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/utf_32_le.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/utf_7.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/utf_8.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/utf_8_sig.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/uu_codec.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/zlib_codec.cpython-310.pyc", + "lib/python3.10/encodings/aliases.py", + "lib/python3.10/encodings/ascii.py", + "lib/python3.10/encodings/base64_codec.py", + "lib/python3.10/encodings/big5.py", + "lib/python3.10/encodings/big5hkscs.py", + "lib/python3.10/encodings/bz2_codec.py", + "lib/python3.10/encodings/charmap.py", + "lib/python3.10/encodings/cp037.py", + "lib/python3.10/encodings/cp1006.py", + "lib/python3.10/encodings/cp1026.py", + "lib/python3.10/encodings/cp1125.py", + "lib/python3.10/encodings/cp1140.py", + "lib/python3.10/encodings/cp1250.py", + "lib/python3.10/encodings/cp1251.py", + "lib/python3.10/encodings/cp1252.py", + "lib/python3.10/encodings/cp1253.py", + "lib/python3.10/encodings/cp1254.py", + "lib/python3.10/encodings/cp1255.py", + "lib/python3.10/encodings/cp1256.py", + "lib/python3.10/encodings/cp1257.py", + "lib/python3.10/encodings/cp1258.py", + "lib/python3.10/encodings/cp273.py", + "lib/python3.10/encodings/cp424.py", + "lib/python3.10/encodings/cp437.py", + "lib/python3.10/encodings/cp500.py", + "lib/python3.10/encodings/cp720.py", + "lib/python3.10/encodings/cp737.py", + "lib/python3.10/encodings/cp775.py", + "lib/python3.10/encodings/cp850.py", + "lib/python3.10/encodings/cp852.py", + "lib/python3.10/encodings/cp855.py", + "lib/python3.10/encodings/cp856.py", + "lib/python3.10/encodings/cp857.py", + "lib/python3.10/encodings/cp858.py", + "lib/python3.10/encodings/cp860.py", + "lib/python3.10/encodings/cp861.py", + "lib/python3.10/encodings/cp862.py", + "lib/python3.10/encodings/cp863.py", + "lib/python3.10/encodings/cp864.py", + "lib/python3.10/encodings/cp865.py", + "lib/python3.10/encodings/cp866.py", + "lib/python3.10/encodings/cp869.py", + "lib/python3.10/encodings/cp874.py", + "lib/python3.10/encodings/cp875.py", + "lib/python3.10/encodings/cp932.py", + "lib/python3.10/encodings/cp949.py", + "lib/python3.10/encodings/cp950.py", + "lib/python3.10/encodings/euc_jis_2004.py", + "lib/python3.10/encodings/euc_jisx0213.py", + "lib/python3.10/encodings/euc_jp.py", + "lib/python3.10/encodings/euc_kr.py", + "lib/python3.10/encodings/gb18030.py", + "lib/python3.10/encodings/gb2312.py", + "lib/python3.10/encodings/gbk.py", + "lib/python3.10/encodings/hex_codec.py", + "lib/python3.10/encodings/hp_roman8.py", + "lib/python3.10/encodings/hz.py", + "lib/python3.10/encodings/idna.py", + "lib/python3.10/encodings/iso2022_jp.py", + "lib/python3.10/encodings/iso2022_jp_1.py", + "lib/python3.10/encodings/iso2022_jp_2.py", + "lib/python3.10/encodings/iso2022_jp_2004.py", + "lib/python3.10/encodings/iso2022_jp_3.py", + "lib/python3.10/encodings/iso2022_jp_ext.py", + "lib/python3.10/encodings/iso2022_kr.py", + "lib/python3.10/encodings/iso8859_1.py", + "lib/python3.10/encodings/iso8859_10.py", + "lib/python3.10/encodings/iso8859_11.py", + "lib/python3.10/encodings/iso8859_13.py", + "lib/python3.10/encodings/iso8859_14.py", + "lib/python3.10/encodings/iso8859_15.py", + "lib/python3.10/encodings/iso8859_16.py", + "lib/python3.10/encodings/iso8859_2.py", + "lib/python3.10/encodings/iso8859_3.py", + "lib/python3.10/encodings/iso8859_4.py", + "lib/python3.10/encodings/iso8859_5.py", + "lib/python3.10/encodings/iso8859_6.py", + "lib/python3.10/encodings/iso8859_7.py", + "lib/python3.10/encodings/iso8859_8.py", + "lib/python3.10/encodings/iso8859_9.py", + "lib/python3.10/encodings/johab.py", + "lib/python3.10/encodings/koi8_r.py", + "lib/python3.10/encodings/koi8_t.py", + "lib/python3.10/encodings/koi8_u.py", + "lib/python3.10/encodings/kz1048.py", + "lib/python3.10/encodings/latin_1.py", + "lib/python3.10/encodings/mac_arabic.py", + "lib/python3.10/encodings/mac_croatian.py", + "lib/python3.10/encodings/mac_cyrillic.py", + "lib/python3.10/encodings/mac_farsi.py", + "lib/python3.10/encodings/mac_greek.py", + "lib/python3.10/encodings/mac_iceland.py", + "lib/python3.10/encodings/mac_latin2.py", + "lib/python3.10/encodings/mac_roman.py", + "lib/python3.10/encodings/mac_romanian.py", + "lib/python3.10/encodings/mac_turkish.py", + "lib/python3.10/encodings/mbcs.py", + "lib/python3.10/encodings/oem.py", + "lib/python3.10/encodings/palmos.py", + "lib/python3.10/encodings/ptcp154.py", + "lib/python3.10/encodings/punycode.py", + "lib/python3.10/encodings/quopri_codec.py", + "lib/python3.10/encodings/raw_unicode_escape.py", + "lib/python3.10/encodings/rot_13.py", + "lib/python3.10/encodings/shift_jis.py", + "lib/python3.10/encodings/shift_jis_2004.py", + "lib/python3.10/encodings/shift_jisx0213.py", + "lib/python3.10/encodings/tis_620.py", + "lib/python3.10/encodings/undefined.py", + "lib/python3.10/encodings/unicode_escape.py", + "lib/python3.10/encodings/utf_16.py", + "lib/python3.10/encodings/utf_16_be.py", + "lib/python3.10/encodings/utf_16_le.py", + "lib/python3.10/encodings/utf_32.py", + "lib/python3.10/encodings/utf_32_be.py", + "lib/python3.10/encodings/utf_32_le.py", + "lib/python3.10/encodings/utf_7.py", + "lib/python3.10/encodings/utf_8.py", + "lib/python3.10/encodings/utf_8_sig.py", + "lib/python3.10/encodings/uu_codec.py", + "lib/python3.10/encodings/zlib_codec.py", + "lib/python3.10/ensurepip/__init__.py", + "lib/python3.10/ensurepip/__main__.py", + "lib/python3.10/ensurepip/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/ensurepip/__pycache__/__main__.cpython-310.pyc", + "lib/python3.10/ensurepip/__pycache__/_uninstall.cpython-310.pyc", + "lib/python3.10/ensurepip/_bundled/__init__.py", + "lib/python3.10/ensurepip/_bundled/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/ensurepip/_bundled/pip-22.3.1-py3-none-any.whl", + "lib/python3.10/ensurepip/_bundled/setuptools-65.5.0-py3-none-any.whl", + "lib/python3.10/ensurepip/_uninstall.py", + "lib/python3.10/enum.py", + "lib/python3.10/filecmp.py", + "lib/python3.10/fileinput.py", + "lib/python3.10/fnmatch.py", + "lib/python3.10/fractions.py", + "lib/python3.10/ftplib.py", + "lib/python3.10/functools.py", + "lib/python3.10/genericpath.py", + "lib/python3.10/getopt.py", + "lib/python3.10/getpass.py", + "lib/python3.10/gettext.py", + "lib/python3.10/glob.py", + "lib/python3.10/graphlib.py", + "lib/python3.10/gzip.py", + "lib/python3.10/hashlib.py", + "lib/python3.10/heapq.py", + "lib/python3.10/hmac.py", + "lib/python3.10/html/__init__.py", + "lib/python3.10/html/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/html/__pycache__/entities.cpython-310.pyc", + "lib/python3.10/html/__pycache__/parser.cpython-310.pyc", + "lib/python3.10/html/entities.py", + "lib/python3.10/html/parser.py", + "lib/python3.10/http/__init__.py", + "lib/python3.10/http/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/http/__pycache__/client.cpython-310.pyc", + "lib/python3.10/http/__pycache__/cookiejar.cpython-310.pyc", + "lib/python3.10/http/__pycache__/cookies.cpython-310.pyc", + "lib/python3.10/http/__pycache__/server.cpython-310.pyc", + "lib/python3.10/http/client.py", + "lib/python3.10/http/cookiejar.py", + "lib/python3.10/http/cookies.py", + "lib/python3.10/http/server.py", + "lib/python3.10/idlelib/CREDITS.txt", + "lib/python3.10/idlelib/ChangeLog", + "lib/python3.10/idlelib/HISTORY.txt", + "lib/python3.10/idlelib/Icons/README.txt", + "lib/python3.10/idlelib/Icons/folder.gif", + "lib/python3.10/idlelib/Icons/idle.ico", + "lib/python3.10/idlelib/Icons/idle_16.gif", + "lib/python3.10/idlelib/Icons/idle_16.png", + "lib/python3.10/idlelib/Icons/idle_256.png", + "lib/python3.10/idlelib/Icons/idle_32.gif", + "lib/python3.10/idlelib/Icons/idle_32.png", + "lib/python3.10/idlelib/Icons/idle_48.gif", + "lib/python3.10/idlelib/Icons/idle_48.png", + "lib/python3.10/idlelib/Icons/minusnode.gif", + "lib/python3.10/idlelib/Icons/openfolder.gif", + "lib/python3.10/idlelib/Icons/plusnode.gif", + "lib/python3.10/idlelib/Icons/python.gif", + "lib/python3.10/idlelib/Icons/tk.gif", + "lib/python3.10/idlelib/NEWS.txt", + "lib/python3.10/idlelib/NEWS2x.txt", + "lib/python3.10/idlelib/README.txt", + "lib/python3.10/idlelib/TODO.txt", + "lib/python3.10/idlelib/__init__.py", + "lib/python3.10/idlelib/__main__.py", + "lib/python3.10/idlelib/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/__main__.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/autocomplete.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/autocomplete_w.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/autoexpand.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/browser.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/calltip.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/calltip_w.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/codecontext.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/colorizer.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/config.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/config_key.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/configdialog.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/debugger.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/debugger_r.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/debugobj.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/debugobj_r.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/delegator.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/dynoption.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/editor.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/filelist.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/format.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/grep.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/help.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/help_about.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/history.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/hyperparser.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/idle.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/iomenu.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/macosx.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/mainmenu.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/multicall.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/outwin.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/parenmatch.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/pathbrowser.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/percolator.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/pyparse.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/pyshell.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/query.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/redirector.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/replace.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/rpc.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/run.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/runscript.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/scrolledlist.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/search.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/searchbase.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/searchengine.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/sidebar.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/squeezer.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/stackviewer.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/statusbar.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/textview.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/tooltip.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/tree.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/undo.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/util.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/window.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/zoomheight.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/zzdummy.cpython-310.pyc", + "lib/python3.10/idlelib/autocomplete.py", + "lib/python3.10/idlelib/autocomplete_w.py", + "lib/python3.10/idlelib/autoexpand.py", + "lib/python3.10/idlelib/browser.py", + "lib/python3.10/idlelib/calltip.py", + "lib/python3.10/idlelib/calltip_w.py", + "lib/python3.10/idlelib/codecontext.py", + "lib/python3.10/idlelib/colorizer.py", + "lib/python3.10/idlelib/config-extensions.def", + "lib/python3.10/idlelib/config-highlight.def", + "lib/python3.10/idlelib/config-keys.def", + "lib/python3.10/idlelib/config-main.def", + "lib/python3.10/idlelib/config.py", + "lib/python3.10/idlelib/config_key.py", + "lib/python3.10/idlelib/configdialog.py", + "lib/python3.10/idlelib/debugger.py", + "lib/python3.10/idlelib/debugger_r.py", + "lib/python3.10/idlelib/debugobj.py", + "lib/python3.10/idlelib/debugobj_r.py", + "lib/python3.10/idlelib/delegator.py", + "lib/python3.10/idlelib/dynoption.py", + "lib/python3.10/idlelib/editor.py", + "lib/python3.10/idlelib/extend.txt", + "lib/python3.10/idlelib/filelist.py", + "lib/python3.10/idlelib/format.py", + "lib/python3.10/idlelib/grep.py", + "lib/python3.10/idlelib/help.html", + "lib/python3.10/idlelib/help.py", + "lib/python3.10/idlelib/help_about.py", + "lib/python3.10/idlelib/history.py", + "lib/python3.10/idlelib/hyperparser.py", + "lib/python3.10/idlelib/idle.bat", + "lib/python3.10/idlelib/idle.py", + "lib/python3.10/idlelib/idle.pyw", + "lib/python3.10/idlelib/idle_test/README.txt", + "lib/python3.10/idlelib/idle_test/__init__.py", + "lib/python3.10/idlelib/idle_test/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/htest.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/mock_idle.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/mock_tk.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/template.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_autocomplete.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_autocomplete_w.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_autoexpand.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_browser.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_calltip.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_calltip_w.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_codecontext.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_colorizer.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_config.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_config_key.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_configdialog.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_debugger.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_debugger_r.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_debugobj.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_debugobj_r.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_delegator.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_editmenu.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_editor.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_filelist.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_format.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_grep.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_help.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_help_about.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_history.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_hyperparser.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_iomenu.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_macosx.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_mainmenu.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_multicall.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_outwin.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_parenmatch.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_pathbrowser.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_percolator.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_pyparse.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_pyshell.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_query.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_redirector.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_replace.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_rpc.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_run.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_runscript.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_scrolledlist.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_search.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_searchbase.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_searchengine.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_sidebar.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_squeezer.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_stackviewer.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_statusbar.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_text.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_textview.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_tooltip.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_tree.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_undo.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_util.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_warning.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_window.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_zoomheight.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_zzdummy.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/tkinter_testing_utils.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/example_noext", + "lib/python3.10/idlelib/idle_test/example_stub.pyi", + "lib/python3.10/idlelib/idle_test/htest.py", + "lib/python3.10/idlelib/idle_test/mock_idle.py", + "lib/python3.10/idlelib/idle_test/mock_tk.py", + "lib/python3.10/idlelib/idle_test/template.py", + "lib/python3.10/idlelib/idle_test/test_autocomplete.py", + "lib/python3.10/idlelib/idle_test/test_autocomplete_w.py", + "lib/python3.10/idlelib/idle_test/test_autoexpand.py", + "lib/python3.10/idlelib/idle_test/test_browser.py", + "lib/python3.10/idlelib/idle_test/test_calltip.py", + "lib/python3.10/idlelib/idle_test/test_calltip_w.py", + "lib/python3.10/idlelib/idle_test/test_codecontext.py", + "lib/python3.10/idlelib/idle_test/test_colorizer.py", + "lib/python3.10/idlelib/idle_test/test_config.py", + "lib/python3.10/idlelib/idle_test/test_config_key.py", + "lib/python3.10/idlelib/idle_test/test_configdialog.py", + "lib/python3.10/idlelib/idle_test/test_debugger.py", + "lib/python3.10/idlelib/idle_test/test_debugger_r.py", + "lib/python3.10/idlelib/idle_test/test_debugobj.py", + "lib/python3.10/idlelib/idle_test/test_debugobj_r.py", + "lib/python3.10/idlelib/idle_test/test_delegator.py", + "lib/python3.10/idlelib/idle_test/test_editmenu.py", + "lib/python3.10/idlelib/idle_test/test_editor.py", + "lib/python3.10/idlelib/idle_test/test_filelist.py", + "lib/python3.10/idlelib/idle_test/test_format.py", + "lib/python3.10/idlelib/idle_test/test_grep.py", + "lib/python3.10/idlelib/idle_test/test_help.py", + "lib/python3.10/idlelib/idle_test/test_help_about.py", + "lib/python3.10/idlelib/idle_test/test_history.py", + "lib/python3.10/idlelib/idle_test/test_hyperparser.py", + "lib/python3.10/idlelib/idle_test/test_iomenu.py", + "lib/python3.10/idlelib/idle_test/test_macosx.py", + "lib/python3.10/idlelib/idle_test/test_mainmenu.py", + "lib/python3.10/idlelib/idle_test/test_multicall.py", + "lib/python3.10/idlelib/idle_test/test_outwin.py", + "lib/python3.10/idlelib/idle_test/test_parenmatch.py", + "lib/python3.10/idlelib/idle_test/test_pathbrowser.py", + "lib/python3.10/idlelib/idle_test/test_percolator.py", + "lib/python3.10/idlelib/idle_test/test_pyparse.py", + "lib/python3.10/idlelib/idle_test/test_pyshell.py", + "lib/python3.10/idlelib/idle_test/test_query.py", + "lib/python3.10/idlelib/idle_test/test_redirector.py", + "lib/python3.10/idlelib/idle_test/test_replace.py", + "lib/python3.10/idlelib/idle_test/test_rpc.py", + "lib/python3.10/idlelib/idle_test/test_run.py", + "lib/python3.10/idlelib/idle_test/test_runscript.py", + "lib/python3.10/idlelib/idle_test/test_scrolledlist.py", + "lib/python3.10/idlelib/idle_test/test_search.py", + "lib/python3.10/idlelib/idle_test/test_searchbase.py", + "lib/python3.10/idlelib/idle_test/test_searchengine.py", + "lib/python3.10/idlelib/idle_test/test_sidebar.py", + "lib/python3.10/idlelib/idle_test/test_squeezer.py", + "lib/python3.10/idlelib/idle_test/test_stackviewer.py", + "lib/python3.10/idlelib/idle_test/test_statusbar.py", + "lib/python3.10/idlelib/idle_test/test_text.py", + "lib/python3.10/idlelib/idle_test/test_textview.py", + "lib/python3.10/idlelib/idle_test/test_tooltip.py", + "lib/python3.10/idlelib/idle_test/test_tree.py", + "lib/python3.10/idlelib/idle_test/test_undo.py", + "lib/python3.10/idlelib/idle_test/test_util.py", + "lib/python3.10/idlelib/idle_test/test_warning.py", + "lib/python3.10/idlelib/idle_test/test_window.py", + "lib/python3.10/idlelib/idle_test/test_zoomheight.py", + "lib/python3.10/idlelib/idle_test/test_zzdummy.py", + "lib/python3.10/idlelib/idle_test/tkinter_testing_utils.py", + "lib/python3.10/idlelib/iomenu.py", + "lib/python3.10/idlelib/macosx.py", + "lib/python3.10/idlelib/mainmenu.py", + "lib/python3.10/idlelib/multicall.py", + "lib/python3.10/idlelib/outwin.py", + "lib/python3.10/idlelib/parenmatch.py", + "lib/python3.10/idlelib/pathbrowser.py", + "lib/python3.10/idlelib/percolator.py", + "lib/python3.10/idlelib/pyparse.py", + "lib/python3.10/idlelib/pyshell.py", + "lib/python3.10/idlelib/query.py", + "lib/python3.10/idlelib/redirector.py", + "lib/python3.10/idlelib/replace.py", + "lib/python3.10/idlelib/rpc.py", + "lib/python3.10/idlelib/run.py", + "lib/python3.10/idlelib/runscript.py", + "lib/python3.10/idlelib/scrolledlist.py", + "lib/python3.10/idlelib/search.py", + "lib/python3.10/idlelib/searchbase.py", + "lib/python3.10/idlelib/searchengine.py", + "lib/python3.10/idlelib/sidebar.py", + "lib/python3.10/idlelib/squeezer.py", + "lib/python3.10/idlelib/stackviewer.py", + "lib/python3.10/idlelib/statusbar.py", + "lib/python3.10/idlelib/textview.py", + "lib/python3.10/idlelib/tooltip.py", + "lib/python3.10/idlelib/tree.py", + "lib/python3.10/idlelib/undo.py", + "lib/python3.10/idlelib/util.py", + "lib/python3.10/idlelib/window.py", + "lib/python3.10/idlelib/zoomheight.py", + "lib/python3.10/idlelib/zzdummy.py", + "lib/python3.10/imaplib.py", + "lib/python3.10/imghdr.py", + "lib/python3.10/imp.py", + "lib/python3.10/importlib/__init__.py", + "lib/python3.10/importlib/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/importlib/__pycache__/_abc.cpython-310.pyc", + "lib/python3.10/importlib/__pycache__/_adapters.cpython-310.pyc", + "lib/python3.10/importlib/__pycache__/_bootstrap.cpython-310.pyc", + "lib/python3.10/importlib/__pycache__/_bootstrap_external.cpython-310.pyc", + "lib/python3.10/importlib/__pycache__/_common.cpython-310.pyc", + "lib/python3.10/importlib/__pycache__/abc.cpython-310.pyc", + "lib/python3.10/importlib/__pycache__/machinery.cpython-310.pyc", + "lib/python3.10/importlib/__pycache__/readers.cpython-310.pyc", + "lib/python3.10/importlib/__pycache__/resources.cpython-310.pyc", + "lib/python3.10/importlib/__pycache__/util.cpython-310.pyc", + "lib/python3.10/importlib/_abc.py", + "lib/python3.10/importlib/_adapters.py", + "lib/python3.10/importlib/_bootstrap.py", + "lib/python3.10/importlib/_bootstrap_external.py", + "lib/python3.10/importlib/_common.py", + "lib/python3.10/importlib/abc.py", + "lib/python3.10/importlib/machinery.py", + "lib/python3.10/importlib/metadata/__init__.py", + "lib/python3.10/importlib/metadata/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/importlib/metadata/__pycache__/_adapters.cpython-310.pyc", + "lib/python3.10/importlib/metadata/__pycache__/_collections.cpython-310.pyc", + "lib/python3.10/importlib/metadata/__pycache__/_functools.cpython-310.pyc", + "lib/python3.10/importlib/metadata/__pycache__/_itertools.cpython-310.pyc", + "lib/python3.10/importlib/metadata/__pycache__/_meta.cpython-310.pyc", + "lib/python3.10/importlib/metadata/__pycache__/_text.cpython-310.pyc", + "lib/python3.10/importlib/metadata/_adapters.py", + "lib/python3.10/importlib/metadata/_collections.py", + "lib/python3.10/importlib/metadata/_functools.py", + "lib/python3.10/importlib/metadata/_itertools.py", + "lib/python3.10/importlib/metadata/_meta.py", + "lib/python3.10/importlib/metadata/_text.py", + "lib/python3.10/importlib/readers.py", + "lib/python3.10/importlib/resources.py", + "lib/python3.10/importlib/util.py", + "lib/python3.10/inspect.py", + "lib/python3.10/io.py", + "lib/python3.10/ipaddress.py", + "lib/python3.10/json/__init__.py", + "lib/python3.10/json/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/json/__pycache__/decoder.cpython-310.pyc", + "lib/python3.10/json/__pycache__/encoder.cpython-310.pyc", + "lib/python3.10/json/__pycache__/scanner.cpython-310.pyc", + "lib/python3.10/json/__pycache__/tool.cpython-310.pyc", + "lib/python3.10/json/decoder.py", + "lib/python3.10/json/encoder.py", + "lib/python3.10/json/scanner.py", + "lib/python3.10/json/tool.py", + "lib/python3.10/keyword.py", + "lib/python3.10/lib-dynload/_asyncio.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_bisect.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_blake2.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_bz2.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_codecs_cn.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_codecs_hk.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_codecs_iso2022.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_codecs_jp.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_codecs_kr.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_codecs_tw.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_contextvars.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_crypt.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_csv.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_ctypes.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_ctypes_test.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_curses.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_curses_panel.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_datetime.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_dbm.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_decimal.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_elementtree.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_hashlib.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_heapq.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_json.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_lsprof.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_lzma.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_md5.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_multibytecodec.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_multiprocessing.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_opcode.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_pickle.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_posixshmem.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_posixsubprocess.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_queue.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_random.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_scproxy.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_sha1.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_sha256.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_sha3.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_sha512.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_socket.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_sqlite3.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_ssl.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_statistics.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_struct.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_testbuffer.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_testcapi.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_testimportmultiple.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_testinternalcapi.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_testmultiphase.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_tkinter.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_uuid.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_xxsubinterpreters.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_xxtestfuzz.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_zoneinfo.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/array.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/audioop.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/binascii.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/cmath.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/fcntl.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/grp.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/math.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/mmap.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/nis.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/pyexpat.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/readline.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/resource.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/select.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/syslog.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/termios.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/unicodedata.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/xxlimited.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/xxlimited_35.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/zlib.cpython-310-darwin.so", + "lib/python3.10/lib2to3/Grammar.txt", + "lib/python3.10/lib2to3/Grammar3.10.9.final.0.pickle", + "lib/python3.10/lib2to3/PatternGrammar.txt", + "lib/python3.10/lib2to3/PatternGrammar3.10.9.final.0.pickle", + "lib/python3.10/lib2to3/__init__.py", + "lib/python3.10/lib2to3/__main__.py", + "lib/python3.10/lib2to3/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/lib2to3/__pycache__/__main__.cpython-310.pyc", + "lib/python3.10/lib2to3/__pycache__/btm_matcher.cpython-310.pyc", + "lib/python3.10/lib2to3/__pycache__/btm_utils.cpython-310.pyc", + "lib/python3.10/lib2to3/__pycache__/fixer_base.cpython-310.pyc", + "lib/python3.10/lib2to3/__pycache__/fixer_util.cpython-310.pyc", + "lib/python3.10/lib2to3/__pycache__/main.cpython-310.pyc", + "lib/python3.10/lib2to3/__pycache__/patcomp.cpython-310.pyc", + "lib/python3.10/lib2to3/__pycache__/pygram.cpython-310.pyc", + "lib/python3.10/lib2to3/__pycache__/pytree.cpython-310.pyc", + "lib/python3.10/lib2to3/__pycache__/refactor.cpython-310.pyc", + "lib/python3.10/lib2to3/btm_matcher.py", + "lib/python3.10/lib2to3/btm_utils.py", + "lib/python3.10/lib2to3/fixer_base.py", + "lib/python3.10/lib2to3/fixer_util.py", + "lib/python3.10/lib2to3/fixes/__init__.py", + "lib/python3.10/lib2to3/fixes/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_apply.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_asserts.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_basestring.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_buffer.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_dict.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_except.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_exec.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_execfile.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_exitfunc.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_filter.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_funcattrs.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_future.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_getcwdu.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_has_key.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_idioms.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_import.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_imports.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_imports2.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_input.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_intern.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_isinstance.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_itertools.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_itertools_imports.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_long.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_map.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_metaclass.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_methodattrs.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_ne.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_next.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_nonzero.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_numliterals.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_operator.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_paren.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_print.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_raise.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_raw_input.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_reduce.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_reload.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_renames.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_repr.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_set_literal.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_standarderror.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_sys_exc.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_throw.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_tuple_params.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_types.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_unicode.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_urllib.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_ws_comma.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_xrange.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_xreadlines.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_zip.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/fix_apply.py", + "lib/python3.10/lib2to3/fixes/fix_asserts.py", + "lib/python3.10/lib2to3/fixes/fix_basestring.py", + "lib/python3.10/lib2to3/fixes/fix_buffer.py", + "lib/python3.10/lib2to3/fixes/fix_dict.py", + "lib/python3.10/lib2to3/fixes/fix_except.py", + "lib/python3.10/lib2to3/fixes/fix_exec.py", + "lib/python3.10/lib2to3/fixes/fix_execfile.py", + "lib/python3.10/lib2to3/fixes/fix_exitfunc.py", + "lib/python3.10/lib2to3/fixes/fix_filter.py", + "lib/python3.10/lib2to3/fixes/fix_funcattrs.py", + "lib/python3.10/lib2to3/fixes/fix_future.py", + "lib/python3.10/lib2to3/fixes/fix_getcwdu.py", + "lib/python3.10/lib2to3/fixes/fix_has_key.py", + "lib/python3.10/lib2to3/fixes/fix_idioms.py", + "lib/python3.10/lib2to3/fixes/fix_import.py", + "lib/python3.10/lib2to3/fixes/fix_imports.py", + "lib/python3.10/lib2to3/fixes/fix_imports2.py", + "lib/python3.10/lib2to3/fixes/fix_input.py", + "lib/python3.10/lib2to3/fixes/fix_intern.py", + "lib/python3.10/lib2to3/fixes/fix_isinstance.py", + "lib/python3.10/lib2to3/fixes/fix_itertools.py", + "lib/python3.10/lib2to3/fixes/fix_itertools_imports.py", + "lib/python3.10/lib2to3/fixes/fix_long.py", + "lib/python3.10/lib2to3/fixes/fix_map.py", + "lib/python3.10/lib2to3/fixes/fix_metaclass.py", + "lib/python3.10/lib2to3/fixes/fix_methodattrs.py", + "lib/python3.10/lib2to3/fixes/fix_ne.py", + "lib/python3.10/lib2to3/fixes/fix_next.py", + "lib/python3.10/lib2to3/fixes/fix_nonzero.py", + "lib/python3.10/lib2to3/fixes/fix_numliterals.py", + "lib/python3.10/lib2to3/fixes/fix_operator.py", + "lib/python3.10/lib2to3/fixes/fix_paren.py", + "lib/python3.10/lib2to3/fixes/fix_print.py", + "lib/python3.10/lib2to3/fixes/fix_raise.py", + "lib/python3.10/lib2to3/fixes/fix_raw_input.py", + "lib/python3.10/lib2to3/fixes/fix_reduce.py", + "lib/python3.10/lib2to3/fixes/fix_reload.py", + "lib/python3.10/lib2to3/fixes/fix_renames.py", + "lib/python3.10/lib2to3/fixes/fix_repr.py", + "lib/python3.10/lib2to3/fixes/fix_set_literal.py", + "lib/python3.10/lib2to3/fixes/fix_standarderror.py", + "lib/python3.10/lib2to3/fixes/fix_sys_exc.py", + "lib/python3.10/lib2to3/fixes/fix_throw.py", + "lib/python3.10/lib2to3/fixes/fix_tuple_params.py", + "lib/python3.10/lib2to3/fixes/fix_types.py", + "lib/python3.10/lib2to3/fixes/fix_unicode.py", + "lib/python3.10/lib2to3/fixes/fix_urllib.py", + "lib/python3.10/lib2to3/fixes/fix_ws_comma.py", + "lib/python3.10/lib2to3/fixes/fix_xrange.py", + "lib/python3.10/lib2to3/fixes/fix_xreadlines.py", + "lib/python3.10/lib2to3/fixes/fix_zip.py", + "lib/python3.10/lib2to3/main.py", + "lib/python3.10/lib2to3/patcomp.py", + "lib/python3.10/lib2to3/pgen2/__init__.py", + "lib/python3.10/lib2to3/pgen2/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/lib2to3/pgen2/__pycache__/conv.cpython-310.pyc", + "lib/python3.10/lib2to3/pgen2/__pycache__/driver.cpython-310.pyc", + "lib/python3.10/lib2to3/pgen2/__pycache__/grammar.cpython-310.pyc", + "lib/python3.10/lib2to3/pgen2/__pycache__/literals.cpython-310.pyc", + "lib/python3.10/lib2to3/pgen2/__pycache__/parse.cpython-310.pyc", + "lib/python3.10/lib2to3/pgen2/__pycache__/pgen.cpython-310.pyc", + "lib/python3.10/lib2to3/pgen2/__pycache__/token.cpython-310.pyc", + "lib/python3.10/lib2to3/pgen2/__pycache__/tokenize.cpython-310.pyc", + "lib/python3.10/lib2to3/pgen2/conv.py", + "lib/python3.10/lib2to3/pgen2/driver.py", + "lib/python3.10/lib2to3/pgen2/grammar.py", + "lib/python3.10/lib2to3/pgen2/literals.py", + "lib/python3.10/lib2to3/pgen2/parse.py", + "lib/python3.10/lib2to3/pgen2/pgen.py", + "lib/python3.10/lib2to3/pgen2/token.py", + "lib/python3.10/lib2to3/pgen2/tokenize.py", + "lib/python3.10/lib2to3/pygram.py", + "lib/python3.10/lib2to3/pytree.py", + "lib/python3.10/lib2to3/refactor.py", + "lib/python3.10/lib2to3/tests/__init__.py", + "lib/python3.10/lib2to3/tests/__main__.py", + "lib/python3.10/lib2to3/tests/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/lib2to3/tests/__pycache__/__main__.cpython-310.pyc", + "lib/python3.10/lib2to3/tests/__pycache__/pytree_idempotency.cpython-310.pyc", + "lib/python3.10/lib2to3/tests/__pycache__/support.cpython-310.pyc", + "lib/python3.10/lib2to3/tests/__pycache__/test_all_fixers.cpython-310.pyc", + "lib/python3.10/lib2to3/tests/__pycache__/test_fixers.cpython-310.pyc", + "lib/python3.10/lib2to3/tests/__pycache__/test_main.cpython-310.pyc", + "lib/python3.10/lib2to3/tests/__pycache__/test_parser.cpython-310.pyc", + "lib/python3.10/lib2to3/tests/__pycache__/test_pytree.cpython-310.pyc", + "lib/python3.10/lib2to3/tests/__pycache__/test_refactor.cpython-310.pyc", + "lib/python3.10/lib2to3/tests/__pycache__/test_util.cpython-310.pyc", + "lib/python3.10/lib2to3/tests/data/README", + "lib/python3.10/lib2to3/tests/data/__pycache__/infinite_recursion.cpython-310.pyc", + "lib/python3.10/lib2to3/tests/data/__pycache__/py3_test_grammar.cpython-310.pyc", + "lib/python3.10/lib2to3/tests/data/bom.py", + "lib/python3.10/lib2to3/tests/data/crlf.py", + "lib/python3.10/lib2to3/tests/data/different_encoding.py", + "lib/python3.10/lib2to3/tests/data/false_encoding.py", + "lib/python3.10/lib2to3/tests/data/fixers/__pycache__/bad_order.cpython-310.pyc", + "lib/python3.10/lib2to3/tests/data/fixers/__pycache__/no_fixer_cls.cpython-310.pyc", + "lib/python3.10/lib2to3/tests/data/fixers/__pycache__/parrot_example.cpython-310.pyc", + "lib/python3.10/lib2to3/tests/data/fixers/bad_order.py", + "lib/python3.10/lib2to3/tests/data/fixers/myfixes/__init__.py", + "lib/python3.10/lib2to3/tests/data/fixers/myfixes/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/lib2to3/tests/data/fixers/myfixes/__pycache__/fix_explicit.cpython-310.pyc", + "lib/python3.10/lib2to3/tests/data/fixers/myfixes/__pycache__/fix_first.cpython-310.pyc", + "lib/python3.10/lib2to3/tests/data/fixers/myfixes/__pycache__/fix_last.cpython-310.pyc", + "lib/python3.10/lib2to3/tests/data/fixers/myfixes/__pycache__/fix_parrot.cpython-310.pyc", + "lib/python3.10/lib2to3/tests/data/fixers/myfixes/__pycache__/fix_preorder.cpython-310.pyc", + "lib/python3.10/lib2to3/tests/data/fixers/myfixes/fix_explicit.py", + "lib/python3.10/lib2to3/tests/data/fixers/myfixes/fix_first.py", + "lib/python3.10/lib2to3/tests/data/fixers/myfixes/fix_last.py", + "lib/python3.10/lib2to3/tests/data/fixers/myfixes/fix_parrot.py", + "lib/python3.10/lib2to3/tests/data/fixers/myfixes/fix_preorder.py", + "lib/python3.10/lib2to3/tests/data/fixers/no_fixer_cls.py", + "lib/python3.10/lib2to3/tests/data/fixers/parrot_example.py", + "lib/python3.10/lib2to3/tests/data/infinite_recursion.py", + "lib/python3.10/lib2to3/tests/data/py2_test_grammar.py", + "lib/python3.10/lib2to3/tests/data/py3_test_grammar.py", + "lib/python3.10/lib2to3/tests/pytree_idempotency.py", + "lib/python3.10/lib2to3/tests/support.py", + "lib/python3.10/lib2to3/tests/test_all_fixers.py", + "lib/python3.10/lib2to3/tests/test_fixers.py", + "lib/python3.10/lib2to3/tests/test_main.py", + "lib/python3.10/lib2to3/tests/test_parser.py", + "lib/python3.10/lib2to3/tests/test_pytree.py", + "lib/python3.10/lib2to3/tests/test_refactor.py", + "lib/python3.10/lib2to3/tests/test_util.py", + "lib/python3.10/linecache.py", + "lib/python3.10/locale.py", + "lib/python3.10/logging/__init__.py", + "lib/python3.10/logging/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/logging/__pycache__/config.cpython-310.pyc", + "lib/python3.10/logging/__pycache__/handlers.cpython-310.pyc", + "lib/python3.10/logging/config.py", + "lib/python3.10/logging/handlers.py", + "lib/python3.10/lzma.py", + "lib/python3.10/mailbox.py", + "lib/python3.10/mailcap.py", + "lib/python3.10/mimetypes.py", + "lib/python3.10/modulefinder.py", + "lib/python3.10/multiprocessing/__init__.py", + "lib/python3.10/multiprocessing/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/multiprocessing/__pycache__/connection.cpython-310.pyc", + "lib/python3.10/multiprocessing/__pycache__/context.cpython-310.pyc", + "lib/python3.10/multiprocessing/__pycache__/forkserver.cpython-310.pyc", + "lib/python3.10/multiprocessing/__pycache__/heap.cpython-310.pyc", + "lib/python3.10/multiprocessing/__pycache__/managers.cpython-310.pyc", + "lib/python3.10/multiprocessing/__pycache__/pool.cpython-310.pyc", + "lib/python3.10/multiprocessing/__pycache__/popen_fork.cpython-310.pyc", + "lib/python3.10/multiprocessing/__pycache__/popen_forkserver.cpython-310.pyc", + "lib/python3.10/multiprocessing/__pycache__/popen_spawn_posix.cpython-310.pyc", + "lib/python3.10/multiprocessing/__pycache__/popen_spawn_win32.cpython-310.pyc", + "lib/python3.10/multiprocessing/__pycache__/process.cpython-310.pyc", + "lib/python3.10/multiprocessing/__pycache__/queues.cpython-310.pyc", + "lib/python3.10/multiprocessing/__pycache__/reduction.cpython-310.pyc", + "lib/python3.10/multiprocessing/__pycache__/resource_sharer.cpython-310.pyc", + "lib/python3.10/multiprocessing/__pycache__/resource_tracker.cpython-310.pyc", + "lib/python3.10/multiprocessing/__pycache__/shared_memory.cpython-310.pyc", + "lib/python3.10/multiprocessing/__pycache__/sharedctypes.cpython-310.pyc", + "lib/python3.10/multiprocessing/__pycache__/spawn.cpython-310.pyc", + "lib/python3.10/multiprocessing/__pycache__/synchronize.cpython-310.pyc", + "lib/python3.10/multiprocessing/__pycache__/util.cpython-310.pyc", + "lib/python3.10/multiprocessing/connection.py", + "lib/python3.10/multiprocessing/context.py", + "lib/python3.10/multiprocessing/dummy/__init__.py", + "lib/python3.10/multiprocessing/dummy/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/multiprocessing/dummy/__pycache__/connection.cpython-310.pyc", + "lib/python3.10/multiprocessing/dummy/connection.py", + "lib/python3.10/multiprocessing/forkserver.py", + "lib/python3.10/multiprocessing/heap.py", + "lib/python3.10/multiprocessing/managers.py", + "lib/python3.10/multiprocessing/pool.py", + "lib/python3.10/multiprocessing/popen_fork.py", + "lib/python3.10/multiprocessing/popen_forkserver.py", + "lib/python3.10/multiprocessing/popen_spawn_posix.py", + "lib/python3.10/multiprocessing/popen_spawn_win32.py", + "lib/python3.10/multiprocessing/process.py", + "lib/python3.10/multiprocessing/queues.py", + "lib/python3.10/multiprocessing/reduction.py", + "lib/python3.10/multiprocessing/resource_sharer.py", + "lib/python3.10/multiprocessing/resource_tracker.py", + "lib/python3.10/multiprocessing/shared_memory.py", + "lib/python3.10/multiprocessing/sharedctypes.py", + "lib/python3.10/multiprocessing/spawn.py", + "lib/python3.10/multiprocessing/synchronize.py", + "lib/python3.10/multiprocessing/util.py", + "lib/python3.10/netrc.py", + "lib/python3.10/nntplib.py", + "lib/python3.10/ntpath.py", + "lib/python3.10/nturl2path.py", + "lib/python3.10/numbers.py", + "lib/python3.10/opcode.py", + "lib/python3.10/operator.py", + "lib/python3.10/optparse.py", + "lib/python3.10/os.py", + "lib/python3.10/pathlib.py", + "lib/python3.10/pdb.py", + "lib/python3.10/pickle.py", + "lib/python3.10/pickletools.py", + "lib/python3.10/pipes.py", + "lib/python3.10/pkgutil.py", + "lib/python3.10/platform.py", + "lib/python3.10/plistlib.py", + "lib/python3.10/poplib.py", + "lib/python3.10/posixpath.py", + "lib/python3.10/pprint.py", + "lib/python3.10/profile.py", + "lib/python3.10/pstats.py", + "lib/python3.10/pty.py", + "lib/python3.10/py_compile.py", + "lib/python3.10/pyclbr.py", + "lib/python3.10/pydoc.py", + "lib/python3.10/pydoc_data/__init__.py", + "lib/python3.10/pydoc_data/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/pydoc_data/__pycache__/topics.cpython-310.pyc", + "lib/python3.10/pydoc_data/_pydoc.css", + "lib/python3.10/pydoc_data/topics.py", + "lib/python3.10/queue.py", + "lib/python3.10/quopri.py", + "lib/python3.10/random.py", + "lib/python3.10/re.py", + "lib/python3.10/reprlib.py", + "lib/python3.10/rlcompleter.py", + "lib/python3.10/runpy.py", + "lib/python3.10/sched.py", + "lib/python3.10/secrets.py", + "lib/python3.10/selectors.py", + "lib/python3.10/shelve.py", + "lib/python3.10/shlex.py", + "lib/python3.10/shutil.py", + "lib/python3.10/signal.py", + "lib/python3.10/site-packages/README.txt", + "lib/python3.10/site.py", + "lib/python3.10/smtpd.py", + "lib/python3.10/smtplib.py", + "lib/python3.10/sndhdr.py", + "lib/python3.10/socket.py", + "lib/python3.10/socketserver.py", + "lib/python3.10/sqlite3/__init__.py", + "lib/python3.10/sqlite3/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/sqlite3/__pycache__/dbapi2.cpython-310.pyc", + "lib/python3.10/sqlite3/__pycache__/dump.cpython-310.pyc", + "lib/python3.10/sqlite3/dbapi2.py", + "lib/python3.10/sqlite3/dump.py", + "lib/python3.10/sre_compile.py", + "lib/python3.10/sre_constants.py", + "lib/python3.10/sre_parse.py", + "lib/python3.10/ssl.py", + "lib/python3.10/stat.py", + "lib/python3.10/statistics.py", + "lib/python3.10/string.py", + "lib/python3.10/stringprep.py", + "lib/python3.10/struct.py", + "lib/python3.10/subprocess.py", + "lib/python3.10/sunau.py", + "lib/python3.10/symtable.py", + "lib/python3.10/sysconfig.py", + "lib/python3.10/tabnanny.py", + "lib/python3.10/tarfile.py", + "lib/python3.10/telnetlib.py", + "lib/python3.10/tempfile.py", + "lib/python3.10/test/__init__.py", + "lib/python3.10/test/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/test/__pycache__/test_script_helper.cpython-310.pyc", + "lib/python3.10/test/__pycache__/test_support.cpython-310.pyc", + "lib/python3.10/test/support/__init__.py", + "lib/python3.10/test/support/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/test/support/__pycache__/bytecode_helper.cpython-310.pyc", + "lib/python3.10/test/support/__pycache__/hashlib_helper.cpython-310.pyc", + "lib/python3.10/test/support/__pycache__/import_helper.cpython-310.pyc", + "lib/python3.10/test/support/__pycache__/interpreters.cpython-310.pyc", + "lib/python3.10/test/support/__pycache__/logging_helper.cpython-310.pyc", + "lib/python3.10/test/support/__pycache__/os_helper.cpython-310.pyc", + "lib/python3.10/test/support/__pycache__/script_helper.cpython-310.pyc", + "lib/python3.10/test/support/__pycache__/socket_helper.cpython-310.pyc", + "lib/python3.10/test/support/__pycache__/testresult.cpython-310.pyc", + "lib/python3.10/test/support/__pycache__/threading_helper.cpython-310.pyc", + "lib/python3.10/test/support/__pycache__/warnings_helper.cpython-310.pyc", + "lib/python3.10/test/support/bytecode_helper.py", + "lib/python3.10/test/support/hashlib_helper.py", + "lib/python3.10/test/support/import_helper.py", + "lib/python3.10/test/support/interpreters.py", + "lib/python3.10/test/support/logging_helper.py", + "lib/python3.10/test/support/os_helper.py", + "lib/python3.10/test/support/script_helper.py", + "lib/python3.10/test/support/socket_helper.py", + "lib/python3.10/test/support/testresult.py", + "lib/python3.10/test/support/threading_helper.py", + "lib/python3.10/test/support/warnings_helper.py", + "lib/python3.10/test/test_script_helper.py", + "lib/python3.10/test/test_support.py", + "lib/python3.10/textwrap.py", + "lib/python3.10/this.py", + "lib/python3.10/threading.py", + "lib/python3.10/timeit.py", + "lib/python3.10/tkinter/__init__.py", + "lib/python3.10/tkinter/__main__.py", + "lib/python3.10/tkinter/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/tkinter/__pycache__/__main__.cpython-310.pyc", + "lib/python3.10/tkinter/__pycache__/colorchooser.cpython-310.pyc", + "lib/python3.10/tkinter/__pycache__/commondialog.cpython-310.pyc", + "lib/python3.10/tkinter/__pycache__/constants.cpython-310.pyc", + "lib/python3.10/tkinter/__pycache__/dialog.cpython-310.pyc", + "lib/python3.10/tkinter/__pycache__/dnd.cpython-310.pyc", + "lib/python3.10/tkinter/__pycache__/filedialog.cpython-310.pyc", + "lib/python3.10/tkinter/__pycache__/font.cpython-310.pyc", + "lib/python3.10/tkinter/__pycache__/messagebox.cpython-310.pyc", + "lib/python3.10/tkinter/__pycache__/scrolledtext.cpython-310.pyc", + "lib/python3.10/tkinter/__pycache__/simpledialog.cpython-310.pyc", + "lib/python3.10/tkinter/__pycache__/tix.cpython-310.pyc", + "lib/python3.10/tkinter/__pycache__/ttk.cpython-310.pyc", + "lib/python3.10/tkinter/colorchooser.py", + "lib/python3.10/tkinter/commondialog.py", + "lib/python3.10/tkinter/constants.py", + "lib/python3.10/tkinter/dialog.py", + "lib/python3.10/tkinter/dnd.py", + "lib/python3.10/tkinter/filedialog.py", + "lib/python3.10/tkinter/font.py", + "lib/python3.10/tkinter/messagebox.py", + "lib/python3.10/tkinter/scrolledtext.py", + "lib/python3.10/tkinter/simpledialog.py", + "lib/python3.10/tkinter/tix.py", + "lib/python3.10/tkinter/ttk.py", + "lib/python3.10/token.py", + "lib/python3.10/tokenize.py", + "lib/python3.10/trace.py", + "lib/python3.10/traceback.py", + "lib/python3.10/tracemalloc.py", + "lib/python3.10/tty.py", + "lib/python3.10/turtle.py", + "lib/python3.10/turtledemo/__init__.py", + "lib/python3.10/turtledemo/__main__.py", + "lib/python3.10/turtledemo/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/turtledemo/__pycache__/__main__.cpython-310.pyc", + "lib/python3.10/turtledemo/__pycache__/bytedesign.cpython-310.pyc", + "lib/python3.10/turtledemo/__pycache__/chaos.cpython-310.pyc", + "lib/python3.10/turtledemo/__pycache__/clock.cpython-310.pyc", + "lib/python3.10/turtledemo/__pycache__/colormixer.cpython-310.pyc", + "lib/python3.10/turtledemo/__pycache__/forest.cpython-310.pyc", + "lib/python3.10/turtledemo/__pycache__/fractalcurves.cpython-310.pyc", + "lib/python3.10/turtledemo/__pycache__/lindenmayer.cpython-310.pyc", + "lib/python3.10/turtledemo/__pycache__/minimal_hanoi.cpython-310.pyc", + "lib/python3.10/turtledemo/__pycache__/nim.cpython-310.pyc", + "lib/python3.10/turtledemo/__pycache__/paint.cpython-310.pyc", + "lib/python3.10/turtledemo/__pycache__/peace.cpython-310.pyc", + "lib/python3.10/turtledemo/__pycache__/penrose.cpython-310.pyc", + "lib/python3.10/turtledemo/__pycache__/planet_and_moon.cpython-310.pyc", + "lib/python3.10/turtledemo/__pycache__/rosette.cpython-310.pyc", + "lib/python3.10/turtledemo/__pycache__/round_dance.cpython-310.pyc", + "lib/python3.10/turtledemo/__pycache__/sorting_animate.cpython-310.pyc", + "lib/python3.10/turtledemo/__pycache__/tree.cpython-310.pyc", + "lib/python3.10/turtledemo/__pycache__/two_canvases.cpython-310.pyc", + "lib/python3.10/turtledemo/__pycache__/yinyang.cpython-310.pyc", + "lib/python3.10/turtledemo/bytedesign.py", + "lib/python3.10/turtledemo/chaos.py", + "lib/python3.10/turtledemo/clock.py", + "lib/python3.10/turtledemo/colormixer.py", + "lib/python3.10/turtledemo/forest.py", + "lib/python3.10/turtledemo/fractalcurves.py", + "lib/python3.10/turtledemo/lindenmayer.py", + "lib/python3.10/turtledemo/minimal_hanoi.py", + "lib/python3.10/turtledemo/nim.py", + "lib/python3.10/turtledemo/paint.py", + "lib/python3.10/turtledemo/peace.py", + "lib/python3.10/turtledemo/penrose.py", + "lib/python3.10/turtledemo/planet_and_moon.py", + "lib/python3.10/turtledemo/rosette.py", + "lib/python3.10/turtledemo/round_dance.py", + "lib/python3.10/turtledemo/sorting_animate.py", + "lib/python3.10/turtledemo/tree.py", + "lib/python3.10/turtledemo/turtle.cfg", + "lib/python3.10/turtledemo/two_canvases.py", + "lib/python3.10/turtledemo/yinyang.py", + "lib/python3.10/types.py", + "lib/python3.10/typing.py", + "lib/python3.10/unittest/__init__.py", + "lib/python3.10/unittest/__main__.py", + "lib/python3.10/unittest/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/unittest/__pycache__/__main__.cpython-310.pyc", + "lib/python3.10/unittest/__pycache__/_log.cpython-310.pyc", + "lib/python3.10/unittest/__pycache__/async_case.cpython-310.pyc", + "lib/python3.10/unittest/__pycache__/case.cpython-310.pyc", + "lib/python3.10/unittest/__pycache__/loader.cpython-310.pyc", + "lib/python3.10/unittest/__pycache__/main.cpython-310.pyc", + "lib/python3.10/unittest/__pycache__/mock.cpython-310.pyc", + "lib/python3.10/unittest/__pycache__/result.cpython-310.pyc", + "lib/python3.10/unittest/__pycache__/runner.cpython-310.pyc", + "lib/python3.10/unittest/__pycache__/signals.cpython-310.pyc", + "lib/python3.10/unittest/__pycache__/suite.cpython-310.pyc", + "lib/python3.10/unittest/__pycache__/util.cpython-310.pyc", + "lib/python3.10/unittest/_log.py", + "lib/python3.10/unittest/async_case.py", + "lib/python3.10/unittest/case.py", + "lib/python3.10/unittest/loader.py", + "lib/python3.10/unittest/main.py", + "lib/python3.10/unittest/mock.py", + "lib/python3.10/unittest/result.py", + "lib/python3.10/unittest/runner.py", + "lib/python3.10/unittest/signals.py", + "lib/python3.10/unittest/suite.py", + "lib/python3.10/unittest/util.py", + "lib/python3.10/urllib/__init__.py", + "lib/python3.10/urllib/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/urllib/__pycache__/error.cpython-310.pyc", + "lib/python3.10/urllib/__pycache__/parse.cpython-310.pyc", + "lib/python3.10/urllib/__pycache__/request.cpython-310.pyc", + "lib/python3.10/urllib/__pycache__/response.cpython-310.pyc", + "lib/python3.10/urllib/__pycache__/robotparser.cpython-310.pyc", + "lib/python3.10/urllib/error.py", + "lib/python3.10/urllib/parse.py", + "lib/python3.10/urllib/request.py", + "lib/python3.10/urllib/response.py", + "lib/python3.10/urllib/robotparser.py", + "lib/python3.10/uu.py", + "lib/python3.10/uuid.py", + "lib/python3.10/venv/__init__.py", + "lib/python3.10/venv/__main__.py", + "lib/python3.10/venv/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/venv/__pycache__/__main__.cpython-310.pyc", + "lib/python3.10/venv/scripts/common/Activate.ps1", + "lib/python3.10/venv/scripts/common/activate", + "lib/python3.10/venv/scripts/posix/activate.csh", + "lib/python3.10/venv/scripts/posix/activate.fish", + "lib/python3.10/warnings.py", + "lib/python3.10/wave.py", + "lib/python3.10/weakref.py", + "lib/python3.10/webbrowser.py", + "lib/python3.10/wsgiref/__init__.py", + "lib/python3.10/wsgiref/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/wsgiref/__pycache__/handlers.cpython-310.pyc", + "lib/python3.10/wsgiref/__pycache__/headers.cpython-310.pyc", + "lib/python3.10/wsgiref/__pycache__/simple_server.cpython-310.pyc", + "lib/python3.10/wsgiref/__pycache__/util.cpython-310.pyc", + "lib/python3.10/wsgiref/__pycache__/validate.cpython-310.pyc", + "lib/python3.10/wsgiref/handlers.py", + "lib/python3.10/wsgiref/headers.py", + "lib/python3.10/wsgiref/simple_server.py", + "lib/python3.10/wsgiref/util.py", + "lib/python3.10/wsgiref/validate.py", + "lib/python3.10/xdrlib.py", + "lib/python3.10/xml/__init__.py", + "lib/python3.10/xml/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/xml/dom/NodeFilter.py", + "lib/python3.10/xml/dom/__init__.py", + "lib/python3.10/xml/dom/__pycache__/NodeFilter.cpython-310.pyc", + "lib/python3.10/xml/dom/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/xml/dom/__pycache__/domreg.cpython-310.pyc", + "lib/python3.10/xml/dom/__pycache__/expatbuilder.cpython-310.pyc", + "lib/python3.10/xml/dom/__pycache__/minicompat.cpython-310.pyc", + "lib/python3.10/xml/dom/__pycache__/minidom.cpython-310.pyc", + "lib/python3.10/xml/dom/__pycache__/pulldom.cpython-310.pyc", + "lib/python3.10/xml/dom/__pycache__/xmlbuilder.cpython-310.pyc", + "lib/python3.10/xml/dom/domreg.py", + "lib/python3.10/xml/dom/expatbuilder.py", + "lib/python3.10/xml/dom/minicompat.py", + "lib/python3.10/xml/dom/minidom.py", + "lib/python3.10/xml/dom/pulldom.py", + "lib/python3.10/xml/dom/xmlbuilder.py", + "lib/python3.10/xml/etree/ElementInclude.py", + "lib/python3.10/xml/etree/ElementPath.py", + "lib/python3.10/xml/etree/ElementTree.py", + "lib/python3.10/xml/etree/__init__.py", + "lib/python3.10/xml/etree/__pycache__/ElementInclude.cpython-310.pyc", + "lib/python3.10/xml/etree/__pycache__/ElementPath.cpython-310.pyc", + "lib/python3.10/xml/etree/__pycache__/ElementTree.cpython-310.pyc", + "lib/python3.10/xml/etree/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/xml/etree/__pycache__/cElementTree.cpython-310.pyc", + "lib/python3.10/xml/etree/cElementTree.py", + "lib/python3.10/xml/parsers/__init__.py", + "lib/python3.10/xml/parsers/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/xml/parsers/__pycache__/expat.cpython-310.pyc", + "lib/python3.10/xml/parsers/expat.py", + "lib/python3.10/xml/sax/__init__.py", + "lib/python3.10/xml/sax/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/xml/sax/__pycache__/_exceptions.cpython-310.pyc", + "lib/python3.10/xml/sax/__pycache__/expatreader.cpython-310.pyc", + "lib/python3.10/xml/sax/__pycache__/handler.cpython-310.pyc", + "lib/python3.10/xml/sax/__pycache__/saxutils.cpython-310.pyc", + "lib/python3.10/xml/sax/__pycache__/xmlreader.cpython-310.pyc", + "lib/python3.10/xml/sax/_exceptions.py", + "lib/python3.10/xml/sax/expatreader.py", + "lib/python3.10/xml/sax/handler.py", + "lib/python3.10/xml/sax/saxutils.py", + "lib/python3.10/xml/sax/xmlreader.py", + "lib/python3.10/xmlrpc/__init__.py", + "lib/python3.10/xmlrpc/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/xmlrpc/__pycache__/client.cpython-310.pyc", + "lib/python3.10/xmlrpc/__pycache__/server.cpython-310.pyc", + "lib/python3.10/xmlrpc/client.py", + "lib/python3.10/xmlrpc/server.py", + "lib/python3.10/zipapp.py", + "lib/python3.10/zipfile.py", + "lib/python3.10/zipimport.py", + "lib/python3.10/zoneinfo/__init__.py", + "lib/python3.10/zoneinfo/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/zoneinfo/__pycache__/_common.cpython-310.pyc", + "lib/python3.10/zoneinfo/__pycache__/_tzpath.cpython-310.pyc", + "lib/python3.10/zoneinfo/__pycache__/_zoneinfo.cpython-310.pyc", + "lib/python3.10/zoneinfo/_common.py", + "lib/python3.10/zoneinfo/_tzpath.py", + "lib/python3.10/zoneinfo/_zoneinfo.py", + "share/man/man1/python3.1", + "share/man/man1/python3.10.1" + ], + "fn": "python-3.10.9-hc0d8a6c_1.conda", + "legacy_bz2_md5": "79db6ab46b228ae5779c077a7f4314b9", + "legacy_bz2_size": 13813760, + "license": "PSF-2.0", + "license_family": "PSF", + "link": { + "source": "/Users/donjayamanne/.pyenv/versions/anaconda3-2023.03/pkgs/python-3.10.9-hc0d8a6c_1", + "type": 1 + }, + "md5": "b49223285e681289fe846def063b8c61", + "name": "python", + "package_tarball_full_path": "/Users/donjayamanne/.pyenv/versions/anaconda3-2023.03/pkgs/python-3.10.9-hc0d8a6c_1.conda", + "paths_data": { + "paths": [ + { + "_path": "bin/2to3-3.10", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_7a849mskhu/croot/python-split_1677694510376/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_p", + "sha256": "49f8de215d5769259789d0f08d8de049361c9f25670628f3e5efbd90007a3187", + "sha256_in_prefix": "dd0f50efced047ea4e30d973142d09499d4feb8554842d01442f9f2108d5a741", + "size_in_bytes": 347 + }, + { + "_path": "bin/idle3.10", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_7a849mskhu/croot/python-split_1677694510376/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_p", + "sha256": "65b96fcd8aa20754413b467b9a885fb9e90541c57b6fbdf6ecbdb4a3b8c6d2b8", + "sha256_in_prefix": "435786c49358497a8794c08aded2142087b68d97bf8fc2e7a30e0d1f7cff1f37", + "size_in_bytes": 345 + }, + { + "_path": "bin/pydoc3.10", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_7a849mskhu/croot/python-split_1677694510376/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_p", + "sha256": "5e1857422b891dc0699ca50ca21b719119d2c47092d669a262da1a3cdafef055", + "sha256_in_prefix": "66e27555a064b90acc248e3292372a80e19c7adce86da67fc3f5555c2b4eb8b4", + "size_in_bytes": 330 + }, + { + "_path": "bin/python3.10", + "file_mode": "binary", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_7a849mskhu/croot/python-split_1677694510376/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_p", + "sha256": "57759740171bb912fe1eabd295867fad467018f8fc17cb677b9de841a4d3ddea", + "sha256_in_prefix": "e0c8b88c55eae3c3d331055e6f22e23b51afea4b77d47f748abf897fc80827d8", + "size_in_bytes": 3880624 + }, + { + "_path": "bin/python3.10-config", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_7a849mskhu/croot/python-split_1677694510376/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_p", + "sha256": "73722fe35f6884c20967418b6c0c827670e0323a40e4b0686bd6101c73fd4bfd", + "sha256_in_prefix": "f2ab0a490482c0a1dd2e1bb373c3363233e96953118950fcbe8a6170c3a9a941", + "size_in_bytes": 2289 + }, + { + "_path": "lib/libpython3.10.dylib", + "file_mode": "binary", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_7a849mskhu/croot/python-split_1677694510376/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_p", + "sha256": "9b5064ad68a06a3b6c8a827c359f6cde8a18303d2506d589f5f634b9eb8c3a29", + "sha256_in_prefix": "0f2cc0004c39200b1fee5d7247a40a658522d1b3edd49d84b87e1890a34e1bb1", + "size_in_bytes": 3880992 + }, + { + "_path": "lib/pkgconfig/python-3.10-embed.pc", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_7a849mskhu/croot/python-split_1677694510376/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_p", + "sha256": "267ee6603068cc40b1e3cc70e31b12acae4ea280f32b1ee1d76eb35eb46a97ea", + "sha256_in_prefix": "e72ec48cd066261568511e04e4b8a2c77bb400906871ae000308c26c754161da", + "size_in_bytes": 559 + }, + { + "_path": "lib/pkgconfig/python-3.10.pc", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_7a849mskhu/croot/python-split_1677694510376/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_p", + "sha256": "3437ae5485a090fdee7120bb1913b4616fa3e64a4e762c8d0277bf3faa36c69c", + "sha256_in_prefix": "dd3256512d0f7edc4b316556350fda490e536c229e538bec5650a73470dace73", + "size_in_bytes": 532 + }, + { + "_path": "lib/python3.10/_sysconfigdata__darwin_darwin.py", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_7a849mskhu/croot/python-split_1677694510376/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_p", + "sha256": "04bc97e2a3ff9d6d1b8aa6fe456426b37e2530cace3a9aefd88bb138c20200a1", + "sha256_in_prefix": "3090497323d66dbbc11f637972fa5514d00904beb92846349fb4d2361e497254", + "size_in_bytes": 57548 + }, + { + "_path": "lib/python3.10/_sysconfigdata__darwin_darwin.py.orig", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_7a849mskhu/croot/python-split_1677694510376/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_p", + "sha256": "aa64b16d8e75e057bd4e607f588ee5bf38d3f83022de6c7c5f1375860cdb029c", + "sha256_in_prefix": "ce87da2ca67f461f26ed561573fe5a10ce3bb86594225981b15af1dfd0223115", + "size_in_bytes": 66662 + }, + { + "_path": "lib/python3.10/_sysconfigdata_arm64_apple_darwin20_0_0.py", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_7a849mskhu/croot/python-split_1677694510376/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_p", + "sha256": "bf7fd0677c2d7c908d5b9c8f4da8ea9361ca90f02bafbddb3006957276a68258", + "sha256_in_prefix": "bca2eff7df3e2da0dc25776767cd1748f268b2250b21dfaba88f82d1356c852a", + "size_in_bytes": 59223 + }, + { + "_path": "lib/python3.10/config-3.10-darwin/Makefile", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_7a849mskhu/croot/python-split_1677694510376/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_p", + "sha256": "176f81b1323a41f74e47631bc320d300711102b48cc5ac588cab68cd3d6ca375", + "sha256_in_prefix": "dfec273360eacf5e5dcf06f7da1f9e59cd44fbb6f756720dc18bdc55750835de", + "size_in_bytes": 91516 + }, + { + "_path": "lib/python3.10/config-3.10-darwin/python-config.py", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_7a849mskhu/croot/python-split_1677694510376/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_p", + "sha256": "73722fe35f6884c20967418b6c0c827670e0323a40e4b0686bd6101c73fd4bfd", + "sha256_in_prefix": "f2ab0a490482c0a1dd2e1bb373c3363233e96953118950fcbe8a6170c3a9a941", + "size_in_bytes": 2289 + } + ], + "paths_version": 1 + }, + "requested_spec": "defaults/osx-arm64::python==3.10.9=hc0d8a6c_1[md5=b49223285e681289fe846def063b8c61]", + "sha256": "717f4901666a82f0d1fb71be02870d845a72eaec083218e71200000481e5577b", + "size": 13556748, + "subdir": "osx-arm64", + "timestamp": 1677695073705, + "track_features": "", + "url": "https://repo.anaconda.com/pkgs/main/osx-arm64/python-3.10.9-hc0d8a6c_1.conda", + "version": "3.10.9" +} \ No newline at end of file diff --git a/crates/pet-conda/tests/unix/conda_envs/user_home/miniconda3/conda-meta/python-dateutil-2.8.2-pyhd3eb1b0_0.json b/crates/pet-conda/tests/unix/conda_envs/user_home/miniconda3/conda-meta/python-dateutil-2.8.2-pyhd3eb1b0_0.json new file mode 100644 index 00000000..868b827d --- /dev/null +++ b/crates/pet-conda/tests/unix/conda_envs/user_home/miniconda3/conda-meta/python-dateutil-2.8.2-pyhd3eb1b0_0.json @@ -0,0 +1,159 @@ +{ + "build": "pyhd3eb1b0_0", + "build_number": 0, + "channel": "https://repo.anaconda.com/pkgs/main/noarch", + "constrains": [], + "depends": [ + "python", + "six >=1.5" + ], + "extracted_package_dir": "/Users/donjayamanne/.pyenv/versions/anaconda3-2023.03/pkgs/python-dateutil-2.8.2-pyhd3eb1b0_0", + "features": "", + "files": [ + "lib/python3.10/site-packages/dateutil/__init__.py", + "lib/python3.10/site-packages/dateutil/_common.py", + "lib/python3.10/site-packages/dateutil/_version.py", + "lib/python3.10/site-packages/dateutil/easter.py", + "lib/python3.10/site-packages/dateutil/parser/__init__.py", + "lib/python3.10/site-packages/dateutil/parser/_parser.py", + "lib/python3.10/site-packages/dateutil/parser/isoparser.py", + "lib/python3.10/site-packages/dateutil/relativedelta.py", + "lib/python3.10/site-packages/dateutil/rrule.py", + "lib/python3.10/site-packages/dateutil/tz/__init__.py", + "lib/python3.10/site-packages/dateutil/tz/_common.py", + "lib/python3.10/site-packages/dateutil/tz/_factories.py", + "lib/python3.10/site-packages/dateutil/tz/tz.py", + "lib/python3.10/site-packages/dateutil/tz/win.py", + "lib/python3.10/site-packages/dateutil/tzwin.py", + "lib/python3.10/site-packages/dateutil/utils.py", + "lib/python3.10/site-packages/dateutil/zoneinfo/__init__.py", + "lib/python3.10/site-packages/dateutil/zoneinfo/dateutil-zoneinfo.tar.gz", + "lib/python3.10/site-packages/dateutil/zoneinfo/rebuild.py", + "lib/python3.10/site-packages/python_dateutil-2.8.2.dist-info/INSTALLER", + "lib/python3.10/site-packages/python_dateutil-2.8.2.dist-info/LICENSE", + "lib/python3.10/site-packages/python_dateutil-2.8.2.dist-info/METADATA", + "lib/python3.10/site-packages/python_dateutil-2.8.2.dist-info/RECORD", + "lib/python3.10/site-packages/python_dateutil-2.8.2.dist-info/REQUESTED", + "lib/python3.10/site-packages/python_dateutil-2.8.2.dist-info/WHEEL", + "lib/python3.10/site-packages/python_dateutil-2.8.2.dist-info/direct_url.json", + "lib/python3.10/site-packages/python_dateutil-2.8.2.dist-info/top_level.txt", + "lib/python3.10/site-packages/python_dateutil-2.8.2.dist-info/zip-safe", + "lib/python3.10/site-packages/dateutil/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/dateutil/__pycache__/_common.cpython-310.pyc", + "lib/python3.10/site-packages/dateutil/__pycache__/_version.cpython-310.pyc", + "lib/python3.10/site-packages/dateutil/__pycache__/easter.cpython-310.pyc", + "lib/python3.10/site-packages/dateutil/parser/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/dateutil/parser/__pycache__/_parser.cpython-310.pyc", + "lib/python3.10/site-packages/dateutil/parser/__pycache__/isoparser.cpython-310.pyc", + "lib/python3.10/site-packages/dateutil/__pycache__/relativedelta.cpython-310.pyc", + "lib/python3.10/site-packages/dateutil/__pycache__/rrule.cpython-310.pyc", + "lib/python3.10/site-packages/dateutil/tz/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/dateutil/tz/__pycache__/_common.cpython-310.pyc", + "lib/python3.10/site-packages/dateutil/tz/__pycache__/_factories.cpython-310.pyc", + "lib/python3.10/site-packages/dateutil/tz/__pycache__/tz.cpython-310.pyc", + "lib/python3.10/site-packages/dateutil/tz/__pycache__/win.cpython-310.pyc", + "lib/python3.10/site-packages/dateutil/__pycache__/tzwin.cpython-310.pyc", + "lib/python3.10/site-packages/dateutil/__pycache__/utils.cpython-310.pyc", + "lib/python3.10/site-packages/dateutil/zoneinfo/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/dateutil/zoneinfo/__pycache__/rebuild.cpython-310.pyc" + ], + "fn": "python-dateutil-2.8.2-pyhd3eb1b0_0.conda", + "legacy_bz2_md5": "2eb923cc014094f4acf7f849d67d73f8", + "legacy_bz2_size": 246457, + "license": "BSD-3-Clause and Apache", + "license_family": "BSD", + "link": { + "source": "/Users/donjayamanne/.pyenv/versions/anaconda3-2023.03/pkgs/python-dateutil-2.8.2-pyhd3eb1b0_0", + "type": 1 + }, + "md5": "211ee00320b08a1ac9fea6677649f6c9", + "name": "python-dateutil", + "noarch": "python", + "package_tarball_full_path": "/Users/donjayamanne/.pyenv/versions/anaconda3-2023.03/pkgs/python-dateutil-2.8.2-pyhd3eb1b0_0.conda", + "package_type": "noarch_python", + "paths_data": { + "paths": [ + { + "_path": "lib/python3.10/site-packages/dateutil/__pycache__/__init__.cpython-310.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.10/site-packages/dateutil/__pycache__/_common.cpython-310.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.10/site-packages/dateutil/__pycache__/_version.cpython-310.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.10/site-packages/dateutil/__pycache__/easter.cpython-310.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.10/site-packages/dateutil/parser/__pycache__/__init__.cpython-310.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.10/site-packages/dateutil/parser/__pycache__/_parser.cpython-310.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.10/site-packages/dateutil/parser/__pycache__/isoparser.cpython-310.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.10/site-packages/dateutil/__pycache__/relativedelta.cpython-310.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.10/site-packages/dateutil/__pycache__/rrule.cpython-310.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.10/site-packages/dateutil/tz/__pycache__/__init__.cpython-310.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.10/site-packages/dateutil/tz/__pycache__/_common.cpython-310.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.10/site-packages/dateutil/tz/__pycache__/_factories.cpython-310.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.10/site-packages/dateutil/tz/__pycache__/tz.cpython-310.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.10/site-packages/dateutil/tz/__pycache__/win.cpython-310.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.10/site-packages/dateutil/__pycache__/tzwin.cpython-310.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.10/site-packages/dateutil/__pycache__/utils.cpython-310.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.10/site-packages/dateutil/zoneinfo/__pycache__/__init__.cpython-310.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.10/site-packages/dateutil/zoneinfo/__pycache__/rebuild.cpython-310.pyc", + "path_type": "pyc_file" + } + ], + "paths_version": 1 + }, + "requested_spec": "defaults/noarch::python-dateutil==2.8.2=pyhd3eb1b0_0[md5=211ee00320b08a1ac9fea6677649f6c9]", + "sha256": "01e82704b3d84c1b0b1f8823fa64259eb372a1278e6a40dddf2cefb4c96ab942", + "size": 238135, + "subdir": "noarch", + "timestamp": 1626374695070, + "track_features": "", + "url": "https://repo.anaconda.com/pkgs/main/noarch/python-dateutil-2.8.2-pyhd3eb1b0_0.conda", + "version": "2.8.2" +} \ No newline at end of file diff --git a/crates/pet-conda/tests/unix/conda_envs/user_home/miniconda3/conda-meta/python-fastjsonschema-2.16.2-py310hca03da5_0.json b/crates/pet-conda/tests/unix/conda_envs/user_home/miniconda3/conda-meta/python-fastjsonschema-2.16.2-py310hca03da5_0.json new file mode 100644 index 00000000..1e617319 --- /dev/null +++ b/crates/pet-conda/tests/unix/conda_envs/user_home/miniconda3/conda-meta/python-fastjsonschema-2.16.2-py310hca03da5_0.json @@ -0,0 +1,66 @@ +{ + "build": "py310hca03da5_0", + "build_number": 0, + "channel": "https://repo.anaconda.com/pkgs/main/osx-arm64", + "constrains": [], + "depends": [ + "python >=3.10,<3.11.0a0" + ], + "extracted_package_dir": "/Users/donjayamanne/.pyenv/versions/anaconda3-2023.03/pkgs/python-fastjsonschema-2.16.2-py310hca03da5_0", + "features": "", + "files": [ + "lib/python3.10/site-packages/fastjsonschema-2.16.2.dist-info/AUTHORS", + "lib/python3.10/site-packages/fastjsonschema-2.16.2.dist-info/INSTALLER", + "lib/python3.10/site-packages/fastjsonschema-2.16.2.dist-info/LICENSE", + "lib/python3.10/site-packages/fastjsonschema-2.16.2.dist-info/METADATA", + "lib/python3.10/site-packages/fastjsonschema-2.16.2.dist-info/RECORD", + "lib/python3.10/site-packages/fastjsonschema-2.16.2.dist-info/REQUESTED", + "lib/python3.10/site-packages/fastjsonschema-2.16.2.dist-info/WHEEL", + "lib/python3.10/site-packages/fastjsonschema-2.16.2.dist-info/direct_url.json", + "lib/python3.10/site-packages/fastjsonschema-2.16.2.dist-info/top_level.txt", + "lib/python3.10/site-packages/fastjsonschema/__init__.py", + "lib/python3.10/site-packages/fastjsonschema/__main__.py", + "lib/python3.10/site-packages/fastjsonschema/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/fastjsonschema/__pycache__/__main__.cpython-310.pyc", + "lib/python3.10/site-packages/fastjsonschema/__pycache__/draft04.cpython-310.pyc", + "lib/python3.10/site-packages/fastjsonschema/__pycache__/draft06.cpython-310.pyc", + "lib/python3.10/site-packages/fastjsonschema/__pycache__/draft07.cpython-310.pyc", + "lib/python3.10/site-packages/fastjsonschema/__pycache__/exceptions.cpython-310.pyc", + "lib/python3.10/site-packages/fastjsonschema/__pycache__/generator.cpython-310.pyc", + "lib/python3.10/site-packages/fastjsonschema/__pycache__/indent.cpython-310.pyc", + "lib/python3.10/site-packages/fastjsonschema/__pycache__/ref_resolver.cpython-310.pyc", + "lib/python3.10/site-packages/fastjsonschema/__pycache__/version.cpython-310.pyc", + "lib/python3.10/site-packages/fastjsonschema/draft04.py", + "lib/python3.10/site-packages/fastjsonschema/draft06.py", + "lib/python3.10/site-packages/fastjsonschema/draft07.py", + "lib/python3.10/site-packages/fastjsonschema/exceptions.py", + "lib/python3.10/site-packages/fastjsonschema/generator.py", + "lib/python3.10/site-packages/fastjsonschema/indent.py", + "lib/python3.10/site-packages/fastjsonschema/ref_resolver.py", + "lib/python3.10/site-packages/fastjsonschema/version.py" + ], + "fn": "python-fastjsonschema-2.16.2-py310hca03da5_0.conda", + "legacy_bz2_md5": "fac5645515e04c5ac0e47d80133671e2", + "legacy_bz2_size": 267399, + "license": "BSD-3-Clause", + "license_family": "BSD", + "link": { + "source": "/Users/donjayamanne/.pyenv/versions/anaconda3-2023.03/pkgs/python-fastjsonschema-2.16.2-py310hca03da5_0", + "type": 1 + }, + "md5": "70d5db9481d95286a170b6ef099949ed", + "name": "python-fastjsonschema", + "package_tarball_full_path": "/Users/donjayamanne/.pyenv/versions/anaconda3-2023.03/pkgs/python-fastjsonschema-2.16.2-py310hca03da5_0.conda", + "paths_data": { + "paths": [], + "paths_version": 1 + }, + "requested_spec": "defaults/osx-arm64::python-fastjsonschema==2.16.2=py310hca03da5_0[md5=70d5db9481d95286a170b6ef099949ed]", + "sha256": "074dae8587f84038a5bd10cd37d389b663a812aa0e2115a106e6a6aa757cc3b9", + "size": 237477, + "subdir": "osx-arm64", + "timestamp": 1661368747513, + "track_features": "", + "url": "https://repo.anaconda.com/pkgs/main/osx-arm64/python-fastjsonschema-2.16.2-py310hca03da5_0.conda", + "version": "2.16.2" +} \ No newline at end of file diff --git a/crates/pet-conda/tests/unix/conda_envs/user_home/miniconda3/condabin/conda b/crates/pet-conda/tests/unix/conda_envs/user_home/miniconda3/condabin/conda new file mode 100644 index 00000000..e69de29b diff --git a/crates/pet-conda/tests/unix/conda_envs/user_home/miniconda3/envs/env_python_3/bin/conda b/crates/pet-conda/tests/unix/conda_envs/user_home/miniconda3/envs/env_python_3/bin/conda new file mode 100644 index 00000000..e69de29b diff --git a/crates/pet-conda/tests/unix/conda_envs/user_home/miniconda3/envs/env_python_3/bin/python b/crates/pet-conda/tests/unix/conda_envs/user_home/miniconda3/envs/env_python_3/bin/python new file mode 100644 index 00000000..e69de29b diff --git a/crates/pet-conda/tests/unix/conda_envs/user_home/miniconda3/envs/env_python_3/bin/python3 b/crates/pet-conda/tests/unix/conda_envs/user_home/miniconda3/envs/env_python_3/bin/python3 new file mode 100644 index 00000000..e69de29b diff --git a/crates/pet-conda/tests/unix/conda_envs/user_home/miniconda3/envs/env_python_3/bin/python3.1 b/crates/pet-conda/tests/unix/conda_envs/user_home/miniconda3/envs/env_python_3/bin/python3.1 new file mode 100644 index 00000000..e69de29b diff --git a/crates/pet-conda/tests/unix/conda_envs/user_home/miniconda3/envs/env_python_3/bin/python3.12 b/crates/pet-conda/tests/unix/conda_envs/user_home/miniconda3/envs/env_python_3/bin/python3.12 new file mode 100644 index 00000000..e69de29b diff --git a/crates/pet-conda/tests/unix/conda_envs/user_home/miniconda3/envs/env_python_3/conda-meta/history b/crates/pet-conda/tests/unix/conda_envs/user_home/miniconda3/envs/env_python_3/conda-meta/history new file mode 100644 index 00000000..993b4eae --- /dev/null +++ b/crates/pet-conda/tests/unix/conda_envs/user_home/miniconda3/envs/env_python_3/conda-meta/history @@ -0,0 +1,62 @@ +==> 2024-02-28 23:05:07 <== +# cmd: /Users/donjayamanne/miniconda3/bin/conda create -n conda1 +# conda version: 23.11.0 +==> 2024-02-28 23:08:59 <== +# cmd: /Users/donjayamanne/miniconda3/bin/conda install -c conda-forge --name conda1 ipykernel -y +# conda version: 23.11.0 ++conda-forge/noarch::appnope-0.1.4-pyhd8ed1ab_0 ++conda-forge/noarch::asttokens-2.4.1-pyhd8ed1ab_0 ++conda-forge/noarch::comm-0.2.1-pyhd8ed1ab_0 ++conda-forge/noarch::decorator-5.1.1-pyhd8ed1ab_0 ++conda-forge/noarch::exceptiongroup-1.2.0-pyhd8ed1ab_2 ++conda-forge/noarch::executing-2.0.1-pyhd8ed1ab_0 ++conda-forge/noarch::importlib-metadata-7.0.1-pyha770c72_0 ++conda-forge/noarch::importlib_metadata-7.0.1-hd8ed1ab_0 ++conda-forge/noarch::ipykernel-6.29.3-pyh3cd1d5f_0 ++conda-forge/noarch::ipython-8.22.1-pyh707e725_0 ++conda-forge/noarch::jedi-0.19.1-pyhd8ed1ab_0 ++conda-forge/noarch::jupyter_client-8.6.0-pyhd8ed1ab_0 ++conda-forge/noarch::matplotlib-inline-0.1.6-pyhd8ed1ab_0 ++conda-forge/noarch::nest-asyncio-1.6.0-pyhd8ed1ab_0 ++conda-forge/noarch::packaging-23.2-pyhd8ed1ab_0 ++conda-forge/noarch::parso-0.8.3-pyhd8ed1ab_0 ++conda-forge/noarch::pexpect-4.9.0-pyhd8ed1ab_0 ++conda-forge/noarch::pickleshare-0.7.5-py_1003 ++conda-forge/noarch::pip-24.0-pyhd8ed1ab_0 ++conda-forge/noarch::platformdirs-4.2.0-pyhd8ed1ab_0 ++conda-forge/noarch::prompt-toolkit-3.0.42-pyha770c72_0 ++conda-forge/noarch::ptyprocess-0.7.0-pyhd3deb0d_0 ++conda-forge/noarch::pure_eval-0.2.2-pyhd8ed1ab_0 ++conda-forge/noarch::pygments-2.17.2-pyhd8ed1ab_0 ++conda-forge/noarch::python-dateutil-2.8.2-pyhd8ed1ab_0 ++conda-forge/noarch::setuptools-69.1.1-pyhd8ed1ab_0 ++conda-forge/noarch::six-1.16.0-pyh6c4a22f_0 ++conda-forge/noarch::stack_data-0.6.2-pyhd8ed1ab_0 ++conda-forge/noarch::traitlets-5.14.1-pyhd8ed1ab_0 ++conda-forge/noarch::typing_extensions-4.10.0-pyha770c72_0 ++conda-forge/noarch::tzdata-2024a-h0c530f3_0 ++conda-forge/noarch::wcwidth-0.2.13-pyhd8ed1ab_0 ++conda-forge/noarch::wheel-0.42.0-pyhd8ed1ab_0 ++conda-forge/noarch::zipp-3.17.0-pyhd8ed1ab_0 ++conda-forge/osx-arm64::bzip2-1.0.8-h93a5062_5 ++conda-forge/osx-arm64::ca-certificates-2024.2.2-hf0a4a13_0 ++conda-forge/osx-arm64::debugpy-1.8.1-py312h20a0b95_0 ++conda-forge/osx-arm64::jupyter_core-5.7.1-py312h81bd7bf_0 ++conda-forge/osx-arm64::libcxx-16.0.6-h4653b0c_0 ++conda-forge/osx-arm64::libexpat-2.5.0-hb7217d7_1 ++conda-forge/osx-arm64::libffi-3.4.2-h3422bc3_5 ++conda-forge/osx-arm64::libsodium-1.0.18-h27ca646_1 ++conda-forge/osx-arm64::libsqlite-3.45.1-h091b4b1_0 ++conda-forge/osx-arm64::libzlib-1.2.13-h53f4e23_5 ++conda-forge/osx-arm64::ncurses-6.4-h463b476_2 ++conda-forge/osx-arm64::openssl-3.2.1-h0d3ecfb_0 ++conda-forge/osx-arm64::psutil-5.9.8-py312he37b823_0 ++conda-forge/osx-arm64::python-3.12.2-hdf0ec26_0_cpython ++conda-forge/osx-arm64::python_abi-3.12-4_cp312 ++conda-forge/osx-arm64::pyzmq-25.1.2-py312h1edf716_0 ++conda-forge/osx-arm64::readline-8.2-h92ec313_1 ++conda-forge/osx-arm64::tk-8.6.13-h5083fa2_1 ++conda-forge/osx-arm64::tornado-6.4-py312he37b823_0 ++conda-forge/osx-arm64::xz-5.2.6-h57fd34a_0 ++conda-forge/osx-arm64::zeromq-4.3.5-h965bd2d_0 +# update specs: ['ipykernel'] diff --git a/crates/pet-conda/tests/unix/conda_envs/user_home/miniconda3/envs/env_python_3/conda-meta/pygments-2.17.2-pyhd8ed1ab_0.json b/crates/pet-conda/tests/unix/conda_envs/user_home/miniconda3/envs/env_python_3/conda-meta/pygments-2.17.2-pyhd8ed1ab_0.json new file mode 100644 index 00000000..9ae64493 --- /dev/null +++ b/crates/pet-conda/tests/unix/conda_envs/user_home/miniconda3/envs/env_python_3/conda-meta/pygments-2.17.2-pyhd8ed1ab_0.json @@ -0,0 +1,4285 @@ +{ + "build": "pyhd8ed1ab_0", + "build_number": 0, + "channel": "https://conda.anaconda.org/conda-forge/noarch", + "constrains": [], + "depends": [ + "python >=3.7" + ], + "extracted_package_dir": "/Users/donjayamanne/miniconda3/pkgs/pygments-2.17.2-pyhd8ed1ab_0", + "files": [ + "lib/python3.12/site-packages/pygments-2.17.2.dist-info/INSTALLER", + "lib/python3.12/site-packages/pygments-2.17.2.dist-info/METADATA", + "lib/python3.12/site-packages/pygments-2.17.2.dist-info/RECORD", + "lib/python3.12/site-packages/pygments-2.17.2.dist-info/REQUESTED", + "lib/python3.12/site-packages/pygments-2.17.2.dist-info/WHEEL", + "lib/python3.12/site-packages/pygments-2.17.2.dist-info/direct_url.json", + "lib/python3.12/site-packages/pygments-2.17.2.dist-info/entry_points.txt", + "lib/python3.12/site-packages/pygments-2.17.2.dist-info/licenses/AUTHORS", + "lib/python3.12/site-packages/pygments-2.17.2.dist-info/licenses/LICENSE", + "lib/python3.12/site-packages/pygments/__init__.py", + "lib/python3.12/site-packages/pygments/__main__.py", + "lib/python3.12/site-packages/pygments/cmdline.py", + "lib/python3.12/site-packages/pygments/console.py", + "lib/python3.12/site-packages/pygments/filter.py", + "lib/python3.12/site-packages/pygments/filters/__init__.py", + "lib/python3.12/site-packages/pygments/formatter.py", + "lib/python3.12/site-packages/pygments/formatters/__init__.py", + "lib/python3.12/site-packages/pygments/formatters/_mapping.py", + "lib/python3.12/site-packages/pygments/formatters/bbcode.py", + "lib/python3.12/site-packages/pygments/formatters/groff.py", + "lib/python3.12/site-packages/pygments/formatters/html.py", + "lib/python3.12/site-packages/pygments/formatters/img.py", + "lib/python3.12/site-packages/pygments/formatters/irc.py", + "lib/python3.12/site-packages/pygments/formatters/latex.py", + "lib/python3.12/site-packages/pygments/formatters/other.py", + "lib/python3.12/site-packages/pygments/formatters/pangomarkup.py", + "lib/python3.12/site-packages/pygments/formatters/rtf.py", + "lib/python3.12/site-packages/pygments/formatters/svg.py", + "lib/python3.12/site-packages/pygments/formatters/terminal.py", + "lib/python3.12/site-packages/pygments/formatters/terminal256.py", + "lib/python3.12/site-packages/pygments/lexer.py", + "lib/python3.12/site-packages/pygments/lexers/__init__.py", + "lib/python3.12/site-packages/pygments/lexers/_ada_builtins.py", + "lib/python3.12/site-packages/pygments/lexers/_asy_builtins.py", + "lib/python3.12/site-packages/pygments/lexers/_cl_builtins.py", + "lib/python3.12/site-packages/pygments/lexers/_cocoa_builtins.py", + "lib/python3.12/site-packages/pygments/lexers/_csound_builtins.py", + "lib/python3.12/site-packages/pygments/lexers/_css_builtins.py", + "lib/python3.12/site-packages/pygments/lexers/_julia_builtins.py", + "lib/python3.12/site-packages/pygments/lexers/_lasso_builtins.py", + "lib/python3.12/site-packages/pygments/lexers/_lilypond_builtins.py", + "lib/python3.12/site-packages/pygments/lexers/_lua_builtins.py", + "lib/python3.12/site-packages/pygments/lexers/_mapping.py", + "lib/python3.12/site-packages/pygments/lexers/_mql_builtins.py", + "lib/python3.12/site-packages/pygments/lexers/_mysql_builtins.py", + "lib/python3.12/site-packages/pygments/lexers/_openedge_builtins.py", + "lib/python3.12/site-packages/pygments/lexers/_php_builtins.py", + "lib/python3.12/site-packages/pygments/lexers/_postgres_builtins.py", + "lib/python3.12/site-packages/pygments/lexers/_qlik_builtins.py", + "lib/python3.12/site-packages/pygments/lexers/_scheme_builtins.py", + "lib/python3.12/site-packages/pygments/lexers/_scilab_builtins.py", + "lib/python3.12/site-packages/pygments/lexers/_sourcemod_builtins.py", + "lib/python3.12/site-packages/pygments/lexers/_stan_builtins.py", + "lib/python3.12/site-packages/pygments/lexers/_stata_builtins.py", + "lib/python3.12/site-packages/pygments/lexers/_tsql_builtins.py", + "lib/python3.12/site-packages/pygments/lexers/_usd_builtins.py", + "lib/python3.12/site-packages/pygments/lexers/_vbscript_builtins.py", + "lib/python3.12/site-packages/pygments/lexers/_vim_builtins.py", + "lib/python3.12/site-packages/pygments/lexers/actionscript.py", + "lib/python3.12/site-packages/pygments/lexers/ada.py", + "lib/python3.12/site-packages/pygments/lexers/agile.py", + "lib/python3.12/site-packages/pygments/lexers/algebra.py", + "lib/python3.12/site-packages/pygments/lexers/ambient.py", + "lib/python3.12/site-packages/pygments/lexers/amdgpu.py", + "lib/python3.12/site-packages/pygments/lexers/ampl.py", + "lib/python3.12/site-packages/pygments/lexers/apdlexer.py", + "lib/python3.12/site-packages/pygments/lexers/apl.py", + "lib/python3.12/site-packages/pygments/lexers/archetype.py", + "lib/python3.12/site-packages/pygments/lexers/arrow.py", + "lib/python3.12/site-packages/pygments/lexers/arturo.py", + "lib/python3.12/site-packages/pygments/lexers/asc.py", + "lib/python3.12/site-packages/pygments/lexers/asm.py", + "lib/python3.12/site-packages/pygments/lexers/asn1.py", + "lib/python3.12/site-packages/pygments/lexers/automation.py", + "lib/python3.12/site-packages/pygments/lexers/bare.py", + "lib/python3.12/site-packages/pygments/lexers/basic.py", + "lib/python3.12/site-packages/pygments/lexers/bdd.py", + "lib/python3.12/site-packages/pygments/lexers/berry.py", + "lib/python3.12/site-packages/pygments/lexers/bibtex.py", + "lib/python3.12/site-packages/pygments/lexers/blueprint.py", + "lib/python3.12/site-packages/pygments/lexers/boa.py", + "lib/python3.12/site-packages/pygments/lexers/bqn.py", + "lib/python3.12/site-packages/pygments/lexers/business.py", + "lib/python3.12/site-packages/pygments/lexers/c_cpp.py", + "lib/python3.12/site-packages/pygments/lexers/c_like.py", + "lib/python3.12/site-packages/pygments/lexers/capnproto.py", + "lib/python3.12/site-packages/pygments/lexers/carbon.py", + "lib/python3.12/site-packages/pygments/lexers/cddl.py", + "lib/python3.12/site-packages/pygments/lexers/chapel.py", + "lib/python3.12/site-packages/pygments/lexers/clean.py", + "lib/python3.12/site-packages/pygments/lexers/comal.py", + "lib/python3.12/site-packages/pygments/lexers/compiled.py", + "lib/python3.12/site-packages/pygments/lexers/configs.py", + "lib/python3.12/site-packages/pygments/lexers/console.py", + "lib/python3.12/site-packages/pygments/lexers/cplint.py", + "lib/python3.12/site-packages/pygments/lexers/crystal.py", + "lib/python3.12/site-packages/pygments/lexers/csound.py", + "lib/python3.12/site-packages/pygments/lexers/css.py", + "lib/python3.12/site-packages/pygments/lexers/d.py", + "lib/python3.12/site-packages/pygments/lexers/dalvik.py", + "lib/python3.12/site-packages/pygments/lexers/data.py", + "lib/python3.12/site-packages/pygments/lexers/dax.py", + "lib/python3.12/site-packages/pygments/lexers/devicetree.py", + "lib/python3.12/site-packages/pygments/lexers/diff.py", + "lib/python3.12/site-packages/pygments/lexers/dns.py", + "lib/python3.12/site-packages/pygments/lexers/dotnet.py", + "lib/python3.12/site-packages/pygments/lexers/dsls.py", + "lib/python3.12/site-packages/pygments/lexers/dylan.py", + "lib/python3.12/site-packages/pygments/lexers/ecl.py", + "lib/python3.12/site-packages/pygments/lexers/eiffel.py", + "lib/python3.12/site-packages/pygments/lexers/elm.py", + "lib/python3.12/site-packages/pygments/lexers/elpi.py", + "lib/python3.12/site-packages/pygments/lexers/email.py", + "lib/python3.12/site-packages/pygments/lexers/erlang.py", + "lib/python3.12/site-packages/pygments/lexers/esoteric.py", + "lib/python3.12/site-packages/pygments/lexers/ezhil.py", + "lib/python3.12/site-packages/pygments/lexers/factor.py", + "lib/python3.12/site-packages/pygments/lexers/fantom.py", + "lib/python3.12/site-packages/pygments/lexers/felix.py", + "lib/python3.12/site-packages/pygments/lexers/fift.py", + "lib/python3.12/site-packages/pygments/lexers/floscript.py", + "lib/python3.12/site-packages/pygments/lexers/forth.py", + "lib/python3.12/site-packages/pygments/lexers/fortran.py", + "lib/python3.12/site-packages/pygments/lexers/foxpro.py", + "lib/python3.12/site-packages/pygments/lexers/freefem.py", + "lib/python3.12/site-packages/pygments/lexers/func.py", + "lib/python3.12/site-packages/pygments/lexers/functional.py", + "lib/python3.12/site-packages/pygments/lexers/futhark.py", + "lib/python3.12/site-packages/pygments/lexers/gcodelexer.py", + "lib/python3.12/site-packages/pygments/lexers/gdscript.py", + "lib/python3.12/site-packages/pygments/lexers/go.py", + "lib/python3.12/site-packages/pygments/lexers/grammar_notation.py", + "lib/python3.12/site-packages/pygments/lexers/graph.py", + "lib/python3.12/site-packages/pygments/lexers/graphics.py", + "lib/python3.12/site-packages/pygments/lexers/graphql.py", + "lib/python3.12/site-packages/pygments/lexers/graphviz.py", + "lib/python3.12/site-packages/pygments/lexers/gsql.py", + "lib/python3.12/site-packages/pygments/lexers/haskell.py", + "lib/python3.12/site-packages/pygments/lexers/haxe.py", + "lib/python3.12/site-packages/pygments/lexers/hdl.py", + "lib/python3.12/site-packages/pygments/lexers/hexdump.py", + "lib/python3.12/site-packages/pygments/lexers/html.py", + "lib/python3.12/site-packages/pygments/lexers/idl.py", + "lib/python3.12/site-packages/pygments/lexers/igor.py", + "lib/python3.12/site-packages/pygments/lexers/inferno.py", + "lib/python3.12/site-packages/pygments/lexers/installers.py", + "lib/python3.12/site-packages/pygments/lexers/int_fiction.py", + "lib/python3.12/site-packages/pygments/lexers/iolang.py", + "lib/python3.12/site-packages/pygments/lexers/j.py", + "lib/python3.12/site-packages/pygments/lexers/javascript.py", + "lib/python3.12/site-packages/pygments/lexers/jmespath.py", + "lib/python3.12/site-packages/pygments/lexers/jslt.py", + "lib/python3.12/site-packages/pygments/lexers/jsonnet.py", + "lib/python3.12/site-packages/pygments/lexers/jsx.py", + "lib/python3.12/site-packages/pygments/lexers/julia.py", + "lib/python3.12/site-packages/pygments/lexers/jvm.py", + "lib/python3.12/site-packages/pygments/lexers/kuin.py", + "lib/python3.12/site-packages/pygments/lexers/kusto.py", + "lib/python3.12/site-packages/pygments/lexers/ldap.py", + "lib/python3.12/site-packages/pygments/lexers/lean.py", + "lib/python3.12/site-packages/pygments/lexers/lilypond.py", + "lib/python3.12/site-packages/pygments/lexers/lisp.py", + "lib/python3.12/site-packages/pygments/lexers/macaulay2.py", + "lib/python3.12/site-packages/pygments/lexers/make.py", + "lib/python3.12/site-packages/pygments/lexers/markup.py", + "lib/python3.12/site-packages/pygments/lexers/math.py", + "lib/python3.12/site-packages/pygments/lexers/matlab.py", + "lib/python3.12/site-packages/pygments/lexers/maxima.py", + "lib/python3.12/site-packages/pygments/lexers/meson.py", + "lib/python3.12/site-packages/pygments/lexers/mime.py", + "lib/python3.12/site-packages/pygments/lexers/minecraft.py", + "lib/python3.12/site-packages/pygments/lexers/mips.py", + "lib/python3.12/site-packages/pygments/lexers/ml.py", + "lib/python3.12/site-packages/pygments/lexers/modeling.py", + "lib/python3.12/site-packages/pygments/lexers/modula2.py", + "lib/python3.12/site-packages/pygments/lexers/monte.py", + "lib/python3.12/site-packages/pygments/lexers/mosel.py", + "lib/python3.12/site-packages/pygments/lexers/ncl.py", + "lib/python3.12/site-packages/pygments/lexers/nimrod.py", + "lib/python3.12/site-packages/pygments/lexers/nit.py", + "lib/python3.12/site-packages/pygments/lexers/nix.py", + "lib/python3.12/site-packages/pygments/lexers/oberon.py", + "lib/python3.12/site-packages/pygments/lexers/objective.py", + "lib/python3.12/site-packages/pygments/lexers/ooc.py", + "lib/python3.12/site-packages/pygments/lexers/openscad.py", + "lib/python3.12/site-packages/pygments/lexers/other.py", + "lib/python3.12/site-packages/pygments/lexers/parasail.py", + "lib/python3.12/site-packages/pygments/lexers/parsers.py", + "lib/python3.12/site-packages/pygments/lexers/pascal.py", + "lib/python3.12/site-packages/pygments/lexers/pawn.py", + "lib/python3.12/site-packages/pygments/lexers/perl.py", + "lib/python3.12/site-packages/pygments/lexers/phix.py", + "lib/python3.12/site-packages/pygments/lexers/php.py", + "lib/python3.12/site-packages/pygments/lexers/pointless.py", + "lib/python3.12/site-packages/pygments/lexers/pony.py", + "lib/python3.12/site-packages/pygments/lexers/praat.py", + "lib/python3.12/site-packages/pygments/lexers/procfile.py", + "lib/python3.12/site-packages/pygments/lexers/prolog.py", + "lib/python3.12/site-packages/pygments/lexers/promql.py", + "lib/python3.12/site-packages/pygments/lexers/prql.py", + "lib/python3.12/site-packages/pygments/lexers/ptx.py", + "lib/python3.12/site-packages/pygments/lexers/python.py", + "lib/python3.12/site-packages/pygments/lexers/q.py", + "lib/python3.12/site-packages/pygments/lexers/qlik.py", + "lib/python3.12/site-packages/pygments/lexers/qvt.py", + "lib/python3.12/site-packages/pygments/lexers/r.py", + "lib/python3.12/site-packages/pygments/lexers/rdf.py", + "lib/python3.12/site-packages/pygments/lexers/rebol.py", + "lib/python3.12/site-packages/pygments/lexers/resource.py", + "lib/python3.12/site-packages/pygments/lexers/ride.py", + "lib/python3.12/site-packages/pygments/lexers/rita.py", + "lib/python3.12/site-packages/pygments/lexers/rnc.py", + "lib/python3.12/site-packages/pygments/lexers/roboconf.py", + "lib/python3.12/site-packages/pygments/lexers/robotframework.py", + "lib/python3.12/site-packages/pygments/lexers/ruby.py", + "lib/python3.12/site-packages/pygments/lexers/rust.py", + "lib/python3.12/site-packages/pygments/lexers/sas.py", + "lib/python3.12/site-packages/pygments/lexers/savi.py", + "lib/python3.12/site-packages/pygments/lexers/scdoc.py", + "lib/python3.12/site-packages/pygments/lexers/scripting.py", + "lib/python3.12/site-packages/pygments/lexers/sgf.py", + "lib/python3.12/site-packages/pygments/lexers/shell.py", + "lib/python3.12/site-packages/pygments/lexers/sieve.py", + "lib/python3.12/site-packages/pygments/lexers/slash.py", + "lib/python3.12/site-packages/pygments/lexers/smalltalk.py", + "lib/python3.12/site-packages/pygments/lexers/smithy.py", + "lib/python3.12/site-packages/pygments/lexers/smv.py", + "lib/python3.12/site-packages/pygments/lexers/snobol.py", + "lib/python3.12/site-packages/pygments/lexers/solidity.py", + "lib/python3.12/site-packages/pygments/lexers/sophia.py", + "lib/python3.12/site-packages/pygments/lexers/special.py", + "lib/python3.12/site-packages/pygments/lexers/spice.py", + "lib/python3.12/site-packages/pygments/lexers/sql.py", + "lib/python3.12/site-packages/pygments/lexers/srcinfo.py", + "lib/python3.12/site-packages/pygments/lexers/stata.py", + "lib/python3.12/site-packages/pygments/lexers/supercollider.py", + "lib/python3.12/site-packages/pygments/lexers/tal.py", + "lib/python3.12/site-packages/pygments/lexers/tcl.py", + "lib/python3.12/site-packages/pygments/lexers/teal.py", + "lib/python3.12/site-packages/pygments/lexers/templates.py", + "lib/python3.12/site-packages/pygments/lexers/teraterm.py", + "lib/python3.12/site-packages/pygments/lexers/testing.py", + "lib/python3.12/site-packages/pygments/lexers/text.py", + "lib/python3.12/site-packages/pygments/lexers/textedit.py", + "lib/python3.12/site-packages/pygments/lexers/textfmts.py", + "lib/python3.12/site-packages/pygments/lexers/theorem.py", + "lib/python3.12/site-packages/pygments/lexers/thingsdb.py", + "lib/python3.12/site-packages/pygments/lexers/tlb.py", + "lib/python3.12/site-packages/pygments/lexers/tls.py", + "lib/python3.12/site-packages/pygments/lexers/tnt.py", + "lib/python3.12/site-packages/pygments/lexers/trafficscript.py", + "lib/python3.12/site-packages/pygments/lexers/typoscript.py", + "lib/python3.12/site-packages/pygments/lexers/ul4.py", + "lib/python3.12/site-packages/pygments/lexers/unicon.py", + "lib/python3.12/site-packages/pygments/lexers/urbi.py", + "lib/python3.12/site-packages/pygments/lexers/usd.py", + "lib/python3.12/site-packages/pygments/lexers/varnish.py", + "lib/python3.12/site-packages/pygments/lexers/verification.py", + "lib/python3.12/site-packages/pygments/lexers/verifpal.py", + "lib/python3.12/site-packages/pygments/lexers/vip.py", + "lib/python3.12/site-packages/pygments/lexers/vyper.py", + "lib/python3.12/site-packages/pygments/lexers/web.py", + "lib/python3.12/site-packages/pygments/lexers/webassembly.py", + "lib/python3.12/site-packages/pygments/lexers/webidl.py", + "lib/python3.12/site-packages/pygments/lexers/webmisc.py", + "lib/python3.12/site-packages/pygments/lexers/wgsl.py", + "lib/python3.12/site-packages/pygments/lexers/whiley.py", + "lib/python3.12/site-packages/pygments/lexers/wowtoc.py", + "lib/python3.12/site-packages/pygments/lexers/wren.py", + "lib/python3.12/site-packages/pygments/lexers/x10.py", + "lib/python3.12/site-packages/pygments/lexers/xorg.py", + "lib/python3.12/site-packages/pygments/lexers/yang.py", + "lib/python3.12/site-packages/pygments/lexers/yara.py", + "lib/python3.12/site-packages/pygments/lexers/zig.py", + "lib/python3.12/site-packages/pygments/modeline.py", + "lib/python3.12/site-packages/pygments/plugin.py", + "lib/python3.12/site-packages/pygments/regexopt.py", + "lib/python3.12/site-packages/pygments/scanner.py", + "lib/python3.12/site-packages/pygments/sphinxext.py", + "lib/python3.12/site-packages/pygments/style.py", + "lib/python3.12/site-packages/pygments/styles/__init__.py", + "lib/python3.12/site-packages/pygments/styles/_mapping.py", + "lib/python3.12/site-packages/pygments/styles/abap.py", + "lib/python3.12/site-packages/pygments/styles/algol.py", + "lib/python3.12/site-packages/pygments/styles/algol_nu.py", + "lib/python3.12/site-packages/pygments/styles/arduino.py", + "lib/python3.12/site-packages/pygments/styles/autumn.py", + "lib/python3.12/site-packages/pygments/styles/borland.py", + "lib/python3.12/site-packages/pygments/styles/bw.py", + "lib/python3.12/site-packages/pygments/styles/colorful.py", + "lib/python3.12/site-packages/pygments/styles/default.py", + "lib/python3.12/site-packages/pygments/styles/dracula.py", + "lib/python3.12/site-packages/pygments/styles/emacs.py", + "lib/python3.12/site-packages/pygments/styles/friendly.py", + "lib/python3.12/site-packages/pygments/styles/friendly_grayscale.py", + "lib/python3.12/site-packages/pygments/styles/fruity.py", + "lib/python3.12/site-packages/pygments/styles/gh_dark.py", + "lib/python3.12/site-packages/pygments/styles/gruvbox.py", + "lib/python3.12/site-packages/pygments/styles/igor.py", + "lib/python3.12/site-packages/pygments/styles/inkpot.py", + "lib/python3.12/site-packages/pygments/styles/lightbulb.py", + "lib/python3.12/site-packages/pygments/styles/lilypond.py", + "lib/python3.12/site-packages/pygments/styles/lovelace.py", + "lib/python3.12/site-packages/pygments/styles/manni.py", + "lib/python3.12/site-packages/pygments/styles/material.py", + "lib/python3.12/site-packages/pygments/styles/monokai.py", + "lib/python3.12/site-packages/pygments/styles/murphy.py", + "lib/python3.12/site-packages/pygments/styles/native.py", + "lib/python3.12/site-packages/pygments/styles/nord.py", + "lib/python3.12/site-packages/pygments/styles/onedark.py", + "lib/python3.12/site-packages/pygments/styles/paraiso_dark.py", + "lib/python3.12/site-packages/pygments/styles/paraiso_light.py", + "lib/python3.12/site-packages/pygments/styles/pastie.py", + "lib/python3.12/site-packages/pygments/styles/perldoc.py", + "lib/python3.12/site-packages/pygments/styles/rainbow_dash.py", + "lib/python3.12/site-packages/pygments/styles/rrt.py", + "lib/python3.12/site-packages/pygments/styles/sas.py", + "lib/python3.12/site-packages/pygments/styles/solarized.py", + "lib/python3.12/site-packages/pygments/styles/staroffice.py", + "lib/python3.12/site-packages/pygments/styles/stata_dark.py", + "lib/python3.12/site-packages/pygments/styles/stata_light.py", + "lib/python3.12/site-packages/pygments/styles/tango.py", + "lib/python3.12/site-packages/pygments/styles/trac.py", + "lib/python3.12/site-packages/pygments/styles/vim.py", + "lib/python3.12/site-packages/pygments/styles/vs.py", + "lib/python3.12/site-packages/pygments/styles/xcode.py", + "lib/python3.12/site-packages/pygments/styles/zenburn.py", + "lib/python3.12/site-packages/pygments/token.py", + "lib/python3.12/site-packages/pygments/unistring.py", + "lib/python3.12/site-packages/pygments/util.py", + "lib/python3.12/site-packages/pygments/__pycache__/__init__.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/__pycache__/__main__.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/__pycache__/cmdline.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/__pycache__/console.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/__pycache__/filter.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/filters/__pycache__/__init__.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/__pycache__/formatter.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/formatters/__pycache__/__init__.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/formatters/__pycache__/_mapping.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/formatters/__pycache__/bbcode.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/formatters/__pycache__/groff.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/formatters/__pycache__/html.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/formatters/__pycache__/img.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/formatters/__pycache__/irc.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/formatters/__pycache__/latex.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/formatters/__pycache__/other.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/formatters/__pycache__/pangomarkup.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/formatters/__pycache__/rtf.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/formatters/__pycache__/svg.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/formatters/__pycache__/terminal.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/formatters/__pycache__/terminal256.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/__pycache__/lexer.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/__init__.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/_ada_builtins.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/_asy_builtins.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/_cl_builtins.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/_cocoa_builtins.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/_csound_builtins.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/_css_builtins.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/_julia_builtins.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/_lasso_builtins.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/_lilypond_builtins.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/_lua_builtins.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/_mapping.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/_mql_builtins.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/_mysql_builtins.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/_openedge_builtins.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/_php_builtins.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/_postgres_builtins.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/_qlik_builtins.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/_scheme_builtins.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/_scilab_builtins.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/_sourcemod_builtins.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/_stan_builtins.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/_stata_builtins.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/_tsql_builtins.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/_usd_builtins.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/_vbscript_builtins.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/_vim_builtins.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/actionscript.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/ada.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/agile.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/algebra.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/ambient.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/amdgpu.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/ampl.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/apdlexer.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/apl.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/archetype.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/arrow.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/arturo.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/asc.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/asm.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/asn1.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/automation.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/bare.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/basic.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/bdd.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/berry.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/bibtex.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/blueprint.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/boa.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/bqn.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/business.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/c_cpp.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/c_like.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/capnproto.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/carbon.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/cddl.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/chapel.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/clean.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/comal.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/compiled.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/configs.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/console.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/cplint.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/crystal.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/csound.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/css.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/d.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/dalvik.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/data.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/dax.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/devicetree.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/diff.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/dns.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/dotnet.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/dsls.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/dylan.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/ecl.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/eiffel.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/elm.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/elpi.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/email.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/erlang.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/esoteric.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/ezhil.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/factor.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/fantom.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/felix.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/fift.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/floscript.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/forth.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/fortran.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/foxpro.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/freefem.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/func.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/functional.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/futhark.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/gcodelexer.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/gdscript.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/go.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/grammar_notation.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/graph.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/graphics.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/graphql.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/graphviz.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/gsql.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/haskell.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/haxe.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/hdl.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/hexdump.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/html.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/idl.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/igor.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/inferno.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/installers.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/int_fiction.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/iolang.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/j.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/javascript.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/jmespath.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/jslt.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/jsonnet.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/jsx.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/julia.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/jvm.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/kuin.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/kusto.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/ldap.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/lean.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/lilypond.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/lisp.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/macaulay2.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/make.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/markup.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/math.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/matlab.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/maxima.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/meson.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/mime.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/minecraft.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/mips.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/ml.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/modeling.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/modula2.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/monte.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/mosel.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/ncl.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/nimrod.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/nit.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/nix.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/oberon.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/objective.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/ooc.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/openscad.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/other.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/parasail.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/parsers.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/pascal.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/pawn.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/perl.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/phix.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/php.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/pointless.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/pony.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/praat.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/procfile.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/prolog.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/promql.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/prql.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/ptx.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/python.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/q.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/qlik.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/qvt.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/r.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/rdf.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/rebol.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/resource.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/ride.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/rita.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/rnc.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/roboconf.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/robotframework.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/ruby.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/rust.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/sas.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/savi.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/scdoc.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/scripting.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/sgf.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/shell.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/sieve.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/slash.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/smalltalk.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/smithy.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/smv.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/snobol.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/solidity.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/sophia.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/special.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/spice.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/sql.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/srcinfo.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/stata.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/supercollider.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/tal.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/tcl.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/teal.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/templates.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/teraterm.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/testing.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/text.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/textedit.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/textfmts.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/theorem.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/thingsdb.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/tlb.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/tls.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/tnt.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/trafficscript.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/typoscript.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/ul4.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/unicon.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/urbi.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/usd.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/varnish.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/verification.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/verifpal.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/vip.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/vyper.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/web.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/webassembly.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/webidl.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/webmisc.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/wgsl.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/whiley.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/wowtoc.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/wren.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/x10.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/xorg.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/yang.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/yara.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/lexers/__pycache__/zig.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/__pycache__/modeline.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/__pycache__/plugin.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/__pycache__/regexopt.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/__pycache__/scanner.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/__pycache__/sphinxext.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/__pycache__/style.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/styles/__pycache__/__init__.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/styles/__pycache__/_mapping.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/styles/__pycache__/abap.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/styles/__pycache__/algol.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/styles/__pycache__/algol_nu.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/styles/__pycache__/arduino.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/styles/__pycache__/autumn.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/styles/__pycache__/borland.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/styles/__pycache__/bw.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/styles/__pycache__/colorful.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/styles/__pycache__/default.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/styles/__pycache__/dracula.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/styles/__pycache__/emacs.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/styles/__pycache__/friendly.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/styles/__pycache__/friendly_grayscale.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/styles/__pycache__/fruity.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/styles/__pycache__/gh_dark.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/styles/__pycache__/gruvbox.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/styles/__pycache__/igor.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/styles/__pycache__/inkpot.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/styles/__pycache__/lightbulb.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/styles/__pycache__/lilypond.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/styles/__pycache__/lovelace.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/styles/__pycache__/manni.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/styles/__pycache__/material.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/styles/__pycache__/monokai.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/styles/__pycache__/murphy.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/styles/__pycache__/native.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/styles/__pycache__/nord.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/styles/__pycache__/onedark.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/styles/__pycache__/paraiso_dark.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/styles/__pycache__/paraiso_light.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/styles/__pycache__/pastie.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/styles/__pycache__/perldoc.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/styles/__pycache__/rainbow_dash.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/styles/__pycache__/rrt.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/styles/__pycache__/sas.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/styles/__pycache__/solarized.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/styles/__pycache__/staroffice.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/styles/__pycache__/stata_dark.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/styles/__pycache__/stata_light.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/styles/__pycache__/tango.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/styles/__pycache__/trac.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/styles/__pycache__/vim.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/styles/__pycache__/vs.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/styles/__pycache__/xcode.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/styles/__pycache__/zenburn.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/__pycache__/token.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/__pycache__/unistring.cpython-312.pyc", + "lib/python3.12/site-packages/pygments/__pycache__/util.cpython-312.pyc", + "bin/pygmentize" + ], + "fn": "pygments-2.17.2-pyhd8ed1ab_0.conda", + "license": "BSD-2-Clause", + "link": { + "source": "/Users/donjayamanne/miniconda3/pkgs/pygments-2.17.2-pyhd8ed1ab_0", + "type": 1 + }, + "md5": "140a7f159396547e9799aa98f9f0742e", + "name": "pygments", + "noarch": "python", + "package_tarball_full_path": "/Users/donjayamanne/miniconda3/pkgs/pygments-2.17.2-pyhd8ed1ab_0.conda", + "package_type": "noarch_python", + "paths_data": { + "paths": [ + { + "_path": "site-packages/pygments-2.17.2.dist-info/INSTALLER", + "path_type": "hardlink", + "sha256": "d0edee15f91b406f3f99726e44eb990be6e34fd0345b52b910c568e0eef6a2a8", + "sha256_in_prefix": "d0edee15f91b406f3f99726e44eb990be6e34fd0345b52b910c568e0eef6a2a8", + "size_in_bytes": 5 + }, + { + "_path": "site-packages/pygments-2.17.2.dist-info/METADATA", + "path_type": "hardlink", + "sha256": "cc7fbb14bb31cdd91a722f246ec1f35fc9f326fb0f3ced50908904c575797376", + "sha256_in_prefix": "cc7fbb14bb31cdd91a722f246ec1f35fc9f326fb0f3ced50908904c575797376", + "size_in_bytes": 2592 + }, + { + "_path": "site-packages/pygments-2.17.2.dist-info/RECORD", + "path_type": "hardlink", + "sha256": "dc4ac9fb9e165e4a0788ee337acb37e793f284ec4471535e068280bc2c30b116", + "sha256_in_prefix": "dc4ac9fb9e165e4a0788ee337acb37e793f284ec4471535e068280bc2c30b116", + "size_in_bytes": 45249 + }, + { + "_path": "site-packages/pygments-2.17.2.dist-info/REQUESTED", + "path_type": "hardlink", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size_in_bytes": 0 + }, + { + "_path": "site-packages/pygments-2.17.2.dist-info/WHEEL", + "path_type": "hardlink", + "sha256": "f5006e1e183a14d5bb969a5ba05daf2956c2193573b05ca48114238e56a3ae10", + "sha256_in_prefix": "f5006e1e183a14d5bb969a5ba05daf2956c2193573b05ca48114238e56a3ae10", + "size_in_bytes": 87 + }, + { + "_path": "site-packages/pygments-2.17.2.dist-info/direct_url.json", + "path_type": "hardlink", + "sha256": "85b953817e88fa65e1ccbf5d54cf0f2fa0c9ac127ab1cd23161706f0358cdd69", + "sha256_in_prefix": "85b953817e88fa65e1ccbf5d54cf0f2fa0c9ac127ab1cd23161706f0358cdd69", + "size_in_bytes": 104 + }, + { + "_path": "site-packages/pygments-2.17.2.dist-info/entry_points.txt", + "path_type": "hardlink", + "sha256": "b945f0f9784c281117e2959c0ada6e4d39cf84bde1ece104da35a2e75550b1af", + "sha256_in_prefix": "b945f0f9784c281117e2959c0ada6e4d39cf84bde1ece104da35a2e75550b1af", + "size_in_bytes": 53 + }, + { + "_path": "site-packages/pygments-2.17.2.dist-info/licenses/AUTHORS", + "path_type": "hardlink", + "sha256": "71408c264e8030a8ee751f76cd9ff75f0e66586b30b243c5418a54d46f184436", + "sha256_in_prefix": "71408c264e8030a8ee751f76cd9ff75f0e66586b30b243c5418a54d46f184436", + "size_in_bytes": 10281 + }, + { + "_path": "site-packages/pygments-2.17.2.dist-info/licenses/LICENSE", + "path_type": "hardlink", + "sha256": "a9d66f1d526df02e29dce73436d34e56e8632f46c275bbdffc70569e882f9f17", + "sha256_in_prefix": "a9d66f1d526df02e29dce73436d34e56e8632f46c275bbdffc70569e882f9f17", + "size_in_bytes": 1331 + }, + { + "_path": "site-packages/pygments/__init__.py", + "path_type": "hardlink", + "sha256": "84e562dc5c16bab7350a3e7b689432af5b42899e9d54cf7ce367985e414f9989", + "sha256_in_prefix": "84e562dc5c16bab7350a3e7b689432af5b42899e9d54cf7ce367985e414f9989", + "size_in_bytes": 2959 + }, + { + "_path": "site-packages/pygments/__main__.py", + "path_type": "hardlink", + "sha256": "c55ce4ef01bde24b2439f2d3e8e4575913d1659d0801abce7910ad1979f6c843", + "sha256_in_prefix": "c55ce4ef01bde24b2439f2d3e8e4575913d1659d0801abce7910ad1979f6c843", + "size_in_bytes": 348 + }, + { + "_path": "site-packages/pygments/cmdline.py", + "path_type": "hardlink", + "sha256": "e410eb29bfdc39cbf3a743ecf2baf8ac520ef2461bd792439448912a9a13c161", + "sha256_in_prefix": "e410eb29bfdc39cbf3a743ecf2baf8ac520ef2461bd792439448912a9a13c161", + "size_in_bytes": 23530 + }, + { + "_path": "site-packages/pygments/console.py", + "path_type": "hardlink", + "sha256": "db06795be53a4ee7490f5fcd2d4c237253296e898533dd6536fd75ffad2c7c66", + "sha256_in_prefix": "db06795be53a4ee7490f5fcd2d4c237253296e898533dd6536fd75ffad2c7c66", + "size_in_bytes": 1697 + }, + { + "_path": "site-packages/pygments/filter.py", + "path_type": "hardlink", + "sha256": "8f968b33d6bdc12c7a787d68cb8ef7a12909d3684658da6d065568e2cd60ff7d", + "sha256_in_prefix": "8f968b33d6bdc12c7a787d68cb8ef7a12909d3684658da6d065568e2cd60ff7d", + "size_in_bytes": 1938 + }, + { + "_path": "site-packages/pygments/filters/__init__.py", + "path_type": "hardlink", + "sha256": "abcafc19f2b774ed36d5348725da7037087a44729b00bedc782ce885abd668dd", + "sha256_in_prefix": "abcafc19f2b774ed36d5348725da7037087a44729b00bedc782ce885abd668dd", + "size_in_bytes": 40338 + }, + { + "_path": "site-packages/pygments/formatter.py", + "path_type": "hardlink", + "sha256": "633d35c93d4d4905d317c1afb0bc494a67b3ec4ad354eb319b733a1953ee1fec", + "sha256_in_prefix": "633d35c93d4d4905d317c1afb0bc494a67b3ec4ad354eb319b733a1953ee1fec", + "size_in_bytes": 4154 + }, + { + "_path": "site-packages/pygments/formatters/__init__.py", + "path_type": "hardlink", + "sha256": "d60005db5b7c1460290d7a43a71e5ba94d0caea23bc653c59cf320dae5e7d109", + "sha256_in_prefix": "d60005db5b7c1460290d7a43a71e5ba94d0caea23bc653c59cf320dae5e7d109", + "size_in_bytes": 5395 + }, + { + "_path": "site-packages/pygments/formatters/_mapping.py", + "path_type": "hardlink", + "sha256": "d42c37ec5b9094d69c9f144a9ad94f5f89f22e85fdfedb64a39670b1c354659e", + "sha256_in_prefix": "d42c37ec5b9094d69c9f144a9ad94f5f89f22e85fdfedb64a39670b1c354659e", + "size_in_bytes": 4176 + }, + { + "_path": "site-packages/pygments/formatters/bbcode.py", + "path_type": "hardlink", + "sha256": "ef370d727a0d8fe742c8996b1e79adab4576a3c6460f5e0de5a9c5578150e4f1", + "sha256_in_prefix": "ef370d727a0d8fe742c8996b1e79adab4576a3c6460f5e0de5a9c5578150e4f1", + "size_in_bytes": 3290 + }, + { + "_path": "site-packages/pygments/formatters/groff.py", + "path_type": "hardlink", + "sha256": "bdadb195208df9efe2d1cfc3cf4760dc757d023b7d1b8e4f5da0a2ec212c2dd8", + "sha256_in_prefix": "bdadb195208df9efe2d1cfc3cf4760dc757d023b7d1b8e4f5da0a2ec212c2dd8", + "size_in_bytes": 5070 + }, + { + "_path": "site-packages/pygments/formatters/html.py", + "path_type": "hardlink", + "sha256": "d4bd2a0616211e899ea835164394023dd69b841c23e482ff6e87ad42dad7b45e", + "sha256_in_prefix": "d4bd2a0616211e899ea835164394023dd69b841c23e482ff6e87ad42dad7b45e", + "size_in_bytes": 35640 + }, + { + "_path": "site-packages/pygments/formatters/img.py", + "path_type": "hardlink", + "sha256": "874ffbac1102322cf9625bb799cf380b9f4da908b272c65a9c13e087f8c9ba3a", + "sha256_in_prefix": "874ffbac1102322cf9625bb799cf380b9f4da908b272c65a9c13e087f8c9ba3a", + "size_in_bytes": 23116 + }, + { + "_path": "site-packages/pygments/formatters/irc.py", + "path_type": "hardlink", + "sha256": "264cdeef9ced6b222484d8a37e7148b2a39447e633e5fc0440cfe879674e9d15", + "sha256_in_prefix": "264cdeef9ced6b222484d8a37e7148b2a39447e633e5fc0440cfe879674e9d15", + "size_in_bytes": 4945 + }, + { + "_path": "site-packages/pygments/formatters/latex.py", + "path_type": "hardlink", + "sha256": "e3c80c6fcce2620c90549e0e7f1f31dca6b6974441a26818827e738de40afef3", + "sha256_in_prefix": "e3c80c6fcce2620c90549e0e7f1f31dca6b6974441a26818827e738de40afef3", + "size_in_bytes": 19303 + }, + { + "_path": "site-packages/pygments/formatters/other.py", + "path_type": "hardlink", + "sha256": "4732619577981f22f1882e6f112cb8d5650ad053aa24fc6f32247a5689f4cf94", + "sha256_in_prefix": "4732619577981f22f1882e6f112cb8d5650ad053aa24fc6f32247a5689f4cf94", + "size_in_bytes": 5025 + }, + { + "_path": "site-packages/pygments/formatters/pangomarkup.py", + "path_type": "hardlink", + "sha256": "d22e07ecd2ecc5cc73142254e4e3432668652efb122c29da167f855c0e523109", + "sha256_in_prefix": "d22e07ecd2ecc5cc73142254e4e3432668652efb122c29da167f855c0e523109", + "size_in_bytes": 2200 + }, + { + "_path": "site-packages/pygments/formatters/rtf.py", + "path_type": "hardlink", + "sha256": "f31821686301057ab65cd8fe656373600797fc6a880cca9406224b0c2ba5ccd2", + "sha256_in_prefix": "f31821686301057ab65cd8fe656373600797fc6a880cca9406224b0c2ba5ccd2", + "size_in_bytes": 4990 + }, + { + "_path": "site-packages/pygments/formatters/svg.py", + "path_type": "hardlink", + "sha256": "5718c4fa2a9aad05c9105462b2cb8b6eca285d40955d680e6d0edce2e6fee738", + "sha256_in_prefix": "5718c4fa2a9aad05c9105462b2cb8b6eca285d40955d680e6d0edce2e6fee738", + "size_in_bytes": 7299 + }, + { + "_path": "site-packages/pygments/formatters/terminal.py", + "path_type": "hardlink", + "sha256": "3ff76bec62f245320a83c2c471e08eaf9079786cc640110b03725038cbd9f150", + "sha256_in_prefix": "3ff76bec62f245320a83c2c471e08eaf9079786cc640110b03725038cbd9f150", + "size_in_bytes": 4626 + }, + { + "_path": "site-packages/pygments/formatters/terminal256.py", + "path_type": "hardlink", + "sha256": "ff162d3545130227b9061ed2f7c9ebb7b5c894b5144730f2928b0feed4fbd38e", + "sha256_in_prefix": "ff162d3545130227b9061ed2f7c9ebb7b5c894b5144730f2928b0feed4fbd38e", + "size_in_bytes": 11717 + }, + { + "_path": "site-packages/pygments/lexer.py", + "path_type": "hardlink", + "sha256": "72eec89179bfb2129d7e65d7ae52f26f14594bf451049a1a6cec1066a2cf50ee", + "sha256_in_prefix": "72eec89179bfb2129d7e65d7ae52f26f14594bf451049a1a6cec1066a2cf50ee", + "size_in_bytes": 35044 + }, + { + "_path": "site-packages/pygments/lexers/__init__.py", + "path_type": "hardlink", + "sha256": "b9db095dd79fca1c1451f8ac0b71366e35a1ddc00d4c4d195de5c188ab64f037", + "sha256_in_prefix": "b9db095dd79fca1c1451f8ac0b71366e35a1ddc00d4c4d195de5c188ab64f037", + "size_in_bytes": 12113 + }, + { + "_path": "site-packages/pygments/lexers/_ada_builtins.py", + "path_type": "hardlink", + "sha256": "6792224a976e81e294e07f9211ccd63d81ba10ed1ef91ee5c0feed85f391a285", + "sha256_in_prefix": "6792224a976e81e294e07f9211ccd63d81ba10ed1ef91ee5c0feed85f391a285", + "size_in_bytes": 1543 + }, + { + "_path": "site-packages/pygments/lexers/_asy_builtins.py", + "path_type": "hardlink", + "sha256": "aa7d4f9ae8a36743f9324775856987d5aad4b74df019647b40d65fec00817024", + "sha256_in_prefix": "aa7d4f9ae8a36743f9324775856987d5aad4b74df019647b40d65fec00817024", + "size_in_bytes": 27287 + }, + { + "_path": "site-packages/pygments/lexers/_cl_builtins.py", + "path_type": "hardlink", + "sha256": "9f46358de8bdb2cad9e7c12fe063310d3b29617539f13c8084b273040a4bb6d1", + "sha256_in_prefix": "9f46358de8bdb2cad9e7c12fe063310d3b29617539f13c8084b273040a4bb6d1", + "size_in_bytes": 13994 + }, + { + "_path": "site-packages/pygments/lexers/_cocoa_builtins.py", + "path_type": "hardlink", + "sha256": "2ef68fc1f8ccdabef7c89c1330dbb54a20cacd65aace12418cdfe48af9d8b32a", + "sha256_in_prefix": "2ef68fc1f8ccdabef7c89c1330dbb54a20cacd65aace12418cdfe48af9d8b32a", + "size_in_bytes": 105182 + }, + { + "_path": "site-packages/pygments/lexers/_csound_builtins.py", + "path_type": "hardlink", + "sha256": "218d87d0483c88115d996c1e7171b00c2e351a5af0fdb58b7a7402b69e831f38", + "sha256_in_prefix": "218d87d0483c88115d996c1e7171b00c2e351a5af0fdb58b7a7402b69e831f38", + "size_in_bytes": 18414 + }, + { + "_path": "site-packages/pygments/lexers/_css_builtins.py", + "path_type": "hardlink", + "sha256": "22e49557cf00f1bdfbf97b17185e3fe8fe971795afdf07774b160e4b57ce1b25", + "sha256_in_prefix": "22e49557cf00f1bdfbf97b17185e3fe8fe971795afdf07774b160e4b57ce1b25", + "size_in_bytes": 12446 + }, + { + "_path": "site-packages/pygments/lexers/_julia_builtins.py", + "path_type": "hardlink", + "sha256": "7afaef5098c028df1b09e068a17a807869d645cd2a06a1bf5b64cc44f5aaed0e", + "sha256_in_prefix": "7afaef5098c028df1b09e068a17a807869d645cd2a06a1bf5b64cc44f5aaed0e", + "size_in_bytes": 11883 + }, + { + "_path": "site-packages/pygments/lexers/_lasso_builtins.py", + "path_type": "hardlink", + "sha256": "f4b77cec2b31001f544d5efb23d5bab3f6efe29fa473682b3a773c130edccb7b", + "sha256_in_prefix": "f4b77cec2b31001f544d5efb23d5bab3f6efe29fa473682b3a773c130edccb7b", + "size_in_bytes": 134510 + }, + { + "_path": "site-packages/pygments/lexers/_lilypond_builtins.py", + "path_type": "hardlink", + "sha256": "ad598835062ade243dfb95bf8c6af05b843d397ff3117dfb23ea67e62f186b57", + "sha256_in_prefix": "ad598835062ade243dfb95bf8c6af05b843d397ff3117dfb23ea67e62f186b57", + "size_in_bytes": 108094 + }, + { + "_path": "site-packages/pygments/lexers/_lua_builtins.py", + "path_type": "hardlink", + "sha256": "c7c812389cc19703051fd5c5c70805d3ede4327d3ae984504cb27233f7e5db6b", + "sha256_in_prefix": "c7c812389cc19703051fd5c5c70805d3ede4327d3ae984504cb27233f7e5db6b", + "size_in_bytes": 8116 + }, + { + "_path": "site-packages/pygments/lexers/_mapping.py", + "path_type": "hardlink", + "sha256": "d820659686ca07d0eca3d91b91aabf2164ef0f767624eab1fc7b09ead04b0d76", + "sha256_in_prefix": "d820659686ca07d0eca3d91b91aabf2164ef0f767624eab1fc7b09ead04b0d76", + "size_in_bytes": 68026 + }, + { + "_path": "site-packages/pygments/lexers/_mql_builtins.py", + "path_type": "hardlink", + "sha256": "8f62b8b3761efed6047c913250ac6fa91de7b3f64e2c719a88f0e1906464e349", + "sha256_in_prefix": "8f62b8b3761efed6047c913250ac6fa91de7b3f64e2c719a88f0e1906464e349", + "size_in_bytes": 24713 + }, + { + "_path": "site-packages/pygments/lexers/_mysql_builtins.py", + "path_type": "hardlink", + "sha256": "f0ba8fb0cdfc47612dd54f2c83ea32d3d69e75bfa33b50e05469acb03530ea48", + "sha256_in_prefix": "f0ba8fb0cdfc47612dd54f2c83ea32d3d69e75bfa33b50e05469acb03530ea48", + "size_in_bytes": 25842 + }, + { + "_path": "site-packages/pygments/lexers/_openedge_builtins.py", + "path_type": "hardlink", + "sha256": "64ad15c23d0f7c2b60e56a4e5c2bc8d0e527a33acd6d0c58fc7341fc98405d07", + "sha256_in_prefix": "64ad15c23d0f7c2b60e56a4e5c2bc8d0e527a33acd6d0c58fc7341fc98405d07", + "size_in_bytes": 49398 + }, + { + "_path": "site-packages/pygments/lexers/_php_builtins.py", + "path_type": "hardlink", + "sha256": "9ecfc4d76c057b809edc43f7f01d034610278474eb761ed67e18e70d6827249e", + "sha256_in_prefix": "9ecfc4d76c057b809edc43f7f01d034610278474eb761ed67e18e70d6827249e", + "size_in_bytes": 107930 + }, + { + "_path": "site-packages/pygments/lexers/_postgres_builtins.py", + "path_type": "hardlink", + "sha256": "2d06f34dae4808fa93b297c193bff8255e9b923079973eeeb960143518fa5b81", + "sha256_in_prefix": "2d06f34dae4808fa93b297c193bff8255e9b923079973eeeb960143518fa5b81", + "size_in_bytes": 13355 + }, + { + "_path": "site-packages/pygments/lexers/_qlik_builtins.py", + "path_type": "hardlink", + "sha256": "cdcf9fabff265ec47f5d5cd31171518c66eec1d0022773bd42b3221067ee2b14", + "sha256_in_prefix": "cdcf9fabff265ec47f5d5cd31171518c66eec1d0022773bd42b3221067ee2b14", + "size_in_bytes": 12595 + }, + { + "_path": "site-packages/pygments/lexers/_scheme_builtins.py", + "path_type": "hardlink", + "sha256": "65d660ebe30aed9b76aaa3920544b90fd63350bb65248b94c6f937f6bf874cd7", + "sha256_in_prefix": "65d660ebe30aed9b76aaa3920544b90fd63350bb65248b94c6f937f6bf874cd7", + "size_in_bytes": 32564 + }, + { + "_path": "site-packages/pygments/lexers/_scilab_builtins.py", + "path_type": "hardlink", + "sha256": "89bfb06513b1b0a062f9cb0c565181147a730f3913d053e7db0659376f7ff51c", + "sha256_in_prefix": "89bfb06513b1b0a062f9cb0c565181147a730f3913d053e7db0659376f7ff51c", + "size_in_bytes": 52413 + }, + { + "_path": "site-packages/pygments/lexers/_sourcemod_builtins.py", + "path_type": "hardlink", + "sha256": "9d5d9970d4ef318ef1e284369e248d5755d31fd6e45db700b76f80e8e0ece799", + "sha256_in_prefix": "9d5d9970d4ef318ef1e284369e248d5755d31fd6e45db700b76f80e8e0ece799", + "size_in_bytes": 26781 + }, + { + "_path": "site-packages/pygments/lexers/_stan_builtins.py", + "path_type": "hardlink", + "sha256": "825fe9a34d6d9ef57fb468f7d63287a9a4a7c9b868c3d125bc58d8538bd6748b", + "sha256_in_prefix": "825fe9a34d6d9ef57fb468f7d63287a9a4a7c9b868c3d125bc58d8538bd6748b", + "size_in_bytes": 13445 + }, + { + "_path": "site-packages/pygments/lexers/_stata_builtins.py", + "path_type": "hardlink", + "sha256": "84818a22471a9507ad2303a8377d2e7e539881820e946de627a1fa7fcd9e76ba", + "sha256_in_prefix": "84818a22471a9507ad2303a8377d2e7e539881820e946de627a1fa7fcd9e76ba", + "size_in_bytes": 27227 + }, + { + "_path": "site-packages/pygments/lexers/_tsql_builtins.py", + "path_type": "hardlink", + "sha256": "c0329f0e47ed0148cf416d513e3030b1a2c4e9565e4c2c82cb6d73e38533ed57", + "sha256_in_prefix": "c0329f0e47ed0148cf416d513e3030b1a2c4e9565e4c2c82cb6d73e38533ed57", + "size_in_bytes": 15460 + }, + { + "_path": "site-packages/pygments/lexers/_usd_builtins.py", + "path_type": "hardlink", + "sha256": "1fb0181f391a8b3778985accb63bc8f75ddc5fd61d2b8aacf49ace94875c97b7", + "sha256_in_prefix": "1fb0181f391a8b3778985accb63bc8f75ddc5fd61d2b8aacf49ace94875c97b7", + "size_in_bytes": 1658 + }, + { + "_path": "site-packages/pygments/lexers/_vbscript_builtins.py", + "path_type": "hardlink", + "sha256": "121cc460893e0c122e534b0c83f75abd248bd70fa8dde9e54f54bdbb396365f3", + "sha256_in_prefix": "121cc460893e0c122e534b0c83f75abd248bd70fa8dde9e54f54bdbb396365f3", + "size_in_bytes": 4225 + }, + { + "_path": "site-packages/pygments/lexers/_vim_builtins.py", + "path_type": "hardlink", + "sha256": "046f76f4d0b2ea0dcb1e1a63f11fee7945aa2dbb88b74932089871475439489a", + "sha256_in_prefix": "046f76f4d0b2ea0dcb1e1a63f11fee7945aa2dbb88b74932089871475439489a", + "size_in_bytes": 57066 + }, + { + "_path": "site-packages/pygments/lexers/actionscript.py", + "path_type": "hardlink", + "sha256": "955af06d7d8e62737e28c19de23df2d33f9b58774dc430dc7fca5e14ca3dc761", + "sha256_in_prefix": "955af06d7d8e62737e28c19de23df2d33f9b58774dc430dc7fca5e14ca3dc761", + "size_in_bytes": 11676 + }, + { + "_path": "site-packages/pygments/lexers/ada.py", + "path_type": "hardlink", + "sha256": "dcf02f0d73cba6f9692c2492565de4d517013e6eccd8bcc8dd95353090cfa83e", + "sha256_in_prefix": "dcf02f0d73cba6f9692c2492565de4d517013e6eccd8bcc8dd95353090cfa83e", + "size_in_bytes": 5320 + }, + { + "_path": "site-packages/pygments/lexers/agile.py", + "path_type": "hardlink", + "sha256": "0b99b4eef22c0a2af6026aefd102b4021d476d372304e07031d17ec76affffa1", + "sha256_in_prefix": "0b99b4eef22c0a2af6026aefd102b4021d476d372304e07031d17ec76affffa1", + "size_in_bytes": 876 + }, + { + "_path": "site-packages/pygments/lexers/algebra.py", + "path_type": "hardlink", + "sha256": "d72a012faa47fea495add8378156cc27b1ee65bb2128bf8a8f9d26786dfb5cf9", + "sha256_in_prefix": "d72a012faa47fea495add8378156cc27b1ee65bb2128bf8a8f9d26786dfb5cf9", + "size_in_bytes": 9874 + }, + { + "_path": "site-packages/pygments/lexers/ambient.py", + "path_type": "hardlink", + "sha256": "bb7df7939992732ddc5140d0109771310bce117d7a6aaa537750e225e4d8cea1", + "sha256_in_prefix": "bb7df7939992732ddc5140d0109771310bce117d7a6aaa537750e225e4d8cea1", + "size_in_bytes": 2606 + }, + { + "_path": "site-packages/pygments/lexers/amdgpu.py", + "path_type": "hardlink", + "sha256": "7f8e98bf3575b03dde11f71d9116088e44b5613b47c95253e53d9ac0be3c765a", + "sha256_in_prefix": "7f8e98bf3575b03dde11f71d9116088e44b5613b47c95253e53d9ac0be3c765a", + "size_in_bytes": 1670 + }, + { + "_path": "site-packages/pygments/lexers/ampl.py", + "path_type": "hardlink", + "sha256": "95f1c0034646e03bf7f25e704d88ba2279575d727ae456972e3654d2d47fb16c", + "sha256_in_prefix": "95f1c0034646e03bf7f25e704d88ba2279575d727ae456972e3654d2d47fb16c", + "size_in_bytes": 4177 + }, + { + "_path": "site-packages/pygments/lexers/apdlexer.py", + "path_type": "hardlink", + "sha256": "11b82c96b58634560e6bc6be7cdf8f32fe3fa42bf729b768ed320737f0c25c08", + "sha256_in_prefix": "11b82c96b58634560e6bc6be7cdf8f32fe3fa42bf729b768ed320737f0c25c08", + "size_in_bytes": 30766 + }, + { + "_path": "site-packages/pygments/lexers/apl.py", + "path_type": "hardlink", + "sha256": "7f84302a97f332250f4570b399c05f37df535766152b2373674f44cb46ee6d87", + "sha256_in_prefix": "7f84302a97f332250f4570b399c05f37df535766152b2373674f44cb46ee6d87", + "size_in_bytes": 3405 + }, + { + "_path": "site-packages/pygments/lexers/archetype.py", + "path_type": "hardlink", + "sha256": "a69b34b643da2b554f25e3c98341f26867d34f0129029809faa83d309f5aeb21", + "sha256_in_prefix": "a69b34b643da2b554f25e3c98341f26867d34f0129029809faa83d309f5aeb21", + "size_in_bytes": 11469 + }, + { + "_path": "site-packages/pygments/lexers/arrow.py", + "path_type": "hardlink", + "sha256": "c2723717d668f47698226176a6092c768b32de1933b45c80e461b271bb50a083", + "sha256_in_prefix": "c2723717d668f47698226176a6092c768b32de1933b45c80e461b271bb50a083", + "size_in_bytes": 3565 + }, + { + "_path": "site-packages/pygments/lexers/arturo.py", + "path_type": "hardlink", + "sha256": "c08172b539d9024295b4756328ae452b65cb4627bf85cbfc612b356765001650", + "sha256_in_prefix": "c08172b539d9024295b4756328ae452b65cb4627bf85cbfc612b356765001650", + "size_in_bytes": 11417 + }, + { + "_path": "site-packages/pygments/lexers/asc.py", + "path_type": "hardlink", + "sha256": "35bd8f1d0656d77e75fafacb72d2115ffef4ce7871f0280693be72edbe1f8440", + "sha256_in_prefix": "35bd8f1d0656d77e75fafacb72d2115ffef4ce7871f0280693be72edbe1f8440", + "size_in_bytes": 1658 + }, + { + "_path": "site-packages/pygments/lexers/asm.py", + "path_type": "hardlink", + "sha256": "dac48f838b4b38fcd44d0a13021f292f9b566dd4bf2a6a904abf414d02d546dd", + "sha256_in_prefix": "dac48f838b4b38fcd44d0a13021f292f9b566dd4bf2a6a904abf414d02d546dd", + "size_in_bytes": 41243 + }, + { + "_path": "site-packages/pygments/lexers/asn1.py", + "path_type": "hardlink", + "sha256": "cf4d4d4e714f160574290c9d997bc502b8dc97e6cb0dff134639b71105f2fa45", + "sha256_in_prefix": "cf4d4d4e714f160574290c9d997bc502b8dc97e6cb0dff134639b71105f2fa45", + "size_in_bytes": 4263 + }, + { + "_path": "site-packages/pygments/lexers/automation.py", + "path_type": "hardlink", + "sha256": "6606a5edc292963d12687017c7df201e334cd6dbc25483b653292c785aae372e", + "sha256_in_prefix": "6606a5edc292963d12687017c7df201e334cd6dbc25483b653292c785aae372e", + "size_in_bytes": 19815 + }, + { + "_path": "site-packages/pygments/lexers/bare.py", + "path_type": "hardlink", + "sha256": "d16101c6ff854a0a30d51159cda5c6168d348b0925205e45a632590ce3966c3a", + "sha256_in_prefix": "d16101c6ff854a0a30d51159cda5c6168d348b0925205e45a632590ce3966c3a", + "size_in_bytes": 3021 + }, + { + "_path": "site-packages/pygments/lexers/basic.py", + "path_type": "hardlink", + "sha256": "73167ba0aabddb88fcfe00e894bfc80d5e0248ddaf5ca93a4bb0c8c365a54dcf", + "sha256_in_prefix": "73167ba0aabddb88fcfe00e894bfc80d5e0248ddaf5ca93a4bb0c8c365a54dcf", + "size_in_bytes": 27923 + }, + { + "_path": "site-packages/pygments/lexers/bdd.py", + "path_type": "hardlink", + "sha256": "26c03e5bffa820264aad94b58bb34d62b4660d155fde2b88d4fb9f51d3244215", + "sha256_in_prefix": "26c03e5bffa820264aad94b58bb34d62b4660d155fde2b88d4fb9f51d3244215", + "size_in_bytes": 1652 + }, + { + "_path": "site-packages/pygments/lexers/berry.py", + "path_type": "hardlink", + "sha256": "b30734118f9b11fd303455217ef76481698ff8f5d5f0f1af84d6a0aadb14aa60", + "sha256_in_prefix": "b30734118f9b11fd303455217ef76481698ff8f5d5f0f1af84d6a0aadb14aa60", + "size_in_bytes": 3211 + }, + { + "_path": "site-packages/pygments/lexers/bibtex.py", + "path_type": "hardlink", + "sha256": "8f3ba8f651191cf2b300032921e21690d4ebe48d4b3be4cc9f557d49dc874f5a", + "sha256_in_prefix": "8f3ba8f651191cf2b300032921e21690d4ebe48d4b3be4cc9f557d49dc874f5a", + "size_in_bytes": 4723 + }, + { + "_path": "site-packages/pygments/lexers/blueprint.py", + "path_type": "hardlink", + "sha256": "895c88d34810ef63c86e0ab65a49d5c4d39e09b45c232726db800788b139160d", + "sha256_in_prefix": "895c88d34810ef63c86e0ab65a49d5c4d39e09b45c232726db800788b139160d", + "size_in_bytes": 6189 + }, + { + "_path": "site-packages/pygments/lexers/boa.py", + "path_type": "hardlink", + "sha256": "6e2e5994f57ad577a1abc6e649d172aaddc13758c2d37a41e2de45a1ae2f28fc", + "sha256_in_prefix": "6e2e5994f57ad577a1abc6e649d172aaddc13758c2d37a41e2de45a1ae2f28fc", + "size_in_bytes": 3915 + }, + { + "_path": "site-packages/pygments/lexers/bqn.py", + "path_type": "hardlink", + "sha256": "7c9391a6aeb4521b56d0ddfc1a7998a80b2443f3ba419b5cfedc385dc6780f92", + "sha256_in_prefix": "7c9391a6aeb4521b56d0ddfc1a7998a80b2443f3ba419b5cfedc385dc6780f92", + "size_in_bytes": 3338 + }, + { + "_path": "site-packages/pygments/lexers/business.py", + "path_type": "hardlink", + "sha256": "f901d14d609d69b595f1221b299d682c7e4d437f9b9523c44bc8e321b12f0ff2", + "sha256_in_prefix": "f901d14d609d69b595f1221b299d682c7e4d437f9b9523c44bc8e321b12f0ff2", + "size_in_bytes": 28112 + }, + { + "_path": "site-packages/pygments/lexers/c_cpp.py", + "path_type": "hardlink", + "sha256": "d7b3bbb597e70c842a8e71446a31d572aa167f70a93fc2e85a5076c7c6afc061", + "sha256_in_prefix": "d7b3bbb597e70c842a8e71446a31d572aa167f70a93fc2e85a5076c7c6afc061", + "size_in_bytes": 17946 + }, + { + "_path": "site-packages/pygments/lexers/c_like.py", + "path_type": "hardlink", + "sha256": "b9639b5aac42e1df99cb2cc41b6c9a8ca660a6ae2220dc8072ac3b2cc9e7c595", + "sha256_in_prefix": "b9639b5aac42e1df99cb2cc41b6c9a8ca660a6ae2220dc8072ac3b2cc9e7c595", + "size_in_bytes": 29206 + }, + { + "_path": "site-packages/pygments/lexers/capnproto.py", + "path_type": "hardlink", + "sha256": "7c4df02bedd90733ec0da15ff44904d5d9c60d18496dc0aa8f2057466f06943e", + "sha256_in_prefix": "7c4df02bedd90733ec0da15ff44904d5d9c60d18496dc0aa8f2057466f06943e", + "size_in_bytes": 2175 + }, + { + "_path": "site-packages/pygments/lexers/carbon.py", + "path_type": "hardlink", + "sha256": "25a3b7b0f787f32299c23dfcb4252e8abcf57d217bd12d24a12aaed7f307f156", + "sha256_in_prefix": "25a3b7b0f787f32299c23dfcb4252e8abcf57d217bd12d24a12aaed7f307f156", + "size_in_bytes": 3222 + }, + { + "_path": "site-packages/pygments/lexers/cddl.py", + "path_type": "hardlink", + "sha256": "3d94baeb5d7ffe1637e8d663f27f50fff24c5cd2d29bf68c58ba42e756b173e3", + "sha256_in_prefix": "3d94baeb5d7ffe1637e8d663f27f50fff24c5cd2d29bf68c58ba42e756b173e3", + "size_in_bytes": 5182 + }, + { + "_path": "site-packages/pygments/lexers/chapel.py", + "path_type": "hardlink", + "sha256": "d6816dd21d1187b267176ab0d50b53d17ce451a9d5f976fd5e2f41f597076880", + "sha256_in_prefix": "d6816dd21d1187b267176ab0d50b53d17ce451a9d5f976fd5e2f41f597076880", + "size_in_bytes": 5157 + }, + { + "_path": "site-packages/pygments/lexers/clean.py", + "path_type": "hardlink", + "sha256": "69f25ed28ad4ed4c7fa669ab6d23583cbad30a463fcf43094e685406a3edc895", + "sha256_in_prefix": "69f25ed28ad4ed4c7fa669ab6d23583cbad30a463fcf43094e685406a3edc895", + "size_in_bytes": 6395 + }, + { + "_path": "site-packages/pygments/lexers/comal.py", + "path_type": "hardlink", + "sha256": "f48c317f154154c9fb523db1a3e582afb4612d10eb0deeb08d37408b98564f68", + "sha256_in_prefix": "f48c317f154154c9fb523db1a3e582afb4612d10eb0deeb08d37408b98564f68", + "size_in_bytes": 3156 + }, + { + "_path": "site-packages/pygments/lexers/compiled.py", + "path_type": "hardlink", + "sha256": "c6ff24ae0a0381dd3b4035d53da6b9ba2a75925f6d069ae4193d4ae7e0f08961", + "sha256_in_prefix": "c6ff24ae0a0381dd3b4035d53da6b9ba2a75925f6d069ae4193d4ae7e0f08961", + "size_in_bytes": 1407 + }, + { + "_path": "site-packages/pygments/lexers/configs.py", + "path_type": "hardlink", + "sha256": "18c3fc254078290eb9fdd1457f93f3e53c8d5c52397f5cd9b127aaf65ba3c99b", + "sha256_in_prefix": "18c3fc254078290eb9fdd1457f93f3e53c8d5c52397f5cd9b127aaf65ba3c99b", + "size_in_bytes": 50077 + }, + { + "_path": "site-packages/pygments/lexers/console.py", + "path_type": "hardlink", + "sha256": "d7b938360aecd04b1a260f74b9de9d95ef88d52be3a0e89827ec6e1a92deb132", + "sha256_in_prefix": "d7b938360aecd04b1a260f74b9de9d95ef88d52be3a0e89827ec6e1a92deb132", + "size_in_bytes": 4148 + }, + { + "_path": "site-packages/pygments/lexers/cplint.py", + "path_type": "hardlink", + "sha256": "1eb2ae8512a32be6adc3514a4ffceee0526394738ce41a69473a318ac5dba593", + "sha256_in_prefix": "1eb2ae8512a32be6adc3514a4ffceee0526394738ce41a69473a318ac5dba593", + "size_in_bytes": 1390 + }, + { + "_path": "site-packages/pygments/lexers/crystal.py", + "path_type": "hardlink", + "sha256": "af1c59a74137bffafd4ee5b07802e264eff820a206220e460898cfaba6707599", + "sha256_in_prefix": "af1c59a74137bffafd4ee5b07802e264eff820a206220e460898cfaba6707599", + "size_in_bytes": 15757 + }, + { + "_path": "site-packages/pygments/lexers/csound.py", + "path_type": "hardlink", + "sha256": "caece909d66e1c39abd9e68da1d8250eb0a05f55badb1b50be38ad9c79570bab", + "sha256_in_prefix": "caece909d66e1c39abd9e68da1d8250eb0a05f55badb1b50be38ad9c79570bab", + "size_in_bytes": 16994 + }, + { + "_path": "site-packages/pygments/lexers/css.py", + "path_type": "hardlink", + "sha256": "9592971125706516138e3464c81e1c6295e4f421dc57153f7a66f3151b4f8616", + "sha256_in_prefix": "9592971125706516138e3464c81e1c6295e4f421dc57153f7a66f3151b4f8616", + "size_in_bytes": 25322 + }, + { + "_path": "site-packages/pygments/lexers/d.py", + "path_type": "hardlink", + "sha256": "7f5745bf69805ea2ca489439f66ebabb5323f6eb377c3b24c65b65ac9f040663", + "sha256_in_prefix": "7f5745bf69805ea2ca489439f66ebabb5323f6eb377c3b24c65b65ac9f040663", + "size_in_bytes": 9875 + }, + { + "_path": "site-packages/pygments/lexers/dalvik.py", + "path_type": "hardlink", + "sha256": "d088bd2885164f91642642cab94707a073e16afe1e107aac5992f6fe290fd595", + "sha256_in_prefix": "d088bd2885164f91642642cab94707a073e16afe1e107aac5992f6fe290fd595", + "size_in_bytes": 4607 + }, + { + "_path": "site-packages/pygments/lexers/data.py", + "path_type": "hardlink", + "sha256": "8a0f030092b943c8642a88d0f518da58cb07f2388d6eecf0681693f8c61cf55a", + "sha256_in_prefix": "8a0f030092b943c8642a88d0f518da58cb07f2388d6eecf0681693f8c61cf55a", + "size_in_bytes": 27032 + }, + { + "_path": "site-packages/pygments/lexers/dax.py", + "path_type": "hardlink", + "sha256": "a1ddc3e737daaf223930ef7713f380f935297a401c8d7bfbde5ea4362b79ee82", + "sha256_in_prefix": "a1ddc3e737daaf223930ef7713f380f935297a401c8d7bfbde5ea4362b79ee82", + "size_in_bytes": 8099 + }, + { + "_path": "site-packages/pygments/lexers/devicetree.py", + "path_type": "hardlink", + "sha256": "e062a2b990b96d8c06fe0225df47d91fc555db3a3872ac1d7a642b420587ed94", + "sha256_in_prefix": "e062a2b990b96d8c06fe0225df47d91fc555db3a3872ac1d7a642b420587ed94", + "size_in_bytes": 4020 + }, + { + "_path": "site-packages/pygments/lexers/diff.py", + "path_type": "hardlink", + "sha256": "540c80151166c8c1fceb9ac4277ec8dd3a72ae92d4a04314f7976eaf0e872d17", + "sha256_in_prefix": "540c80151166c8c1fceb9ac4277ec8dd3a72ae92d4a04314f7976eaf0e872d17", + "size_in_bytes": 5278 + }, + { + "_path": "site-packages/pygments/lexers/dns.py", + "path_type": "hardlink", + "sha256": "fa5d57efe47700a0e27fae4922f2ff4dcfdd25d22368e06adfcfa141fd7b6568", + "sha256_in_prefix": "fa5d57efe47700a0e27fae4922f2ff4dcfdd25d22368e06adfcfa141fd7b6568", + "size_in_bytes": 3781 + }, + { + "_path": "site-packages/pygments/lexers/dotnet.py", + "path_type": "hardlink", + "sha256": "56325687bbec94c348a1074f14d525019234131b8b155e8476bcb061a223a905", + "sha256_in_prefix": "56325687bbec94c348a1074f14d525019234131b8b155e8476bcb061a223a905", + "size_in_bytes": 37623 + }, + { + "_path": "site-packages/pygments/lexers/dsls.py", + "path_type": "hardlink", + "sha256": "1553573fdf1fe5157e87faa20ad5beab29dfdd067e783e0db9da4963a70b895e", + "sha256_in_prefix": "1553573fdf1fe5157e87faa20ad5beab29dfdd067e783e0db9da4963a70b895e", + "size_in_bytes": 36786 + }, + { + "_path": "site-packages/pygments/lexers/dylan.py", + "path_type": "hardlink", + "sha256": "3dbae75d973da5aaa690e5498eca00c5fb39facd0c034f34573a22bb79d9ba6f", + "sha256_in_prefix": "3dbae75d973da5aaa690e5498eca00c5fb39facd0c034f34573a22bb79d9ba6f", + "size_in_bytes": 10319 + }, + { + "_path": "site-packages/pygments/lexers/ecl.py", + "path_type": "hardlink", + "sha256": "09ece5ead59ff9af213041147c9a9823710f7fab124b7911cf41a23ae1484386", + "sha256_in_prefix": "09ece5ead59ff9af213041147c9a9823710f7fab124b7911cf41a23ae1484386", + "size_in_bytes": 6372 + }, + { + "_path": "site-packages/pygments/lexers/eiffel.py", + "path_type": "hardlink", + "sha256": "3d7781171df14a26d3ad548303426a13fcac90b596ca79da2e9f4eec5579effe", + "sha256_in_prefix": "3d7781171df14a26d3ad548303426a13fcac90b596ca79da2e9f4eec5579effe", + "size_in_bytes": 2691 + }, + { + "_path": "site-packages/pygments/lexers/elm.py", + "path_type": "hardlink", + "sha256": "acaa440899930cd980419bba6025fdafe4c0a0fdefedaa4bd8745cbad1bace59", + "sha256_in_prefix": "acaa440899930cd980419bba6025fdafe4c0a0fdefedaa4bd8745cbad1bace59", + "size_in_bytes": 3153 + }, + { + "_path": "site-packages/pygments/lexers/elpi.py", + "path_type": "hardlink", + "sha256": "2e277ceb5ad634219fbfcdfd803f04d8910ff079213b480258658ab9cd2ca372", + "sha256_in_prefix": "2e277ceb5ad634219fbfcdfd803f04d8910ff079213b480258658ab9cd2ca372", + "size_in_bytes": 6710 + }, + { + "_path": "site-packages/pygments/lexers/email.py", + "path_type": "hardlink", + "sha256": "101dd8bd10c43fafc1e81d70cead2f4b8ff3ac15f9db37725f188d237287831b", + "sha256_in_prefix": "101dd8bd10c43fafc1e81d70cead2f4b8ff3ac15f9db37725f188d237287831b", + "size_in_bytes": 4742 + }, + { + "_path": "site-packages/pygments/lexers/erlang.py", + "path_type": "hardlink", + "sha256": "121171ff40fdc3ce4308947d172529ac53e2683bc9a6cdf1cbe2a7e30856723b", + "sha256_in_prefix": "121171ff40fdc3ce4308947d172529ac53e2683bc9a6cdf1cbe2a7e30856723b", + "size_in_bytes": 19170 + }, + { + "_path": "site-packages/pygments/lexers/esoteric.py", + "path_type": "hardlink", + "sha256": "57efb0d96f89ca5e3207c034d1fe068a455e6577bfe6558713444c9dfba82d36", + "sha256_in_prefix": "57efb0d96f89ca5e3207c034d1fe068a455e6577bfe6558713444c9dfba82d36", + "size_in_bytes": 10396 + }, + { + "_path": "site-packages/pygments/lexers/ezhil.py", + "path_type": "hardlink", + "sha256": "c6ef7030411255608b80d8ad492d084bce794d227761bd8a5c1af1998a87292a", + "sha256_in_prefix": "c6ef7030411255608b80d8ad492d084bce794d227761bd8a5c1af1998a87292a", + "size_in_bytes": 3273 + }, + { + "_path": "site-packages/pygments/lexers/factor.py", + "path_type": "hardlink", + "sha256": "89548865a4fbfaa008e35c0ffffa765e34d2c911014b2004acf2d518fe1b31e5", + "sha256_in_prefix": "89548865a4fbfaa008e35c0ffffa765e34d2c911014b2004acf2d518fe1b31e5", + "size_in_bytes": 19531 + }, + { + "_path": "site-packages/pygments/lexers/fantom.py", + "path_type": "hardlink", + "sha256": "d03ca550728278131f40ae107336af2f9ba0c8f4d5d2ee47d0b934613bfafe65", + "sha256_in_prefix": "d03ca550728278131f40ae107336af2f9ba0c8f4d5d2ee47d0b934613bfafe65", + "size_in_bytes": 10197 + }, + { + "_path": "site-packages/pygments/lexers/felix.py", + "path_type": "hardlink", + "sha256": "7c9b1dd2635a4b0923537dbed74dfef570f3cf3da58fe38d3e25bc264640ab13", + "sha256_in_prefix": "7c9b1dd2635a4b0923537dbed74dfef570f3cf3da58fe38d3e25bc264640ab13", + "size_in_bytes": 9646 + }, + { + "_path": "site-packages/pygments/lexers/fift.py", + "path_type": "hardlink", + "sha256": "2121f5d41bf3d7966c3234cc74b0ec1c5c761d88291b20d496f8b508df0c0bc4", + "sha256_in_prefix": "2121f5d41bf3d7966c3234cc74b0ec1c5c761d88291b20d496f8b508df0c0bc4", + "size_in_bytes": 1621 + }, + { + "_path": "site-packages/pygments/lexers/floscript.py", + "path_type": "hardlink", + "sha256": "5183c79766207b3ed17c13d3534d2150c5eb535d2607df7abf3eab162b00993b", + "sha256_in_prefix": "5183c79766207b3ed17c13d3534d2150c5eb535d2607df7abf3eab162b00993b", + "size_in_bytes": 2668 + }, + { + "_path": "site-packages/pygments/lexers/forth.py", + "path_type": "hardlink", + "sha256": "3f37d7921a6eb05206570af356ca8b8258e5c9b37dd8e794d3f137ac7ba9da6d", + "sha256_in_prefix": "3f37d7921a6eb05206570af356ca8b8258e5c9b37dd8e794d3f137ac7ba9da6d", + "size_in_bytes": 7194 + }, + { + "_path": "site-packages/pygments/lexers/fortran.py", + "path_type": "hardlink", + "sha256": "dc3024a1f5cd54fe71722e39022b16cb725adec9e1266ea58066b7a340674a4a", + "sha256_in_prefix": "dc3024a1f5cd54fe71722e39022b16cb725adec9e1266ea58066b7a340674a4a", + "size_in_bytes": 10346 + }, + { + "_path": "site-packages/pygments/lexers/foxpro.py", + "path_type": "hardlink", + "sha256": "5e655c5a0c3bd2f877d60ae2dcb85fac1d9843e4619149012a5cb4c47b7c550b", + "sha256_in_prefix": "5e655c5a0c3bd2f877d60ae2dcb85fac1d9843e4619149012a5cb4c47b7c550b", + "size_in_bytes": 26212 + }, + { + "_path": "site-packages/pygments/lexers/freefem.py", + "path_type": "hardlink", + "sha256": "7bf6238c766ef0fcd007290bce1a58d912478c29cbc67966a068fee518a73fa7", + "sha256_in_prefix": "7bf6238c766ef0fcd007290bce1a58d912478c29cbc67966a068fee518a73fa7", + "size_in_bytes": 26914 + }, + { + "_path": "site-packages/pygments/lexers/func.py", + "path_type": "hardlink", + "sha256": "87a20709dc9d58aa5071a982d570062636862be503be1f6233466e5902b4e5d4", + "sha256_in_prefix": "87a20709dc9d58aa5071a982d570062636862be503be1f6233466e5902b4e5d4", + "size_in_bytes": 3622 + }, + { + "_path": "site-packages/pygments/lexers/functional.py", + "path_type": "hardlink", + "sha256": "229bcf2a8991183a86b3f319663917e6788c1993bdb395f50e4d070f23bdcd63", + "sha256_in_prefix": "229bcf2a8991183a86b3f319663917e6788c1993bdb395f50e4d070f23bdcd63", + "size_in_bytes": 674 + }, + { + "_path": "site-packages/pygments/lexers/futhark.py", + "path_type": "hardlink", + "sha256": "3703582f14357de270b4f8c6e785664a6a3f66d713aad973af4410a699b15943", + "sha256_in_prefix": "3703582f14357de270b4f8c6e785664a6a3f66d713aad973af4410a699b15943", + "size_in_bytes": 3732 + }, + { + "_path": "site-packages/pygments/lexers/gcodelexer.py", + "path_type": "hardlink", + "sha256": "1fbe78b760ca92025817e9b39b8b88f5da9cd2a134d9f8e56597d73347a0e8b7", + "sha256_in_prefix": "1fbe78b760ca92025817e9b39b8b88f5da9cd2a134d9f8e56597d73347a0e8b7", + "size_in_bytes": 826 + }, + { + "_path": "site-packages/pygments/lexers/gdscript.py", + "path_type": "hardlink", + "sha256": "0c5bdff5e2602627390d41edda5ac992c4aee57e9e5d17eb877d2de720154b36", + "sha256_in_prefix": "0c5bdff5e2602627390d41edda5ac992c4aee57e9e5d17eb877d2de720154b36", + "size_in_bytes": 7543 + }, + { + "_path": "site-packages/pygments/lexers/go.py", + "path_type": "hardlink", + "sha256": "f034a0b139468d0d50906c34935158f07ceeafd07540e593200eb8daa6fd4476", + "sha256_in_prefix": "f034a0b139468d0d50906c34935158f07ceeafd07540e593200eb8daa6fd4476", + "size_in_bytes": 3784 + }, + { + "_path": "site-packages/pygments/lexers/grammar_notation.py", + "path_type": "hardlink", + "sha256": "48d40d8209a36020b4c913769b6affdf75f6a5af1bc340312c9b06d46e458dd4", + "sha256_in_prefix": "48d40d8209a36020b4c913769b6affdf75f6a5af1bc340312c9b06d46e458dd4", + "size_in_bytes": 7980 + }, + { + "_path": "site-packages/pygments/lexers/graph.py", + "path_type": "hardlink", + "sha256": "a0f5a76a2d436ceaa84bbc882aab82773673b40e9023c8fa475249fe00af244b", + "sha256_in_prefix": "a0f5a76a2d436ceaa84bbc882aab82773673b40e9023c8fa475249fe00af244b", + "size_in_bytes": 4109 + }, + { + "_path": "site-packages/pygments/lexers/graphics.py", + "path_type": "hardlink", + "sha256": "02a8737928e943093556b8ff393e6328324ca2707dd12af4d66337abdd161958", + "sha256_in_prefix": "02a8737928e943093556b8ff393e6328324ca2707dd12af4d66337abdd161958", + "size_in_bytes": 39026 + }, + { + "_path": "site-packages/pygments/lexers/graphql.py", + "path_type": "hardlink", + "sha256": "b301f79e71129201729de9c12438f3cca6922a438643dadb9be905b36f80bc83", + "sha256_in_prefix": "b301f79e71129201729de9c12438f3cca6922a438643dadb9be905b36f80bc83", + "size_in_bytes": 5602 + }, + { + "_path": "site-packages/pygments/lexers/graphviz.py", + "path_type": "hardlink", + "sha256": "ff225a476096fbeda58ef9cf74d8ec54ebe8b0fa14270d296f739fdf79d606d9", + "sha256_in_prefix": "ff225a476096fbeda58ef9cf74d8ec54ebe8b0fa14270d296f739fdf79d606d9", + "size_in_bytes": 1935 + }, + { + "_path": "site-packages/pygments/lexers/gsql.py", + "path_type": "hardlink", + "sha256": "ec60d6a355afb79526261002f0740d0f591b74e341444d5885d6b0073806ac70", + "sha256_in_prefix": "ec60d6a355afb79526261002f0740d0f591b74e341444d5885d6b0073806ac70", + "size_in_bytes": 3991 + }, + { + "_path": "site-packages/pygments/lexers/haskell.py", + "path_type": "hardlink", + "sha256": "46460487df9a9877914b4f9d539372cf844be0a289cf6ecfb1684da5ff82ecd0", + "sha256_in_prefix": "46460487df9a9877914b4f9d539372cf844be0a289cf6ecfb1684da5ff82ecd0", + "size_in_bytes": 32898 + }, + { + "_path": "site-packages/pygments/lexers/haxe.py", + "path_type": "hardlink", + "sha256": "5b820b955364d43e9448c6b62a4af4d0815aa2ab5423177970ef3fc56ce8db79", + "sha256_in_prefix": "5b820b955364d43e9448c6b62a4af4d0815aa2ab5423177970ef3fc56ce8db79", + "size_in_bytes": 30976 + }, + { + "_path": "site-packages/pygments/lexers/hdl.py", + "path_type": "hardlink", + "sha256": "c40e589f086068e4f3bcba44d5520ff23ee5e4b336163929b2c67231edec3ed6", + "sha256_in_prefix": "c40e589f086068e4f3bcba44d5520ff23ee5e4b336163929b2c67231edec3ed6", + "size_in_bytes": 22520 + }, + { + "_path": "site-packages/pygments/lexers/hexdump.py", + "path_type": "hardlink", + "sha256": "40bbd7cd69a8dbfc6a1cccb9e4e4d7501d790a893240b3331ef997bb0323eb3f", + "sha256_in_prefix": "40bbd7cd69a8dbfc6a1cccb9e4e4d7501d790a893240b3331ef997bb0323eb3f", + "size_in_bytes": 3603 + }, + { + "_path": "site-packages/pygments/lexers/html.py", + "path_type": "hardlink", + "sha256": "22f99b318bae1ec39d90e381bfb0d564bee8b8e34b7ddf5f56d8d1148080603d", + "sha256_in_prefix": "22f99b318bae1ec39d90e381bfb0d564bee8b8e34b7ddf5f56d8d1148080603d", + "size_in_bytes": 20260 + }, + { + "_path": "site-packages/pygments/lexers/idl.py", + "path_type": "hardlink", + "sha256": "6e14b8deeff270854df9dc652f4ae45435b42ae9eebf89c280c8b0e02ac45539", + "sha256_in_prefix": "6e14b8deeff270854df9dc652f4ae45435b42ae9eebf89c280c8b0e02ac45539", + "size_in_bytes": 15450 + }, + { + "_path": "site-packages/pygments/lexers/igor.py", + "path_type": "hardlink", + "sha256": "6057462c082aa129e9eb0a64db76f06e08fbb954916f2a86e2bdd7afb86df314", + "sha256_in_prefix": "6057462c082aa129e9eb0a64db76f06e08fbb954916f2a86e2bdd7afb86df314", + "size_in_bytes": 31658 + }, + { + "_path": "site-packages/pygments/lexers/inferno.py", + "path_type": "hardlink", + "sha256": "d29469a11ed6d4aa7cabff66c58e37ad8c3f45879fdebb89eb15752f061bcf70", + "sha256_in_prefix": "d29469a11ed6d4aa7cabff66c58e37ad8c3f45879fdebb89eb15752f061bcf70", + "size_in_bytes": 3136 + }, + { + "_path": "site-packages/pygments/lexers/installers.py", + "path_type": "hardlink", + "sha256": "e7f8e19735988bfe8b304afc067a5b8e0892719fc6dd0ec01fa7d31b85ab3d17", + "sha256_in_prefix": "e7f8e19735988bfe8b304afc067a5b8e0892719fc6dd0ec01fa7d31b85ab3d17", + "size_in_bytes": 13178 + }, + { + "_path": "site-packages/pygments/lexers/int_fiction.py", + "path_type": "hardlink", + "sha256": "0a4185acc3e2659e9a43ad3b138c9f6434dc629cf5a5dadb7786b3cb1ed7557f", + "sha256_in_prefix": "0a4185acc3e2659e9a43ad3b138c9f6434dc629cf5a5dadb7786b3cb1ed7557f", + "size_in_bytes": 57119 + }, + { + "_path": "site-packages/pygments/lexers/iolang.py", + "path_type": "hardlink", + "sha256": "89ea26fac73cc5d5db1e2e20e4b0e87ef2ddb8a65d54148e1305e870a9905368", + "sha256_in_prefix": "89ea26fac73cc5d5db1e2e20e4b0e87ef2ddb8a65d54148e1305e870a9905368", + "size_in_bytes": 1906 + }, + { + "_path": "site-packages/pygments/lexers/j.py", + "path_type": "hardlink", + "sha256": "29dd1181aff5bb053f6217d779bbc6b872a93973364951f4ff1fc2aa40895429", + "sha256_in_prefix": "29dd1181aff5bb053f6217d779bbc6b872a93973364951f4ff1fc2aa40895429", + "size_in_bytes": 4854 + }, + { + "_path": "site-packages/pygments/lexers/javascript.py", + "path_type": "hardlink", + "sha256": "cb8bdef6cda3ab851a4ebf4f86434444896ed83a5b3ff97ae0dfebd8924e055d", + "sha256_in_prefix": "cb8bdef6cda3ab851a4ebf4f86434444896ed83a5b3ff97ae0dfebd8924e055d", + "size_in_bytes": 62859 + }, + { + "_path": "site-packages/pygments/lexers/jmespath.py", + "path_type": "hardlink", + "sha256": "dcfe3f6105e1e08a28843421a21d29aaec85b941d577cf20eca6265588373683", + "sha256_in_prefix": "dcfe3f6105e1e08a28843421a21d29aaec85b941d577cf20eca6265588373683", + "size_in_bytes": 2059 + }, + { + "_path": "site-packages/pygments/lexers/jslt.py", + "path_type": "hardlink", + "sha256": "72f1f62c8b949e485aaa17d6be42234bbb12c761695d212f977ace178edde98d", + "sha256_in_prefix": "72f1f62c8b949e485aaa17d6be42234bbb12c761695d212f977ace178edde98d", + "size_in_bytes": 3701 + }, + { + "_path": "site-packages/pygments/lexers/jsonnet.py", + "path_type": "hardlink", + "sha256": "0a2253d344e9d25060f63ff5116f9debfa68ba6b47a0fd939844150e57f7713b", + "sha256_in_prefix": "0a2253d344e9d25060f63ff5116f9debfa68ba6b47a0fd939844150e57f7713b", + "size_in_bytes": 5635 + }, + { + "_path": "site-packages/pygments/lexers/jsx.py", + "path_type": "hardlink", + "sha256": "5c5439277554d58b3eca3c514eead41fe8187692247f84d5f3bcefb6c1f96fea", + "sha256_in_prefix": "5c5439277554d58b3eca3c514eead41fe8187692247f84d5f3bcefb6c1f96fea", + "size_in_bytes": 2234 + }, + { + "_path": "site-packages/pygments/lexers/julia.py", + "path_type": "hardlink", + "sha256": "179cee466ece49941e5759daee56acca91031ab78b03339d7da2a61f51c8c601", + "sha256_in_prefix": "179cee466ece49941e5759daee56acca91031ab78b03339d7da2a61f51c8c601", + "size_in_bytes": 11646 + }, + { + "_path": "site-packages/pygments/lexers/jvm.py", + "path_type": "hardlink", + "sha256": "9f246f205d76a13651994d2a0e180e431f00b14828663d73314f2d0c6c8e3fc5", + "sha256_in_prefix": "9f246f205d76a13651994d2a0e180e431f00b14828663d73314f2d0c6c8e3fc5", + "size_in_bytes": 72929 + }, + { + "_path": "site-packages/pygments/lexers/kuin.py", + "path_type": "hardlink", + "sha256": "01550377a240cb58c294861e4033dc57e3bbc467dbef1edfa2337b85bec03475", + "sha256_in_prefix": "01550377a240cb58c294861e4033dc57e3bbc467dbef1edfa2337b85bec03475", + "size_in_bytes": 11406 + }, + { + "_path": "site-packages/pygments/lexers/kusto.py", + "path_type": "hardlink", + "sha256": "26a936c71d2f55f65ae6e16ae4a19981445e67b147850e47bd3e817911b39a78", + "sha256_in_prefix": "26a936c71d2f55f65ae6e16ae4a19981445e67b147850e47bd3e817911b39a78", + "size_in_bytes": 3478 + }, + { + "_path": "site-packages/pygments/lexers/ldap.py", + "path_type": "hardlink", + "sha256": "54203438a93306ebd22873a917d4af940f02d6d7d1bda86ed0c361cfee0ba414", + "sha256_in_prefix": "54203438a93306ebd22873a917d4af940f02d6d7d1bda86ed0c361cfee0ba414", + "size_in_bytes": 6553 + }, + { + "_path": "site-packages/pygments/lexers/lean.py", + "path_type": "hardlink", + "sha256": "f14c619e071ae7b367269d4909a6c457107a49483341511410c9a69666dcf174", + "sha256_in_prefix": "f14c619e071ae7b367269d4909a6c457107a49483341511410c9a69666dcf174", + "size_in_bytes": 4297 + }, + { + "_path": "site-packages/pygments/lexers/lilypond.py", + "path_type": "hardlink", + "sha256": "fc0e4fecf6884cff023971bc772f674bb0b37dd298d9439ed572c6b6e72e8a9e", + "sha256_in_prefix": "fc0e4fecf6884cff023971bc772f674bb0b37dd298d9439ed572c6b6e72e8a9e", + "size_in_bytes": 9753 + }, + { + "_path": "site-packages/pygments/lexers/lisp.py", + "path_type": "hardlink", + "sha256": "2e4bae740d4ff5c651cc6a95df40bee5889c02b2e83fd50806e9741e27f8d6fe", + "sha256_in_prefix": "2e4bae740d4ff5c651cc6a95df40bee5889c02b2e83fd50806e9741e27f8d6fe", + "size_in_bytes": 144398 + }, + { + "_path": "site-packages/pygments/lexers/macaulay2.py", + "path_type": "hardlink", + "sha256": "684745ce3acfed15cfe4171103739089cf78ba686fab5b86c5414cbb9382eca3", + "sha256_in_prefix": "684745ce3acfed15cfe4171103739089cf78ba686fab5b86c5414cbb9382eca3", + "size_in_bytes": 32171 + }, + { + "_path": "site-packages/pygments/lexers/make.py", + "path_type": "hardlink", + "sha256": "ad660ca30139cc5ea6600dd5ac9849f92fe7db5e3e3ad59e5dd8c90ca8d70289", + "sha256_in_prefix": "ad660ca30139cc5ea6600dd5ac9849f92fe7db5e3e3ad59e5dd8c90ca8d70289", + "size_in_bytes": 7694 + }, + { + "_path": "site-packages/pygments/lexers/markup.py", + "path_type": "hardlink", + "sha256": "b102e490a4ba778d057b8df3faf151d9bbd6b8d4c9bee279e05f8564a920ccda", + "sha256_in_prefix": "b102e490a4ba778d057b8df3faf151d9bbd6b8d4c9bee279e05f8564a920ccda", + "size_in_bytes": 60257 + }, + { + "_path": "site-packages/pygments/lexers/math.py", + "path_type": "hardlink", + "sha256": "5a5ea55355567afb505f29adea37437aecfd2c43223ca9753a7dd99b741743c3", + "sha256_in_prefix": "5a5ea55355567afb505f29adea37437aecfd2c43223ca9753a7dd99b741743c3", + "size_in_bytes": 676 + }, + { + "_path": "site-packages/pygments/lexers/matlab.py", + "path_type": "hardlink", + "sha256": "5a9946e7bf3f981eac1e50c37e063cdd231a74272a0ffb0de496f9f77ad2afac", + "sha256_in_prefix": "5a9946e7bf3f981eac1e50c37e063cdd231a74272a0ffb0de496f9f77ad2afac", + "size_in_bytes": 132852 + }, + { + "_path": "site-packages/pygments/lexers/maxima.py", + "path_type": "hardlink", + "sha256": "b4b4a378320164a1d1a0c96e76017ba01773d714c01f2bc8106e81b21c815f23", + "sha256_in_prefix": "b4b4a378320164a1d1a0c96e76017ba01773d714c01f2bc8106e81b21c815f23", + "size_in_bytes": 2716 + }, + { + "_path": "site-packages/pygments/lexers/meson.py", + "path_type": "hardlink", + "sha256": "8a3d0281b1142dfa8b31c63f050ecfc660b058e60b73d5d9c2dac02c54a29c40", + "sha256_in_prefix": "8a3d0281b1142dfa8b31c63f050ecfc660b058e60b73d5d9c2dac02c54a29c40", + "size_in_bytes": 4337 + }, + { + "_path": "site-packages/pygments/lexers/mime.py", + "path_type": "hardlink", + "sha256": "fb08f7a6f010ccd4c2f1f4d993d015e10f8b21084c52871eb7e8f692a1a3e60b", + "sha256_in_prefix": "fb08f7a6f010ccd4c2f1f4d993d015e10f8b21084c52871eb7e8f692a1a3e60b", + "size_in_bytes": 7538 + }, + { + "_path": "site-packages/pygments/lexers/minecraft.py", + "path_type": "hardlink", + "sha256": "86de505e8aedfd987defc26d5bc14579d668860e6fbecd1085f82d9c0a1325bc", + "sha256_in_prefix": "86de505e8aedfd987defc26d5bc14579d668860e6fbecd1085f82d9c0a1325bc", + "size_in_bytes": 13810 + }, + { + "_path": "site-packages/pygments/lexers/mips.py", + "path_type": "hardlink", + "sha256": "2417ef38fa791d31a9e9bd24ca7923cee24e4d101d4ec2497633d62c0b6ed5fa", + "sha256_in_prefix": "2417ef38fa791d31a9e9bd24ca7923cee24e4d101d4ec2497633d62c0b6ed5fa", + "size_in_bytes": 4604 + }, + { + "_path": "site-packages/pygments/lexers/ml.py", + "path_type": "hardlink", + "sha256": "69c32aafd56a57fefdfa8f2bae573c3d265861cd509b2a25a377f5f15c7cd628", + "sha256_in_prefix": "69c32aafd56a57fefdfa8f2bae573c3d265861cd509b2a25a377f5f15c7cd628", + "size_in_bytes": 35315 + }, + { + "_path": "site-packages/pygments/lexers/modeling.py", + "path_type": "hardlink", + "sha256": "dcac6e22cd7e95bfc537ddb59020a08eaf3847af404c4a7a2b5110c966b1a7b3", + "sha256_in_prefix": "dcac6e22cd7e95bfc537ddb59020a08eaf3847af404c4a7a2b5110c966b1a7b3", + "size_in_bytes": 13524 + }, + { + "_path": "site-packages/pygments/lexers/modula2.py", + "path_type": "hardlink", + "sha256": "cfee106c6e0182377ed0e342f5269d825a825b642620c97eeb46ff9f7e55fbbd", + "sha256_in_prefix": "cfee106c6e0182377ed0e342f5269d825a825b642620c97eeb46ff9f7e55fbbd", + "size_in_bytes": 53073 + }, + { + "_path": "site-packages/pygments/lexers/monte.py", + "path_type": "hardlink", + "sha256": "a4a3ca3a4c31706cc92d58ac03e1fbc49256f49521d92b17c838b7da61799d24", + "sha256_in_prefix": "a4a3ca3a4c31706cc92d58ac03e1fbc49256f49521d92b17c838b7da61799d24", + "size_in_bytes": 6290 + }, + { + "_path": "site-packages/pygments/lexers/mosel.py", + "path_type": "hardlink", + "sha256": "fc979a68ae499f4afb25cb8b97adaed6c97ab889e4acff60e04a2c09ff59f884", + "sha256_in_prefix": "fc979a68ae499f4afb25cb8b97adaed6c97ab889e4acff60e04a2c09ff59f884", + "size_in_bytes": 9187 + }, + { + "_path": "site-packages/pygments/lexers/ncl.py", + "path_type": "hardlink", + "sha256": "3ba09c93253cc8004a9b1f319a3e2ae84da2b163919af34eed7975257e4dc154", + "sha256_in_prefix": "3ba09c93253cc8004a9b1f319a3e2ae84da2b163919af34eed7975257e4dc154", + "size_in_bytes": 63962 + }, + { + "_path": "site-packages/pygments/lexers/nimrod.py", + "path_type": "hardlink", + "sha256": "3bff1dc64f71def95814f623a5ef22a90702adc666367044fcb7759733bbc552", + "sha256_in_prefix": "3bff1dc64f71def95814f623a5ef22a90702adc666367044fcb7759733bbc552", + "size_in_bytes": 6416 + }, + { + "_path": "site-packages/pygments/lexers/nit.py", + "path_type": "hardlink", + "sha256": "1a18dafc05fc0c883f280fab9af8262fbea4648fa5ab7a4044c89e6d88bd36ac", + "sha256_in_prefix": "1a18dafc05fc0c883f280fab9af8262fbea4648fa5ab7a4044c89e6d88bd36ac", + "size_in_bytes": 2726 + }, + { + "_path": "site-packages/pygments/lexers/nix.py", + "path_type": "hardlink", + "sha256": "275866fabe0d583fcb7c490220e66abef1355215c1445db3262eb439ac684bfa", + "sha256_in_prefix": "275866fabe0d583fcb7c490220e66abef1355215c1445db3262eb439ac684bfa", + "size_in_bytes": 4398 + }, + { + "_path": "site-packages/pygments/lexers/oberon.py", + "path_type": "hardlink", + "sha256": "2e0620cc63eeb3bc359492d402ed9c9884501848108a2777e101f95296bb52ba", + "sha256_in_prefix": "2e0620cc63eeb3bc359492d402ed9c9884501848108a2777e101f95296bb52ba", + "size_in_bytes": 4169 + }, + { + "_path": "site-packages/pygments/lexers/objective.py", + "path_type": "hardlink", + "sha256": "56851e6586b568ee6b53af5d0e9bf839be45398cabde79be789de6d24bad8b45", + "sha256_in_prefix": "56851e6586b568ee6b53af5d0e9bf839be45398cabde79be789de6d24bad8b45", + "size_in_bytes": 22961 + }, + { + "_path": "site-packages/pygments/lexers/ooc.py", + "path_type": "hardlink", + "sha256": "0448fb91f3a2985fd08bad91f81f1b9981b2ff94081358d2db435fae7344f52b", + "sha256_in_prefix": "0448fb91f3a2985fd08bad91f81f1b9981b2ff94081358d2db435fae7344f52b", + "size_in_bytes": 2982 + }, + { + "_path": "site-packages/pygments/lexers/openscad.py", + "path_type": "hardlink", + "sha256": "245e1c524eab02c1fd0655c376475731294a6a3a6086d3a6d0dcbe422928899d", + "sha256_in_prefix": "245e1c524eab02c1fd0655c376475731294a6a3a6086d3a6d0dcbe422928899d", + "size_in_bytes": 3701 + }, + { + "_path": "site-packages/pygments/lexers/other.py", + "path_type": "hardlink", + "sha256": "a1756d4c42c23c5c70b89c4de63fe262bb7443d0289eaf86928b6771414fa5e1", + "sha256_in_prefix": "a1756d4c42c23c5c70b89c4de63fe262bb7443d0289eaf86928b6771414fa5e1", + "size_in_bytes": 1744 + }, + { + "_path": "site-packages/pygments/lexers/parasail.py", + "path_type": "hardlink", + "sha256": "3313b8d0e4e0ff9cff1273326fac1e4078e1b732f55a04b07e3097734ce5f366", + "sha256_in_prefix": "3313b8d0e4e0ff9cff1273326fac1e4078e1b732f55a04b07e3097734ce5f366", + "size_in_bytes": 2720 + }, + { + "_path": "site-packages/pygments/lexers/parsers.py", + "path_type": "hardlink", + "sha256": "262413dc832c7f67f424b6e20e9ba964d4ac1e73141f9ecea00af40ffdc0bdb6", + "sha256_in_prefix": "262413dc832c7f67f424b6e20e9ba964d4ac1e73141f9ecea00af40ffdc0bdb6", + "size_in_bytes": 25904 + }, + { + "_path": "site-packages/pygments/lexers/pascal.py", + "path_type": "hardlink", + "sha256": "107662fe687857b2ee197b5c6d3427aeb7ea0c35dc1b25700ef26637c5d1729b", + "sha256_in_prefix": "107662fe687857b2ee197b5c6d3427aeb7ea0c35dc1b25700ef26637c5d1729b", + "size_in_bytes": 30880 + }, + { + "_path": "site-packages/pygments/lexers/pawn.py", + "path_type": "hardlink", + "sha256": "7cdabbdd5c10a1778a89114a6082b3cce0a57146f678b3c9221ca6967c4a6658", + "sha256_in_prefix": "7cdabbdd5c10a1778a89114a6082b3cce0a57146f678b3c9221ca6967c4a6658", + "size_in_bytes": 8146 + }, + { + "_path": "site-packages/pygments/lexers/perl.py", + "path_type": "hardlink", + "sha256": "f36ffbb1a691dea0459529d663212d922afbbaf5d379466a1548637647534d7b", + "sha256_in_prefix": "f36ffbb1a691dea0459529d663212d922afbbaf5d379466a1548637647534d7b", + "size_in_bytes": 39170 + }, + { + "_path": "site-packages/pygments/lexers/phix.py", + "path_type": "hardlink", + "sha256": "e3c24440aff48a38e2a700e5d45fa293407f08650cb193af5e5bd7cc8a875669", + "sha256_in_prefix": "e3c24440aff48a38e2a700e5d45fa293407f08650cb193af5e5bd7cc8a875669", + "size_in_bytes": 23252 + }, + { + "_path": "site-packages/pygments/lexers/php.py", + "path_type": "hardlink", + "sha256": "6f8b155994ccab4b7618c95a166cd85899daf56b83405226faf76a5e46fcf71a", + "sha256_in_prefix": "6f8b155994ccab4b7618c95a166cd85899daf56b83405226faf76a5e46fcf71a", + "size_in_bytes": 13040 + }, + { + "_path": "site-packages/pygments/lexers/pointless.py", + "path_type": "hardlink", + "sha256": "7540139585546646e0810e8f5329832a107450aa83a3e2827f4169fc48d6b133", + "sha256_in_prefix": "7540139585546646e0810e8f5329832a107450aa83a3e2827f4169fc48d6b133", + "size_in_bytes": 1975 + }, + { + "_path": "site-packages/pygments/lexers/pony.py", + "path_type": "hardlink", + "sha256": "934dc30214befc6f1266c7d764e8c5e5891068c436f3fbb2ebcfc231ac6e502e", + "sha256_in_prefix": "934dc30214befc6f1266c7d764e8c5e5891068c436f3fbb2ebcfc231ac6e502e", + "size_in_bytes": 3244 + }, + { + "_path": "site-packages/pygments/lexers/praat.py", + "path_type": "hardlink", + "sha256": "ad3979192a09e7c2d0c517ff124d00d47e220a6d885501711304af6cc922eedc", + "sha256_in_prefix": "ad3979192a09e7c2d0c517ff124d00d47e220a6d885501711304af6cc922eedc", + "size_in_bytes": 12677 + }, + { + "_path": "site-packages/pygments/lexers/procfile.py", + "path_type": "hardlink", + "sha256": "9da41971dbf15548d3e7a47453afd8a6034281f98d13d5e3cf1f6e41eb25f828", + "sha256_in_prefix": "9da41971dbf15548d3e7a47453afd8a6034281f98d13d5e3cf1f6e41eb25f828", + "size_in_bytes": 1156 + }, + { + "_path": "site-packages/pygments/lexers/prolog.py", + "path_type": "hardlink", + "sha256": "4f35a44988f153ee490059789e0de4b0035bc8c22f0f25d6751e484ac05968ab", + "sha256_in_prefix": "4f35a44988f153ee490059789e0de4b0035bc8c22f0f25d6751e484ac05968ab", + "size_in_bytes": 12506 + }, + { + "_path": "site-packages/pygments/lexers/promql.py", + "path_type": "hardlink", + "sha256": "430d155c8246464c3a6624b3bed47428589698fbb223dc715e00e5fe5ddc1e67", + "sha256_in_prefix": "430d155c8246464c3a6624b3bed47428589698fbb223dc715e00e5fe5ddc1e67", + "size_in_bytes": 4715 + }, + { + "_path": "site-packages/pygments/lexers/prql.py", + "path_type": "hardlink", + "sha256": "317935bf43effb368355664755fdd1bc364d3e323ae4f17eb3b6b485452b5705", + "sha256_in_prefix": "317935bf43effb368355664755fdd1bc364d3e323ae4f17eb3b6b485452b5705", + "size_in_bytes": 8748 + }, + { + "_path": "site-packages/pygments/lexers/ptx.py", + "path_type": "hardlink", + "sha256": "c2ce608469ad4cb689db36a65948b109b764cdb8e7c5dc19c88e2dde682b7528", + "sha256_in_prefix": "c2ce608469ad4cb689db36a65948b109b764cdb8e7c5dc19c88e2dde682b7528", + "size_in_bytes": 4502 + }, + { + "_path": "site-packages/pygments/lexers/python.py", + "path_type": "hardlink", + "sha256": "7e9fa972f4bb29027bfe9c586e7e2cd0e34f14e15c584451c381767be08ffc0d", + "sha256_in_prefix": "7e9fa972f4bb29027bfe9c586e7e2cd0e34f14e15c584451c381767be08ffc0d", + "size_in_bytes": 53400 + }, + { + "_path": "site-packages/pygments/lexers/q.py", + "path_type": "hardlink", + "sha256": "570dfac7aac8a765356fc194b546cc95c0f4315a96dee9c264430112df8f7e54", + "sha256_in_prefix": "570dfac7aac8a765356fc194b546cc95c0f4315a96dee9c264430112df8f7e54", + "size_in_bytes": 6932 + }, + { + "_path": "site-packages/pygments/lexers/qlik.py", + "path_type": "hardlink", + "sha256": "80201009ed53bb2fdc308e27e7549bf1f1b9d0bef702099430458c9994477898", + "sha256_in_prefix": "80201009ed53bb2fdc308e27e7549bf1f1b9d0bef702099430458c9994477898", + "size_in_bytes": 3665 + }, + { + "_path": "site-packages/pygments/lexers/qvt.py", + "path_type": "hardlink", + "sha256": "2231f2a29903a1c86542dfdf21feccaf1c3ce29220fa08f80640c7b4488a6ff5", + "sha256_in_prefix": "2231f2a29903a1c86542dfdf21feccaf1c3ce29220fa08f80640c7b4488a6ff5", + "size_in_bytes": 6072 + }, + { + "_path": "site-packages/pygments/lexers/r.py", + "path_type": "hardlink", + "sha256": "c4c48da4d3771e6d16e75f9311fbf33de386b686ccda7223195988a15c9d95f5", + "sha256_in_prefix": "c4c48da4d3771e6d16e75f9311fbf33de386b686ccda7223195988a15c9d95f5", + "size_in_bytes": 6185 + }, + { + "_path": "site-packages/pygments/lexers/rdf.py", + "path_type": "hardlink", + "sha256": "44d20126104a330a71947cc5da99ca24f5283a36e23e6a056436a30dde264b31", + "sha256_in_prefix": "44d20126104a330a71947cc5da99ca24f5283a36e23e6a056436a30dde264b31", + "size_in_bytes": 15981 + }, + { + "_path": "site-packages/pygments/lexers/rebol.py", + "path_type": "hardlink", + "sha256": "4cc4f72655e85af25b67065d2ee7a4c20bf9f381c43f599fb03da0f4eaa3d085", + "sha256_in_prefix": "4cc4f72655e85af25b67065d2ee7a4c20bf9f381c43f599fb03da0f4eaa3d085", + "size_in_bytes": 18248 + }, + { + "_path": "site-packages/pygments/lexers/resource.py", + "path_type": "hardlink", + "sha256": "2b1c50262f4d3e6821a5ad667a4c5414177c79a89207da55fc5e0476ce242b49", + "sha256_in_prefix": "2b1c50262f4d3e6821a5ad667a4c5414177c79a89207da55fc5e0476ce242b49", + "size_in_bytes": 2902 + }, + { + "_path": "site-packages/pygments/lexers/ride.py", + "path_type": "hardlink", + "sha256": "d264fcf6896ea33e65513f1aafab8f892c13201c3231cea81d89eb339418ed5a", + "sha256_in_prefix": "d264fcf6896ea33e65513f1aafab8f892c13201c3231cea81d89eb339418ed5a", + "size_in_bytes": 5056 + }, + { + "_path": "site-packages/pygments/lexers/rita.py", + "path_type": "hardlink", + "sha256": "80f6cc8650b24bf7a4cd720a6e85c6126b46665492531d24eaa72e5841ee33ab", + "sha256_in_prefix": "80f6cc8650b24bf7a4cd720a6e85c6126b46665492531d24eaa72e5841ee33ab", + "size_in_bytes": 1128 + }, + { + "_path": "site-packages/pygments/lexers/rnc.py", + "path_type": "hardlink", + "sha256": "4a35ca2563627d34d6402f4d95c58d99d864967d11104a44bda63a9d5cba9f8c", + "sha256_in_prefix": "4a35ca2563627d34d6402f4d95c58d99d864967d11104a44bda63a9d5cba9f8c", + "size_in_bytes": 1973 + }, + { + "_path": "site-packages/pygments/lexers/roboconf.py", + "path_type": "hardlink", + "sha256": "1d8d1d48f27183b92743e70ce98a2d5fc128563b908be2de29829e5a943217de", + "sha256_in_prefix": "1d8d1d48f27183b92743e70ce98a2d5fc128563b908be2de29829e5a943217de", + "size_in_bytes": 1962 + }, + { + "_path": "site-packages/pygments/lexers/robotframework.py", + "path_type": "hardlink", + "sha256": "309e1c9d40d9583ad70a9622fa424ba9ed47a73276e0332d36cc037ae4a75427", + "sha256_in_prefix": "309e1c9d40d9583ad70a9622fa424ba9ed47a73276e0332d36cc037ae4a75427", + "size_in_bytes": 18449 + }, + { + "_path": "site-packages/pygments/lexers/ruby.py", + "path_type": "hardlink", + "sha256": "f4e7b1b7d6eac02ec4e121377c00782dd77dffd4dbabb0f80fde11400fbc6dc7", + "sha256_in_prefix": "f4e7b1b7d6eac02ec4e121377c00782dd77dffd4dbabb0f80fde11400fbc6dc7", + "size_in_bytes": 22672 + }, + { + "_path": "site-packages/pygments/lexers/rust.py", + "path_type": "hardlink", + "sha256": "3aae5b1607ff85c38bc6204b8733c0ad4157820dd475eff1a5e28f0b783e1c32", + "sha256_in_prefix": "3aae5b1607ff85c38bc6204b8733c0ad4157820dd475eff1a5e28f0b783e1c32", + "size_in_bytes": 8216 + }, + { + "_path": "site-packages/pygments/lexers/sas.py", + "path_type": "hardlink", + "sha256": "bb4be43cb7a15fb50446c288928a02e081497537f8e0bdbf42a769c750deef09", + "sha256_in_prefix": "bb4be43cb7a15fb50446c288928a02e081497537f8e0bdbf42a769c750deef09", + "size_in_bytes": 9400 + }, + { + "_path": "site-packages/pygments/lexers/savi.py", + "path_type": "hardlink", + "sha256": "dc0e7adc1f96ce9e401991b4aee49088f6def9cdee606c023d49a73c948428e9", + "sha256_in_prefix": "dc0e7adc1f96ce9e401991b4aee49088f6def9cdee606c023d49a73c948428e9", + "size_in_bytes": 4645 + }, + { + "_path": "site-packages/pygments/lexers/scdoc.py", + "path_type": "hardlink", + "sha256": "fd4292e55659e1e695a71992afa2ff3fc3abf2002df662265f81d6bb0d531a5a", + "sha256_in_prefix": "fd4292e55659e1e695a71992afa2ff3fc3abf2002df662265f81d6bb0d531a5a", + "size_in_bytes": 2525 + }, + { + "_path": "site-packages/pygments/lexers/scripting.py", + "path_type": "hardlink", + "sha256": "1245cacd62e0fa3a6c57cadea76616e9f0ec083cfe7777d8d6abf541513b308f", + "sha256_in_prefix": "1245cacd62e0fa3a6c57cadea76616e9f0ec083cfe7777d8d6abf541513b308f", + "size_in_bytes": 70014 + }, + { + "_path": "site-packages/pygments/lexers/sgf.py", + "path_type": "hardlink", + "sha256": "39add234bdf5c0df2b858d206f2eb591b3f1b6dbd14094d1377f0248c5223091", + "sha256_in_prefix": "39add234bdf5c0df2b858d206f2eb591b3f1b6dbd14094d1377f0248c5223091", + "size_in_bytes": 1986 + }, + { + "_path": "site-packages/pygments/lexers/shell.py", + "path_type": "hardlink", + "sha256": "a02d75e433661333d83dd28de63354cfe815e3873fa956f663939f18ede043f5", + "sha256_in_prefix": "a02d75e433661333d83dd28de63354cfe815e3873fa956f663939f18ede043f5", + "size_in_bytes": 36466 + }, + { + "_path": "site-packages/pygments/lexers/sieve.py", + "path_type": "hardlink", + "sha256": "94b7022ddbe3f807ae7621b6c6adb34cdd7abf4cd21172b9bdcaf591e8344f10", + "sha256_in_prefix": "94b7022ddbe3f807ae7621b6c6adb34cdd7abf4cd21172b9bdcaf591e8344f10", + "size_in_bytes": 2441 + }, + { + "_path": "site-packages/pygments/lexers/slash.py", + "path_type": "hardlink", + "sha256": "feca0fae6175ca5030ec859f4474cc3147627f0cb8a0d57916960c050b154b23", + "sha256_in_prefix": "feca0fae6175ca5030ec859f4474cc3147627f0cb8a0d57916960c050b154b23", + "size_in_bytes": 8482 + }, + { + "_path": "site-packages/pygments/lexers/smalltalk.py", + "path_type": "hardlink", + "sha256": "f5436a8c258e6b2de76f9055a8dd8cbb0f828badd69ec716eb125c1a735656ae", + "sha256_in_prefix": "f5436a8c258e6b2de76f9055a8dd8cbb0f828badd69ec716eb125c1a735656ae", + "size_in_bytes": 7206 + }, + { + "_path": "site-packages/pygments/lexers/smithy.py", + "path_type": "hardlink", + "sha256": "14cbd65cabe317f85436a23b0666586d546b3e0e7f0279f33911cfa77b24717b", + "sha256_in_prefix": "14cbd65cabe317f85436a23b0666586d546b3e0e7f0279f33911cfa77b24717b", + "size_in_bytes": 2660 + }, + { + "_path": "site-packages/pygments/lexers/smv.py", + "path_type": "hardlink", + "sha256": "5725ae4e3b4085a666bbaa191b73a6fe4537361a2b573f62bf37aefe67d18f0a", + "sha256_in_prefix": "5725ae4e3b4085a666bbaa191b73a6fe4537361a2b573f62bf37aefe67d18f0a", + "size_in_bytes": 2773 + }, + { + "_path": "site-packages/pygments/lexers/snobol.py", + "path_type": "hardlink", + "sha256": "5a9ed588c9dd772efdb56263b20481f6420f161fce85a338636b598d60eebcc2", + "sha256_in_prefix": "5a9ed588c9dd772efdb56263b20481f6420f161fce85a338636b598d60eebcc2", + "size_in_bytes": 2732 + }, + { + "_path": "site-packages/pygments/lexers/solidity.py", + "path_type": "hardlink", + "sha256": "3219b2a5be56cf119d05a429c9269ef4d6e21499659047b3762b631da8dded10", + "sha256_in_prefix": "3219b2a5be56cf119d05a429c9269ef4d6e21499659047b3762b631da8dded10", + "size_in_bytes": 3127 + }, + { + "_path": "site-packages/pygments/lexers/sophia.py", + "path_type": "hardlink", + "sha256": "d20011bf40db322ec359473bf77a5de1fec82b149e3a592393f79ecfcb4b8a1b", + "sha256_in_prefix": "d20011bf40db322ec359473bf77a5de1fec82b149e3a592393f79ecfcb4b8a1b", + "size_in_bytes": 3330 + }, + { + "_path": "site-packages/pygments/lexers/special.py", + "path_type": "hardlink", + "sha256": "4835aa04a99698acaf8bc54d7cfa56d55e20edeae069de117d4ba60e1e9b36b9", + "sha256_in_prefix": "4835aa04a99698acaf8bc54d7cfa56d55e20edeae069de117d4ba60e1e9b36b9", + "size_in_bytes": 3414 + }, + { + "_path": "site-packages/pygments/lexers/spice.py", + "path_type": "hardlink", + "sha256": "873030b73a1c3341988d96acaac5f552fea3624c20926f7022f69da64cb0dadc", + "sha256_in_prefix": "873030b73a1c3341988d96acaac5f552fea3624c20926f7022f69da64cb0dadc", + "size_in_bytes": 2735 + }, + { + "_path": "site-packages/pygments/lexers/sql.py", + "path_type": "hardlink", + "sha256": "222ac1ac3ba4b30dceb2f7b1a1bf745c2987ec744871a041803c8ad5acba06e0", + "sha256_in_prefix": "222ac1ac3ba4b30dceb2f7b1a1bf745c2987ec744871a041803c8ad5acba06e0", + "size_in_bytes": 42107 + }, + { + "_path": "site-packages/pygments/lexers/srcinfo.py", + "path_type": "hardlink", + "sha256": "c7fe83b19d262956c8feffc6e5b2c1425d16c85c23ded5e63aa7c7201eb3bdee", + "sha256_in_prefix": "c7fe83b19d262956c8feffc6e5b2c1425d16c85c23ded5e63aa7c7201eb3bdee", + "size_in_bytes": 1693 + }, + { + "_path": "site-packages/pygments/lexers/stata.py", + "path_type": "hardlink", + "sha256": "f8845f2e5feba6e3a22acd159e973a3842ae03a0176e4956e9104673bc731843", + "sha256_in_prefix": "f8845f2e5feba6e3a22acd159e973a3842ae03a0176e4956e9104673bc731843", + "size_in_bytes": 6416 + }, + { + "_path": "site-packages/pygments/lexers/supercollider.py", + "path_type": "hardlink", + "sha256": "51ae116e609160fcfb3dc4f5bb296801b7ca73d9198a6ee700aaf9e44dbab1c6", + "sha256_in_prefix": "51ae116e609160fcfb3dc4f5bb296801b7ca73d9198a6ee700aaf9e44dbab1c6", + "size_in_bytes": 3698 + }, + { + "_path": "site-packages/pygments/lexers/tal.py", + "path_type": "hardlink", + "sha256": "7d710999253be0898ec825671085b541aeeb58a2220c72a60e5a485b7394a7ec", + "sha256_in_prefix": "7d710999253be0898ec825671085b541aeeb58a2220c72a60e5a485b7394a7ec", + "size_in_bytes": 2898 + }, + { + "_path": "site-packages/pygments/lexers/tcl.py", + "path_type": "hardlink", + "sha256": "4938c74a555e5a8f84838b4aaa7ffb9b7ff779f7261cfd160a82f5fcf2b9b6dd", + "sha256_in_prefix": "4938c74a555e5a8f84838b4aaa7ffb9b7ff779f7261cfd160a82f5fcf2b9b6dd", + "size_in_bytes": 5513 + }, + { + "_path": "site-packages/pygments/lexers/teal.py", + "path_type": "hardlink", + "sha256": "b7c78eceb22222656e52d9019523e5f58e2896b080676d52401f93ebb5996ac4", + "sha256_in_prefix": "b7c78eceb22222656e52d9019523e5f58e2896b080676d52401f93ebb5996ac4", + "size_in_bytes": 3523 + }, + { + "_path": "site-packages/pygments/lexers/templates.py", + "path_type": "hardlink", + "sha256": "11ac2de4c5ce7b5576441fef869eb4f7b190323a0a1cf4845872a27e174c6b3c", + "sha256_in_prefix": "11ac2de4c5ce7b5576441fef869eb4f7b190323a0a1cf4845872a27e174c6b3c", + "size_in_bytes": 72610 + }, + { + "_path": "site-packages/pygments/lexers/teraterm.py", + "path_type": "hardlink", + "sha256": "ef53622de7f2e342fa47807eab2fa1a3c532e24010aac8bb88bc5ec420d2e6b5", + "sha256_in_prefix": "ef53622de7f2e342fa47807eab2fa1a3c532e24010aac8bb88bc5ec420d2e6b5", + "size_in_bytes": 9719 + }, + { + "_path": "site-packages/pygments/lexers/testing.py", + "path_type": "hardlink", + "sha256": "51ef77ba1dfa97b24a7347140e72e693e136db56f9cbbaadeb15c7bda251c6de", + "sha256_in_prefix": "51ef77ba1dfa97b24a7347140e72e693e136db56f9cbbaadeb15c7bda251c6de", + "size_in_bytes": 10767 + }, + { + "_path": "site-packages/pygments/lexers/text.py", + "path_type": "hardlink", + "sha256": "9ed17c430b2e86cab241dc4c07a1fb3183fba3c03bc52c477b450c4d92ca48af", + "sha256_in_prefix": "9ed17c430b2e86cab241dc4c07a1fb3183fba3c03bc52c477b450c4d92ca48af", + "size_in_bytes": 1029 + }, + { + "_path": "site-packages/pygments/lexers/textedit.py", + "path_type": "hardlink", + "sha256": "c5553edcae7ed0a1246f4a49e21263ae3a67cfd849688b8b40ec5f93d9cb5a33", + "sha256_in_prefix": "c5553edcae7ed0a1246f4a49e21263ae3a67cfd849688b8b40ec5f93d9cb5a33", + "size_in_bytes": 7609 + }, + { + "_path": "site-packages/pygments/lexers/textfmts.py", + "path_type": "hardlink", + "sha256": "77983c0160cae7f3173273e18fab7b4fb48e2ec93ac0fa6d46682701d6c09d47", + "sha256_in_prefix": "77983c0160cae7f3173273e18fab7b4fb48e2ec93ac0fa6d46682701d6c09d47", + "size_in_bytes": 15310 + }, + { + "_path": "site-packages/pygments/lexers/theorem.py", + "path_type": "hardlink", + "sha256": "05fcfdf34eeca47d0be10974ff4bb41c37d3e2de59d8f3e4ef56bd26ab97965a", + "sha256_in_prefix": "05fcfdf34eeca47d0be10974ff4bb41c37d3e2de59d8f3e4ef56bd26ab97965a", + "size_in_bytes": 16659 + }, + { + "_path": "site-packages/pygments/lexers/thingsdb.py", + "path_type": "hardlink", + "sha256": "1707a57215415ca7f79dcefc52003d4b225b1ed6b710c76b2e7422cc8c52e521", + "sha256_in_prefix": "1707a57215415ca7f79dcefc52003d4b225b1ed6b710c76b2e7422cc8c52e521", + "size_in_bytes": 4228 + }, + { + "_path": "site-packages/pygments/lexers/tlb.py", + "path_type": "hardlink", + "sha256": "b100ac2b78fccea19523f282baeaec98eaf8248b37b1fa6a17fc0fa50a7228cd", + "sha256_in_prefix": "b100ac2b78fccea19523f282baeaec98eaf8248b37b1fa6a17fc0fa50a7228cd", + "size_in_bytes": 1377 + }, + { + "_path": "site-packages/pygments/lexers/tls.py", + "path_type": "hardlink", + "sha256": "29f23ccbb69b619cc2fe3470bed8bf7e800052b5929a98dd4374463dc3fcca9b", + "sha256_in_prefix": "29f23ccbb69b619cc2fe3470bed8bf7e800052b5929a98dd4374463dc3fcca9b", + "size_in_bytes": 1541 + }, + { + "_path": "site-packages/pygments/lexers/tnt.py", + "path_type": "hardlink", + "sha256": "baf75cb30e4d4598db168b970444f7fb0f08ecb1bd86accc5e22bab3f18ad996", + "sha256_in_prefix": "baf75cb30e4d4598db168b970444f7fb0f08ecb1bd86accc5e22bab3f18ad996", + "size_in_bytes": 10457 + }, + { + "_path": "site-packages/pygments/lexers/trafficscript.py", + "path_type": "hardlink", + "sha256": "18397fedc4858add5a9d51fb28d1f4a95b6cd5e1dca7f186c69cc861665a6de8", + "sha256_in_prefix": "18397fedc4858add5a9d51fb28d1f4a95b6cd5e1dca7f186c69cc861665a6de8", + "size_in_bytes": 1474 + }, + { + "_path": "site-packages/pygments/lexers/typoscript.py", + "path_type": "hardlink", + "sha256": "9c80142256cbe6c56aa5312ddf861d5060cd9aeeb46bb8ad05869a50cbb3008b", + "sha256_in_prefix": "9c80142256cbe6c56aa5312ddf861d5060cd9aeeb46bb8ad05869a50cbb3008b", + "size_in_bytes": 8207 + }, + { + "_path": "site-packages/pygments/lexers/ul4.py", + "path_type": "hardlink", + "sha256": "5ce9b9756896b56377450329039547be5d49d63834d7848adbb6899d58ead42d", + "sha256_in_prefix": "5ce9b9756896b56377450329039547be5d49d63834d7848adbb6899d58ead42d", + "size_in_bytes": 8956 + }, + { + "_path": "site-packages/pygments/lexers/unicon.py", + "path_type": "hardlink", + "sha256": "e0c0e7c2c817ccb966d33683a98afdb8714db29802cd044dcf2c4295543e44c2", + "sha256_in_prefix": "e0c0e7c2c817ccb966d33683a98afdb8714db29802cd044dcf2c4295543e44c2", + "size_in_bytes": 18512 + }, + { + "_path": "site-packages/pygments/lexers/urbi.py", + "path_type": "hardlink", + "sha256": "dc29317cc3aaa52559a4eabbff862b59c9a3ab8077085fc80c623102c79d590d", + "sha256_in_prefix": "dc29317cc3aaa52559a4eabbff862b59c9a3ab8077085fc80c623102c79d590d", + "size_in_bytes": 6037 + }, + { + "_path": "site-packages/pygments/lexers/usd.py", + "path_type": "hardlink", + "sha256": "ec5892fca57543d0af7f9d5f00798caabe500f3d4eb63a93929d52fbc572413c", + "sha256_in_prefix": "ec5892fca57543d0af7f9d5f00798caabe500f3d4eb63a93929d52fbc572413c", + "size_in_bytes": 3513 + }, + { + "_path": "site-packages/pygments/lexers/varnish.py", + "path_type": "hardlink", + "sha256": "2d82faae1230f80a49453e2a93115ac46ef538f6c7b2216fe26b5faf49b538f6", + "sha256_in_prefix": "2d82faae1230f80a49453e2a93115ac46ef538f6c7b2216fe26b5faf49b538f6", + "size_in_bytes": 7273 + }, + { + "_path": "site-packages/pygments/lexers/verification.py", + "path_type": "hardlink", + "sha256": "d42d67b6abd99ab0adcc757d7832206b52ed4388e90256fa1a75a436e7042574", + "sha256_in_prefix": "d42d67b6abd99ab0adcc757d7832206b52ed4388e90256fa1a75a436e7042574", + "size_in_bytes": 3885 + }, + { + "_path": "site-packages/pygments/lexers/verifpal.py", + "path_type": "hardlink", + "sha256": "0c5d27425af0fd7b76dce385a4e0bcfcb4696165e5a27d52ef2c63e9e81bb436", + "sha256_in_prefix": "0c5d27425af0fd7b76dce385a4e0bcfcb4696165e5a27d52ef2c63e9e81bb436", + "size_in_bytes": 2662 + }, + { + "_path": "site-packages/pygments/lexers/vip.py", + "path_type": "hardlink", + "sha256": "327f1949454bb8682ab7508cb215c57a54b7a7c0c1a943b2a85ad9c960466e57", + "sha256_in_prefix": "327f1949454bb8682ab7508cb215c57a54b7a7c0c1a943b2a85ad9c960466e57", + "size_in_bytes": 5713 + }, + { + "_path": "site-packages/pygments/lexers/vyper.py", + "path_type": "hardlink", + "sha256": "54588ec68f4986b3d0285b560ce8d6cfa1dc708c23031107e361b34a433b2e10", + "sha256_in_prefix": "54588ec68f4986b3d0285b560ce8d6cfa1dc708c23031107e361b34a433b2e10", + "size_in_bytes": 5595 + }, + { + "_path": "site-packages/pygments/lexers/web.py", + "path_type": "hardlink", + "sha256": "96c722b7f3605ec1c32fcb23bcdbc016b88f05edb8733d1bdab046145a5896ff", + "sha256_in_prefix": "96c722b7f3605ec1c32fcb23bcdbc016b88f05edb8733d1bdab046145a5896ff", + "size_in_bytes": 894 + }, + { + "_path": "site-packages/pygments/lexers/webassembly.py", + "path_type": "hardlink", + "sha256": "1c6169e2a3002b47a3c74a26ad3844b48be5fc0aca39e4bb6f8c99922a6a988a", + "sha256_in_prefix": "1c6169e2a3002b47a3c74a26ad3844b48be5fc0aca39e4bb6f8c99922a6a988a", + "size_in_bytes": 5699 + }, + { + "_path": "site-packages/pygments/lexers/webidl.py", + "path_type": "hardlink", + "sha256": "55ea8eee2dd8f9ed0e6ed2f19f5b2788698bfc2bce59e91a3f65f2505cc394b4", + "sha256_in_prefix": "55ea8eee2dd8f9ed0e6ed2f19f5b2788698bfc2bce59e91a3f65f2505cc394b4", + "size_in_bytes": 10517 + }, + { + "_path": "site-packages/pygments/lexers/webmisc.py", + "path_type": "hardlink", + "sha256": "bde202b545cbdf779f7dc6035fcfc553517443915f65fcdc0b64f2bb94984fd0", + "sha256_in_prefix": "bde202b545cbdf779f7dc6035fcfc553517443915f65fcdc0b64f2bb94984fd0", + "size_in_bytes": 40549 + }, + { + "_path": "site-packages/pygments/lexers/wgsl.py", + "path_type": "hardlink", + "sha256": "31f7e08f7c79b45c2c2968a1c3691b8529a1bc634481073fa498ba0b79844317", + "sha256_in_prefix": "31f7e08f7c79b45c2c2968a1c3691b8529a1bc634481073fa498ba0b79844317", + "size_in_bytes": 11920 + }, + { + "_path": "site-packages/pygments/lexers/whiley.py", + "path_type": "hardlink", + "sha256": "49b6dfb5a22d4a021d733cd3f2a395f261f59ba743dda33612f464e2295ae82a", + "sha256_in_prefix": "49b6dfb5a22d4a021d733cd3f2a395f261f59ba743dda33612f464e2295ae82a", + "size_in_bytes": 4018 + }, + { + "_path": "site-packages/pygments/lexers/wowtoc.py", + "path_type": "hardlink", + "sha256": "a3fd354864c9de379c547129921a8777023ae974158bcc0d79a8d560f6dde01a", + "sha256_in_prefix": "a3fd354864c9de379c547129921a8777023ae974158bcc0d79a8d560f6dde01a", + "size_in_bytes": 4021 + }, + { + "_path": "site-packages/pygments/lexers/wren.py", + "path_type": "hardlink", + "sha256": "2372da233cb769ad1a0d725df4f269f92889b6024792d2121dd43fcd0b8c1cb6", + "sha256_in_prefix": "2372da233cb769ad1a0d725df4f269f92889b6024792d2121dd43fcd0b8c1cb6", + "size_in_bytes": 3239 + }, + { + "_path": "site-packages/pygments/lexers/x10.py", + "path_type": "hardlink", + "sha256": "a77570420ef47bc651da2c11da463eca88d3c83fecdf154930b4c25aba73e877", + "sha256_in_prefix": "a77570420ef47bc651da2c11da463eca88d3c83fecdf154930b4c25aba73e877", + "size_in_bytes": 1920 + }, + { + "_path": "site-packages/pygments/lexers/xorg.py", + "path_type": "hardlink", + "sha256": "ad72953508a29e236868ce154e42c58f5d3a34b75d081a35055e39053c53d471", + "sha256_in_prefix": "ad72953508a29e236868ce154e42c58f5d3a34b75d081a35055e39053c53d471", + "size_in_bytes": 902 + }, + { + "_path": "site-packages/pygments/lexers/yang.py", + "path_type": "hardlink", + "sha256": "af1d3ca2462f26058c7ba8cc464b7ecac12e6938bce57e431344391076fe1218", + "sha256_in_prefix": "af1d3ca2462f26058c7ba8cc464b7ecac12e6938bce57e431344391076fe1218", + "size_in_bytes": 4500 + }, + { + "_path": "site-packages/pygments/lexers/yara.py", + "path_type": "hardlink", + "sha256": "9c5c0fb66b8085ee6aae6fcf2a57559d602215968b7a2a608b9ab7fabd551b01", + "sha256_in_prefix": "9c5c0fb66b8085ee6aae6fcf2a57559d602215968b7a2a608b9ab7fabd551b01", + "size_in_bytes": 2428 + }, + { + "_path": "site-packages/pygments/lexers/zig.py", + "path_type": "hardlink", + "sha256": "07941919f128364a001b9119c47936f0c6759f64351afc75d6472f4d0e8de57f", + "sha256_in_prefix": "07941919f128364a001b9119c47936f0c6759f64351afc75d6472f4d0e8de57f", + "size_in_bytes": 3953 + }, + { + "_path": "site-packages/pygments/modeline.py", + "path_type": "hardlink", + "sha256": "785daf3b82e9386a0fbc828a91b3df9f2badf214f852279b64fa5bf8160641d2", + "sha256_in_prefix": "785daf3b82e9386a0fbc828a91b3df9f2badf214f852279b64fa5bf8160641d2", + "size_in_bytes": 986 + }, + { + "_path": "site-packages/pygments/plugin.py", + "path_type": "hardlink", + "sha256": "93f82d24706b8830d688d8a743e87faa70d49bb1273cbb97693187dc2779a59c", + "sha256_in_prefix": "93f82d24706b8830d688d8a743e87faa70d49bb1273cbb97693187dc2779a59c", + "size_in_bytes": 2579 + }, + { + "_path": "site-packages/pygments/regexopt.py", + "path_type": "hardlink", + "sha256": "8e0d402e881c60653de93412f62b0197a742aefc39cb9fbe04ffcafae164ffcb", + "sha256_in_prefix": "8e0d402e881c60653de93412f62b0197a742aefc39cb9fbe04ffcafae164ffcb", + "size_in_bytes": 3072 + }, + { + "_path": "site-packages/pygments/scanner.py", + "path_type": "hardlink", + "sha256": "6ff9eee7f7f71c2812769e52fda351050d4c4829b86630f079cd8e993462724c", + "sha256_in_prefix": "6ff9eee7f7f71c2812769e52fda351050d4c4829b86630f079cd8e993462724c", + "size_in_bytes": 3092 + }, + { + "_path": "site-packages/pygments/sphinxext.py", + "path_type": "hardlink", + "sha256": "946c3deebe4b42b06f79cb4c3732f4df04440ab8ecd474579bc2bf97b4fe2279", + "sha256_in_prefix": "946c3deebe4b42b06f79cb4c3732f4df04440ab8ecd474579bc2bf97b4fe2279", + "size_in_bytes": 7687 + }, + { + "_path": "site-packages/pygments/style.py", + "path_type": "hardlink", + "sha256": "6fd2f478f9e025b7491dcd8637495943e38645e552d8b2c9ec2c340adaaf6247", + "sha256_in_prefix": "6fd2f478f9e025b7491dcd8637495943e38645e552d8b2c9ec2c340adaaf6247", + "size_in_bytes": 6408 + }, + { + "_path": "site-packages/pygments/styles/__init__.py", + "path_type": "hardlink", + "sha256": "fef0f7922c5630656e050ac0d56cffac912d924f3dd56d040f9e62f044018420", + "sha256_in_prefix": "fef0f7922c5630656e050ac0d56cffac912d924f3dd56d040f9e62f044018420", + "size_in_bytes": 2006 + }, + { + "_path": "site-packages/pygments/styles/_mapping.py", + "path_type": "hardlink", + "sha256": "f2763d6dc105d59c3d5eed1b9aa7dfa981071db359bc24078add8e5652561f29", + "sha256_in_prefix": "f2763d6dc105d59c3d5eed1b9aa7dfa981071db359bc24078add8e5652561f29", + "size_in_bytes": 3251 + }, + { + "_path": "site-packages/pygments/styles/abap.py", + "path_type": "hardlink", + "sha256": "bbe42e4c2ea640aab86090389a4b42427d9c304956c299285f74bbbac6d838e0", + "sha256_in_prefix": "bbe42e4c2ea640aab86090389a4b42427d9c304956c299285f74bbbac6d838e0", + "size_in_bytes": 749 + }, + { + "_path": "site-packages/pygments/styles/algol.py", + "path_type": "hardlink", + "sha256": "3f740a85f3b395502aad4f76b23867691ec4a8239050ec3b2e4fc8f5ea4a6ed6", + "sha256_in_prefix": "3f740a85f3b395502aad4f76b23867691ec4a8239050ec3b2e4fc8f5ea4a6ed6", + "size_in_bytes": 2262 + }, + { + "_path": "site-packages/pygments/styles/algol_nu.py", + "path_type": "hardlink", + "sha256": "3ace12d05503310f74e4edd1acb55162c8efec0a55e93a45adfc0a9f0fa16604", + "sha256_in_prefix": "3ace12d05503310f74e4edd1acb55162c8efec0a55e93a45adfc0a9f0fa16604", + "size_in_bytes": 2283 + }, + { + "_path": "site-packages/pygments/styles/arduino.py", + "path_type": "hardlink", + "sha256": "fc2be01cddf5b8a0d0e3baefc39128ae0731ca5e4aa514211bf604b461087f1a", + "sha256_in_prefix": "fc2be01cddf5b8a0d0e3baefc39128ae0731ca5e4aa514211bf604b461087f1a", + "size_in_bytes": 4557 + }, + { + "_path": "site-packages/pygments/styles/autumn.py", + "path_type": "hardlink", + "sha256": "75d7a0d8e3f63741e79dfd44b530adb5afe5d4c11cf38265cfeab4bba0d560c9", + "sha256_in_prefix": "75d7a0d8e3f63741e79dfd44b530adb5afe5d4c11cf38265cfeab4bba0d560c9", + "size_in_bytes": 2195 + }, + { + "_path": "site-packages/pygments/styles/borland.py", + "path_type": "hardlink", + "sha256": "2bd0a165461e54257f527782f86bb06db16e1ac6ee24f4265d4e0ce623bdf900", + "sha256_in_prefix": "2bd0a165461e54257f527782f86bb06db16e1ac6ee24f4265d4e0ce623bdf900", + "size_in_bytes": 1611 + }, + { + "_path": "site-packages/pygments/styles/bw.py", + "path_type": "hardlink", + "sha256": "9bf69a51c29972814a7c233186dc7348223f5e61de523530e6f7593e3bd9a7e8", + "sha256_in_prefix": "9bf69a51c29972814a7c233186dc7348223f5e61de523530e6f7593e3bd9a7e8", + "size_in_bytes": 1406 + }, + { + "_path": "site-packages/pygments/styles/colorful.py", + "path_type": "hardlink", + "sha256": "f32723a218159e93223254b125c4b812518f12bed8cc61694b81d37cba9969b4", + "sha256_in_prefix": "f32723a218159e93223254b125c4b812518f12bed8cc61694b81d37cba9969b4", + "size_in_bytes": 2832 + }, + { + "_path": "site-packages/pygments/styles/default.py", + "path_type": "hardlink", + "sha256": "7e20fe3886e90a3abe494b5ddf1dee6e691537c9fb681578edfc280eb4de1245", + "sha256_in_prefix": "7e20fe3886e90a3abe494b5ddf1dee6e691537c9fb681578edfc280eb4de1245", + "size_in_bytes": 2588 + }, + { + "_path": "site-packages/pygments/styles/dracula.py", + "path_type": "hardlink", + "sha256": "e4bc9652650de70cb63211eec8470e6e967a68c68ba516003c21bbfd9d0c084e", + "sha256_in_prefix": "e4bc9652650de70cb63211eec8470e6e967a68c68ba516003c21bbfd9d0c084e", + "size_in_bytes": 2182 + }, + { + "_path": "site-packages/pygments/styles/emacs.py", + "path_type": "hardlink", + "sha256": "cff6a93741b70b10495824ee1e0a8b7f88271b6390a44a8f50d98cd8c21ccdef", + "sha256_in_prefix": "cff6a93741b70b10495824ee1e0a8b7f88271b6390a44a8f50d98cd8c21ccdef", + "size_in_bytes": 2535 + }, + { + "_path": "site-packages/pygments/styles/friendly.py", + "path_type": "hardlink", + "sha256": "73f39a912bc95710f9bd515016bcf6d1a549cd51c8856ddca2343be82226c6c7", + "sha256_in_prefix": "73f39a912bc95710f9bd515016bcf6d1a549cd51c8856ddca2343be82226c6c7", + "size_in_bytes": 2604 + }, + { + "_path": "site-packages/pygments/styles/friendly_grayscale.py", + "path_type": "hardlink", + "sha256": "1fa6ec4a7987a9ae2b500868a8f935da78106fcf874bd2e729ec309396d20e0f", + "sha256_in_prefix": "1fa6ec4a7987a9ae2b500868a8f935da78106fcf874bd2e729ec309396d20e0f", + "size_in_bytes": 2828 + }, + { + "_path": "site-packages/pygments/styles/fruity.py", + "path_type": "hardlink", + "sha256": "aeb40917bfb9819d2264356262ee2de83ae35b8188731e88947879d6eb3e25c0", + "sha256_in_prefix": "aeb40917bfb9819d2264356262ee2de83ae35b8188731e88947879d6eb3e25c0", + "size_in_bytes": 1324 + }, + { + "_path": "site-packages/pygments/styles/gh_dark.py", + "path_type": "hardlink", + "sha256": "38c4b01c59c037dadc8f061410bd93952f799e85a35b7ece6943e1c9abde2221", + "sha256_in_prefix": "38c4b01c59c037dadc8f061410bd93952f799e85a35b7ece6943e1c9abde2221", + "size_in_bytes": 3590 + }, + { + "_path": "site-packages/pygments/styles/gruvbox.py", + "path_type": "hardlink", + "sha256": "f75f8c39faaaa17ad83af077c76bd867792f17f9d2df8a2a369a2a0fb93861ce", + "sha256_in_prefix": "f75f8c39faaaa17ad83af077c76bd867792f17f9d2df8a2a369a2a0fb93861ce", + "size_in_bytes": 3387 + }, + { + "_path": "site-packages/pygments/styles/igor.py", + "path_type": "hardlink", + "sha256": "288ac1a38055f88033fb304ae2bd20c676eb21648715efd8b3ab92b9b7814387", + "sha256_in_prefix": "288ac1a38055f88033fb304ae2bd20c676eb21648715efd8b3ab92b9b7814387", + "size_in_bytes": 737 + }, + { + "_path": "site-packages/pygments/styles/inkpot.py", + "path_type": "hardlink", + "sha256": "3ae6b6e944152d7b196d27e87f2cfb67c68a4a227d853b9f037c45e879188c6a", + "sha256_in_prefix": "3ae6b6e944152d7b196d27e87f2cfb67c68a4a227d853b9f037c45e879188c6a", + "size_in_bytes": 2404 + }, + { + "_path": "site-packages/pygments/styles/lightbulb.py", + "path_type": "hardlink", + "sha256": "1c2658fa1f8235b672528808e6019047f778866166ab12f160d27ca9c652165b", + "sha256_in_prefix": "1c2658fa1f8235b672528808e6019047f778866166ab12f160d27ca9c652165b", + "size_in_bytes": 3172 + }, + { + "_path": "site-packages/pygments/styles/lilypond.py", + "path_type": "hardlink", + "sha256": "242d76c59dc4241e4d0fc10771369d7c69a09db6b21aaf2504e3d9b91daf532d", + "sha256_in_prefix": "242d76c59dc4241e4d0fc10771369d7c69a09db6b21aaf2504e3d9b91daf532d", + "size_in_bytes": 2066 + }, + { + "_path": "site-packages/pygments/styles/lovelace.py", + "path_type": "hardlink", + "sha256": "aadd021be148215c5f999a70fa9113670167800c0ca67abf19e480be6476e5a9", + "sha256_in_prefix": "aadd021be148215c5f999a70fa9113670167800c0ca67abf19e480be6476e5a9", + "size_in_bytes": 3178 + }, + { + "_path": "site-packages/pygments/styles/manni.py", + "path_type": "hardlink", + "sha256": "05385e7f0502512508e5f981daab4fa1b82e1a5ca834c624581160ee790dc930", + "sha256_in_prefix": "05385e7f0502512508e5f981daab4fa1b82e1a5ca834c624581160ee790dc930", + "size_in_bytes": 2443 + }, + { + "_path": "site-packages/pygments/styles/material.py", + "path_type": "hardlink", + "sha256": "f22ac35fd113a7d059dc896da112d83932dec5399acf4df57a2eeecafbb918da", + "sha256_in_prefix": "f22ac35fd113a7d059dc896da112d83932dec5399acf4df57a2eeecafbb918da", + "size_in_bytes": 4201 + }, + { + "_path": "site-packages/pygments/styles/monokai.py", + "path_type": "hardlink", + "sha256": "81318332736e2bc6475ea55c9792378a820595b8b03c3991cb5eeff867ada552", + "sha256_in_prefix": "81318332736e2bc6475ea55c9792378a820595b8b03c3991cb5eeff867ada552", + "size_in_bytes": 5184 + }, + { + "_path": "site-packages/pygments/styles/murphy.py", + "path_type": "hardlink", + "sha256": "244f5f06dfba305dc7e94118b442562bba7fb772f3e05bac49b9cfca736ee363", + "sha256_in_prefix": "244f5f06dfba305dc7e94118b442562bba7fb772f3e05bac49b9cfca736ee363", + "size_in_bytes": 2805 + }, + { + "_path": "site-packages/pygments/styles/native.py", + "path_type": "hardlink", + "sha256": "ad5056abec01836bc0780b3f8bf54d971816ce0f9e6d57e8ad35f37815f6268e", + "sha256_in_prefix": "ad5056abec01836bc0780b3f8bf54d971816ce0f9e6d57e8ad35f37815f6268e", + "size_in_bytes": 2043 + }, + { + "_path": "site-packages/pygments/styles/nord.py", + "path_type": "hardlink", + "sha256": "3bf9edd86acc2b93ac411d3c01ef70511cd9c796dc1b2b28c609966eaf3172a7", + "sha256_in_prefix": "3bf9edd86acc2b93ac411d3c01ef70511cd9c796dc1b2b28c609966eaf3172a7", + "size_in_bytes": 5391 + }, + { + "_path": "site-packages/pygments/styles/onedark.py", + "path_type": "hardlink", + "sha256": "e51aaf1167c4a85f28db0d0dffc97e53ea1f898497b47494ce4b57330028008a", + "sha256_in_prefix": "e51aaf1167c4a85f28db0d0dffc97e53ea1f898497b47494ce4b57330028008a", + "size_in_bytes": 1719 + }, + { + "_path": "site-packages/pygments/styles/paraiso_dark.py", + "path_type": "hardlink", + "sha256": "943779b9013bf70bc18469aba4b4b72889e9474b271715b00e6ff43b6c5398a6", + "sha256_in_prefix": "943779b9013bf70bc18469aba4b4b72889e9474b271715b00e6ff43b6c5398a6", + "size_in_bytes": 5662 + }, + { + "_path": "site-packages/pygments/styles/paraiso_light.py", + "path_type": "hardlink", + "sha256": "3f93e4953a8c50bea97281aa3aa58a065dbbb733cef7a11253e83af8aadd81a4", + "sha256_in_prefix": "3f93e4953a8c50bea97281aa3aa58a065dbbb733cef7a11253e83af8aadd81a4", + "size_in_bytes": 5668 + }, + { + "_path": "site-packages/pygments/styles/pastie.py", + "path_type": "hardlink", + "sha256": "75456839a8d60cbee01dbd8cd6c292bc8a6dd4d17202c11260f6917afb91556a", + "sha256_in_prefix": "75456839a8d60cbee01dbd8cd6c292bc8a6dd4d17202c11260f6917afb91556a", + "size_in_bytes": 2525 + }, + { + "_path": "site-packages/pygments/styles/perldoc.py", + "path_type": "hardlink", + "sha256": "a6d5942210377e163f6a7fd5bff3a5d22171768326066295982da3b09b2f95a9", + "sha256_in_prefix": "a6d5942210377e163f6a7fd5bff3a5d22171768326066295982da3b09b2f95a9", + "size_in_bytes": 2230 + }, + { + "_path": "site-packages/pygments/styles/rainbow_dash.py", + "path_type": "hardlink", + "sha256": "c2356cdfdd78233015db7767391e712c694ce14b82d6f0dde89e22a135a22436", + "sha256_in_prefix": "c2356cdfdd78233015db7767391e712c694ce14b82d6f0dde89e22a135a22436", + "size_in_bytes": 2540 + }, + { + "_path": "site-packages/pygments/styles/rrt.py", + "path_type": "hardlink", + "sha256": "53029e4dc604b44a4e47fa35e33b9d6a9a654f14f2057d433eac3623d454cb07", + "sha256_in_prefix": "53029e4dc604b44a4e47fa35e33b9d6a9a654f14f2057d433eac3623d454cb07", + "size_in_bytes": 964 + }, + { + "_path": "site-packages/pygments/styles/sas.py", + "path_type": "hardlink", + "sha256": "56729170956576ad8a96710ef2923b48539ab5b684e33d22d30ebfa99b4e53de", + "sha256_in_prefix": "56729170956576ad8a96710ef2923b48539ab5b684e33d22d30ebfa99b4e53de", + "size_in_bytes": 1440 + }, + { + "_path": "site-packages/pygments/styles/solarized.py", + "path_type": "hardlink", + "sha256": "9992c1ea08e7fd8fba2bfd2968d5495c8f656713daf47be440ca4144c498eb64", + "sha256_in_prefix": "9992c1ea08e7fd8fba2bfd2968d5495c8f656713daf47be440ca4144c498eb64", + "size_in_bytes": 4247 + }, + { + "_path": "site-packages/pygments/styles/staroffice.py", + "path_type": "hardlink", + "sha256": "44cf4a4ef33bc1179de4a5b8299f6705e29386b0dec6aa8b4b7667d8e87b1fab", + "sha256_in_prefix": "44cf4a4ef33bc1179de4a5b8299f6705e29386b0dec6aa8b4b7667d8e87b1fab", + "size_in_bytes": 831 + }, + { + "_path": "site-packages/pygments/styles/stata_dark.py", + "path_type": "hardlink", + "sha256": "3a0ce30c523435b1f896611ce12c5c7d4b103e1060921e4f875b09ff8c76f2d3", + "sha256_in_prefix": "3a0ce30c523435b1f896611ce12c5c7d4b103e1060921e4f875b09ff8c76f2d3", + "size_in_bytes": 1257 + }, + { + "_path": "site-packages/pygments/styles/stata_light.py", + "path_type": "hardlink", + "sha256": "65c7439cb873330cf7d478736f2f98f09fd400067404f3e0304ac7ab249103d4", + "sha256_in_prefix": "65c7439cb873330cf7d478736f2f98f09fd400067404f3e0304ac7ab249103d4", + "size_in_bytes": 1289 + }, + { + "_path": "site-packages/pygments/styles/tango.py", + "path_type": "hardlink", + "sha256": "ffde711a2529b8a20954d6f17e190f333c35f6fc1e2943df66c00f70804acfe9", + "sha256_in_prefix": "ffde711a2529b8a20954d6f17e190f333c35f6fc1e2943df66c00f70804acfe9", + "size_in_bytes": 7137 + }, + { + "_path": "site-packages/pygments/styles/trac.py", + "path_type": "hardlink", + "sha256": "f756e2ff38e81793387b436b17fa7bed891ad80e9f4849b1526755b3622e4503", + "sha256_in_prefix": "f756e2ff38e81793387b436b17fa7bed891ad80e9f4849b1526755b3622e4503", + "size_in_bytes": 1981 + }, + { + "_path": "site-packages/pygments/styles/vim.py", + "path_type": "hardlink", + "sha256": "ec333a6ee21ff724f2aafc8054628ca30f489e6977ae38a9699f51f0c6a29832", + "sha256_in_prefix": "ec333a6ee21ff724f2aafc8054628ca30f489e6977ae38a9699f51f0c6a29832", + "size_in_bytes": 2019 + }, + { + "_path": "site-packages/pygments/styles/vs.py", + "path_type": "hardlink", + "sha256": "c06220666ef31c111c53b30b99501e847f49c3fbb155fd465afa89b339f3ab57", + "sha256_in_prefix": "c06220666ef31c111c53b30b99501e847f49c3fbb155fd465afa89b339f3ab57", + "size_in_bytes": 1130 + }, + { + "_path": "site-packages/pygments/styles/xcode.py", + "path_type": "hardlink", + "sha256": "fa50d6f32de111770971e49dafd6cefd3555448c67fe141e55f070591ce453f4", + "sha256_in_prefix": "fa50d6f32de111770971e49dafd6cefd3555448c67fe141e55f070591ce453f4", + "size_in_bytes": 1504 + }, + { + "_path": "site-packages/pygments/styles/zenburn.py", + "path_type": "hardlink", + "sha256": "1e077e1c6782c1a35c0fe559fb06ec10bfe7bf6035d6e39756a1d7abe292cb79", + "sha256_in_prefix": "1e077e1c6782c1a35c0fe559fb06ec10bfe7bf6035d6e39756a1d7abe292cb79", + "size_in_bytes": 2203 + }, + { + "_path": "site-packages/pygments/token.py", + "path_type": "hardlink", + "sha256": "0d755070b50b567d392c6eb76da822a89776147dd4ce179550199d41e5e7d54f", + "sha256_in_prefix": "0d755070b50b567d392c6eb76da822a89776147dd4ce179550199d41e5e7d54f", + "size_in_bytes": 6226 + }, + { + "_path": "site-packages/pygments/unistring.py", + "path_type": "hardlink", + "sha256": "15a51f1b5e0d04910a2d0a18f6a8fa258797ae961c2e62ae96085dc4e18568e7", + "sha256_in_prefix": "15a51f1b5e0d04910a2d0a18f6a8fa258797ae961c2e62ae96085dc4e18568e7", + "size_in_bytes": 63223 + }, + { + "_path": "site-packages/pygments/util.py", + "path_type": "hardlink", + "sha256": "004558d2aa27cb210c82fe03a3674836baea500c149365d84aa1cceb9d2ecde9", + "sha256_in_prefix": "004558d2aa27cb210c82fe03a3674836baea500c149365d84aa1cceb9d2ecde9", + "size_in_bytes": 10230 + }, + { + "_path": "lib/python3.12/site-packages/pygments/__pycache__/__init__.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/__pycache__/__main__.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/__pycache__/cmdline.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/__pycache__/console.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/__pycache__/filter.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/filters/__pycache__/__init__.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/__pycache__/formatter.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/formatters/__pycache__/__init__.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/formatters/__pycache__/_mapping.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/formatters/__pycache__/bbcode.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/formatters/__pycache__/groff.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/formatters/__pycache__/html.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/formatters/__pycache__/img.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/formatters/__pycache__/irc.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/formatters/__pycache__/latex.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/formatters/__pycache__/other.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/formatters/__pycache__/pangomarkup.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/formatters/__pycache__/rtf.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/formatters/__pycache__/svg.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/formatters/__pycache__/terminal.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/formatters/__pycache__/terminal256.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/__pycache__/lexer.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/__init__.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/_ada_builtins.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/_asy_builtins.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/_cl_builtins.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/_cocoa_builtins.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/_csound_builtins.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/_css_builtins.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/_julia_builtins.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/_lasso_builtins.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/_lilypond_builtins.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/_lua_builtins.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/_mapping.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/_mql_builtins.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/_mysql_builtins.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/_openedge_builtins.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/_php_builtins.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/_postgres_builtins.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/_qlik_builtins.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/_scheme_builtins.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/_scilab_builtins.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/_sourcemod_builtins.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/_stan_builtins.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/_stata_builtins.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/_tsql_builtins.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/_usd_builtins.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/_vbscript_builtins.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/_vim_builtins.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/actionscript.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/ada.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/agile.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/algebra.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/ambient.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/amdgpu.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/ampl.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/apdlexer.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/apl.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/archetype.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/arrow.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/arturo.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/asc.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/asm.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/asn1.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/automation.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/bare.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/basic.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/bdd.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/berry.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/bibtex.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/blueprint.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/boa.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/bqn.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/business.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/c_cpp.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/c_like.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/capnproto.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/carbon.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/cddl.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/chapel.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/clean.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/comal.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/compiled.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/configs.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/console.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/cplint.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/crystal.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/csound.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/css.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/d.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/dalvik.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/data.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/dax.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/devicetree.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/diff.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/dns.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/dotnet.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/dsls.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/dylan.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/ecl.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/eiffel.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/elm.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/elpi.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/email.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/erlang.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/esoteric.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/ezhil.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/factor.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/fantom.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/felix.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/fift.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/floscript.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/forth.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/fortran.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/foxpro.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/freefem.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/func.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/functional.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/futhark.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/gcodelexer.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/gdscript.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/go.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/grammar_notation.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/graph.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/graphics.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/graphql.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/graphviz.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/gsql.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/haskell.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/haxe.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/hdl.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/hexdump.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/html.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/idl.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/igor.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/inferno.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/installers.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/int_fiction.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/iolang.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/j.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/javascript.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/jmespath.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/jslt.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/jsonnet.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/jsx.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/julia.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/jvm.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/kuin.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/kusto.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/ldap.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/lean.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/lilypond.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/lisp.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/macaulay2.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/make.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/markup.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/math.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/matlab.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/maxima.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/meson.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/mime.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/minecraft.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/mips.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/ml.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/modeling.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/modula2.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/monte.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/mosel.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/ncl.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/nimrod.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/nit.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/nix.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/oberon.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/objective.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/ooc.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/openscad.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/other.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/parasail.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/parsers.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/pascal.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/pawn.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/perl.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/phix.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/php.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/pointless.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/pony.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/praat.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/procfile.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/prolog.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/promql.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/prql.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/ptx.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/python.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/q.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/qlik.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/qvt.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/r.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/rdf.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/rebol.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/resource.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/ride.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/rita.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/rnc.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/roboconf.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/robotframework.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/ruby.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/rust.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/sas.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/savi.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/scdoc.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/scripting.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/sgf.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/shell.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/sieve.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/slash.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/smalltalk.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/smithy.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/smv.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/snobol.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/solidity.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/sophia.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/special.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/spice.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/sql.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/srcinfo.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/stata.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/supercollider.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/tal.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/tcl.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/teal.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/templates.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/teraterm.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/testing.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/text.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/textedit.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/textfmts.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/theorem.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/thingsdb.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/tlb.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/tls.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/tnt.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/trafficscript.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/typoscript.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/ul4.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/unicon.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/urbi.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/usd.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/varnish.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/verification.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/verifpal.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/vip.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/vyper.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/web.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/webassembly.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/webidl.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/webmisc.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/wgsl.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/whiley.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/wowtoc.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/wren.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/x10.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/xorg.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/yang.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/yara.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/lexers/__pycache__/zig.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/__pycache__/modeline.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/__pycache__/plugin.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/__pycache__/regexopt.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/__pycache__/scanner.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/__pycache__/sphinxext.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/__pycache__/style.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/styles/__pycache__/__init__.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/styles/__pycache__/_mapping.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/styles/__pycache__/abap.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/styles/__pycache__/algol.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/styles/__pycache__/algol_nu.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/styles/__pycache__/arduino.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/styles/__pycache__/autumn.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/styles/__pycache__/borland.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/styles/__pycache__/bw.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/styles/__pycache__/colorful.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/styles/__pycache__/default.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/styles/__pycache__/dracula.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/styles/__pycache__/emacs.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/styles/__pycache__/friendly.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/styles/__pycache__/friendly_grayscale.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/styles/__pycache__/fruity.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/styles/__pycache__/gh_dark.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/styles/__pycache__/gruvbox.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/styles/__pycache__/igor.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/styles/__pycache__/inkpot.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/styles/__pycache__/lightbulb.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/styles/__pycache__/lilypond.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/styles/__pycache__/lovelace.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/styles/__pycache__/manni.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/styles/__pycache__/material.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/styles/__pycache__/monokai.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/styles/__pycache__/murphy.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/styles/__pycache__/native.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/styles/__pycache__/nord.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/styles/__pycache__/onedark.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/styles/__pycache__/paraiso_dark.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/styles/__pycache__/paraiso_light.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/styles/__pycache__/pastie.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/styles/__pycache__/perldoc.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/styles/__pycache__/rainbow_dash.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/styles/__pycache__/rrt.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/styles/__pycache__/sas.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/styles/__pycache__/solarized.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/styles/__pycache__/staroffice.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/styles/__pycache__/stata_dark.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/styles/__pycache__/stata_light.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/styles/__pycache__/tango.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/styles/__pycache__/trac.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/styles/__pycache__/vim.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/styles/__pycache__/vs.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/styles/__pycache__/xcode.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/styles/__pycache__/zenburn.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/__pycache__/token.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/__pycache__/unistring.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/pygments/__pycache__/util.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "bin/pygmentize", + "path_type": "unix_python_entry_point" + } + ], + "paths_version": 1 + }, + "requested_spec": "None", + "sha256": "af5f8867450dc292f98ea387d4d8945fc574284677c8f60eaa9846ede7387257", + "size": 860425, + "subdir": "noarch", + "timestamp": 1700608076000, + "url": "https://conda.anaconda.org/conda-forge/noarch/pygments-2.17.2-pyhd8ed1ab_0.conda", + "version": "2.17.2" +} \ No newline at end of file diff --git a/crates/pet-conda/tests/unix/conda_envs/user_home/miniconda3/envs/env_python_3/conda-meta/python-3.12.2-hdf0ec26_0_cpython.json b/crates/pet-conda/tests/unix/conda_envs/user_home/miniconda3/envs/env_python_3/conda-meta/python-3.12.2-hdf0ec26_0_cpython.json new file mode 100644 index 00000000..7b6c566f --- /dev/null +++ b/crates/pet-conda/tests/unix/conda_envs/user_home/miniconda3/envs/env_python_3/conda-meta/python-3.12.2-hdf0ec26_0_cpython.json @@ -0,0 +1,15444 @@ +{ + "build": "hdf0ec26_0_cpython", + "build_number": 0, + "channel": "https://conda.anaconda.org/conda-forge/osx-arm64", + "constrains": [ + "python_abi 3.12.* *_cp312" + ], + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "libexpat >=2.5.0,<3.0a0", + "libffi >=3.4,<4.0a0", + "libsqlite >=3.45.1,<4.0a0", + "libzlib >=1.2.13,<1.3.0a0", + "ncurses >=6.4,<7.0a0", + "openssl >=3.2.1,<4.0a0", + "readline >=8.2,<9.0a0", + "tk >=8.6.13,<8.7.0a0", + "tzdata", + "xz >=5.2.6,<6.0a0", + "pip" + ], + "extracted_package_dir": "/Users/donjayamanne/miniconda3/pkgs/python-3.12.2-hdf0ec26_0_cpython", + "files": [ + "bin/2to3", + "bin/2to3-3.12", + "bin/idle3", + "bin/idle3.12", + "bin/pydoc", + "bin/pydoc3", + "bin/pydoc3.12", + "bin/python", + "bin/python3", + "bin/python3-config", + "bin/python3.1", + "bin/python3.12", + "bin/python3.12-config", + "include/python3.12/Python.h", + "include/python3.12/abstract.h", + "include/python3.12/bltinmodule.h", + "include/python3.12/boolobject.h", + "include/python3.12/bytearrayobject.h", + "include/python3.12/bytesobject.h", + "include/python3.12/ceval.h", + "include/python3.12/codecs.h", + "include/python3.12/compile.h", + "include/python3.12/complexobject.h", + "include/python3.12/cpython/abstract.h", + "include/python3.12/cpython/bytearrayobject.h", + "include/python3.12/cpython/bytesobject.h", + "include/python3.12/cpython/cellobject.h", + "include/python3.12/cpython/ceval.h", + "include/python3.12/cpython/classobject.h", + "include/python3.12/cpython/code.h", + "include/python3.12/cpython/compile.h", + "include/python3.12/cpython/complexobject.h", + "include/python3.12/cpython/context.h", + "include/python3.12/cpython/descrobject.h", + "include/python3.12/cpython/dictobject.h", + "include/python3.12/cpython/fileobject.h", + "include/python3.12/cpython/fileutils.h", + "include/python3.12/cpython/floatobject.h", + "include/python3.12/cpython/frameobject.h", + "include/python3.12/cpython/funcobject.h", + "include/python3.12/cpython/genobject.h", + "include/python3.12/cpython/import.h", + "include/python3.12/cpython/initconfig.h", + "include/python3.12/cpython/interpreteridobject.h", + "include/python3.12/cpython/listobject.h", + "include/python3.12/cpython/longintrepr.h", + "include/python3.12/cpython/longobject.h", + "include/python3.12/cpython/memoryobject.h", + "include/python3.12/cpython/methodobject.h", + "include/python3.12/cpython/modsupport.h", + "include/python3.12/cpython/object.h", + "include/python3.12/cpython/objimpl.h", + "include/python3.12/cpython/odictobject.h", + "include/python3.12/cpython/picklebufobject.h", + "include/python3.12/cpython/pthread_stubs.h", + "include/python3.12/cpython/pyctype.h", + "include/python3.12/cpython/pydebug.h", + "include/python3.12/cpython/pyerrors.h", + "include/python3.12/cpython/pyfpe.h", + "include/python3.12/cpython/pyframe.h", + "include/python3.12/cpython/pylifecycle.h", + "include/python3.12/cpython/pymem.h", + "include/python3.12/cpython/pystate.h", + "include/python3.12/cpython/pythonrun.h", + "include/python3.12/cpython/pythread.h", + "include/python3.12/cpython/pytime.h", + "include/python3.12/cpython/setobject.h", + "include/python3.12/cpython/sysmodule.h", + "include/python3.12/cpython/traceback.h", + "include/python3.12/cpython/tupleobject.h", + "include/python3.12/cpython/unicodeobject.h", + "include/python3.12/cpython/warnings.h", + "include/python3.12/cpython/weakrefobject.h", + "include/python3.12/datetime.h", + "include/python3.12/descrobject.h", + "include/python3.12/dictobject.h", + "include/python3.12/dynamic_annotations.h", + "include/python3.12/enumobject.h", + "include/python3.12/errcode.h", + "include/python3.12/exports.h", + "include/python3.12/fileobject.h", + "include/python3.12/fileutils.h", + "include/python3.12/floatobject.h", + "include/python3.12/frameobject.h", + "include/python3.12/genericaliasobject.h", + "include/python3.12/import.h", + "include/python3.12/internal/pycore_abstract.h", + "include/python3.12/internal/pycore_asdl.h", + "include/python3.12/internal/pycore_ast.h", + "include/python3.12/internal/pycore_ast_state.h", + "include/python3.12/internal/pycore_atexit.h", + "include/python3.12/internal/pycore_atomic.h", + "include/python3.12/internal/pycore_atomic_funcs.h", + "include/python3.12/internal/pycore_bitutils.h", + "include/python3.12/internal/pycore_blocks_output_buffer.h", + "include/python3.12/internal/pycore_bytes_methods.h", + "include/python3.12/internal/pycore_bytesobject.h", + "include/python3.12/internal/pycore_call.h", + "include/python3.12/internal/pycore_ceval.h", + "include/python3.12/internal/pycore_ceval_state.h", + "include/python3.12/internal/pycore_code.h", + "include/python3.12/internal/pycore_compile.h", + "include/python3.12/internal/pycore_condvar.h", + "include/python3.12/internal/pycore_context.h", + "include/python3.12/internal/pycore_descrobject.h", + "include/python3.12/internal/pycore_dict.h", + "include/python3.12/internal/pycore_dict_state.h", + "include/python3.12/internal/pycore_dtoa.h", + "include/python3.12/internal/pycore_emscripten_signal.h", + "include/python3.12/internal/pycore_exceptions.h", + "include/python3.12/internal/pycore_faulthandler.h", + "include/python3.12/internal/pycore_fileutils.h", + "include/python3.12/internal/pycore_fileutils_windows.h", + "include/python3.12/internal/pycore_floatobject.h", + "include/python3.12/internal/pycore_flowgraph.h", + "include/python3.12/internal/pycore_format.h", + "include/python3.12/internal/pycore_frame.h", + "include/python3.12/internal/pycore_function.h", + "include/python3.12/internal/pycore_gc.h", + "include/python3.12/internal/pycore_genobject.h", + "include/python3.12/internal/pycore_getopt.h", + "include/python3.12/internal/pycore_gil.h", + "include/python3.12/internal/pycore_global_objects.h", + "include/python3.12/internal/pycore_global_objects_fini_generated.h", + "include/python3.12/internal/pycore_global_strings.h", + "include/python3.12/internal/pycore_hamt.h", + "include/python3.12/internal/pycore_hashtable.h", + "include/python3.12/internal/pycore_import.h", + "include/python3.12/internal/pycore_initconfig.h", + "include/python3.12/internal/pycore_instruments.h", + "include/python3.12/internal/pycore_interp.h", + "include/python3.12/internal/pycore_intrinsics.h", + "include/python3.12/internal/pycore_list.h", + "include/python3.12/internal/pycore_long.h", + "include/python3.12/internal/pycore_memoryobject.h", + "include/python3.12/internal/pycore_moduleobject.h", + "include/python3.12/internal/pycore_namespace.h", + "include/python3.12/internal/pycore_object.h", + "include/python3.12/internal/pycore_object_state.h", + "include/python3.12/internal/pycore_obmalloc.h", + "include/python3.12/internal/pycore_obmalloc_init.h", + "include/python3.12/internal/pycore_opcode.h", + "include/python3.12/internal/pycore_opcode_utils.h", + "include/python3.12/internal/pycore_parser.h", + "include/python3.12/internal/pycore_pathconfig.h", + "include/python3.12/internal/pycore_pyarena.h", + "include/python3.12/internal/pycore_pyerrors.h", + "include/python3.12/internal/pycore_pyhash.h", + "include/python3.12/internal/pycore_pylifecycle.h", + "include/python3.12/internal/pycore_pymath.h", + "include/python3.12/internal/pycore_pymem.h", + "include/python3.12/internal/pycore_pymem_init.h", + "include/python3.12/internal/pycore_pystate.h", + "include/python3.12/internal/pycore_pythread.h", + "include/python3.12/internal/pycore_range.h", + "include/python3.12/internal/pycore_runtime.h", + "include/python3.12/internal/pycore_runtime_init.h", + "include/python3.12/internal/pycore_runtime_init_generated.h", + "include/python3.12/internal/pycore_signal.h", + "include/python3.12/internal/pycore_sliceobject.h", + "include/python3.12/internal/pycore_strhex.h", + "include/python3.12/internal/pycore_structseq.h", + "include/python3.12/internal/pycore_symtable.h", + "include/python3.12/internal/pycore_sysmodule.h", + "include/python3.12/internal/pycore_time.h", + "include/python3.12/internal/pycore_token.h", + "include/python3.12/internal/pycore_traceback.h", + "include/python3.12/internal/pycore_tracemalloc.h", + "include/python3.12/internal/pycore_tuple.h", + "include/python3.12/internal/pycore_typeobject.h", + "include/python3.12/internal/pycore_typevarobject.h", + "include/python3.12/internal/pycore_ucnhash.h", + "include/python3.12/internal/pycore_unicodeobject.h", + "include/python3.12/internal/pycore_unicodeobject_generated.h", + "include/python3.12/internal/pycore_unionobject.h", + "include/python3.12/internal/pycore_warnings.h", + "include/python3.12/interpreteridobject.h", + "include/python3.12/intrcheck.h", + "include/python3.12/iterobject.h", + "include/python3.12/listobject.h", + "include/python3.12/longobject.h", + "include/python3.12/marshal.h", + "include/python3.12/memoryobject.h", + "include/python3.12/methodobject.h", + "include/python3.12/modsupport.h", + "include/python3.12/moduleobject.h", + "include/python3.12/object.h", + "include/python3.12/objimpl.h", + "include/python3.12/opcode.h", + "include/python3.12/osdefs.h", + "include/python3.12/osmodule.h", + "include/python3.12/patchlevel.h", + "include/python3.12/py_curses.h", + "include/python3.12/pybuffer.h", + "include/python3.12/pycapsule.h", + "include/python3.12/pyconfig.h", + "include/python3.12/pydtrace.h", + "include/python3.12/pyerrors.h", + "include/python3.12/pyexpat.h", + "include/python3.12/pyframe.h", + "include/python3.12/pyhash.h", + "include/python3.12/pylifecycle.h", + "include/python3.12/pymacconfig.h", + "include/python3.12/pymacro.h", + "include/python3.12/pymath.h", + "include/python3.12/pymem.h", + "include/python3.12/pyport.h", + "include/python3.12/pystate.h", + "include/python3.12/pystats.h", + "include/python3.12/pystrcmp.h", + "include/python3.12/pystrtod.h", + "include/python3.12/pythonrun.h", + "include/python3.12/pythread.h", + "include/python3.12/pytypedefs.h", + "include/python3.12/rangeobject.h", + "include/python3.12/setobject.h", + "include/python3.12/sliceobject.h", + "include/python3.12/structmember.h", + "include/python3.12/structseq.h", + "include/python3.12/sysmodule.h", + "include/python3.12/traceback.h", + "include/python3.12/tracemalloc.h", + "include/python3.12/tupleobject.h", + "include/python3.12/typeslots.h", + "include/python3.12/unicodeobject.h", + "include/python3.12/warnings.h", + "include/python3.12/weakrefobject.h", + "lib/libpython3.12.dylib", + "lib/pkgconfig/python-3.12-embed.pc", + "lib/pkgconfig/python-3.12.pc", + "lib/pkgconfig/python3-embed.pc", + "lib/pkgconfig/python3.pc", + "lib/python3.1", + "lib/python3.12/LICENSE.txt", + "lib/python3.12/__future__.py", + "lib/python3.12/__hello__.py", + "lib/python3.12/__phello__/__init__.py", + "lib/python3.12/__phello__/__pycache__/__init__.cpython-312.pyc", + "lib/python3.12/__phello__/__pycache__/spam.cpython-312.pyc", + "lib/python3.12/__phello__/spam.py", + "lib/python3.12/__pycache__/__future__.cpython-312.pyc", + "lib/python3.12/__pycache__/__hello__.cpython-312.pyc", + "lib/python3.12/__pycache__/_aix_support.cpython-312.pyc", + "lib/python3.12/__pycache__/_collections_abc.cpython-312.pyc", + "lib/python3.12/__pycache__/_compat_pickle.cpython-312.pyc", + "lib/python3.12/__pycache__/_compression.cpython-312.pyc", + "lib/python3.12/__pycache__/_markupbase.cpython-312.pyc", + "lib/python3.12/__pycache__/_osx_support.cpython-312.pyc", + "lib/python3.12/__pycache__/_py_abc.cpython-312.pyc", + "lib/python3.12/__pycache__/_pydatetime.cpython-312.pyc", + "lib/python3.12/__pycache__/_pydecimal.cpython-312.pyc", + "lib/python3.12/__pycache__/_pyio.cpython-312.pyc", + "lib/python3.12/__pycache__/_pylong.cpython-312.pyc", + "lib/python3.12/__pycache__/_sitebuiltins.cpython-312.pyc", + "lib/python3.12/__pycache__/_strptime.cpython-312.pyc", + "lib/python3.12/__pycache__/_sysconfigdata__darwin_darwin.cpython-312.pyc", + "lib/python3.12/__pycache__/_sysconfigdata_arm64_apple_darwin20_0_0.cpython-312.pyc", + "lib/python3.12/__pycache__/_threading_local.cpython-312.pyc", + "lib/python3.12/__pycache__/_weakrefset.cpython-312.pyc", + "lib/python3.12/__pycache__/abc.cpython-312.pyc", + "lib/python3.12/__pycache__/aifc.cpython-312.pyc", + "lib/python3.12/__pycache__/antigravity.cpython-312.pyc", + "lib/python3.12/__pycache__/argparse.cpython-312.pyc", + "lib/python3.12/__pycache__/ast.cpython-312.pyc", + "lib/python3.12/__pycache__/base64.cpython-312.pyc", + "lib/python3.12/__pycache__/bdb.cpython-312.pyc", + "lib/python3.12/__pycache__/bisect.cpython-312.pyc", + "lib/python3.12/__pycache__/bz2.cpython-312.pyc", + "lib/python3.12/__pycache__/cProfile.cpython-312.pyc", + "lib/python3.12/__pycache__/calendar.cpython-312.pyc", + "lib/python3.12/__pycache__/cgi.cpython-312.pyc", + "lib/python3.12/__pycache__/cgitb.cpython-312.pyc", + "lib/python3.12/__pycache__/chunk.cpython-312.pyc", + "lib/python3.12/__pycache__/cmd.cpython-312.pyc", + "lib/python3.12/__pycache__/code.cpython-312.pyc", + "lib/python3.12/__pycache__/codecs.cpython-312.pyc", + "lib/python3.12/__pycache__/codeop.cpython-312.pyc", + "lib/python3.12/__pycache__/colorsys.cpython-312.pyc", + "lib/python3.12/__pycache__/compileall.cpython-312.pyc", + "lib/python3.12/__pycache__/configparser.cpython-312.pyc", + "lib/python3.12/__pycache__/contextlib.cpython-312.pyc", + "lib/python3.12/__pycache__/contextvars.cpython-312.pyc", + "lib/python3.12/__pycache__/copy.cpython-312.pyc", + "lib/python3.12/__pycache__/copyreg.cpython-312.pyc", + "lib/python3.12/__pycache__/crypt.cpython-312.pyc", + "lib/python3.12/__pycache__/csv.cpython-312.pyc", + "lib/python3.12/__pycache__/dataclasses.cpython-312.pyc", + "lib/python3.12/__pycache__/datetime.cpython-312.pyc", + "lib/python3.12/__pycache__/decimal.cpython-312.pyc", + "lib/python3.12/__pycache__/difflib.cpython-312.pyc", + "lib/python3.12/__pycache__/dis.cpython-312.pyc", + "lib/python3.12/__pycache__/doctest.cpython-312.pyc", + "lib/python3.12/__pycache__/enum.cpython-312.pyc", + "lib/python3.12/__pycache__/filecmp.cpython-312.pyc", + "lib/python3.12/__pycache__/fileinput.cpython-312.pyc", + "lib/python3.12/__pycache__/fnmatch.cpython-312.pyc", + "lib/python3.12/__pycache__/fractions.cpython-312.pyc", + "lib/python3.12/__pycache__/ftplib.cpython-312.pyc", + "lib/python3.12/__pycache__/functools.cpython-312.pyc", + "lib/python3.12/__pycache__/genericpath.cpython-312.pyc", + "lib/python3.12/__pycache__/getopt.cpython-312.pyc", + "lib/python3.12/__pycache__/getpass.cpython-312.pyc", + "lib/python3.12/__pycache__/gettext.cpython-312.pyc", + "lib/python3.12/__pycache__/glob.cpython-312.pyc", + "lib/python3.12/__pycache__/graphlib.cpython-312.pyc", + "lib/python3.12/__pycache__/gzip.cpython-312.pyc", + "lib/python3.12/__pycache__/hashlib.cpython-312.pyc", + "lib/python3.12/__pycache__/heapq.cpython-312.pyc", + "lib/python3.12/__pycache__/hmac.cpython-312.pyc", + "lib/python3.12/__pycache__/imaplib.cpython-312.pyc", + "lib/python3.12/__pycache__/imghdr.cpython-312.pyc", + "lib/python3.12/__pycache__/inspect.cpython-312.pyc", + "lib/python3.12/__pycache__/io.cpython-312.pyc", + "lib/python3.12/__pycache__/ipaddress.cpython-312.pyc", + "lib/python3.12/__pycache__/keyword.cpython-312.pyc", + "lib/python3.12/__pycache__/linecache.cpython-312.pyc", + "lib/python3.12/__pycache__/locale.cpython-312.pyc", + "lib/python3.12/__pycache__/lzma.cpython-312.pyc", + "lib/python3.12/__pycache__/mailbox.cpython-312.pyc", + "lib/python3.12/__pycache__/mailcap.cpython-312.pyc", + "lib/python3.12/__pycache__/mimetypes.cpython-312.pyc", + "lib/python3.12/__pycache__/modulefinder.cpython-312.pyc", + "lib/python3.12/__pycache__/netrc.cpython-312.pyc", + "lib/python3.12/__pycache__/nntplib.cpython-312.pyc", + "lib/python3.12/__pycache__/ntpath.cpython-312.pyc", + "lib/python3.12/__pycache__/nturl2path.cpython-312.pyc", + "lib/python3.12/__pycache__/numbers.cpython-312.pyc", + "lib/python3.12/__pycache__/opcode.cpython-312.pyc", + "lib/python3.12/__pycache__/operator.cpython-312.pyc", + "lib/python3.12/__pycache__/optparse.cpython-312.pyc", + "lib/python3.12/__pycache__/os.cpython-312.pyc", + "lib/python3.12/__pycache__/pathlib.cpython-312.pyc", + "lib/python3.12/__pycache__/pdb.cpython-312.pyc", + "lib/python3.12/__pycache__/pickle.cpython-312.pyc", + "lib/python3.12/__pycache__/pickletools.cpython-312.pyc", + "lib/python3.12/__pycache__/pipes.cpython-312.pyc", + "lib/python3.12/__pycache__/pkgutil.cpython-312.pyc", + "lib/python3.12/__pycache__/platform.cpython-312.pyc", + "lib/python3.12/__pycache__/plistlib.cpython-312.pyc", + "lib/python3.12/__pycache__/poplib.cpython-312.pyc", + "lib/python3.12/__pycache__/posixpath.cpython-312.pyc", + "lib/python3.12/__pycache__/pprint.cpython-312.pyc", + "lib/python3.12/__pycache__/profile.cpython-312.pyc", + "lib/python3.12/__pycache__/pstats.cpython-312.pyc", + "lib/python3.12/__pycache__/pty.cpython-312.pyc", + "lib/python3.12/__pycache__/py_compile.cpython-312.pyc", + "lib/python3.12/__pycache__/pyclbr.cpython-312.pyc", + "lib/python3.12/__pycache__/pydoc.cpython-312.pyc", + "lib/python3.12/__pycache__/queue.cpython-312.pyc", + "lib/python3.12/__pycache__/quopri.cpython-312.pyc", + "lib/python3.12/__pycache__/random.cpython-312.pyc", + "lib/python3.12/__pycache__/reprlib.cpython-312.pyc", + "lib/python3.12/__pycache__/rlcompleter.cpython-312.pyc", + "lib/python3.12/__pycache__/runpy.cpython-312.pyc", + "lib/python3.12/__pycache__/sched.cpython-312.pyc", + "lib/python3.12/__pycache__/secrets.cpython-312.pyc", + "lib/python3.12/__pycache__/selectors.cpython-312.pyc", + "lib/python3.12/__pycache__/shelve.cpython-312.pyc", + "lib/python3.12/__pycache__/shlex.cpython-312.pyc", + "lib/python3.12/__pycache__/shutil.cpython-312.pyc", + "lib/python3.12/__pycache__/signal.cpython-312.pyc", + "lib/python3.12/__pycache__/site.cpython-312.pyc", + "lib/python3.12/__pycache__/smtplib.cpython-312.pyc", + "lib/python3.12/__pycache__/sndhdr.cpython-312.pyc", + "lib/python3.12/__pycache__/socket.cpython-312.pyc", + "lib/python3.12/__pycache__/socketserver.cpython-312.pyc", + "lib/python3.12/__pycache__/sre_compile.cpython-312.pyc", + "lib/python3.12/__pycache__/sre_constants.cpython-312.pyc", + "lib/python3.12/__pycache__/sre_parse.cpython-312.pyc", + "lib/python3.12/__pycache__/ssl.cpython-312.pyc", + "lib/python3.12/__pycache__/stat.cpython-312.pyc", + "lib/python3.12/__pycache__/statistics.cpython-312.pyc", + "lib/python3.12/__pycache__/string.cpython-312.pyc", + "lib/python3.12/__pycache__/stringprep.cpython-312.pyc", + "lib/python3.12/__pycache__/struct.cpython-312.pyc", + "lib/python3.12/__pycache__/subprocess.cpython-312.pyc", + "lib/python3.12/__pycache__/sunau.cpython-312.pyc", + "lib/python3.12/__pycache__/symtable.cpython-312.pyc", + "lib/python3.12/__pycache__/sysconfig.cpython-312.pyc", + "lib/python3.12/__pycache__/tabnanny.cpython-312.pyc", + "lib/python3.12/__pycache__/tarfile.cpython-312.pyc", + "lib/python3.12/__pycache__/telnetlib.cpython-312.pyc", + "lib/python3.12/__pycache__/tempfile.cpython-312.pyc", + "lib/python3.12/__pycache__/textwrap.cpython-312.pyc", + "lib/python3.12/__pycache__/this.cpython-312.pyc", + "lib/python3.12/__pycache__/threading.cpython-312.pyc", + "lib/python3.12/__pycache__/timeit.cpython-312.pyc", + "lib/python3.12/__pycache__/token.cpython-312.pyc", + "lib/python3.12/__pycache__/tokenize.cpython-312.pyc", + "lib/python3.12/__pycache__/trace.cpython-312.pyc", + "lib/python3.12/__pycache__/traceback.cpython-312.pyc", + "lib/python3.12/__pycache__/tracemalloc.cpython-312.pyc", + "lib/python3.12/__pycache__/tty.cpython-312.pyc", + "lib/python3.12/__pycache__/turtle.cpython-312.pyc", + "lib/python3.12/__pycache__/types.cpython-312.pyc", + "lib/python3.12/__pycache__/typing.cpython-312.pyc", + "lib/python3.12/__pycache__/uu.cpython-312.pyc", + "lib/python3.12/__pycache__/uuid.cpython-312.pyc", + "lib/python3.12/__pycache__/warnings.cpython-312.pyc", + "lib/python3.12/__pycache__/wave.cpython-312.pyc", + "lib/python3.12/__pycache__/weakref.cpython-312.pyc", + "lib/python3.12/__pycache__/webbrowser.cpython-312.pyc", + "lib/python3.12/__pycache__/xdrlib.cpython-312.pyc", + "lib/python3.12/__pycache__/zipapp.cpython-312.pyc", + "lib/python3.12/__pycache__/zipimport.cpython-312.pyc", + "lib/python3.12/_aix_support.py", + "lib/python3.12/_collections_abc.py", + "lib/python3.12/_compat_pickle.py", + "lib/python3.12/_compression.py", + "lib/python3.12/_markupbase.py", + "lib/python3.12/_osx_support.py", + "lib/python3.12/_py_abc.py", + "lib/python3.12/_pydatetime.py", + "lib/python3.12/_pydecimal.py", + "lib/python3.12/_pyio.py", + "lib/python3.12/_pylong.py", + "lib/python3.12/_sitebuiltins.py", + "lib/python3.12/_strptime.py", + "lib/python3.12/_sysconfigdata__darwin_darwin.py", + "lib/python3.12/_sysconfigdata__darwin_darwin.py.orig", + "lib/python3.12/_sysconfigdata_arm64_apple_darwin20_0_0.py", + "lib/python3.12/_threading_local.py", + "lib/python3.12/_weakrefset.py", + "lib/python3.12/abc.py", + "lib/python3.12/aifc.py", + "lib/python3.12/antigravity.py", + "lib/python3.12/argparse.py", + "lib/python3.12/ast.py", + "lib/python3.12/asyncio/__init__.py", + "lib/python3.12/asyncio/__main__.py", + "lib/python3.12/asyncio/__pycache__/__init__.cpython-312.pyc", + "lib/python3.12/asyncio/__pycache__/__main__.cpython-312.pyc", + "lib/python3.12/asyncio/__pycache__/base_events.cpython-312.pyc", + "lib/python3.12/asyncio/__pycache__/base_futures.cpython-312.pyc", + "lib/python3.12/asyncio/__pycache__/base_subprocess.cpython-312.pyc", + "lib/python3.12/asyncio/__pycache__/base_tasks.cpython-312.pyc", + "lib/python3.12/asyncio/__pycache__/constants.cpython-312.pyc", + "lib/python3.12/asyncio/__pycache__/coroutines.cpython-312.pyc", + "lib/python3.12/asyncio/__pycache__/events.cpython-312.pyc", + "lib/python3.12/asyncio/__pycache__/exceptions.cpython-312.pyc", + "lib/python3.12/asyncio/__pycache__/format_helpers.cpython-312.pyc", + "lib/python3.12/asyncio/__pycache__/futures.cpython-312.pyc", + "lib/python3.12/asyncio/__pycache__/locks.cpython-312.pyc", + "lib/python3.12/asyncio/__pycache__/log.cpython-312.pyc", + "lib/python3.12/asyncio/__pycache__/mixins.cpython-312.pyc", + "lib/python3.12/asyncio/__pycache__/proactor_events.cpython-312.pyc", + "lib/python3.12/asyncio/__pycache__/protocols.cpython-312.pyc", + "lib/python3.12/asyncio/__pycache__/queues.cpython-312.pyc", + "lib/python3.12/asyncio/__pycache__/runners.cpython-312.pyc", + "lib/python3.12/asyncio/__pycache__/selector_events.cpython-312.pyc", + "lib/python3.12/asyncio/__pycache__/sslproto.cpython-312.pyc", + "lib/python3.12/asyncio/__pycache__/staggered.cpython-312.pyc", + "lib/python3.12/asyncio/__pycache__/streams.cpython-312.pyc", + "lib/python3.12/asyncio/__pycache__/subprocess.cpython-312.pyc", + "lib/python3.12/asyncio/__pycache__/taskgroups.cpython-312.pyc", + "lib/python3.12/asyncio/__pycache__/tasks.cpython-312.pyc", + "lib/python3.12/asyncio/__pycache__/threads.cpython-312.pyc", + "lib/python3.12/asyncio/__pycache__/timeouts.cpython-312.pyc", + "lib/python3.12/asyncio/__pycache__/transports.cpython-312.pyc", + "lib/python3.12/asyncio/__pycache__/trsock.cpython-312.pyc", + "lib/python3.12/asyncio/__pycache__/unix_events.cpython-312.pyc", + "lib/python3.12/asyncio/__pycache__/windows_events.cpython-312.pyc", + "lib/python3.12/asyncio/__pycache__/windows_utils.cpython-312.pyc", + "lib/python3.12/asyncio/base_events.py", + "lib/python3.12/asyncio/base_futures.py", + "lib/python3.12/asyncio/base_subprocess.py", + "lib/python3.12/asyncio/base_tasks.py", + "lib/python3.12/asyncio/constants.py", + "lib/python3.12/asyncio/coroutines.py", + "lib/python3.12/asyncio/events.py", + "lib/python3.12/asyncio/exceptions.py", + "lib/python3.12/asyncio/format_helpers.py", + "lib/python3.12/asyncio/futures.py", + "lib/python3.12/asyncio/locks.py", + "lib/python3.12/asyncio/log.py", + "lib/python3.12/asyncio/mixins.py", + "lib/python3.12/asyncio/proactor_events.py", + "lib/python3.12/asyncio/protocols.py", + "lib/python3.12/asyncio/queues.py", + "lib/python3.12/asyncio/runners.py", + "lib/python3.12/asyncio/selector_events.py", + "lib/python3.12/asyncio/sslproto.py", + "lib/python3.12/asyncio/staggered.py", + "lib/python3.12/asyncio/streams.py", + "lib/python3.12/asyncio/subprocess.py", + "lib/python3.12/asyncio/taskgroups.py", + "lib/python3.12/asyncio/tasks.py", + "lib/python3.12/asyncio/threads.py", + "lib/python3.12/asyncio/timeouts.py", + "lib/python3.12/asyncio/transports.py", + "lib/python3.12/asyncio/trsock.py", + "lib/python3.12/asyncio/unix_events.py", + "lib/python3.12/asyncio/windows_events.py", + "lib/python3.12/asyncio/windows_utils.py", + "lib/python3.12/base64.py", + "lib/python3.12/bdb.py", + "lib/python3.12/bisect.py", + "lib/python3.12/bz2.py", + "lib/python3.12/cProfile.py", + "lib/python3.12/calendar.py", + "lib/python3.12/cgi.py", + "lib/python3.12/cgitb.py", + "lib/python3.12/chunk.py", + "lib/python3.12/cmd.py", + "lib/python3.12/code.py", + "lib/python3.12/codecs.py", + "lib/python3.12/codeop.py", + "lib/python3.12/collections/__init__.py", + "lib/python3.12/collections/__pycache__/__init__.cpython-312.pyc", + "lib/python3.12/collections/__pycache__/abc.cpython-312.pyc", + "lib/python3.12/collections/abc.py", + "lib/python3.12/colorsys.py", + "lib/python3.12/compileall.py", + "lib/python3.12/concurrent/__init__.py", + "lib/python3.12/concurrent/__pycache__/__init__.cpython-312.pyc", + "lib/python3.12/concurrent/futures/__init__.py", + "lib/python3.12/concurrent/futures/__pycache__/__init__.cpython-312.pyc", + "lib/python3.12/concurrent/futures/__pycache__/_base.cpython-312.pyc", + "lib/python3.12/concurrent/futures/__pycache__/process.cpython-312.pyc", + "lib/python3.12/concurrent/futures/__pycache__/thread.cpython-312.pyc", + "lib/python3.12/concurrent/futures/_base.py", + "lib/python3.12/concurrent/futures/process.py", + "lib/python3.12/concurrent/futures/thread.py", + "lib/python3.12/config-3.12-darwin/Makefile", + "lib/python3.12/config-3.12-darwin/Setup", + "lib/python3.12/config-3.12-darwin/Setup.bootstrap", + "lib/python3.12/config-3.12-darwin/Setup.local", + "lib/python3.12/config-3.12-darwin/Setup.stdlib", + "lib/python3.12/config-3.12-darwin/__pycache__/python-config.cpython-312.pyc", + "lib/python3.12/config-3.12-darwin/config.c", + "lib/python3.12/config-3.12-darwin/config.c.in", + "lib/python3.12/config-3.12-darwin/install-sh", + "lib/python3.12/config-3.12-darwin/makesetup", + "lib/python3.12/config-3.12-darwin/python-config.py", + "lib/python3.12/config-3.12-darwin/python.o", + "lib/python3.12/configparser.py", + "lib/python3.12/contextlib.py", + "lib/python3.12/contextvars.py", + "lib/python3.12/copy.py", + "lib/python3.12/copyreg.py", + "lib/python3.12/crypt.py", + "lib/python3.12/csv.py", + "lib/python3.12/ctypes/__init__.py", + "lib/python3.12/ctypes/__pycache__/__init__.cpython-312.pyc", + "lib/python3.12/ctypes/__pycache__/_aix.cpython-312.pyc", + "lib/python3.12/ctypes/__pycache__/_endian.cpython-312.pyc", + "lib/python3.12/ctypes/__pycache__/util.cpython-312.pyc", + "lib/python3.12/ctypes/__pycache__/wintypes.cpython-312.pyc", + "lib/python3.12/ctypes/_aix.py", + "lib/python3.12/ctypes/_endian.py", + "lib/python3.12/ctypes/macholib/README.ctypes", + "lib/python3.12/ctypes/macholib/__init__.py", + "lib/python3.12/ctypes/macholib/__pycache__/__init__.cpython-312.pyc", + "lib/python3.12/ctypes/macholib/__pycache__/dyld.cpython-312.pyc", + "lib/python3.12/ctypes/macholib/__pycache__/dylib.cpython-312.pyc", + "lib/python3.12/ctypes/macholib/__pycache__/framework.cpython-312.pyc", + "lib/python3.12/ctypes/macholib/dyld.py", + "lib/python3.12/ctypes/macholib/dylib.py", + "lib/python3.12/ctypes/macholib/fetch_macholib", + "lib/python3.12/ctypes/macholib/fetch_macholib.bat", + "lib/python3.12/ctypes/macholib/framework.py", + "lib/python3.12/ctypes/util.py", + "lib/python3.12/ctypes/wintypes.py", + "lib/python3.12/curses/__init__.py", + "lib/python3.12/curses/__pycache__/__init__.cpython-312.pyc", + "lib/python3.12/curses/__pycache__/ascii.cpython-312.pyc", + "lib/python3.12/curses/__pycache__/has_key.cpython-312.pyc", + "lib/python3.12/curses/__pycache__/panel.cpython-312.pyc", + "lib/python3.12/curses/__pycache__/textpad.cpython-312.pyc", + "lib/python3.12/curses/ascii.py", + "lib/python3.12/curses/has_key.py", + "lib/python3.12/curses/panel.py", + "lib/python3.12/curses/textpad.py", + "lib/python3.12/dataclasses.py", + "lib/python3.12/datetime.py", + "lib/python3.12/dbm/__init__.py", + "lib/python3.12/dbm/__pycache__/__init__.cpython-312.pyc", + "lib/python3.12/dbm/__pycache__/dumb.cpython-312.pyc", + "lib/python3.12/dbm/__pycache__/gnu.cpython-312.pyc", + "lib/python3.12/dbm/__pycache__/ndbm.cpython-312.pyc", + "lib/python3.12/dbm/dumb.py", + "lib/python3.12/dbm/gnu.py", + "lib/python3.12/dbm/ndbm.py", + "lib/python3.12/decimal.py", + "lib/python3.12/difflib.py", + "lib/python3.12/dis.py", + "lib/python3.12/doctest.py", + "lib/python3.12/email/__init__.py", + "lib/python3.12/email/__pycache__/__init__.cpython-312.pyc", + "lib/python3.12/email/__pycache__/_encoded_words.cpython-312.pyc", + "lib/python3.12/email/__pycache__/_header_value_parser.cpython-312.pyc", + "lib/python3.12/email/__pycache__/_parseaddr.cpython-312.pyc", + "lib/python3.12/email/__pycache__/_policybase.cpython-312.pyc", + "lib/python3.12/email/__pycache__/base64mime.cpython-312.pyc", + "lib/python3.12/email/__pycache__/charset.cpython-312.pyc", + "lib/python3.12/email/__pycache__/contentmanager.cpython-312.pyc", + "lib/python3.12/email/__pycache__/encoders.cpython-312.pyc", + "lib/python3.12/email/__pycache__/errors.cpython-312.pyc", + "lib/python3.12/email/__pycache__/feedparser.cpython-312.pyc", + "lib/python3.12/email/__pycache__/generator.cpython-312.pyc", + "lib/python3.12/email/__pycache__/header.cpython-312.pyc", + "lib/python3.12/email/__pycache__/headerregistry.cpython-312.pyc", + "lib/python3.12/email/__pycache__/iterators.cpython-312.pyc", + "lib/python3.12/email/__pycache__/message.cpython-312.pyc", + "lib/python3.12/email/__pycache__/parser.cpython-312.pyc", + "lib/python3.12/email/__pycache__/policy.cpython-312.pyc", + "lib/python3.12/email/__pycache__/quoprimime.cpython-312.pyc", + "lib/python3.12/email/__pycache__/utils.cpython-312.pyc", + "lib/python3.12/email/_encoded_words.py", + "lib/python3.12/email/_header_value_parser.py", + "lib/python3.12/email/_parseaddr.py", + "lib/python3.12/email/_policybase.py", + "lib/python3.12/email/architecture.rst", + "lib/python3.12/email/base64mime.py", + "lib/python3.12/email/charset.py", + "lib/python3.12/email/contentmanager.py", + "lib/python3.12/email/encoders.py", + "lib/python3.12/email/errors.py", + "lib/python3.12/email/feedparser.py", + "lib/python3.12/email/generator.py", + "lib/python3.12/email/header.py", + "lib/python3.12/email/headerregistry.py", + "lib/python3.12/email/iterators.py", + "lib/python3.12/email/message.py", + "lib/python3.12/email/mime/__init__.py", + "lib/python3.12/email/mime/__pycache__/__init__.cpython-312.pyc", + "lib/python3.12/email/mime/__pycache__/application.cpython-312.pyc", + "lib/python3.12/email/mime/__pycache__/audio.cpython-312.pyc", + "lib/python3.12/email/mime/__pycache__/base.cpython-312.pyc", + "lib/python3.12/email/mime/__pycache__/image.cpython-312.pyc", + "lib/python3.12/email/mime/__pycache__/message.cpython-312.pyc", + "lib/python3.12/email/mime/__pycache__/multipart.cpython-312.pyc", + "lib/python3.12/email/mime/__pycache__/nonmultipart.cpython-312.pyc", + "lib/python3.12/email/mime/__pycache__/text.cpython-312.pyc", + "lib/python3.12/email/mime/application.py", + "lib/python3.12/email/mime/audio.py", + "lib/python3.12/email/mime/base.py", + "lib/python3.12/email/mime/image.py", + "lib/python3.12/email/mime/message.py", + "lib/python3.12/email/mime/multipart.py", + "lib/python3.12/email/mime/nonmultipart.py", + "lib/python3.12/email/mime/text.py", + "lib/python3.12/email/parser.py", + "lib/python3.12/email/policy.py", + "lib/python3.12/email/quoprimime.py", + "lib/python3.12/email/utils.py", + "lib/python3.12/encodings/__init__.py", + "lib/python3.12/encodings/__pycache__/__init__.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/aliases.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/ascii.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/base64_codec.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/big5.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/big5hkscs.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/bz2_codec.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/charmap.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/cp037.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/cp1006.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/cp1026.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/cp1125.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/cp1140.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/cp1250.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/cp1251.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/cp1252.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/cp1253.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/cp1254.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/cp1255.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/cp1256.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/cp1257.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/cp1258.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/cp273.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/cp424.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/cp437.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/cp500.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/cp720.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/cp737.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/cp775.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/cp850.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/cp852.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/cp855.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/cp856.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/cp857.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/cp858.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/cp860.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/cp861.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/cp862.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/cp863.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/cp864.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/cp865.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/cp866.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/cp869.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/cp874.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/cp875.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/cp932.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/cp949.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/cp950.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/euc_jis_2004.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/euc_jisx0213.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/euc_jp.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/euc_kr.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/gb18030.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/gb2312.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/gbk.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/hex_codec.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/hp_roman8.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/hz.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/idna.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/iso2022_jp.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/iso2022_jp_1.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/iso2022_jp_2.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/iso2022_jp_2004.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/iso2022_jp_3.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/iso2022_jp_ext.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/iso2022_kr.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/iso8859_1.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/iso8859_10.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/iso8859_11.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/iso8859_13.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/iso8859_14.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/iso8859_15.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/iso8859_16.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/iso8859_2.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/iso8859_3.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/iso8859_4.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/iso8859_5.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/iso8859_6.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/iso8859_7.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/iso8859_8.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/iso8859_9.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/johab.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/koi8_r.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/koi8_t.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/koi8_u.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/kz1048.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/latin_1.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/mac_arabic.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/mac_croatian.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/mac_cyrillic.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/mac_farsi.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/mac_greek.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/mac_iceland.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/mac_latin2.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/mac_roman.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/mac_romanian.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/mac_turkish.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/mbcs.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/oem.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/palmos.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/ptcp154.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/punycode.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/quopri_codec.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/raw_unicode_escape.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/rot_13.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/shift_jis.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/shift_jis_2004.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/shift_jisx0213.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/tis_620.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/undefined.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/unicode_escape.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/utf_16.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/utf_16_be.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/utf_16_le.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/utf_32.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/utf_32_be.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/utf_32_le.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/utf_7.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/utf_8.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/utf_8_sig.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/uu_codec.cpython-312.pyc", + "lib/python3.12/encodings/__pycache__/zlib_codec.cpython-312.pyc", + "lib/python3.12/encodings/aliases.py", + "lib/python3.12/encodings/ascii.py", + "lib/python3.12/encodings/base64_codec.py", + "lib/python3.12/encodings/big5.py", + "lib/python3.12/encodings/big5hkscs.py", + "lib/python3.12/encodings/bz2_codec.py", + "lib/python3.12/encodings/charmap.py", + "lib/python3.12/encodings/cp037.py", + "lib/python3.12/encodings/cp1006.py", + "lib/python3.12/encodings/cp1026.py", + "lib/python3.12/encodings/cp1125.py", + "lib/python3.12/encodings/cp1140.py", + "lib/python3.12/encodings/cp1250.py", + "lib/python3.12/encodings/cp1251.py", + "lib/python3.12/encodings/cp1252.py", + "lib/python3.12/encodings/cp1253.py", + "lib/python3.12/encodings/cp1254.py", + "lib/python3.12/encodings/cp1255.py", + "lib/python3.12/encodings/cp1256.py", + "lib/python3.12/encodings/cp1257.py", + "lib/python3.12/encodings/cp1258.py", + "lib/python3.12/encodings/cp273.py", + "lib/python3.12/encodings/cp424.py", + "lib/python3.12/encodings/cp437.py", + "lib/python3.12/encodings/cp500.py", + "lib/python3.12/encodings/cp720.py", + "lib/python3.12/encodings/cp737.py", + "lib/python3.12/encodings/cp775.py", + "lib/python3.12/encodings/cp850.py", + "lib/python3.12/encodings/cp852.py", + "lib/python3.12/encodings/cp855.py", + "lib/python3.12/encodings/cp856.py", + "lib/python3.12/encodings/cp857.py", + "lib/python3.12/encodings/cp858.py", + "lib/python3.12/encodings/cp860.py", + "lib/python3.12/encodings/cp861.py", + "lib/python3.12/encodings/cp862.py", + "lib/python3.12/encodings/cp863.py", + "lib/python3.12/encodings/cp864.py", + "lib/python3.12/encodings/cp865.py", + "lib/python3.12/encodings/cp866.py", + "lib/python3.12/encodings/cp869.py", + "lib/python3.12/encodings/cp874.py", + "lib/python3.12/encodings/cp875.py", + "lib/python3.12/encodings/cp932.py", + "lib/python3.12/encodings/cp949.py", + "lib/python3.12/encodings/cp950.py", + "lib/python3.12/encodings/euc_jis_2004.py", + "lib/python3.12/encodings/euc_jisx0213.py", + "lib/python3.12/encodings/euc_jp.py", + "lib/python3.12/encodings/euc_kr.py", + "lib/python3.12/encodings/gb18030.py", + "lib/python3.12/encodings/gb2312.py", + "lib/python3.12/encodings/gbk.py", + "lib/python3.12/encodings/hex_codec.py", + "lib/python3.12/encodings/hp_roman8.py", + "lib/python3.12/encodings/hz.py", + "lib/python3.12/encodings/idna.py", + "lib/python3.12/encodings/iso2022_jp.py", + "lib/python3.12/encodings/iso2022_jp_1.py", + "lib/python3.12/encodings/iso2022_jp_2.py", + "lib/python3.12/encodings/iso2022_jp_2004.py", + "lib/python3.12/encodings/iso2022_jp_3.py", + "lib/python3.12/encodings/iso2022_jp_ext.py", + "lib/python3.12/encodings/iso2022_kr.py", + "lib/python3.12/encodings/iso8859_1.py", + "lib/python3.12/encodings/iso8859_10.py", + "lib/python3.12/encodings/iso8859_11.py", + "lib/python3.12/encodings/iso8859_13.py", + "lib/python3.12/encodings/iso8859_14.py", + "lib/python3.12/encodings/iso8859_15.py", + "lib/python3.12/encodings/iso8859_16.py", + "lib/python3.12/encodings/iso8859_2.py", + "lib/python3.12/encodings/iso8859_3.py", + "lib/python3.12/encodings/iso8859_4.py", + "lib/python3.12/encodings/iso8859_5.py", + "lib/python3.12/encodings/iso8859_6.py", + "lib/python3.12/encodings/iso8859_7.py", + "lib/python3.12/encodings/iso8859_8.py", + "lib/python3.12/encodings/iso8859_9.py", + "lib/python3.12/encodings/johab.py", + "lib/python3.12/encodings/koi8_r.py", + "lib/python3.12/encodings/koi8_t.py", + "lib/python3.12/encodings/koi8_u.py", + "lib/python3.12/encodings/kz1048.py", + "lib/python3.12/encodings/latin_1.py", + "lib/python3.12/encodings/mac_arabic.py", + "lib/python3.12/encodings/mac_croatian.py", + "lib/python3.12/encodings/mac_cyrillic.py", + "lib/python3.12/encodings/mac_farsi.py", + "lib/python3.12/encodings/mac_greek.py", + "lib/python3.12/encodings/mac_iceland.py", + "lib/python3.12/encodings/mac_latin2.py", + "lib/python3.12/encodings/mac_roman.py", + "lib/python3.12/encodings/mac_romanian.py", + "lib/python3.12/encodings/mac_turkish.py", + "lib/python3.12/encodings/mbcs.py", + "lib/python3.12/encodings/oem.py", + "lib/python3.12/encodings/palmos.py", + "lib/python3.12/encodings/ptcp154.py", + "lib/python3.12/encodings/punycode.py", + "lib/python3.12/encodings/quopri_codec.py", + "lib/python3.12/encodings/raw_unicode_escape.py", + "lib/python3.12/encodings/rot_13.py", + "lib/python3.12/encodings/shift_jis.py", + "lib/python3.12/encodings/shift_jis_2004.py", + "lib/python3.12/encodings/shift_jisx0213.py", + "lib/python3.12/encodings/tis_620.py", + "lib/python3.12/encodings/undefined.py", + "lib/python3.12/encodings/unicode_escape.py", + "lib/python3.12/encodings/utf_16.py", + "lib/python3.12/encodings/utf_16_be.py", + "lib/python3.12/encodings/utf_16_le.py", + "lib/python3.12/encodings/utf_32.py", + "lib/python3.12/encodings/utf_32_be.py", + "lib/python3.12/encodings/utf_32_le.py", + "lib/python3.12/encodings/utf_7.py", + "lib/python3.12/encodings/utf_8.py", + "lib/python3.12/encodings/utf_8_sig.py", + "lib/python3.12/encodings/uu_codec.py", + "lib/python3.12/encodings/zlib_codec.py", + "lib/python3.12/ensurepip/__init__.py", + "lib/python3.12/ensurepip/__main__.py", + "lib/python3.12/ensurepip/__pycache__/__init__.cpython-312.pyc", + "lib/python3.12/ensurepip/__pycache__/__main__.cpython-312.pyc", + "lib/python3.12/ensurepip/__pycache__/_uninstall.cpython-312.pyc", + "lib/python3.12/ensurepip/_bundled/pip-24.0-py3-none-any.whl", + "lib/python3.12/ensurepip/_uninstall.py", + "lib/python3.12/enum.py", + "lib/python3.12/filecmp.py", + "lib/python3.12/fileinput.py", + "lib/python3.12/fnmatch.py", + "lib/python3.12/fractions.py", + "lib/python3.12/ftplib.py", + "lib/python3.12/functools.py", + "lib/python3.12/genericpath.py", + "lib/python3.12/getopt.py", + "lib/python3.12/getpass.py", + "lib/python3.12/gettext.py", + "lib/python3.12/glob.py", + "lib/python3.12/graphlib.py", + "lib/python3.12/gzip.py", + "lib/python3.12/hashlib.py", + "lib/python3.12/heapq.py", + "lib/python3.12/hmac.py", + "lib/python3.12/html/__init__.py", + "lib/python3.12/html/__pycache__/__init__.cpython-312.pyc", + "lib/python3.12/html/__pycache__/entities.cpython-312.pyc", + "lib/python3.12/html/__pycache__/parser.cpython-312.pyc", + "lib/python3.12/html/entities.py", + "lib/python3.12/html/parser.py", + "lib/python3.12/http/__init__.py", + "lib/python3.12/http/__pycache__/__init__.cpython-312.pyc", + "lib/python3.12/http/__pycache__/client.cpython-312.pyc", + "lib/python3.12/http/__pycache__/cookiejar.cpython-312.pyc", + "lib/python3.12/http/__pycache__/cookies.cpython-312.pyc", + "lib/python3.12/http/__pycache__/server.cpython-312.pyc", + "lib/python3.12/http/client.py", + "lib/python3.12/http/cookiejar.py", + "lib/python3.12/http/cookies.py", + "lib/python3.12/http/server.py", + "lib/python3.12/idlelib/CREDITS.txt", + "lib/python3.12/idlelib/ChangeLog", + "lib/python3.12/idlelib/HISTORY.txt", + "lib/python3.12/idlelib/Icons/README.txt", + "lib/python3.12/idlelib/Icons/folder.gif", + "lib/python3.12/idlelib/Icons/idle.ico", + "lib/python3.12/idlelib/Icons/idle_16.gif", + "lib/python3.12/idlelib/Icons/idle_16.png", + "lib/python3.12/idlelib/Icons/idle_256.png", + "lib/python3.12/idlelib/Icons/idle_32.gif", + "lib/python3.12/idlelib/Icons/idle_32.png", + "lib/python3.12/idlelib/Icons/idle_48.gif", + "lib/python3.12/idlelib/Icons/idle_48.png", + "lib/python3.12/idlelib/Icons/minusnode.gif", + "lib/python3.12/idlelib/Icons/openfolder.gif", + "lib/python3.12/idlelib/Icons/plusnode.gif", + "lib/python3.12/idlelib/Icons/python.gif", + "lib/python3.12/idlelib/Icons/tk.gif", + "lib/python3.12/idlelib/NEWS2x.txt", + "lib/python3.12/idlelib/News3.txt", + "lib/python3.12/idlelib/README.txt", + "lib/python3.12/idlelib/TODO.txt", + "lib/python3.12/idlelib/__init__.py", + "lib/python3.12/idlelib/__main__.py", + "lib/python3.12/idlelib/__pycache__/__init__.cpython-312.pyc", + "lib/python3.12/idlelib/__pycache__/__main__.cpython-312.pyc", + "lib/python3.12/idlelib/__pycache__/autocomplete.cpython-312.pyc", + "lib/python3.12/idlelib/__pycache__/autocomplete_w.cpython-312.pyc", + "lib/python3.12/idlelib/__pycache__/autoexpand.cpython-312.pyc", + "lib/python3.12/idlelib/__pycache__/browser.cpython-312.pyc", + "lib/python3.12/idlelib/__pycache__/calltip.cpython-312.pyc", + "lib/python3.12/idlelib/__pycache__/calltip_w.cpython-312.pyc", + "lib/python3.12/idlelib/__pycache__/codecontext.cpython-312.pyc", + "lib/python3.12/idlelib/__pycache__/colorizer.cpython-312.pyc", + "lib/python3.12/idlelib/__pycache__/config.cpython-312.pyc", + "lib/python3.12/idlelib/__pycache__/config_key.cpython-312.pyc", + "lib/python3.12/idlelib/__pycache__/configdialog.cpython-312.pyc", + "lib/python3.12/idlelib/__pycache__/debugger.cpython-312.pyc", + "lib/python3.12/idlelib/__pycache__/debugger_r.cpython-312.pyc", + "lib/python3.12/idlelib/__pycache__/debugobj.cpython-312.pyc", + "lib/python3.12/idlelib/__pycache__/debugobj_r.cpython-312.pyc", + "lib/python3.12/idlelib/__pycache__/delegator.cpython-312.pyc", + "lib/python3.12/idlelib/__pycache__/dynoption.cpython-312.pyc", + "lib/python3.12/idlelib/__pycache__/editor.cpython-312.pyc", + "lib/python3.12/idlelib/__pycache__/filelist.cpython-312.pyc", + "lib/python3.12/idlelib/__pycache__/format.cpython-312.pyc", + "lib/python3.12/idlelib/__pycache__/grep.cpython-312.pyc", + "lib/python3.12/idlelib/__pycache__/help.cpython-312.pyc", + "lib/python3.12/idlelib/__pycache__/help_about.cpython-312.pyc", + "lib/python3.12/idlelib/__pycache__/history.cpython-312.pyc", + "lib/python3.12/idlelib/__pycache__/hyperparser.cpython-312.pyc", + "lib/python3.12/idlelib/__pycache__/idle.cpython-312.pyc", + "lib/python3.12/idlelib/__pycache__/iomenu.cpython-312.pyc", + "lib/python3.12/idlelib/__pycache__/macosx.cpython-312.pyc", + "lib/python3.12/idlelib/__pycache__/mainmenu.cpython-312.pyc", + "lib/python3.12/idlelib/__pycache__/multicall.cpython-312.pyc", + "lib/python3.12/idlelib/__pycache__/outwin.cpython-312.pyc", + "lib/python3.12/idlelib/__pycache__/parenmatch.cpython-312.pyc", + "lib/python3.12/idlelib/__pycache__/pathbrowser.cpython-312.pyc", + "lib/python3.12/idlelib/__pycache__/percolator.cpython-312.pyc", + "lib/python3.12/idlelib/__pycache__/pyparse.cpython-312.pyc", + "lib/python3.12/idlelib/__pycache__/pyshell.cpython-312.pyc", + "lib/python3.12/idlelib/__pycache__/query.cpython-312.pyc", + "lib/python3.12/idlelib/__pycache__/redirector.cpython-312.pyc", + "lib/python3.12/idlelib/__pycache__/replace.cpython-312.pyc", + "lib/python3.12/idlelib/__pycache__/rpc.cpython-312.pyc", + "lib/python3.12/idlelib/__pycache__/run.cpython-312.pyc", + "lib/python3.12/idlelib/__pycache__/runscript.cpython-312.pyc", + "lib/python3.12/idlelib/__pycache__/scrolledlist.cpython-312.pyc", + "lib/python3.12/idlelib/__pycache__/search.cpython-312.pyc", + "lib/python3.12/idlelib/__pycache__/searchbase.cpython-312.pyc", + "lib/python3.12/idlelib/__pycache__/searchengine.cpython-312.pyc", + "lib/python3.12/idlelib/__pycache__/sidebar.cpython-312.pyc", + "lib/python3.12/idlelib/__pycache__/squeezer.cpython-312.pyc", + "lib/python3.12/idlelib/__pycache__/stackviewer.cpython-312.pyc", + "lib/python3.12/idlelib/__pycache__/statusbar.cpython-312.pyc", + "lib/python3.12/idlelib/__pycache__/textview.cpython-312.pyc", + "lib/python3.12/idlelib/__pycache__/tooltip.cpython-312.pyc", + "lib/python3.12/idlelib/__pycache__/tree.cpython-312.pyc", + "lib/python3.12/idlelib/__pycache__/undo.cpython-312.pyc", + "lib/python3.12/idlelib/__pycache__/util.cpython-312.pyc", + "lib/python3.12/idlelib/__pycache__/window.cpython-312.pyc", + "lib/python3.12/idlelib/__pycache__/zoomheight.cpython-312.pyc", + "lib/python3.12/idlelib/__pycache__/zzdummy.cpython-312.pyc", + "lib/python3.12/idlelib/autocomplete.py", + "lib/python3.12/idlelib/autocomplete_w.py", + "lib/python3.12/idlelib/autoexpand.py", + "lib/python3.12/idlelib/browser.py", + "lib/python3.12/idlelib/calltip.py", + "lib/python3.12/idlelib/calltip_w.py", + "lib/python3.12/idlelib/codecontext.py", + "lib/python3.12/idlelib/colorizer.py", + "lib/python3.12/idlelib/config-extensions.def", + "lib/python3.12/idlelib/config-highlight.def", + "lib/python3.12/idlelib/config-keys.def", + "lib/python3.12/idlelib/config-main.def", + "lib/python3.12/idlelib/config.py", + "lib/python3.12/idlelib/config_key.py", + "lib/python3.12/idlelib/configdialog.py", + "lib/python3.12/idlelib/debugger.py", + "lib/python3.12/idlelib/debugger_r.py", + "lib/python3.12/idlelib/debugobj.py", + "lib/python3.12/idlelib/debugobj_r.py", + "lib/python3.12/idlelib/delegator.py", + "lib/python3.12/idlelib/dynoption.py", + "lib/python3.12/idlelib/editor.py", + "lib/python3.12/idlelib/extend.txt", + "lib/python3.12/idlelib/filelist.py", + "lib/python3.12/idlelib/format.py", + "lib/python3.12/idlelib/grep.py", + "lib/python3.12/idlelib/help.html", + "lib/python3.12/idlelib/help.py", + "lib/python3.12/idlelib/help_about.py", + "lib/python3.12/idlelib/history.py", + "lib/python3.12/idlelib/hyperparser.py", + "lib/python3.12/idlelib/idle.bat", + "lib/python3.12/idlelib/idle.py", + "lib/python3.12/idlelib/idle.pyw", + "lib/python3.12/idlelib/idle_test/README.txt", + "lib/python3.12/idlelib/idle_test/__init__.py", + "lib/python3.12/idlelib/idle_test/__pycache__/__init__.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/htest.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/mock_idle.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/mock_tk.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/template.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/test_autocomplete.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/test_autocomplete_w.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/test_autoexpand.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/test_browser.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/test_calltip.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/test_calltip_w.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/test_codecontext.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/test_colorizer.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/test_config.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/test_config_key.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/test_configdialog.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/test_debugger.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/test_debugger_r.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/test_debugobj.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/test_debugobj_r.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/test_delegator.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/test_editmenu.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/test_editor.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/test_filelist.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/test_format.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/test_grep.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/test_help.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/test_help_about.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/test_history.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/test_hyperparser.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/test_iomenu.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/test_macosx.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/test_mainmenu.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/test_multicall.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/test_outwin.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/test_parenmatch.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/test_pathbrowser.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/test_percolator.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/test_pyparse.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/test_pyshell.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/test_query.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/test_redirector.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/test_replace.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/test_rpc.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/test_run.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/test_runscript.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/test_scrolledlist.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/test_search.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/test_searchbase.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/test_searchengine.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/test_sidebar.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/test_squeezer.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/test_stackviewer.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/test_statusbar.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/test_text.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/test_textview.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/test_tooltip.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/test_tree.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/test_undo.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/test_util.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/test_warning.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/test_window.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/test_zoomheight.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/test_zzdummy.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/__pycache__/tkinter_testing_utils.cpython-312.pyc", + "lib/python3.12/idlelib/idle_test/example_noext", + "lib/python3.12/idlelib/idle_test/example_stub.pyi", + "lib/python3.12/idlelib/idle_test/htest.py", + "lib/python3.12/idlelib/idle_test/mock_idle.py", + "lib/python3.12/idlelib/idle_test/mock_tk.py", + "lib/python3.12/idlelib/idle_test/template.py", + "lib/python3.12/idlelib/idle_test/test_autocomplete.py", + "lib/python3.12/idlelib/idle_test/test_autocomplete_w.py", + "lib/python3.12/idlelib/idle_test/test_autoexpand.py", + "lib/python3.12/idlelib/idle_test/test_browser.py", + "lib/python3.12/idlelib/idle_test/test_calltip.py", + "lib/python3.12/idlelib/idle_test/test_calltip_w.py", + "lib/python3.12/idlelib/idle_test/test_codecontext.py", + "lib/python3.12/idlelib/idle_test/test_colorizer.py", + "lib/python3.12/idlelib/idle_test/test_config.py", + "lib/python3.12/idlelib/idle_test/test_config_key.py", + "lib/python3.12/idlelib/idle_test/test_configdialog.py", + "lib/python3.12/idlelib/idle_test/test_debugger.py", + "lib/python3.12/idlelib/idle_test/test_debugger_r.py", + "lib/python3.12/idlelib/idle_test/test_debugobj.py", + "lib/python3.12/idlelib/idle_test/test_debugobj_r.py", + "lib/python3.12/idlelib/idle_test/test_delegator.py", + "lib/python3.12/idlelib/idle_test/test_editmenu.py", + "lib/python3.12/idlelib/idle_test/test_editor.py", + "lib/python3.12/idlelib/idle_test/test_filelist.py", + "lib/python3.12/idlelib/idle_test/test_format.py", + "lib/python3.12/idlelib/idle_test/test_grep.py", + "lib/python3.12/idlelib/idle_test/test_help.py", + "lib/python3.12/idlelib/idle_test/test_help_about.py", + "lib/python3.12/idlelib/idle_test/test_history.py", + "lib/python3.12/idlelib/idle_test/test_hyperparser.py", + "lib/python3.12/idlelib/idle_test/test_iomenu.py", + "lib/python3.12/idlelib/idle_test/test_macosx.py", + "lib/python3.12/idlelib/idle_test/test_mainmenu.py", + "lib/python3.12/idlelib/idle_test/test_multicall.py", + "lib/python3.12/idlelib/idle_test/test_outwin.py", + "lib/python3.12/idlelib/idle_test/test_parenmatch.py", + "lib/python3.12/idlelib/idle_test/test_pathbrowser.py", + "lib/python3.12/idlelib/idle_test/test_percolator.py", + "lib/python3.12/idlelib/idle_test/test_pyparse.py", + "lib/python3.12/idlelib/idle_test/test_pyshell.py", + "lib/python3.12/idlelib/idle_test/test_query.py", + "lib/python3.12/idlelib/idle_test/test_redirector.py", + "lib/python3.12/idlelib/idle_test/test_replace.py", + "lib/python3.12/idlelib/idle_test/test_rpc.py", + "lib/python3.12/idlelib/idle_test/test_run.py", + "lib/python3.12/idlelib/idle_test/test_runscript.py", + "lib/python3.12/idlelib/idle_test/test_scrolledlist.py", + "lib/python3.12/idlelib/idle_test/test_search.py", + "lib/python3.12/idlelib/idle_test/test_searchbase.py", + "lib/python3.12/idlelib/idle_test/test_searchengine.py", + "lib/python3.12/idlelib/idle_test/test_sidebar.py", + "lib/python3.12/idlelib/idle_test/test_squeezer.py", + "lib/python3.12/idlelib/idle_test/test_stackviewer.py", + "lib/python3.12/idlelib/idle_test/test_statusbar.py", + "lib/python3.12/idlelib/idle_test/test_text.py", + "lib/python3.12/idlelib/idle_test/test_textview.py", + "lib/python3.12/idlelib/idle_test/test_tooltip.py", + "lib/python3.12/idlelib/idle_test/test_tree.py", + "lib/python3.12/idlelib/idle_test/test_undo.py", + "lib/python3.12/idlelib/idle_test/test_util.py", + "lib/python3.12/idlelib/idle_test/test_warning.py", + "lib/python3.12/idlelib/idle_test/test_window.py", + "lib/python3.12/idlelib/idle_test/test_zoomheight.py", + "lib/python3.12/idlelib/idle_test/test_zzdummy.py", + "lib/python3.12/idlelib/idle_test/tkinter_testing_utils.py", + "lib/python3.12/idlelib/iomenu.py", + "lib/python3.12/idlelib/macosx.py", + "lib/python3.12/idlelib/mainmenu.py", + "lib/python3.12/idlelib/multicall.py", + "lib/python3.12/idlelib/outwin.py", + "lib/python3.12/idlelib/parenmatch.py", + "lib/python3.12/idlelib/pathbrowser.py", + "lib/python3.12/idlelib/percolator.py", + "lib/python3.12/idlelib/pyparse.py", + "lib/python3.12/idlelib/pyshell.py", + "lib/python3.12/idlelib/query.py", + "lib/python3.12/idlelib/redirector.py", + "lib/python3.12/idlelib/replace.py", + "lib/python3.12/idlelib/rpc.py", + "lib/python3.12/idlelib/run.py", + "lib/python3.12/idlelib/runscript.py", + "lib/python3.12/idlelib/scrolledlist.py", + "lib/python3.12/idlelib/search.py", + "lib/python3.12/idlelib/searchbase.py", + "lib/python3.12/idlelib/searchengine.py", + "lib/python3.12/idlelib/sidebar.py", + "lib/python3.12/idlelib/squeezer.py", + "lib/python3.12/idlelib/stackviewer.py", + "lib/python3.12/idlelib/statusbar.py", + "lib/python3.12/idlelib/textview.py", + "lib/python3.12/idlelib/tooltip.py", + "lib/python3.12/idlelib/tree.py", + "lib/python3.12/idlelib/undo.py", + "lib/python3.12/idlelib/util.py", + "lib/python3.12/idlelib/window.py", + "lib/python3.12/idlelib/zoomheight.py", + "lib/python3.12/idlelib/zzdummy.py", + "lib/python3.12/imaplib.py", + "lib/python3.12/imghdr.py", + "lib/python3.12/importlib/__init__.py", + "lib/python3.12/importlib/__pycache__/__init__.cpython-312.pyc", + "lib/python3.12/importlib/__pycache__/_abc.cpython-312.pyc", + "lib/python3.12/importlib/__pycache__/_bootstrap.cpython-312.pyc", + "lib/python3.12/importlib/__pycache__/_bootstrap_external.cpython-312.pyc", + "lib/python3.12/importlib/__pycache__/abc.cpython-312.pyc", + "lib/python3.12/importlib/__pycache__/machinery.cpython-312.pyc", + "lib/python3.12/importlib/__pycache__/readers.cpython-312.pyc", + "lib/python3.12/importlib/__pycache__/simple.cpython-312.pyc", + "lib/python3.12/importlib/__pycache__/util.cpython-312.pyc", + "lib/python3.12/importlib/_abc.py", + "lib/python3.12/importlib/_bootstrap.py", + "lib/python3.12/importlib/_bootstrap_external.py", + "lib/python3.12/importlib/abc.py", + "lib/python3.12/importlib/machinery.py", + "lib/python3.12/importlib/metadata/__init__.py", + "lib/python3.12/importlib/metadata/__pycache__/__init__.cpython-312.pyc", + "lib/python3.12/importlib/metadata/__pycache__/_adapters.cpython-312.pyc", + "lib/python3.12/importlib/metadata/__pycache__/_collections.cpython-312.pyc", + "lib/python3.12/importlib/metadata/__pycache__/_functools.cpython-312.pyc", + "lib/python3.12/importlib/metadata/__pycache__/_itertools.cpython-312.pyc", + "lib/python3.12/importlib/metadata/__pycache__/_meta.cpython-312.pyc", + "lib/python3.12/importlib/metadata/__pycache__/_text.cpython-312.pyc", + "lib/python3.12/importlib/metadata/_adapters.py", + "lib/python3.12/importlib/metadata/_collections.py", + "lib/python3.12/importlib/metadata/_functools.py", + "lib/python3.12/importlib/metadata/_itertools.py", + "lib/python3.12/importlib/metadata/_meta.py", + "lib/python3.12/importlib/metadata/_text.py", + "lib/python3.12/importlib/readers.py", + "lib/python3.12/importlib/resources/__init__.py", + "lib/python3.12/importlib/resources/__pycache__/__init__.cpython-312.pyc", + "lib/python3.12/importlib/resources/__pycache__/_adapters.cpython-312.pyc", + "lib/python3.12/importlib/resources/__pycache__/_common.cpython-312.pyc", + "lib/python3.12/importlib/resources/__pycache__/_itertools.cpython-312.pyc", + "lib/python3.12/importlib/resources/__pycache__/_legacy.cpython-312.pyc", + "lib/python3.12/importlib/resources/__pycache__/abc.cpython-312.pyc", + "lib/python3.12/importlib/resources/__pycache__/readers.cpython-312.pyc", + "lib/python3.12/importlib/resources/__pycache__/simple.cpython-312.pyc", + "lib/python3.12/importlib/resources/_adapters.py", + "lib/python3.12/importlib/resources/_common.py", + "lib/python3.12/importlib/resources/_itertools.py", + "lib/python3.12/importlib/resources/_legacy.py", + "lib/python3.12/importlib/resources/abc.py", + "lib/python3.12/importlib/resources/readers.py", + "lib/python3.12/importlib/resources/simple.py", + "lib/python3.12/importlib/simple.py", + "lib/python3.12/importlib/util.py", + "lib/python3.12/inspect.py", + "lib/python3.12/io.py", + "lib/python3.12/ipaddress.py", + "lib/python3.12/json/__init__.py", + "lib/python3.12/json/__pycache__/__init__.cpython-312.pyc", + "lib/python3.12/json/__pycache__/decoder.cpython-312.pyc", + "lib/python3.12/json/__pycache__/encoder.cpython-312.pyc", + "lib/python3.12/json/__pycache__/scanner.cpython-312.pyc", + "lib/python3.12/json/__pycache__/tool.cpython-312.pyc", + "lib/python3.12/json/decoder.py", + "lib/python3.12/json/encoder.py", + "lib/python3.12/json/scanner.py", + "lib/python3.12/json/tool.py", + "lib/python3.12/keyword.py", + "lib/python3.12/lib-dynload/_asyncio.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/_bisect.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/_blake2.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/_bz2.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/_codecs_cn.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/_codecs_hk.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/_codecs_iso2022.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/_codecs_jp.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/_codecs_kr.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/_codecs_tw.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/_contextvars.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/_crypt.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/_csv.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/_ctypes.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/_ctypes_test.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/_curses.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/_curses_panel.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/_datetime.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/_dbm.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/_decimal.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/_elementtree.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/_hashlib.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/_heapq.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/_json.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/_lsprof.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/_lzma.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/_md5.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/_multibytecodec.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/_multiprocessing.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/_opcode.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/_pickle.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/_posixshmem.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/_posixsubprocess.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/_queue.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/_random.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/_scproxy.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/_sha1.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/_sha2.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/_sha3.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/_socket.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/_sqlite3.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/_ssl.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/_statistics.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/_struct.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/_testbuffer.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/_testcapi.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/_testclinic.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/_testimportmultiple.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/_testinternalcapi.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/_testmultiphase.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/_testsinglephase.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/_tkinter.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/_uuid.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/_xxinterpchannels.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/_xxsubinterpreters.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/_xxtestfuzz.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/_zoneinfo.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/array.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/audioop.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/binascii.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/cmath.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/fcntl.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/grp.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/math.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/mmap.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/nis.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/pyexpat.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/readline.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/resource.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/select.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/syslog.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/termios.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/unicodedata.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/xxlimited.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/xxlimited_35.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/xxsubtype.cpython-312-darwin.so", + "lib/python3.12/lib-dynload/zlib.cpython-312-darwin.so", + "lib/python3.12/lib2to3/Grammar.txt", + "lib/python3.12/lib2to3/PatternGrammar.txt", + "lib/python3.12/lib2to3/__init__.py", + "lib/python3.12/lib2to3/__main__.py", + "lib/python3.12/lib2to3/__pycache__/__init__.cpython-312.pyc", + "lib/python3.12/lib2to3/__pycache__/__main__.cpython-312.pyc", + "lib/python3.12/lib2to3/__pycache__/btm_matcher.cpython-312.pyc", + "lib/python3.12/lib2to3/__pycache__/btm_utils.cpython-312.pyc", + "lib/python3.12/lib2to3/__pycache__/fixer_base.cpython-312.pyc", + "lib/python3.12/lib2to3/__pycache__/fixer_util.cpython-312.pyc", + "lib/python3.12/lib2to3/__pycache__/main.cpython-312.pyc", + "lib/python3.12/lib2to3/__pycache__/patcomp.cpython-312.pyc", + "lib/python3.12/lib2to3/__pycache__/pygram.cpython-312.pyc", + "lib/python3.12/lib2to3/__pycache__/pytree.cpython-312.pyc", + "lib/python3.12/lib2to3/__pycache__/refactor.cpython-312.pyc", + "lib/python3.12/lib2to3/btm_matcher.py", + "lib/python3.12/lib2to3/btm_utils.py", + "lib/python3.12/lib2to3/fixer_base.py", + "lib/python3.12/lib2to3/fixer_util.py", + "lib/python3.12/lib2to3/fixes/__init__.py", + "lib/python3.12/lib2to3/fixes/__pycache__/__init__.cpython-312.pyc", + "lib/python3.12/lib2to3/fixes/__pycache__/fix_apply.cpython-312.pyc", + "lib/python3.12/lib2to3/fixes/__pycache__/fix_asserts.cpython-312.pyc", + "lib/python3.12/lib2to3/fixes/__pycache__/fix_basestring.cpython-312.pyc", + "lib/python3.12/lib2to3/fixes/__pycache__/fix_buffer.cpython-312.pyc", + "lib/python3.12/lib2to3/fixes/__pycache__/fix_dict.cpython-312.pyc", + "lib/python3.12/lib2to3/fixes/__pycache__/fix_except.cpython-312.pyc", + "lib/python3.12/lib2to3/fixes/__pycache__/fix_exec.cpython-312.pyc", + "lib/python3.12/lib2to3/fixes/__pycache__/fix_execfile.cpython-312.pyc", + "lib/python3.12/lib2to3/fixes/__pycache__/fix_exitfunc.cpython-312.pyc", + "lib/python3.12/lib2to3/fixes/__pycache__/fix_filter.cpython-312.pyc", + "lib/python3.12/lib2to3/fixes/__pycache__/fix_funcattrs.cpython-312.pyc", + "lib/python3.12/lib2to3/fixes/__pycache__/fix_future.cpython-312.pyc", + "lib/python3.12/lib2to3/fixes/__pycache__/fix_getcwdu.cpython-312.pyc", + "lib/python3.12/lib2to3/fixes/__pycache__/fix_has_key.cpython-312.pyc", + "lib/python3.12/lib2to3/fixes/__pycache__/fix_idioms.cpython-312.pyc", + "lib/python3.12/lib2to3/fixes/__pycache__/fix_import.cpython-312.pyc", + "lib/python3.12/lib2to3/fixes/__pycache__/fix_imports.cpython-312.pyc", + "lib/python3.12/lib2to3/fixes/__pycache__/fix_imports2.cpython-312.pyc", + "lib/python3.12/lib2to3/fixes/__pycache__/fix_input.cpython-312.pyc", + "lib/python3.12/lib2to3/fixes/__pycache__/fix_intern.cpython-312.pyc", + "lib/python3.12/lib2to3/fixes/__pycache__/fix_isinstance.cpython-312.pyc", + "lib/python3.12/lib2to3/fixes/__pycache__/fix_itertools.cpython-312.pyc", + "lib/python3.12/lib2to3/fixes/__pycache__/fix_itertools_imports.cpython-312.pyc", + "lib/python3.12/lib2to3/fixes/__pycache__/fix_long.cpython-312.pyc", + "lib/python3.12/lib2to3/fixes/__pycache__/fix_map.cpython-312.pyc", + "lib/python3.12/lib2to3/fixes/__pycache__/fix_metaclass.cpython-312.pyc", + "lib/python3.12/lib2to3/fixes/__pycache__/fix_methodattrs.cpython-312.pyc", + "lib/python3.12/lib2to3/fixes/__pycache__/fix_ne.cpython-312.pyc", + "lib/python3.12/lib2to3/fixes/__pycache__/fix_next.cpython-312.pyc", + "lib/python3.12/lib2to3/fixes/__pycache__/fix_nonzero.cpython-312.pyc", + "lib/python3.12/lib2to3/fixes/__pycache__/fix_numliterals.cpython-312.pyc", + "lib/python3.12/lib2to3/fixes/__pycache__/fix_operator.cpython-312.pyc", + "lib/python3.12/lib2to3/fixes/__pycache__/fix_paren.cpython-312.pyc", + "lib/python3.12/lib2to3/fixes/__pycache__/fix_print.cpython-312.pyc", + "lib/python3.12/lib2to3/fixes/__pycache__/fix_raise.cpython-312.pyc", + "lib/python3.12/lib2to3/fixes/__pycache__/fix_raw_input.cpython-312.pyc", + "lib/python3.12/lib2to3/fixes/__pycache__/fix_reduce.cpython-312.pyc", + "lib/python3.12/lib2to3/fixes/__pycache__/fix_reload.cpython-312.pyc", + "lib/python3.12/lib2to3/fixes/__pycache__/fix_renames.cpython-312.pyc", + "lib/python3.12/lib2to3/fixes/__pycache__/fix_repr.cpython-312.pyc", + "lib/python3.12/lib2to3/fixes/__pycache__/fix_set_literal.cpython-312.pyc", + "lib/python3.12/lib2to3/fixes/__pycache__/fix_standarderror.cpython-312.pyc", + "lib/python3.12/lib2to3/fixes/__pycache__/fix_sys_exc.cpython-312.pyc", + "lib/python3.12/lib2to3/fixes/__pycache__/fix_throw.cpython-312.pyc", + "lib/python3.12/lib2to3/fixes/__pycache__/fix_tuple_params.cpython-312.pyc", + "lib/python3.12/lib2to3/fixes/__pycache__/fix_types.cpython-312.pyc", + "lib/python3.12/lib2to3/fixes/__pycache__/fix_unicode.cpython-312.pyc", + "lib/python3.12/lib2to3/fixes/__pycache__/fix_urllib.cpython-312.pyc", + "lib/python3.12/lib2to3/fixes/__pycache__/fix_ws_comma.cpython-312.pyc", + "lib/python3.12/lib2to3/fixes/__pycache__/fix_xrange.cpython-312.pyc", + "lib/python3.12/lib2to3/fixes/__pycache__/fix_xreadlines.cpython-312.pyc", + "lib/python3.12/lib2to3/fixes/__pycache__/fix_zip.cpython-312.pyc", + "lib/python3.12/lib2to3/fixes/fix_apply.py", + "lib/python3.12/lib2to3/fixes/fix_asserts.py", + "lib/python3.12/lib2to3/fixes/fix_basestring.py", + "lib/python3.12/lib2to3/fixes/fix_buffer.py", + "lib/python3.12/lib2to3/fixes/fix_dict.py", + "lib/python3.12/lib2to3/fixes/fix_except.py", + "lib/python3.12/lib2to3/fixes/fix_exec.py", + "lib/python3.12/lib2to3/fixes/fix_execfile.py", + "lib/python3.12/lib2to3/fixes/fix_exitfunc.py", + "lib/python3.12/lib2to3/fixes/fix_filter.py", + "lib/python3.12/lib2to3/fixes/fix_funcattrs.py", + "lib/python3.12/lib2to3/fixes/fix_future.py", + "lib/python3.12/lib2to3/fixes/fix_getcwdu.py", + "lib/python3.12/lib2to3/fixes/fix_has_key.py", + "lib/python3.12/lib2to3/fixes/fix_idioms.py", + "lib/python3.12/lib2to3/fixes/fix_import.py", + "lib/python3.12/lib2to3/fixes/fix_imports.py", + "lib/python3.12/lib2to3/fixes/fix_imports2.py", + "lib/python3.12/lib2to3/fixes/fix_input.py", + "lib/python3.12/lib2to3/fixes/fix_intern.py", + "lib/python3.12/lib2to3/fixes/fix_isinstance.py", + "lib/python3.12/lib2to3/fixes/fix_itertools.py", + "lib/python3.12/lib2to3/fixes/fix_itertools_imports.py", + "lib/python3.12/lib2to3/fixes/fix_long.py", + "lib/python3.12/lib2to3/fixes/fix_map.py", + "lib/python3.12/lib2to3/fixes/fix_metaclass.py", + "lib/python3.12/lib2to3/fixes/fix_methodattrs.py", + "lib/python3.12/lib2to3/fixes/fix_ne.py", + "lib/python3.12/lib2to3/fixes/fix_next.py", + "lib/python3.12/lib2to3/fixes/fix_nonzero.py", + "lib/python3.12/lib2to3/fixes/fix_numliterals.py", + "lib/python3.12/lib2to3/fixes/fix_operator.py", + "lib/python3.12/lib2to3/fixes/fix_paren.py", + "lib/python3.12/lib2to3/fixes/fix_print.py", + "lib/python3.12/lib2to3/fixes/fix_raise.py", + "lib/python3.12/lib2to3/fixes/fix_raw_input.py", + "lib/python3.12/lib2to3/fixes/fix_reduce.py", + "lib/python3.12/lib2to3/fixes/fix_reload.py", + "lib/python3.12/lib2to3/fixes/fix_renames.py", + "lib/python3.12/lib2to3/fixes/fix_repr.py", + "lib/python3.12/lib2to3/fixes/fix_set_literal.py", + "lib/python3.12/lib2to3/fixes/fix_standarderror.py", + "lib/python3.12/lib2to3/fixes/fix_sys_exc.py", + "lib/python3.12/lib2to3/fixes/fix_throw.py", + "lib/python3.12/lib2to3/fixes/fix_tuple_params.py", + "lib/python3.12/lib2to3/fixes/fix_types.py", + "lib/python3.12/lib2to3/fixes/fix_unicode.py", + "lib/python3.12/lib2to3/fixes/fix_urllib.py", + "lib/python3.12/lib2to3/fixes/fix_ws_comma.py", + "lib/python3.12/lib2to3/fixes/fix_xrange.py", + "lib/python3.12/lib2to3/fixes/fix_xreadlines.py", + "lib/python3.12/lib2to3/fixes/fix_zip.py", + "lib/python3.12/lib2to3/main.py", + "lib/python3.12/lib2to3/patcomp.py", + "lib/python3.12/lib2to3/pgen2/__init__.py", + "lib/python3.12/lib2to3/pgen2/__pycache__/__init__.cpython-312.pyc", + "lib/python3.12/lib2to3/pgen2/__pycache__/conv.cpython-312.pyc", + "lib/python3.12/lib2to3/pgen2/__pycache__/driver.cpython-312.pyc", + "lib/python3.12/lib2to3/pgen2/__pycache__/grammar.cpython-312.pyc", + "lib/python3.12/lib2to3/pgen2/__pycache__/literals.cpython-312.pyc", + "lib/python3.12/lib2to3/pgen2/__pycache__/parse.cpython-312.pyc", + "lib/python3.12/lib2to3/pgen2/__pycache__/pgen.cpython-312.pyc", + "lib/python3.12/lib2to3/pgen2/__pycache__/token.cpython-312.pyc", + "lib/python3.12/lib2to3/pgen2/__pycache__/tokenize.cpython-312.pyc", + "lib/python3.12/lib2to3/pgen2/conv.py", + "lib/python3.12/lib2to3/pgen2/driver.py", + "lib/python3.12/lib2to3/pgen2/grammar.py", + "lib/python3.12/lib2to3/pgen2/literals.py", + "lib/python3.12/lib2to3/pgen2/parse.py", + "lib/python3.12/lib2to3/pgen2/pgen.py", + "lib/python3.12/lib2to3/pgen2/token.py", + "lib/python3.12/lib2to3/pgen2/tokenize.py", + "lib/python3.12/lib2to3/pygram.py", + "lib/python3.12/lib2to3/pytree.py", + "lib/python3.12/lib2to3/refactor.py", + "lib/python3.12/linecache.py", + "lib/python3.12/locale.py", + "lib/python3.12/logging/__init__.py", + "lib/python3.12/logging/__pycache__/__init__.cpython-312.pyc", + "lib/python3.12/logging/__pycache__/config.cpython-312.pyc", + "lib/python3.12/logging/__pycache__/handlers.cpython-312.pyc", + "lib/python3.12/logging/config.py", + "lib/python3.12/logging/handlers.py", + "lib/python3.12/lzma.py", + "lib/python3.12/mailbox.py", + "lib/python3.12/mailcap.py", + "lib/python3.12/mimetypes.py", + "lib/python3.12/modulefinder.py", + "lib/python3.12/multiprocessing/__init__.py", + "lib/python3.12/multiprocessing/__pycache__/__init__.cpython-312.pyc", + "lib/python3.12/multiprocessing/__pycache__/connection.cpython-312.pyc", + "lib/python3.12/multiprocessing/__pycache__/context.cpython-312.pyc", + "lib/python3.12/multiprocessing/__pycache__/forkserver.cpython-312.pyc", + "lib/python3.12/multiprocessing/__pycache__/heap.cpython-312.pyc", + "lib/python3.12/multiprocessing/__pycache__/managers.cpython-312.pyc", + "lib/python3.12/multiprocessing/__pycache__/pool.cpython-312.pyc", + "lib/python3.12/multiprocessing/__pycache__/popen_fork.cpython-312.pyc", + "lib/python3.12/multiprocessing/__pycache__/popen_forkserver.cpython-312.pyc", + "lib/python3.12/multiprocessing/__pycache__/popen_spawn_posix.cpython-312.pyc", + "lib/python3.12/multiprocessing/__pycache__/popen_spawn_win32.cpython-312.pyc", + "lib/python3.12/multiprocessing/__pycache__/process.cpython-312.pyc", + "lib/python3.12/multiprocessing/__pycache__/queues.cpython-312.pyc", + "lib/python3.12/multiprocessing/__pycache__/reduction.cpython-312.pyc", + "lib/python3.12/multiprocessing/__pycache__/resource_sharer.cpython-312.pyc", + "lib/python3.12/multiprocessing/__pycache__/resource_tracker.cpython-312.pyc", + "lib/python3.12/multiprocessing/__pycache__/shared_memory.cpython-312.pyc", + "lib/python3.12/multiprocessing/__pycache__/sharedctypes.cpython-312.pyc", + "lib/python3.12/multiprocessing/__pycache__/spawn.cpython-312.pyc", + "lib/python3.12/multiprocessing/__pycache__/synchronize.cpython-312.pyc", + "lib/python3.12/multiprocessing/__pycache__/util.cpython-312.pyc", + "lib/python3.12/multiprocessing/connection.py", + "lib/python3.12/multiprocessing/context.py", + "lib/python3.12/multiprocessing/dummy/__init__.py", + "lib/python3.12/multiprocessing/dummy/__pycache__/__init__.cpython-312.pyc", + "lib/python3.12/multiprocessing/dummy/__pycache__/connection.cpython-312.pyc", + "lib/python3.12/multiprocessing/dummy/connection.py", + "lib/python3.12/multiprocessing/forkserver.py", + "lib/python3.12/multiprocessing/heap.py", + "lib/python3.12/multiprocessing/managers.py", + "lib/python3.12/multiprocessing/pool.py", + "lib/python3.12/multiprocessing/popen_fork.py", + "lib/python3.12/multiprocessing/popen_forkserver.py", + "lib/python3.12/multiprocessing/popen_spawn_posix.py", + "lib/python3.12/multiprocessing/popen_spawn_win32.py", + "lib/python3.12/multiprocessing/process.py", + "lib/python3.12/multiprocessing/queues.py", + "lib/python3.12/multiprocessing/reduction.py", + "lib/python3.12/multiprocessing/resource_sharer.py", + "lib/python3.12/multiprocessing/resource_tracker.py", + "lib/python3.12/multiprocessing/shared_memory.py", + "lib/python3.12/multiprocessing/sharedctypes.py", + "lib/python3.12/multiprocessing/spawn.py", + "lib/python3.12/multiprocessing/synchronize.py", + "lib/python3.12/multiprocessing/util.py", + "lib/python3.12/netrc.py", + "lib/python3.12/nntplib.py", + "lib/python3.12/ntpath.py", + "lib/python3.12/nturl2path.py", + "lib/python3.12/numbers.py", + "lib/python3.12/opcode.py", + "lib/python3.12/operator.py", + "lib/python3.12/optparse.py", + "lib/python3.12/os.py", + "lib/python3.12/pathlib.py", + "lib/python3.12/pdb.py", + "lib/python3.12/pickle.py", + "lib/python3.12/pickletools.py", + "lib/python3.12/pipes.py", + "lib/python3.12/pkgutil.py", + "lib/python3.12/platform.py", + "lib/python3.12/plistlib.py", + "lib/python3.12/poplib.py", + "lib/python3.12/posixpath.py", + "lib/python3.12/pprint.py", + "lib/python3.12/profile.py", + "lib/python3.12/pstats.py", + "lib/python3.12/pty.py", + "lib/python3.12/py_compile.py", + "lib/python3.12/pyclbr.py", + "lib/python3.12/pydoc.py", + "lib/python3.12/pydoc_data/__init__.py", + "lib/python3.12/pydoc_data/__pycache__/__init__.cpython-312.pyc", + "lib/python3.12/pydoc_data/__pycache__/topics.cpython-312.pyc", + "lib/python3.12/pydoc_data/_pydoc.css", + "lib/python3.12/pydoc_data/topics.py", + "lib/python3.12/queue.py", + "lib/python3.12/quopri.py", + "lib/python3.12/random.py", + "lib/python3.12/re/__init__.py", + "lib/python3.12/re/__pycache__/__init__.cpython-312.pyc", + "lib/python3.12/re/__pycache__/_casefix.cpython-312.pyc", + "lib/python3.12/re/__pycache__/_compiler.cpython-312.pyc", + "lib/python3.12/re/__pycache__/_constants.cpython-312.pyc", + "lib/python3.12/re/__pycache__/_parser.cpython-312.pyc", + "lib/python3.12/re/_casefix.py", + "lib/python3.12/re/_compiler.py", + "lib/python3.12/re/_constants.py", + "lib/python3.12/re/_parser.py", + "lib/python3.12/reprlib.py", + "lib/python3.12/rlcompleter.py", + "lib/python3.12/runpy.py", + "lib/python3.12/sched.py", + "lib/python3.12/secrets.py", + "lib/python3.12/selectors.py", + "lib/python3.12/shelve.py", + "lib/python3.12/shlex.py", + "lib/python3.12/shutil.py", + "lib/python3.12/signal.py", + "lib/python3.12/site-packages/README.txt", + "lib/python3.12/site.py", + "lib/python3.12/smtplib.py", + "lib/python3.12/sndhdr.py", + "lib/python3.12/socket.py", + "lib/python3.12/socketserver.py", + "lib/python3.12/sqlite3/__init__.py", + "lib/python3.12/sqlite3/__main__.py", + "lib/python3.12/sqlite3/__pycache__/__init__.cpython-312.pyc", + "lib/python3.12/sqlite3/__pycache__/__main__.cpython-312.pyc", + "lib/python3.12/sqlite3/__pycache__/dbapi2.cpython-312.pyc", + "lib/python3.12/sqlite3/__pycache__/dump.cpython-312.pyc", + "lib/python3.12/sqlite3/dbapi2.py", + "lib/python3.12/sqlite3/dump.py", + "lib/python3.12/sre_compile.py", + "lib/python3.12/sre_constants.py", + "lib/python3.12/sre_parse.py", + "lib/python3.12/ssl.py", + "lib/python3.12/stat.py", + "lib/python3.12/statistics.py", + "lib/python3.12/string.py", + "lib/python3.12/stringprep.py", + "lib/python3.12/struct.py", + "lib/python3.12/subprocess.py", + "lib/python3.12/sunau.py", + "lib/python3.12/symtable.py", + "lib/python3.12/sysconfig.py", + "lib/python3.12/tabnanny.py", + "lib/python3.12/tarfile.py", + "lib/python3.12/telnetlib.py", + "lib/python3.12/tempfile.py", + "lib/python3.12/test/__init__.py", + "lib/python3.12/test/__pycache__/__init__.cpython-312.pyc", + "lib/python3.12/test/__pycache__/test_script_helper.cpython-312.pyc", + "lib/python3.12/test/__pycache__/test_support.cpython-312.pyc", + "lib/python3.12/test/support/__init__.py", + "lib/python3.12/test/support/__pycache__/__init__.cpython-312.pyc", + "lib/python3.12/test/support/__pycache__/ast_helper.cpython-312.pyc", + "lib/python3.12/test/support/__pycache__/asynchat.cpython-312.pyc", + "lib/python3.12/test/support/__pycache__/asyncore.cpython-312.pyc", + "lib/python3.12/test/support/__pycache__/bytecode_helper.cpython-312.pyc", + "lib/python3.12/test/support/__pycache__/hashlib_helper.cpython-312.pyc", + "lib/python3.12/test/support/__pycache__/hypothesis_helper.cpython-312.pyc", + "lib/python3.12/test/support/__pycache__/import_helper.cpython-312.pyc", + "lib/python3.12/test/support/__pycache__/interpreters.cpython-312.pyc", + "lib/python3.12/test/support/__pycache__/logging_helper.cpython-312.pyc", + "lib/python3.12/test/support/__pycache__/os_helper.cpython-312.pyc", + "lib/python3.12/test/support/__pycache__/pty_helper.cpython-312.pyc", + "lib/python3.12/test/support/__pycache__/script_helper.cpython-312.pyc", + "lib/python3.12/test/support/__pycache__/smtpd.cpython-312.pyc", + "lib/python3.12/test/support/__pycache__/socket_helper.cpython-312.pyc", + "lib/python3.12/test/support/__pycache__/testcase.cpython-312.pyc", + "lib/python3.12/test/support/__pycache__/threading_helper.cpython-312.pyc", + "lib/python3.12/test/support/__pycache__/warnings_helper.cpython-312.pyc", + "lib/python3.12/test/support/_hypothesis_stubs/__init__.py", + "lib/python3.12/test/support/_hypothesis_stubs/__pycache__/__init__.cpython-312.pyc", + "lib/python3.12/test/support/_hypothesis_stubs/__pycache__/_helpers.cpython-312.pyc", + "lib/python3.12/test/support/_hypothesis_stubs/__pycache__/strategies.cpython-312.pyc", + "lib/python3.12/test/support/_hypothesis_stubs/_helpers.py", + "lib/python3.12/test/support/_hypothesis_stubs/strategies.py", + "lib/python3.12/test/support/ast_helper.py", + "lib/python3.12/test/support/asynchat.py", + "lib/python3.12/test/support/asyncore.py", + "lib/python3.12/test/support/bytecode_helper.py", + "lib/python3.12/test/support/hashlib_helper.py", + "lib/python3.12/test/support/hypothesis_helper.py", + "lib/python3.12/test/support/import_helper.py", + "lib/python3.12/test/support/interpreters.py", + "lib/python3.12/test/support/logging_helper.py", + "lib/python3.12/test/support/os_helper.py", + "lib/python3.12/test/support/pty_helper.py", + "lib/python3.12/test/support/script_helper.py", + "lib/python3.12/test/support/smtpd.py", + "lib/python3.12/test/support/socket_helper.py", + "lib/python3.12/test/support/testcase.py", + "lib/python3.12/test/support/threading_helper.py", + "lib/python3.12/test/support/warnings_helper.py", + "lib/python3.12/test/test_script_helper.py", + "lib/python3.12/test/test_support.py", + "lib/python3.12/textwrap.py", + "lib/python3.12/this.py", + "lib/python3.12/threading.py", + "lib/python3.12/timeit.py", + "lib/python3.12/tkinter/__init__.py", + "lib/python3.12/tkinter/__main__.py", + "lib/python3.12/tkinter/__pycache__/__init__.cpython-312.pyc", + "lib/python3.12/tkinter/__pycache__/__main__.cpython-312.pyc", + "lib/python3.12/tkinter/__pycache__/colorchooser.cpython-312.pyc", + "lib/python3.12/tkinter/__pycache__/commondialog.cpython-312.pyc", + "lib/python3.12/tkinter/__pycache__/constants.cpython-312.pyc", + "lib/python3.12/tkinter/__pycache__/dialog.cpython-312.pyc", + "lib/python3.12/tkinter/__pycache__/dnd.cpython-312.pyc", + "lib/python3.12/tkinter/__pycache__/filedialog.cpython-312.pyc", + "lib/python3.12/tkinter/__pycache__/font.cpython-312.pyc", + "lib/python3.12/tkinter/__pycache__/messagebox.cpython-312.pyc", + "lib/python3.12/tkinter/__pycache__/scrolledtext.cpython-312.pyc", + "lib/python3.12/tkinter/__pycache__/simpledialog.cpython-312.pyc", + "lib/python3.12/tkinter/__pycache__/tix.cpython-312.pyc", + "lib/python3.12/tkinter/__pycache__/ttk.cpython-312.pyc", + "lib/python3.12/tkinter/colorchooser.py", + "lib/python3.12/tkinter/commondialog.py", + "lib/python3.12/tkinter/constants.py", + "lib/python3.12/tkinter/dialog.py", + "lib/python3.12/tkinter/dnd.py", + "lib/python3.12/tkinter/filedialog.py", + "lib/python3.12/tkinter/font.py", + "lib/python3.12/tkinter/messagebox.py", + "lib/python3.12/tkinter/scrolledtext.py", + "lib/python3.12/tkinter/simpledialog.py", + "lib/python3.12/tkinter/tix.py", + "lib/python3.12/tkinter/ttk.py", + "lib/python3.12/token.py", + "lib/python3.12/tokenize.py", + "lib/python3.12/tomllib/__init__.py", + "lib/python3.12/tomllib/__pycache__/__init__.cpython-312.pyc", + "lib/python3.12/tomllib/__pycache__/_parser.cpython-312.pyc", + "lib/python3.12/tomllib/__pycache__/_re.cpython-312.pyc", + "lib/python3.12/tomllib/__pycache__/_types.cpython-312.pyc", + "lib/python3.12/tomllib/_parser.py", + "lib/python3.12/tomllib/_re.py", + "lib/python3.12/tomllib/_types.py", + "lib/python3.12/trace.py", + "lib/python3.12/traceback.py", + "lib/python3.12/tracemalloc.py", + "lib/python3.12/tty.py", + "lib/python3.12/turtle.py", + "lib/python3.12/turtledemo/__init__.py", + "lib/python3.12/turtledemo/__main__.py", + "lib/python3.12/turtledemo/__pycache__/__init__.cpython-312.pyc", + "lib/python3.12/turtledemo/__pycache__/__main__.cpython-312.pyc", + "lib/python3.12/turtledemo/__pycache__/bytedesign.cpython-312.pyc", + "lib/python3.12/turtledemo/__pycache__/chaos.cpython-312.pyc", + "lib/python3.12/turtledemo/__pycache__/clock.cpython-312.pyc", + "lib/python3.12/turtledemo/__pycache__/colormixer.cpython-312.pyc", + "lib/python3.12/turtledemo/__pycache__/forest.cpython-312.pyc", + "lib/python3.12/turtledemo/__pycache__/fractalcurves.cpython-312.pyc", + "lib/python3.12/turtledemo/__pycache__/lindenmayer.cpython-312.pyc", + "lib/python3.12/turtledemo/__pycache__/minimal_hanoi.cpython-312.pyc", + "lib/python3.12/turtledemo/__pycache__/nim.cpython-312.pyc", + "lib/python3.12/turtledemo/__pycache__/paint.cpython-312.pyc", + "lib/python3.12/turtledemo/__pycache__/peace.cpython-312.pyc", + "lib/python3.12/turtledemo/__pycache__/penrose.cpython-312.pyc", + "lib/python3.12/turtledemo/__pycache__/planet_and_moon.cpython-312.pyc", + "lib/python3.12/turtledemo/__pycache__/rosette.cpython-312.pyc", + "lib/python3.12/turtledemo/__pycache__/round_dance.cpython-312.pyc", + "lib/python3.12/turtledemo/__pycache__/sorting_animate.cpython-312.pyc", + "lib/python3.12/turtledemo/__pycache__/tree.cpython-312.pyc", + "lib/python3.12/turtledemo/__pycache__/two_canvases.cpython-312.pyc", + "lib/python3.12/turtledemo/__pycache__/yinyang.cpython-312.pyc", + "lib/python3.12/turtledemo/bytedesign.py", + "lib/python3.12/turtledemo/chaos.py", + "lib/python3.12/turtledemo/clock.py", + "lib/python3.12/turtledemo/colormixer.py", + "lib/python3.12/turtledemo/forest.py", + "lib/python3.12/turtledemo/fractalcurves.py", + "lib/python3.12/turtledemo/lindenmayer.py", + "lib/python3.12/turtledemo/minimal_hanoi.py", + "lib/python3.12/turtledemo/nim.py", + "lib/python3.12/turtledemo/paint.py", + "lib/python3.12/turtledemo/peace.py", + "lib/python3.12/turtledemo/penrose.py", + "lib/python3.12/turtledemo/planet_and_moon.py", + "lib/python3.12/turtledemo/rosette.py", + "lib/python3.12/turtledemo/round_dance.py", + "lib/python3.12/turtledemo/sorting_animate.py", + "lib/python3.12/turtledemo/tree.py", + "lib/python3.12/turtledemo/turtle.cfg", + "lib/python3.12/turtledemo/two_canvases.py", + "lib/python3.12/turtledemo/yinyang.py", + "lib/python3.12/types.py", + "lib/python3.12/typing.py", + "lib/python3.12/unittest/__init__.py", + "lib/python3.12/unittest/__main__.py", + "lib/python3.12/unittest/__pycache__/__init__.cpython-312.pyc", + "lib/python3.12/unittest/__pycache__/__main__.cpython-312.pyc", + "lib/python3.12/unittest/__pycache__/_log.cpython-312.pyc", + "lib/python3.12/unittest/__pycache__/async_case.cpython-312.pyc", + "lib/python3.12/unittest/__pycache__/case.cpython-312.pyc", + "lib/python3.12/unittest/__pycache__/loader.cpython-312.pyc", + "lib/python3.12/unittest/__pycache__/main.cpython-312.pyc", + "lib/python3.12/unittest/__pycache__/mock.cpython-312.pyc", + "lib/python3.12/unittest/__pycache__/result.cpython-312.pyc", + "lib/python3.12/unittest/__pycache__/runner.cpython-312.pyc", + "lib/python3.12/unittest/__pycache__/signals.cpython-312.pyc", + "lib/python3.12/unittest/__pycache__/suite.cpython-312.pyc", + "lib/python3.12/unittest/__pycache__/util.cpython-312.pyc", + "lib/python3.12/unittest/_log.py", + "lib/python3.12/unittest/async_case.py", + "lib/python3.12/unittest/case.py", + "lib/python3.12/unittest/loader.py", + "lib/python3.12/unittest/main.py", + "lib/python3.12/unittest/mock.py", + "lib/python3.12/unittest/result.py", + "lib/python3.12/unittest/runner.py", + "lib/python3.12/unittest/signals.py", + "lib/python3.12/unittest/suite.py", + "lib/python3.12/unittest/util.py", + "lib/python3.12/urllib/__init__.py", + "lib/python3.12/urllib/__pycache__/__init__.cpython-312.pyc", + "lib/python3.12/urllib/__pycache__/error.cpython-312.pyc", + "lib/python3.12/urllib/__pycache__/parse.cpython-312.pyc", + "lib/python3.12/urllib/__pycache__/request.cpython-312.pyc", + "lib/python3.12/urllib/__pycache__/response.cpython-312.pyc", + "lib/python3.12/urllib/__pycache__/robotparser.cpython-312.pyc", + "lib/python3.12/urllib/error.py", + "lib/python3.12/urllib/parse.py", + "lib/python3.12/urllib/request.py", + "lib/python3.12/urllib/response.py", + "lib/python3.12/urllib/robotparser.py", + "lib/python3.12/uu.py", + "lib/python3.12/uuid.py", + "lib/python3.12/venv/__init__.py", + "lib/python3.12/venv/__main__.py", + "lib/python3.12/venv/__pycache__/__init__.cpython-312.pyc", + "lib/python3.12/venv/__pycache__/__main__.cpython-312.pyc", + "lib/python3.12/venv/scripts/common/Activate.ps1", + "lib/python3.12/venv/scripts/common/activate", + "lib/python3.12/venv/scripts/posix/activate.csh", + "lib/python3.12/venv/scripts/posix/activate.fish", + "lib/python3.12/warnings.py", + "lib/python3.12/wave.py", + "lib/python3.12/weakref.py", + "lib/python3.12/webbrowser.py", + "lib/python3.12/wsgiref/__init__.py", + "lib/python3.12/wsgiref/__pycache__/__init__.cpython-312.pyc", + "lib/python3.12/wsgiref/__pycache__/handlers.cpython-312.pyc", + "lib/python3.12/wsgiref/__pycache__/headers.cpython-312.pyc", + "lib/python3.12/wsgiref/__pycache__/simple_server.cpython-312.pyc", + "lib/python3.12/wsgiref/__pycache__/types.cpython-312.pyc", + "lib/python3.12/wsgiref/__pycache__/util.cpython-312.pyc", + "lib/python3.12/wsgiref/__pycache__/validate.cpython-312.pyc", + "lib/python3.12/wsgiref/handlers.py", + "lib/python3.12/wsgiref/headers.py", + "lib/python3.12/wsgiref/simple_server.py", + "lib/python3.12/wsgiref/types.py", + "lib/python3.12/wsgiref/util.py", + "lib/python3.12/wsgiref/validate.py", + "lib/python3.12/xdrlib.py", + "lib/python3.12/xml/__init__.py", + "lib/python3.12/xml/__pycache__/__init__.cpython-312.pyc", + "lib/python3.12/xml/dom/NodeFilter.py", + "lib/python3.12/xml/dom/__init__.py", + "lib/python3.12/xml/dom/__pycache__/NodeFilter.cpython-312.pyc", + "lib/python3.12/xml/dom/__pycache__/__init__.cpython-312.pyc", + "lib/python3.12/xml/dom/__pycache__/domreg.cpython-312.pyc", + "lib/python3.12/xml/dom/__pycache__/expatbuilder.cpython-312.pyc", + "lib/python3.12/xml/dom/__pycache__/minicompat.cpython-312.pyc", + "lib/python3.12/xml/dom/__pycache__/minidom.cpython-312.pyc", + "lib/python3.12/xml/dom/__pycache__/pulldom.cpython-312.pyc", + "lib/python3.12/xml/dom/__pycache__/xmlbuilder.cpython-312.pyc", + "lib/python3.12/xml/dom/domreg.py", + "lib/python3.12/xml/dom/expatbuilder.py", + "lib/python3.12/xml/dom/minicompat.py", + "lib/python3.12/xml/dom/minidom.py", + "lib/python3.12/xml/dom/pulldom.py", + "lib/python3.12/xml/dom/xmlbuilder.py", + "lib/python3.12/xml/etree/ElementInclude.py", + "lib/python3.12/xml/etree/ElementPath.py", + "lib/python3.12/xml/etree/ElementTree.py", + "lib/python3.12/xml/etree/__init__.py", + "lib/python3.12/xml/etree/__pycache__/ElementInclude.cpython-312.pyc", + "lib/python3.12/xml/etree/__pycache__/ElementPath.cpython-312.pyc", + "lib/python3.12/xml/etree/__pycache__/ElementTree.cpython-312.pyc", + "lib/python3.12/xml/etree/__pycache__/__init__.cpython-312.pyc", + "lib/python3.12/xml/etree/__pycache__/cElementTree.cpython-312.pyc", + "lib/python3.12/xml/etree/cElementTree.py", + "lib/python3.12/xml/parsers/__init__.py", + "lib/python3.12/xml/parsers/__pycache__/__init__.cpython-312.pyc", + "lib/python3.12/xml/parsers/__pycache__/expat.cpython-312.pyc", + "lib/python3.12/xml/parsers/expat.py", + "lib/python3.12/xml/sax/__init__.py", + "lib/python3.12/xml/sax/__pycache__/__init__.cpython-312.pyc", + "lib/python3.12/xml/sax/__pycache__/_exceptions.cpython-312.pyc", + "lib/python3.12/xml/sax/__pycache__/expatreader.cpython-312.pyc", + "lib/python3.12/xml/sax/__pycache__/handler.cpython-312.pyc", + "lib/python3.12/xml/sax/__pycache__/saxutils.cpython-312.pyc", + "lib/python3.12/xml/sax/__pycache__/xmlreader.cpython-312.pyc", + "lib/python3.12/xml/sax/_exceptions.py", + "lib/python3.12/xml/sax/expatreader.py", + "lib/python3.12/xml/sax/handler.py", + "lib/python3.12/xml/sax/saxutils.py", + "lib/python3.12/xml/sax/xmlreader.py", + "lib/python3.12/xmlrpc/__init__.py", + "lib/python3.12/xmlrpc/__pycache__/__init__.cpython-312.pyc", + "lib/python3.12/xmlrpc/__pycache__/client.cpython-312.pyc", + "lib/python3.12/xmlrpc/__pycache__/server.cpython-312.pyc", + "lib/python3.12/xmlrpc/client.py", + "lib/python3.12/xmlrpc/server.py", + "lib/python3.12/zipapp.py", + "lib/python3.12/zipfile/__init__.py", + "lib/python3.12/zipfile/__main__.py", + "lib/python3.12/zipfile/__pycache__/__init__.cpython-312.pyc", + "lib/python3.12/zipfile/__pycache__/__main__.cpython-312.pyc", + "lib/python3.12/zipfile/_path/__init__.py", + "lib/python3.12/zipfile/_path/__pycache__/__init__.cpython-312.pyc", + "lib/python3.12/zipfile/_path/__pycache__/glob.cpython-312.pyc", + "lib/python3.12/zipfile/_path/glob.py", + "lib/python3.12/zipimport.py", + "lib/python3.12/zoneinfo/__init__.py", + "lib/python3.12/zoneinfo/__pycache__/__init__.cpython-312.pyc", + "lib/python3.12/zoneinfo/__pycache__/_common.cpython-312.pyc", + "lib/python3.12/zoneinfo/__pycache__/_tzpath.cpython-312.pyc", + "lib/python3.12/zoneinfo/__pycache__/_zoneinfo.cpython-312.pyc", + "lib/python3.12/zoneinfo/_common.py", + "lib/python3.12/zoneinfo/_tzpath.py", + "lib/python3.12/zoneinfo/_zoneinfo.py", + "share/man/man1/python3.1", + "share/man/man1/python3.12.1" + ], + "fn": "python-3.12.2-hdf0ec26_0_cpython.conda", + "license": "Python-2.0", + "link": { + "source": "/Users/donjayamanne/miniconda3/pkgs/python-3.12.2-hdf0ec26_0_cpython", + "type": 1 + }, + "md5": "85e91138ae921a2771f57a50120272bd", + "name": "python", + "package_tarball_full_path": "/Users/donjayamanne/miniconda3/pkgs/python-3.12.2-hdf0ec26_0_cpython.conda", + "paths_data": { + "paths": [ + { + "_path": "bin/2to3", + "path_type": "softlink", + "sha256": "ccc93e84439d9c18b5439dc270fb09d7b613d9eb30efa613b4d39452895a6872", + "size_in_bytes": 347 + }, + { + "_path": "bin/2to3-3.12", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/Users/runner/miniforge3/conda-bld/python-split_1708115848844/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placeh", + "sha256": "ccc93e84439d9c18b5439dc270fb09d7b613d9eb30efa613b4d39452895a6872", + "sha256_in_prefix": "2b479c896c7b5bbb3fb73ea1df6f0c33075107b830b0a802cad421dc36c9c187", + "size_in_bytes": 347 + }, + { + "_path": "bin/idle3", + "path_type": "softlink", + "sha256": "77cd853be1090440bcc8bd8b3d62e424f15140ff3a41b1eeb78f1309a4d4d951", + "size_in_bytes": 345 + }, + { + "_path": "bin/idle3.12", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/Users/runner/miniforge3/conda-bld/python-split_1708115848844/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placeh", + "sha256": "77cd853be1090440bcc8bd8b3d62e424f15140ff3a41b1eeb78f1309a4d4d951", + "sha256_in_prefix": "55b80175f900774f4aa4cedb8eff451042f37b2af1b9802ccfa99371e8d4d97a", + "size_in_bytes": 345 + }, + { + "_path": "bin/pydoc", + "path_type": "softlink", + "sha256": "be0a30e51f64a794b5a717171a5cb4ac3234321f6849b21bd0b18e2f8c160285", + "size_in_bytes": 330 + }, + { + "_path": "bin/pydoc3", + "path_type": "softlink", + "sha256": "be0a30e51f64a794b5a717171a5cb4ac3234321f6849b21bd0b18e2f8c160285", + "size_in_bytes": 330 + }, + { + "_path": "bin/pydoc3.12", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/Users/runner/miniforge3/conda-bld/python-split_1708115848844/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placeh", + "sha256": "be0a30e51f64a794b5a717171a5cb4ac3234321f6849b21bd0b18e2f8c160285", + "sha256_in_prefix": "08d4cea2665c0995bf292682ffad2c5d5549f8b2fafafe17be30991d7228fbb3", + "size_in_bytes": 330 + }, + { + "_path": "bin/python", + "path_type": "softlink", + "sha256": "2e5a6d2412ea4948a772ea3b325078c97a16cda01f99745df77f940adfd95841", + "size_in_bytes": 6473936 + }, + { + "_path": "bin/python3", + "path_type": "softlink", + "sha256": "2e5a6d2412ea4948a772ea3b325078c97a16cda01f99745df77f940adfd95841", + "size_in_bytes": 6473936 + }, + { + "_path": "bin/python3-config", + "path_type": "softlink", + "sha256": "d0ca9f1b59946e9c206eae18ff42521af18ada070a568d534c2e5f3ff4fe9598", + "size_in_bytes": 2289 + }, + { + "_path": "bin/python3.1", + "path_type": "softlink", + "sha256": "2e5a6d2412ea4948a772ea3b325078c97a16cda01f99745df77f940adfd95841", + "size_in_bytes": 6473936 + }, + { + "_path": "bin/python3.12", + "file_mode": "binary", + "path_type": "hardlink", + "prefix_placeholder": "/Users/runner/miniforge3/conda-bld/python-split_1708115848844/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placeh", + "sha256": "2e5a6d2412ea4948a772ea3b325078c97a16cda01f99745df77f940adfd95841", + "sha256_in_prefix": "68f3e91cee7775f714e7e663154298ce21850bc3da738e29ec689b7b4e54301c", + "size_in_bytes": 6473936 + }, + { + "_path": "bin/python3.12-config", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/Users/runner/miniforge3/conda-bld/python-split_1708115848844/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placeh", + "sha256": "d0ca9f1b59946e9c206eae18ff42521af18ada070a568d534c2e5f3ff4fe9598", + "sha256_in_prefix": "f0fbf2d550f63d4b6ca56d2609a89cb6647c71894010636fc6ddd305fd1c7cfb", + "size_in_bytes": 2289 + }, + { + "_path": "include/python3.12/Python.h", + "path_type": "hardlink", + "sha256": "0b4a45e50087a78e9a88a70e1b247a05dccc0e089164c7c8ece4331b80355fa6", + "sha256_in_prefix": "0b4a45e50087a78e9a88a70e1b247a05dccc0e089164c7c8ece4331b80355fa6", + "size_in_bytes": 2854 + }, + { + "_path": "include/python3.12/abstract.h", + "path_type": "hardlink", + "sha256": "8f0b27427f4e16b4295b2ab1a7bb499bf86748fafbd1959e220c506ed59f774f", + "sha256_in_prefix": "8f0b27427f4e16b4295b2ab1a7bb499bf86748fafbd1959e220c506ed59f774f", + "size_in_bytes": 32616 + }, + { + "_path": "include/python3.12/bltinmodule.h", + "path_type": "hardlink", + "sha256": "1b5101b4b85409fd910032713906800bbb83580503036469c2a60ac8e80b8f72", + "sha256_in_prefix": "1b5101b4b85409fd910032713906800bbb83580503036469c2a60ac8e80b8f72", + "size_in_bytes": 264 + }, + { + "_path": "include/python3.12/boolobject.h", + "path_type": "hardlink", + "sha256": "84289d5b1a1b7ed6c547f4f081fba70e90a9d60dfa2d2b3155c33cdd2af41340", + "sha256_in_prefix": "84289d5b1a1b7ed6c547f4f081fba70e90a9d60dfa2d2b3155c33cdd2af41340", + "size_in_bytes": 1136 + }, + { + "_path": "include/python3.12/bytearrayobject.h", + "path_type": "hardlink", + "sha256": "0e93963caf43a057fb293ae5183d1b8bb45c9f57926ce8308f67a0f452843e85", + "sha256_in_prefix": "0e93963caf43a057fb293ae5183d1b8bb45c9f57926ce8308f67a0f452843e85", + "size_in_bytes": 1466 + }, + { + "_path": "include/python3.12/bytesobject.h", + "path_type": "hardlink", + "sha256": "de8551db9323e7dc463717a624f2d35dacd17cdf0c7a7f6299128dd06348cf30", + "sha256_in_prefix": "de8551db9323e7dc463717a624f2d35dacd17cdf0c7a7f6299128dd06348cf30", + "size_in_bytes": 2619 + }, + { + "_path": "include/python3.12/ceval.h", + "path_type": "hardlink", + "sha256": "9531cce1b80e804d46a9ef31bd22605f54d0ae0609dc3470946a4d8d4270af3a", + "sha256_in_prefix": "9531cce1b80e804d46a9ef31bd22605f54d0ae0609dc3470946a4d8d4270af3a", + "size_in_bytes": 6267 + }, + { + "_path": "include/python3.12/codecs.h", + "path_type": "hardlink", + "sha256": "0ca3c6e55e7ff62872b47aeeb7379d784b03ebfc61bbd029b67485fe783baac5", + "sha256_in_prefix": "0ca3c6e55e7ff62872b47aeeb7379d784b03ebfc61bbd029b67485fe783baac5", + "size_in_bytes": 7071 + }, + { + "_path": "include/python3.12/compile.h", + "path_type": "hardlink", + "sha256": "1f10c818b29007e6a4446505a1140dd77ca6618ad81e87b502f4e22f4b274406", + "sha256_in_prefix": "1f10c818b29007e6a4446505a1140dd77ca6618ad81e87b502f4e22f4b274406", + "size_in_bytes": 448 + }, + { + "_path": "include/python3.12/complexobject.h", + "path_type": "hardlink", + "sha256": "9356805a24503256cd8914d7b7700357e01f471c211f9241c81981d89d6c3af8", + "sha256_in_prefix": "9356805a24503256cd8914d7b7700357e01f471c211f9241c81981d89d6c3af8", + "size_in_bytes": 728 + }, + { + "_path": "include/python3.12/cpython/abstract.h", + "path_type": "hardlink", + "sha256": "07d8b3b9c7db77e30adef4c4d9c7a4453b8eb1f48341ed5394bd5eebe239c9fd", + "sha256_in_prefix": "07d8b3b9c7db77e30adef4c4d9c7a4453b8eb1f48341ed5394bd5eebe239c9fd", + "size_in_bytes": 7870 + }, + { + "_path": "include/python3.12/cpython/bytearrayobject.h", + "path_type": "hardlink", + "sha256": "ae5e099856657f3b8606701df312866eaa88992f6cfd9f8567456e1588efceb1", + "sha256_in_prefix": "ae5e099856657f3b8606701df312866eaa88992f6cfd9f8567456e1588efceb1", + "size_in_bytes": 1163 + }, + { + "_path": "include/python3.12/cpython/bytesobject.h", + "path_type": "hardlink", + "sha256": "a7535615c2637b60e53c32355b489f49c6bc979be3a58adae5b0049231b43a6c", + "sha256_in_prefix": "a7535615c2637b60e53c32355b489f49c6bc979be3a58adae5b0049231b43a6c", + "size_in_bytes": 4426 + }, + { + "_path": "include/python3.12/cpython/cellobject.h", + "path_type": "hardlink", + "sha256": "844f06178bbce2e9377a46ccc80e2aae85a73750932576a6cc4de934cc508cea", + "sha256_in_prefix": "844f06178bbce2e9377a46ccc80e2aae85a73750932576a6cc4de934cc508cea", + "size_in_bytes": 1076 + }, + { + "_path": "include/python3.12/cpython/ceval.h", + "path_type": "hardlink", + "sha256": "b08c549971f1006e681267dd8a88481353ce4bd89b9d859f81b72cf9bf867895", + "sha256_in_prefix": "b08c549971f1006e681267dd8a88481353ce4bd89b9d859f81b72cf9bf867895", + "size_in_bytes": 1650 + }, + { + "_path": "include/python3.12/cpython/classobject.h", + "path_type": "hardlink", + "sha256": "b38a0ecdebeae2a4d28dfe8a5f2833f676d38be9561ca4bdfdf5087bbe2f9332", + "sha256_in_prefix": "b38a0ecdebeae2a4d28dfe8a5f2833f676d38be9561ca4bdfdf5087bbe2f9332", + "size_in_bytes": 2245 + }, + { + "_path": "include/python3.12/cpython/code.h", + "path_type": "hardlink", + "sha256": "2382c3cd9db5f1686e84c94ac8cd729fab81791c9de7fdbc045ac5d26a3d9d9c", + "sha256_in_prefix": "2382c3cd9db5f1686e84c94ac8cd729fab81791c9de7fdbc045ac5d26a3d9d9c", + "size_in_bytes": 16189 + }, + { + "_path": "include/python3.12/cpython/compile.h", + "path_type": "hardlink", + "sha256": "32d7397c6fa5478feb2a4101641fca6dba3ac77abe4deed5c0f713a6cd6564f5", + "sha256_in_prefix": "32d7397c6fa5478feb2a4101641fca6dba3ac77abe4deed5c0f713a6cd6564f5", + "size_in_bytes": 2660 + }, + { + "_path": "include/python3.12/cpython/complexobject.h", + "path_type": "hardlink", + "sha256": "a4c110008e4d791a4577ce6ebee33bc512ec3e3db918bd2c296f00dd79379fcb", + "sha256_in_prefix": "a4c110008e4d791a4577ce6ebee33bc512ec3e3db918bd2c296f00dd79379fcb", + "size_in_bytes": 1248 + }, + { + "_path": "include/python3.12/cpython/context.h", + "path_type": "hardlink", + "sha256": "9e34d54a789cbf0d78d5ebb126e8384342c08dd81d944d10e3d8f0de0bbba10a", + "sha256_in_prefix": "9e34d54a789cbf0d78d5ebb126e8384342c08dd81d944d10e3d8f0de0bbba10a", + "size_in_bytes": 1965 + }, + { + "_path": "include/python3.12/cpython/descrobject.h", + "path_type": "hardlink", + "sha256": "a1ee0124142fe91204d0c5e85169b55341b2167111a1447e3a8ed50f9bd5a12f", + "sha256_in_prefix": "a1ee0124142fe91204d0c5e85169b55341b2167111a1447e3a8ed50f9bd5a12f", + "size_in_bytes": 1642 + }, + { + "_path": "include/python3.12/cpython/dictobject.h", + "path_type": "hardlink", + "sha256": "5ac16d73f22038b12bd06904cf02a14bbdd723234d1d899354f1a041e8659505", + "sha256_in_prefix": "5ac16d73f22038b12bd06904cf02a14bbdd723234d1d899354f1a041e8659505", + "size_in_bytes": 4686 + }, + { + "_path": "include/python3.12/cpython/fileobject.h", + "path_type": "hardlink", + "sha256": "16ab872cbe2bb3351ce3090873440903b1460c1d68aed483c70c31edc4140ba2", + "sha256_in_prefix": "16ab872cbe2bb3351ce3090873440903b1460c1d68aed483c70c31edc4140ba2", + "size_in_bytes": 818 + }, + { + "_path": "include/python3.12/cpython/fileutils.h", + "path_type": "hardlink", + "sha256": "d7a2f703c6fba2efabd0b1cc916ad36074363a27a000987cfad17e21f04d44f1", + "sha256_in_prefix": "d7a2f703c6fba2efabd0b1cc916ad36074363a27a000987cfad17e21f04d44f1", + "size_in_bytes": 232 + }, + { + "_path": "include/python3.12/cpython/floatobject.h", + "path_type": "hardlink", + "sha256": "f1c53f5b87f221db66004b836aa2fc9462aa46c2fbe46b417a8ddc803ce2f585", + "sha256_in_prefix": "f1c53f5b87f221db66004b836aa2fc9462aa46c2fbe46b417a8ddc803ce2f585", + "size_in_bytes": 900 + }, + { + "_path": "include/python3.12/cpython/frameobject.h", + "path_type": "hardlink", + "sha256": "e1421b58c6a25efb56f423a749c313e3f5392f58cc0c7f4f09b0412217a4a734", + "sha256_in_prefix": "e1421b58c6a25efb56f423a749c313e3f5392f58cc0c7f4f09b0412217a4a734", + "size_in_bytes": 1108 + }, + { + "_path": "include/python3.12/cpython/funcobject.h", + "path_type": "hardlink", + "sha256": "744cd5bc453de548ec454f1fb26e58efa581f3a51dee2b09872cb45bc3a5f981", + "sha256_in_prefix": "744cd5bc453de548ec454f1fb26e58efa581f3a51dee2b09872cb45bc3a5f981", + "size_in_bytes": 7150 + }, + { + "_path": "include/python3.12/cpython/genobject.h", + "path_type": "hardlink", + "sha256": "24f9bd2f19341dc73c7deebca17117ea3a94fd89865c0c6548e1bf5882f51d95", + "sha256_in_prefix": "24f9bd2f19341dc73c7deebca17117ea3a94fd89865c0c6548e1bf5882f51d95", + "size_in_bytes": 3316 + }, + { + "_path": "include/python3.12/cpython/import.h", + "path_type": "hardlink", + "sha256": "f3a6cb7ea774d2ffcb64c834dffaf008e8f9f3f10b23600d5522d82176cb241c", + "sha256_in_prefix": "f3a6cb7ea774d2ffcb64c834dffaf008e8f9f3f10b23600d5522d82176cb241c", + "size_in_bytes": 1623 + }, + { + "_path": "include/python3.12/cpython/initconfig.h", + "path_type": "hardlink", + "sha256": "86e3b9d1de6f310415912e2cdfdc276e311c026ec7fdf6190893f6313cd860a3", + "sha256_in_prefix": "86e3b9d1de6f310415912e2cdfdc276e311c026ec7fdf6190893f6313cd860a3", + "size_in_bytes": 7820 + }, + { + "_path": "include/python3.12/cpython/interpreteridobject.h", + "path_type": "hardlink", + "sha256": "8fc79784d556245d7b7f382063ef3797e3aebd0a6b375a95027dd63a5dfa30b6", + "sha256_in_prefix": "8fc79784d556245d7b7f382063ef3797e3aebd0a6b375a95027dd63a5dfa30b6", + "size_in_bytes": 387 + }, + { + "_path": "include/python3.12/cpython/listobject.h", + "path_type": "hardlink", + "sha256": "0ccca44b405add7a8c19d7a5e7701e06ab904cce5c430016b50f7968aef296fe", + "sha256_in_prefix": "0ccca44b405add7a8c19d7a5e7701e06ab904cce5c430016b50f7968aef296fe", + "size_in_bytes": 1633 + }, + { + "_path": "include/python3.12/cpython/longintrepr.h", + "path_type": "hardlink", + "sha256": "65ca4c2129e3dce303029a70add853b1ed25520df71ad731853f520862a5ff70", + "sha256_in_prefix": "65ca4c2129e3dce303029a70add853b1ed25520df71ad731853f520862a5ff70", + "size_in_bytes": 4879 + }, + { + "_path": "include/python3.12/cpython/longobject.h", + "path_type": "hardlink", + "sha256": "b443782d6b69a2cfd141ac13ac8b7a8d69e47bfdae9df984de4991b2d248b8b8", + "sha256_in_prefix": "b443782d6b69a2cfd141ac13ac8b7a8d69e47bfdae9df984de4991b2d248b8b8", + "size_in_bytes": 4679 + }, + { + "_path": "include/python3.12/cpython/memoryobject.h", + "path_type": "hardlink", + "sha256": "62f414f21611a31f453af7c8326b309aad8f79166087a951844921c50cc84dc7", + "sha256_in_prefix": "62f414f21611a31f453af7c8326b309aad8f79166087a951844921c50cc84dc7", + "size_in_bytes": 2272 + }, + { + "_path": "include/python3.12/cpython/methodobject.h", + "path_type": "hardlink", + "sha256": "5beb9f3b68ac72efe403a1b0a3fbbb14a5606a49a2840b9c7e9ff243d82d79b9", + "sha256_in_prefix": "5beb9f3b68ac72efe403a1b0a3fbbb14a5606a49a2840b9c7e9ff243d82d79b9", + "size_in_bytes": 2276 + }, + { + "_path": "include/python3.12/cpython/modsupport.h", + "path_type": "hardlink", + "sha256": "a8d08132874d9d642ade82e62e87a510577b7bd4ab0685a90b044cc3b005232d", + "sha256_in_prefix": "a8d08132874d9d642ade82e62e87a510577b7bd4ab0685a90b044cc3b005232d", + "size_in_bytes": 4336 + }, + { + "_path": "include/python3.12/cpython/object.h", + "path_type": "hardlink", + "sha256": "f412fd84202ef228e6bf239c9a5a408b8d8623481a15452f8f3331dfc6342134", + "sha256_in_prefix": "f412fd84202ef228e6bf239c9a5a408b8d8623481a15452f8f3331dfc6342134", + "size_in_bytes": 21212 + }, + { + "_path": "include/python3.12/cpython/objimpl.h", + "path_type": "hardlink", + "sha256": "d99f0cff4297590a49f6616dbf1b04a06c745bed0a280ae35acc56fb3c47f2f3", + "sha256_in_prefix": "d99f0cff4297590a49f6616dbf1b04a06c745bed0a280ae35acc56fb3c47f2f3", + "size_in_bytes": 3316 + }, + { + "_path": "include/python3.12/cpython/odictobject.h", + "path_type": "hardlink", + "sha256": "97dc6296e890463fc6994247e885df65cd4024dc1b05facfdc984c37d646b919", + "sha256_in_prefix": "97dc6296e890463fc6994247e885df65cd4024dc1b05facfdc984c37d646b919", + "size_in_bytes": 1311 + }, + { + "_path": "include/python3.12/cpython/picklebufobject.h", + "path_type": "hardlink", + "sha256": "7040fb48462296c903f2f0d24d2b54e0de63cf7512dcf8d3048a0cadf7d94fd0", + "sha256_in_prefix": "7040fb48462296c903f2f0d24d2b54e0de63cf7512dcf8d3048a0cadf7d94fd0", + "size_in_bytes": 848 + }, + { + "_path": "include/python3.12/cpython/pthread_stubs.h", + "path_type": "hardlink", + "sha256": "0f3108e0430ee937098c86352d2ced6e3ec7f5cb5bc7e06eebee58cf779fcd89", + "sha256_in_prefix": "0f3108e0430ee937098c86352d2ced6e3ec7f5cb5bc7e06eebee58cf779fcd89", + "size_in_bytes": 3505 + }, + { + "_path": "include/python3.12/cpython/pyctype.h", + "path_type": "hardlink", + "sha256": "10b5ccbc210fd2832e9c34849a3952e8db75f0016add89188358b1da6a8f3dbb", + "sha256_in_prefix": "10b5ccbc210fd2832e9c34849a3952e8db75f0016add89188358b1da6a8f3dbb", + "size_in_bytes": 1387 + }, + { + "_path": "include/python3.12/cpython/pydebug.h", + "path_type": "hardlink", + "sha256": "83d72e867b4fc9ac87efdfcb41c3d30ec20fa239fe6a74d1b85aa92e1f8d9506", + "sha256_in_prefix": "83d72e867b4fc9ac87efdfcb41c3d30ec20fa239fe6a74d1b85aa92e1f8d9506", + "size_in_bytes": 1413 + }, + { + "_path": "include/python3.12/cpython/pyerrors.h", + "path_type": "hardlink", + "sha256": "1f5070d787263e3aa8845dc90b38aaeb0945be83ef2ba993a40b4af926daacad", + "sha256_in_prefix": "1f5070d787263e3aa8845dc90b38aaeb0945be83ef2ba993a40b4af926daacad", + "size_in_bytes": 4276 + }, + { + "_path": "include/python3.12/cpython/pyfpe.h", + "path_type": "hardlink", + "sha256": "ea7bfa7d891a0b5372d8b40a57d1b466b7824296e5c3f8d50b1a7cde084429b7", + "sha256_in_prefix": "ea7bfa7d891a0b5372d8b40a57d1b466b7824296e5c3f8d50b1a7cde084429b7", + "size_in_bytes": 444 + }, + { + "_path": "include/python3.12/cpython/pyframe.h", + "path_type": "hardlink", + "sha256": "0c7ea17874b967892de6f6623aa426d5eaf267a56e6bbb84b3fefa40e59ec1b8", + "sha256_in_prefix": "0c7ea17874b967892de6f6623aa426d5eaf267a56e6bbb84b3fefa40e59ec1b8", + "size_in_bytes": 1479 + }, + { + "_path": "include/python3.12/cpython/pylifecycle.h", + "path_type": "hardlink", + "sha256": "02505815b8bc3e33fe31a11f4f7f960826aa1dce2c4cee6d62d2a0394470c9bf", + "sha256_in_prefix": "02505815b8bc3e33fe31a11f4f7f960826aa1dce2c4cee6d62d2a0394470c9bf", + "size_in_bytes": 3423 + }, + { + "_path": "include/python3.12/cpython/pymem.h", + "path_type": "hardlink", + "sha256": "8a3795a9350b10548e8ad6d37dad69be2abd3870a751e67faa32a19a090608db", + "sha256_in_prefix": "8a3795a9350b10548e8ad6d37dad69be2abd3870a751e67faa32a19a090608db", + "size_in_bytes": 3379 + }, + { + "_path": "include/python3.12/cpython/pystate.h", + "path_type": "hardlink", + "sha256": "012cb810792852a79ac96af53fb92ee4beb543eace6d0e9934fb873de106d05d", + "sha256_in_prefix": "012cb810792852a79ac96af53fb92ee4beb543eace6d0e9934fb873de106d05d", + "size_in_bytes": 16921 + }, + { + "_path": "include/python3.12/cpython/pythonrun.h", + "path_type": "hardlink", + "sha256": "3290ea064e7450aaf43320a5fcac22d9b36acfab43d1d2c3381ade4b726ced8f", + "sha256_in_prefix": "3290ea064e7450aaf43320a5fcac22d9b36acfab43d1d2c3381ade4b726ced8f", + "size_in_bytes": 4903 + }, + { + "_path": "include/python3.12/cpython/pythread.h", + "path_type": "hardlink", + "sha256": "7239113064e41ba5a678b665af17bee1f878d51076f6d82f89d5d52151ebf573", + "sha256_in_prefix": "7239113064e41ba5a678b665af17bee1f878d51076f6d82f89d5d52151ebf573", + "size_in_bytes": 1426 + }, + { + "_path": "include/python3.12/cpython/pytime.h", + "path_type": "hardlink", + "sha256": "64b70f16b9e6845e0378f2f9108952731ca5bd43b33609781dccd5af70d60204", + "sha256_in_prefix": "64b70f16b9e6845e0378f2f9108952731ca5bd43b33609781dccd5af70d60204", + "size_in_bytes": 12375 + }, + { + "_path": "include/python3.12/cpython/setobject.h", + "path_type": "hardlink", + "sha256": "c965bf093325e20c319af5183a8e5723d4d0b373cb6d1b8781df8c1e588963c0", + "sha256_in_prefix": "c965bf093325e20c319af5183a8e5723d4d0b373cb6d1b8781df8c1e588963c0", + "size_in_bytes": 2146 + }, + { + "_path": "include/python3.12/cpython/sysmodule.h", + "path_type": "hardlink", + "sha256": "d4936db24692cccadb19c11accda260787f95e5658f88cfc752d9a49344ee051", + "sha256_in_prefix": "d4936db24692cccadb19c11accda260787f95e5658f88cfc752d9a49344ee051", + "size_in_bytes": 489 + }, + { + "_path": "include/python3.12/cpython/traceback.h", + "path_type": "hardlink", + "sha256": "7898a3c168973e1119fb3b57f144be627c1468082ab0b91d001dd876dd1dbcb6", + "sha256_in_prefix": "7898a3c168973e1119fb3b57f144be627c1468082ab0b91d001dd876dd1dbcb6", + "size_in_bytes": 444 + }, + { + "_path": "include/python3.12/cpython/tupleobject.h", + "path_type": "hardlink", + "sha256": "301c0720038f50d8e9087b38cf1392524abf9e28262b677d841fc1a7e172c3f3", + "sha256_in_prefix": "301c0720038f50d8e9087b38cf1392524abf9e28262b677d841fc1a7e172c3f3", + "size_in_bytes": 1377 + }, + { + "_path": "include/python3.12/cpython/unicodeobject.h", + "path_type": "hardlink", + "sha256": "1fece91b6ddd3b131e4c2783973b9226f1efe6e53a2530da21bb75f18ebad6c5", + "sha256_in_prefix": "1fece91b6ddd3b131e4c2783973b9226f1efe6e53a2530da21bb75f18ebad6c5", + "size_in_bytes": 34467 + }, + { + "_path": "include/python3.12/cpython/warnings.h", + "path_type": "hardlink", + "sha256": "b758a2e42b0c497ea811464f579603d14fc30b50bd6ebe064d8d2a7df7e2bd76", + "sha256_in_prefix": "b758a2e42b0c497ea811464f579603d14fc30b50bd6ebe064d8d2a7df7e2bd76", + "size_in_bytes": 564 + }, + { + "_path": "include/python3.12/cpython/weakrefobject.h", + "path_type": "hardlink", + "sha256": "be0ab05169da7efcd13aba0ddc58604a80328d4e60349df6d4efdd1bf363e1a2", + "sha256_in_prefix": "be0ab05169da7efcd13aba0ddc58604a80328d4e60349df6d4efdd1bf363e1a2", + "size_in_bytes": 2032 + }, + { + "_path": "include/python3.12/datetime.h", + "path_type": "hardlink", + "sha256": "f3d8192cada0f490a67233e615e5974f062501b2876147118ddb042ee4a7f988", + "sha256_in_prefix": "f3d8192cada0f490a67233e615e5974f062501b2876147118ddb042ee4a7f988", + "size_in_bytes": 9769 + }, + { + "_path": "include/python3.12/descrobject.h", + "path_type": "hardlink", + "sha256": "2956a488f4c4c61341e361dac949cfa4a217e0fbd0097892513b02363c9570a7", + "sha256_in_prefix": "2956a488f4c4c61341e361dac949cfa4a217e0fbd0097892513b02363c9570a7", + "size_in_bytes": 3080 + }, + { + "_path": "include/python3.12/dictobject.h", + "path_type": "hardlink", + "sha256": "08f92e2a4421d3e81fa0fa1b60cbe97f2d69897226368481b0ffc41eeb202356", + "sha256_in_prefix": "08f92e2a4421d3e81fa0fa1b60cbe97f2d69897226368481b0ffc41eeb202356", + "size_in_bytes": 3860 + }, + { + "_path": "include/python3.12/dynamic_annotations.h", + "path_type": "hardlink", + "sha256": "3e4366f7d082835049730358d277a5ad7a60e16d1601f5622f0a045a37c152ac", + "sha256_in_prefix": "3e4366f7d082835049730358d277a5ad7a60e16d1601f5622f0a045a37c152ac", + "size_in_bytes": 22471 + }, + { + "_path": "include/python3.12/enumobject.h", + "path_type": "hardlink", + "sha256": "2244fe250db9995068fe74dce0e23fd70c12b03fd94751d98b773be8f64896b6", + "sha256_in_prefix": "2244fe250db9995068fe74dce0e23fd70c12b03fd94751d98b773be8f64896b6", + "size_in_bytes": 253 + }, + { + "_path": "include/python3.12/errcode.h", + "path_type": "hardlink", + "sha256": "e09ffcbb80580103d52992eb5fd8fd01b9930fda5e8f3874bfb9ee7aa2fe99fa", + "sha256_in_prefix": "e09ffcbb80580103d52992eb5fd8fd01b9930fda5e8f3874bfb9ee7aa2fe99fa", + "size_in_bytes": 1779 + }, + { + "_path": "include/python3.12/exports.h", + "path_type": "hardlink", + "sha256": "d02e9937f747660b218062bcdab504b706cad264b4df993f749d9118f2f7b65c", + "sha256_in_prefix": "d02e9937f747660b218062bcdab504b706cad264b4df993f749d9118f2f7b65c", + "size_in_bytes": 1267 + }, + { + "_path": "include/python3.12/fileobject.h", + "path_type": "hardlink", + "sha256": "133e57cf705cbdaa79a0c115b27e748cc24dedb51ea17b441ff65d05df28a674", + "sha256_in_prefix": "133e57cf705cbdaa79a0c115b27e748cc24dedb51ea17b441ff65d05df28a674", + "size_in_bytes": 1650 + }, + { + "_path": "include/python3.12/fileutils.h", + "path_type": "hardlink", + "sha256": "51ae1c2ca70a8005206f653121d1ba3247f59421c96399739845d687980e9b01", + "sha256_in_prefix": "51ae1c2ca70a8005206f653121d1ba3247f59421c96399739845d687980e9b01", + "size_in_bytes": 507 + }, + { + "_path": "include/python3.12/floatobject.h", + "path_type": "hardlink", + "sha256": "2da72b48fa342e53f72848d468c3c11a9d5b62922f2bd71c286331f54f2364a1", + "sha256_in_prefix": "2da72b48fa342e53f72848d468c3c11a9d5b62922f2bd71c286331f54f2364a1", + "size_in_bytes": 1532 + }, + { + "_path": "include/python3.12/frameobject.h", + "path_type": "hardlink", + "sha256": "969cd93065ce79b81bbc67a65d31b742e23f30bf79d6e44a306963d552ed0c35", + "sha256_in_prefix": "969cd93065ce79b81bbc67a65d31b742e23f30bf79d6e44a306963d552ed0c35", + "size_in_bytes": 336 + }, + { + "_path": "include/python3.12/genericaliasobject.h", + "path_type": "hardlink", + "sha256": "0e53a0b18c114be68eccea9ffd1dd577e204b1f0ada4d3aedc8e7ee0c80fc7f8", + "sha256_in_prefix": "0e53a0b18c114be68eccea9ffd1dd577e204b1f0ada4d3aedc8e7ee0c80fc7f8", + "size_in_bytes": 334 + }, + { + "_path": "include/python3.12/import.h", + "path_type": "hardlink", + "sha256": "4113e1b6afa760c3decce2bb765835adda19861394974cfe301e1ccb482e2b94", + "sha256_in_prefix": "4113e1b6afa760c3decce2bb765835adda19861394974cfe301e1ccb482e2b94", + "size_in_bytes": 3033 + }, + { + "_path": "include/python3.12/internal/pycore_abstract.h", + "path_type": "hardlink", + "sha256": "75ecd34cdcd06fc64fcfa550f66975d755619e7cf06fdae8ecbe2de6ec49ce39", + "sha256_in_prefix": "75ecd34cdcd06fc64fcfa550f66975d755619e7cf06fdae8ecbe2de6ec49ce39", + "size_in_bytes": 611 + }, + { + "_path": "include/python3.12/internal/pycore_asdl.h", + "path_type": "hardlink", + "sha256": "b29dace0f84849c4a24bc3745523a36911cd192bad7ec6fb48aba8facff51d3e", + "sha256_in_prefix": "b29dace0f84849c4a24bc3745523a36911cd192bad7ec6fb48aba8facff51d3e", + "size_in_bytes": 3035 + }, + { + "_path": "include/python3.12/internal/pycore_ast.h", + "path_type": "hardlink", + "sha256": "064b6778fa758fb2580fb8770f77dd0d1eb19323df0e345373788c75754910cf", + "sha256_in_prefix": "064b6778fa758fb2580fb8770f77dd0d1eb19323df0e345373788c75754910cf", + "size_in_bytes": 31288 + }, + { + "_path": "include/python3.12/internal/pycore_ast_state.h", + "path_type": "hardlink", + "sha256": "1d76a7b5207c653a86dec97aab5ba1fcc5c75e94333662792a692cb68e5b26c6", + "sha256_in_prefix": "1d76a7b5207c653a86dec97aab5ba1fcc5c75e94333662792a692cb68e5b26c6", + "size_in_bytes": 6749 + }, + { + "_path": "include/python3.12/internal/pycore_atexit.h", + "path_type": "hardlink", + "sha256": "8c5c88b8452894cf8a5f243ceb9021060f0fe8f5689cbc3e705c19c5edc0798a", + "sha256_in_prefix": "8c5c88b8452894cf8a5f243ceb9021060f0fe8f5689cbc3e705c19c5edc0798a", + "size_in_bytes": 1149 + }, + { + "_path": "include/python3.12/internal/pycore_atomic.h", + "path_type": "hardlink", + "sha256": "95e7118e799ad3faafc8e58a29b2d1f1a4bb94e1aac3273e042f379f8e12d4e6", + "sha256_in_prefix": "95e7118e799ad3faafc8e58a29b2d1f1a4bb94e1aac3273e042f379f8e12d4e6", + "size_in_bytes": 16979 + }, + { + "_path": "include/python3.12/internal/pycore_atomic_funcs.h", + "path_type": "hardlink", + "sha256": "9d5cfa13ad863a0cc1b0ab06861c1f8cfbdc7d730b9c4603e5777a608263d399", + "sha256_in_prefix": "9d5cfa13ad863a0cc1b0ab06861c1f8cfbdc7d730b9c4603e5777a608263d399", + "size_in_bytes": 2438 + }, + { + "_path": "include/python3.12/internal/pycore_bitutils.h", + "path_type": "hardlink", + "sha256": "86628b9cbefe4ff000e1190cd36f37b70a2dad6a4e9231cc2466a84579cc2139", + "sha256_in_prefix": "86628b9cbefe4ff000e1190cd36f37b70a2dad6a4e9231cc2466a84579cc2139", + "size_in_bytes": 6062 + }, + { + "_path": "include/python3.12/internal/pycore_blocks_output_buffer.h", + "path_type": "hardlink", + "sha256": "03fed5054d0d78e3711e73995e484fefb81495c063a5b9ef555c0395d7fc1ebc", + "sha256_in_prefix": "03fed5054d0d78e3711e73995e484fefb81495c063a5b9ef555c0395d7fc1ebc", + "size_in_bytes": 8688 + }, + { + "_path": "include/python3.12/internal/pycore_bytes_methods.h", + "path_type": "hardlink", + "sha256": "1534326dbf027e9bb472be5ccf8b82fab48f3282cc7f6a61629b801fc80afc00", + "sha256_in_prefix": "1534326dbf027e9bb472be5ccf8b82fab48f3282cc7f6a61629b801fc80afc00", + "size_in_bytes": 3384 + }, + { + "_path": "include/python3.12/internal/pycore_bytesobject.h", + "path_type": "hardlink", + "sha256": "d3ecf25cf0f0e9815ac24f496e5ccbbf8d57a10e570da81e84f2b5f6e95b59b8", + "sha256_in_prefix": "d3ecf25cf0f0e9815ac24f496e5ccbbf8d57a10e570da81e84f2b5f6e95b59b8", + "size_in_bytes": 1339 + }, + { + "_path": "include/python3.12/internal/pycore_call.h", + "path_type": "hardlink", + "sha256": "5e780aed2dc991455a0e528fc7baca8df61d2e4bec4e137d7e788668b5750ec5", + "sha256_in_prefix": "5e780aed2dc991455a0e528fc7baca8df61d2e4bec4e137d7e788668b5750ec5", + "size_in_bytes": 3920 + }, + { + "_path": "include/python3.12/internal/pycore_ceval.h", + "path_type": "hardlink", + "sha256": "1af22b50c9ececfc4c3a5f37ecb70cc1c0eefad5a2656e6e22fc088cae54e226", + "sha256_in_prefix": "1af22b50c9ececfc4c3a5f37ecb70cc1c0eefad5a2656e6e22fc088cae54e226", + "size_in_bytes": 5265 + }, + { + "_path": "include/python3.12/internal/pycore_ceval_state.h", + "path_type": "hardlink", + "sha256": "f29e3d6dcac96b0067a17845df8483013230805db10c6f3c5ecd02b9134640e7", + "sha256_in_prefix": "f29e3d6dcac96b0067a17845df8483013230805db10c6f3c5ecd02b9134640e7", + "size_in_bytes": 2744 + }, + { + "_path": "include/python3.12/internal/pycore_code.h", + "path_type": "hardlink", + "sha256": "48e78dd1a12e6afa6e54e26f8e7c4f56e20689b84189d503507c7f6c36819092", + "sha256_in_prefix": "48e78dd1a12e6afa6e54e26f8e7c4f56e20689b84189d503507c7f6c36819092", + "size_in_bytes": 15835 + }, + { + "_path": "include/python3.12/internal/pycore_compile.h", + "path_type": "hardlink", + "sha256": "4d386629f5e0ea801a01122833f11363cf9f1584aef6e9692ffd0b95eda37cbc", + "sha256_in_prefix": "4d386629f5e0ea801a01122833f11363cf9f1584aef6e9692ffd0b95eda37cbc", + "size_in_bytes": 3453 + }, + { + "_path": "include/python3.12/internal/pycore_condvar.h", + "path_type": "hardlink", + "sha256": "89a5d9c366c2e1c312e1ace5067d184380242c944deb698b6a4f53b51abd5826", + "sha256_in_prefix": "89a5d9c366c2e1c312e1ace5067d184380242c944deb698b6a4f53b51abd5826", + "size_in_bytes": 2839 + }, + { + "_path": "include/python3.12/internal/pycore_context.h", + "path_type": "hardlink", + "sha256": "974d6bafbe0164d60dd1bc4f09b5eac9bcc9e2d9066924ba2a2ba6d502f115b5", + "sha256_in_prefix": "974d6bafbe0164d60dd1bc4f09b5eac9bcc9e2d9066924ba2a2ba6d502f115b5", + "size_in_bytes": 1301 + }, + { + "_path": "include/python3.12/internal/pycore_descrobject.h", + "path_type": "hardlink", + "sha256": "d9be424b5c2d109b51338016acab6132f299c0640fc069fb0e1d48575089574e", + "sha256_in_prefix": "d9be424b5c2d109b51338016acab6132f299c0640fc069fb0e1d48575089574e", + "size_in_bytes": 499 + }, + { + "_path": "include/python3.12/internal/pycore_dict.h", + "path_type": "hardlink", + "sha256": "4d51e7184d50a5f8785a1cbdc9f6eb36b86201158ae6e3527884ce2b5dd504bf", + "sha256_in_prefix": "4d51e7184d50a5f8785a1cbdc9f6eb36b86201158ae6e3527884ce2b5dd504bf", + "size_in_bytes": 6384 + }, + { + "_path": "include/python3.12/internal/pycore_dict_state.h", + "path_type": "hardlink", + "sha256": "5a15c2bb4020ce4a1d7a4c651e0f98b4becd910f89cd7c4089c80a0419ec4f1c", + "sha256_in_prefix": "5a15c2bb4020ce4a1d7a4c651e0f98b4becd910f89cd7c4089c80a0419ec4f1c", + "size_in_bytes": 1095 + }, + { + "_path": "include/python3.12/internal/pycore_dtoa.h", + "path_type": "hardlink", + "sha256": "a67261c7187a02a6d2ef7fef8207acb85ce5906f4ee970f4f06822f695f489ad", + "sha256_in_prefix": "a67261c7187a02a6d2ef7fef8207acb85ce5906f4ee970f4f06822f695f489ad", + "size_in_bytes": 1626 + }, + { + "_path": "include/python3.12/internal/pycore_emscripten_signal.h", + "path_type": "hardlink", + "sha256": "1acd47a1c09e365be8c7fa51db31307021cc2e471471fc199e26f317df58c4b8", + "sha256_in_prefix": "1acd47a1c09e365be8c7fa51db31307021cc2e471471fc199e26f317df58c4b8", + "size_in_bytes": 562 + }, + { + "_path": "include/python3.12/internal/pycore_exceptions.h", + "path_type": "hardlink", + "sha256": "4590af737d53afcbd7d559434190d2d8ff4f5cd0e923837721aea5ebb000ef68", + "sha256_in_prefix": "4590af737d53afcbd7d559434190d2d8ff4f5cd0e923837721aea5ebb000ef68", + "size_in_bytes": 842 + }, + { + "_path": "include/python3.12/internal/pycore_faulthandler.h", + "path_type": "hardlink", + "sha256": "6444dce1924eae011d27385183ad1a5de6908501cedce2e1531abd834c68cae7", + "sha256_in_prefix": "6444dce1924eae011d27385183ad1a5de6908501cedce2e1531abd834c68cae7", + "size_in_bytes": 2220 + }, + { + "_path": "include/python3.12/internal/pycore_fileutils.h", + "path_type": "hardlink", + "sha256": "ea9cac693c87dc049f199cecd2844592ee08d0283dc0b059c4caab517932af73", + "sha256_in_prefix": "ea9cac693c87dc049f199cecd2844592ee08d0283dc0b059c4caab517932af73", + "size_in_bytes": 7910 + }, + { + "_path": "include/python3.12/internal/pycore_fileutils_windows.h", + "path_type": "hardlink", + "sha256": "9e976ea0f3457c8b40db0a3b2cfea9e9684737f75282400ec0040ae0df1e6385", + "sha256_in_prefix": "9e976ea0f3457c8b40db0a3b2cfea9e9684737f75282400ec0040ae0df1e6385", + "size_in_bytes": 2724 + }, + { + "_path": "include/python3.12/internal/pycore_floatobject.h", + "path_type": "hardlink", + "sha256": "021fef24c4b7e7390c793af7ccf12ddd94b1871e27d26997b37eb3093d5380b5", + "sha256_in_prefix": "021fef24c4b7e7390c793af7ccf12ddd94b1871e27d26997b37eb3093d5380b5", + "size_in_bytes": 1578 + }, + { + "_path": "include/python3.12/internal/pycore_flowgraph.h", + "path_type": "hardlink", + "sha256": "c58cdc30ce8c853404f55881813ec69d6dbf921f2769ec9e289b5155b7a349db", + "sha256_in_prefix": "c58cdc30ce8c853404f55881813ec69d6dbf921f2769ec9e289b5155b7a349db", + "size_in_bytes": 4630 + }, + { + "_path": "include/python3.12/internal/pycore_format.h", + "path_type": "hardlink", + "sha256": "253cc77e6d11ba20d297813e064650fa965b3653f150bd85f805b94db5f3a98d", + "sha256_in_prefix": "253cc77e6d11ba20d297813e064650fa965b3653f150bd85f805b94db5f3a98d", + "size_in_bytes": 480 + }, + { + "_path": "include/python3.12/internal/pycore_frame.h", + "path_type": "hardlink", + "sha256": "97c7e2722af4c30c240b8b3c867a54b2fe49a4207d2e566c6a19a9d190fd0f8a", + "sha256_in_prefix": "97c7e2722af4c30c240b8b3c867a54b2fe49a4207d2e566c6a19a9d190fd0f8a", + "size_in_bytes": 9256 + }, + { + "_path": "include/python3.12/internal/pycore_function.h", + "path_type": "hardlink", + "sha256": "8fad970bd3f31347aed72b92acd17270dbb6ec5333ab5ed6fe43dc9cf2527841", + "sha256_in_prefix": "8fad970bd3f31347aed72b92acd17270dbb6ec5333ab5ed6fe43dc9cf2527841", + "size_in_bytes": 611 + }, + { + "_path": "include/python3.12/internal/pycore_gc.h", + "path_type": "hardlink", + "sha256": "d0349a94dafb16ec4c05ba5a94d3b9e6cec53fe7b5e0d74216ea31996546f9a3", + "sha256_in_prefix": "d0349a94dafb16ec4c05ba5a94d3b9e6cec53fe7b5e0d74216ea31996546f9a3", + "size_in_bytes": 7658 + }, + { + "_path": "include/python3.12/internal/pycore_genobject.h", + "path_type": "hardlink", + "sha256": "a940f41da1e8d9d12c9c438ea0b4f24e72abc494447bcecd9423b76f54e3402a", + "sha256_in_prefix": "a940f41da1e8d9d12c9c438ea0b4f24e72abc494447bcecd9423b76f54e3402a", + "size_in_bytes": 1186 + }, + { + "_path": "include/python3.12/internal/pycore_getopt.h", + "path_type": "hardlink", + "sha256": "e93393067b66b557b0300e05c10ee904d4be54cadfb214c5328a9225ad199452", + "sha256_in_prefix": "e93393067b66b557b0300e05c10ee904d4be54cadfb214c5328a9225ad199452", + "size_in_bytes": 490 + }, + { + "_path": "include/python3.12/internal/pycore_gil.h", + "path_type": "hardlink", + "sha256": "cf455aacd5651e5b43547ebe69bb324eab84238d92665df53c1df32434bd0d9b", + "sha256_in_prefix": "cf455aacd5651e5b43547ebe69bb324eab84238d92665df53c1df32434bd0d9b", + "size_in_bytes": 1565 + }, + { + "_path": "include/python3.12/internal/pycore_global_objects.h", + "path_type": "hardlink", + "sha256": "ce857a319514b1682eb054bf4a017974b0bf211092819b25f23e877a228090df", + "sha256_in_prefix": "ce857a319514b1682eb054bf4a017974b0bf211092819b25f23e877a228090df", + "size_in_bytes": 3035 + }, + { + "_path": "include/python3.12/internal/pycore_global_objects_fini_generated.h", + "path_type": "hardlink", + "sha256": "79fd2e366a02d8b39181f7466a32af1b1c69ec5566bf301b3d9943c552cf9206", + "sha256_in_prefix": "79fd2e366a02d8b39181f7466a32af1b1c69ec5566bf301b3d9943c552cf9206", + "size_in_bytes": 116175 + }, + { + "_path": "include/python3.12/internal/pycore_global_strings.h", + "path_type": "hardlink", + "sha256": "7991d72ba2c0d8c4cc58575bc29a53fb2a61a89f03335e60320df097d58f1adb", + "sha256_in_prefix": "7991d72ba2c0d8c4cc58575bc29a53fb2a61a89f03335e60320df097d58f1adb", + "size_in_bytes": 25665 + }, + { + "_path": "include/python3.12/internal/pycore_hamt.h", + "path_type": "hardlink", + "sha256": "074b31c2f5701cac43d8dc3e4ede40b2befc6dddfcaa2862cfc8f76234c30ae8", + "sha256_in_prefix": "074b31c2f5701cac43d8dc3e4ede40b2befc6dddfcaa2862cfc8f76234c30ae8", + "size_in_bytes": 3742 + }, + { + "_path": "include/python3.12/internal/pycore_hashtable.h", + "path_type": "hardlink", + "sha256": "690488a7e50ad743e1bb685702fbcfac866ace89d2417a247c1171afdc222261", + "sha256_in_prefix": "690488a7e50ad743e1bb685702fbcfac866ace89d2417a247c1171afdc222261", + "size_in_bytes": 4286 + }, + { + "_path": "include/python3.12/internal/pycore_import.h", + "path_type": "hardlink", + "sha256": "e5b179692f05707e7fb182b908ed46f9a75f4a751b20501a74de2a440c387e1d", + "sha256_in_prefix": "e5b179692f05707e7fb182b908ed46f9a75f4a751b20501a74de2a440c387e1d", + "size_in_bytes": 6358 + }, + { + "_path": "include/python3.12/internal/pycore_initconfig.h", + "path_type": "hardlink", + "sha256": "caf13e2c290ae8375636d0e1f3b1851a90396b3747da650d058c282b8743b558", + "sha256_in_prefix": "caf13e2c290ae8375636d0e1f3b1851a90396b3747da650d058c282b8743b558", + "size_in_bytes": 5706 + }, + { + "_path": "include/python3.12/internal/pycore_instruments.h", + "path_type": "hardlink", + "sha256": "b7358dcda113f7cca10abf8b257cc4aca2be0fe2e5293696c3601fa065731cb8", + "sha256_in_prefix": "b7358dcda113f7cca10abf8b257cc4aca2be0fe2e5293696c3601fa065731cb8", + "size_in_bytes": 2999 + }, + { + "_path": "include/python3.12/internal/pycore_interp.h", + "path_type": "hardlink", + "sha256": "23f5d7884f9e0b212fe79879bbcdc5a2c23c22283db38cadbac6f108bf0f1b75", + "sha256_in_prefix": "23f5d7884f9e0b212fe79879bbcdc5a2c23c22283db38cadbac6f108bf0f1b75", + "size_in_bytes": 9086 + }, + { + "_path": "include/python3.12/internal/pycore_intrinsics.h", + "path_type": "hardlink", + "sha256": "e6d6d1eae51b508196615094a4c17189e9822eacb5c0e94102e78aa7136dd9a8", + "sha256_in_prefix": "e6d6d1eae51b508196615094a4c17189e9822eacb5c0e94102e78aa7136dd9a8", + "size_in_bytes": 1397 + }, + { + "_path": "include/python3.12/internal/pycore_list.h", + "path_type": "hardlink", + "sha256": "470a62bb98b383b85ec738a6577424e6cdd51ae235f4e5ea06c5afdedb6e1652", + "sha256_in_prefix": "470a62bb98b383b85ec738a6577424e6cdd51ae235f4e5ea06c5afdedb6e1652", + "size_in_bytes": 1980 + }, + { + "_path": "include/python3.12/internal/pycore_long.h", + "path_type": "hardlink", + "sha256": "84c0c7bd7ba0c2fbbfb106561e32328e478d8350afe756af6a4862c95d921a06", + "sha256_in_prefix": "84c0c7bd7ba0c2fbbfb106561e32328e478d8350afe756af6a4862c95d921a06", + "size_in_bytes": 7805 + }, + { + "_path": "include/python3.12/internal/pycore_memoryobject.h", + "path_type": "hardlink", + "sha256": "c845bb546019ed9999403018740ee5b26f83f8d888c5288895897cb2bd1b5eec", + "sha256_in_prefix": "c845bb546019ed9999403018740ee5b26f83f8d888c5288895897cb2bd1b5eec", + "size_in_bytes": 383 + }, + { + "_path": "include/python3.12/internal/pycore_moduleobject.h", + "path_type": "hardlink", + "sha256": "55a8f42968545a349d8e0b43cd1822b22ae2cf9fa0fb098c6bb843e7af76e165", + "sha256_in_prefix": "55a8f42968545a349d8e0b43cd1822b22ae2cf9fa0fb098c6bb843e7af76e165", + "size_in_bytes": 1192 + }, + { + "_path": "include/python3.12/internal/pycore_namespace.h", + "path_type": "hardlink", + "sha256": "466fe0e3f48e954d8bfe9e0c73fc9378cf79ca37710778ba6698e1c365304956", + "sha256_in_prefix": "466fe0e3f48e954d8bfe9e0c73fc9378cf79ca37710778ba6698e1c365304956", + "size_in_bytes": 392 + }, + { + "_path": "include/python3.12/internal/pycore_object.h", + "path_type": "hardlink", + "sha256": "ce41bd5e4720ffe713fd4f36798c92ec23ca966799805a0e2d4607dfc1d9dc2e", + "sha256_in_prefix": "ce41bd5e4720ffe713fd4f36798c92ec23ca966799805a0e2d4607dfc1d9dc2e", + "size_in_bytes": 14429 + }, + { + "_path": "include/python3.12/internal/pycore_object_state.h", + "path_type": "hardlink", + "sha256": "3f8950c793e7121629508d4472c6b020f51d9eb583e317383b67da7f931c03ee", + "sha256_in_prefix": "3f8950c793e7121629508d4472c6b020f51d9eb583e317383b67da7f931c03ee", + "size_in_bytes": 737 + }, + { + "_path": "include/python3.12/internal/pycore_obmalloc.h", + "path_type": "hardlink", + "sha256": "d8738004c5dbb5520f401919ed55181a48a9e64a3b51930309fc99fb9d219576", + "sha256_in_prefix": "d8738004c5dbb5520f401919ed55181a48a9e64a3b51930309fc99fb9d219576", + "size_in_bytes": 27284 + }, + { + "_path": "include/python3.12/internal/pycore_obmalloc_init.h", + "path_type": "hardlink", + "sha256": "33853ff5ffac15a8622ff6920ff2bd0bf83d1df7ea6d1563916d05992b3203fb", + "sha256_in_prefix": "33853ff5ffac15a8622ff6920ff2bd0bf83d1df7ea6d1563916d05992b3203fb", + "size_in_bytes": 2085 + }, + { + "_path": "include/python3.12/internal/pycore_opcode.h", + "path_type": "hardlink", + "sha256": "432e30c6145dff72096325d17192d0eff9895b367d4590f782e2d8b9d5f78cd6", + "sha256_in_prefix": "432e30c6145dff72096325d17192d0eff9895b367d4590f782e2d8b9d5f78cd6", + "size_in_bytes": 20081 + }, + { + "_path": "include/python3.12/internal/pycore_opcode_utils.h", + "path_type": "hardlink", + "sha256": "98dfb250812d554278dedee98a2e9cb05b2583b22d2af8ba1aeda6b130a21b40", + "sha256_in_prefix": "98dfb250812d554278dedee98a2e9cb05b2583b22d2af8ba1aeda6b130a21b40", + "size_in_bytes": 2686 + }, + { + "_path": "include/python3.12/internal/pycore_parser.h", + "path_type": "hardlink", + "sha256": "91189a016020eb7de0b1ab8ae38145dbec6b561ae5c75cea15980cb76255ba5b", + "sha256_in_prefix": "91189a016020eb7de0b1ab8ae38145dbec6b561ae5c75cea15980cb76255ba5b", + "size_in_bytes": 1358 + }, + { + "_path": "include/python3.12/internal/pycore_pathconfig.h", + "path_type": "hardlink", + "sha256": "ff96c74aae60eba62bec8c6d52f34471caf07792186bc16d76e7a783f61aa0ed", + "sha256_in_prefix": "ff96c74aae60eba62bec8c6d52f34471caf07792186bc16d76e7a783f61aa0ed", + "size_in_bytes": 606 + }, + { + "_path": "include/python3.12/internal/pycore_pyarena.h", + "path_type": "hardlink", + "sha256": "d4f4e513bae78ff985f51ca48fb7d1a4d57055c59393a1eb661e55e6ec3ba61f", + "sha256_in_prefix": "d4f4e513bae78ff985f51ca48fb7d1a4d57055c59393a1eb661e55e6ec3ba61f", + "size_in_bytes": 2733 + }, + { + "_path": "include/python3.12/internal/pycore_pyerrors.h", + "path_type": "hardlink", + "sha256": "6668d80af8838faf87ff2e37a536c2586e1588d1b23a08f04992c58f6c0630a3", + "sha256_in_prefix": "6668d80af8838faf87ff2e37a536c2586e1588d1b23a08f04992c58f6c0630a3", + "size_in_bytes": 2783 + }, + { + "_path": "include/python3.12/internal/pycore_pyhash.h", + "path_type": "hardlink", + "sha256": "7c631d06afad90fa9c2ddc8dc04b7c2855ee5aa6e7ece0b22d0a966a702abf73", + "sha256_in_prefix": "7c631d06afad90fa9c2ddc8dc04b7c2855ee5aa6e7ece0b22d0a966a702abf73", + "size_in_bytes": 709 + }, + { + "_path": "include/python3.12/internal/pycore_pylifecycle.h", + "path_type": "hardlink", + "sha256": "f6a91e690b8e5d3dca52dcdff63d36a6ad9ad85b7ee1edfc14215cc0483059fa", + "sha256_in_prefix": "f6a91e690b8e5d3dca52dcdff63d36a6ad9ad85b7ee1edfc14215cc0483059fa", + "size_in_bytes": 3365 + }, + { + "_path": "include/python3.12/internal/pycore_pymath.h", + "path_type": "hardlink", + "sha256": "6dd3ea0f9a84bfa3a2eb0a2b7fa1af1dc8aadad3e74305e13f194a1586815376", + "sha256_in_prefix": "6dd3ea0f9a84bfa3a2eb0a2b7fa1af1dc8aadad3e74305e13f194a1586815376", + "size_in_bytes": 8600 + }, + { + "_path": "include/python3.12/internal/pycore_pymem.h", + "path_type": "hardlink", + "sha256": "ad0b35bbf5e665e90223499f8954bfcf36448b1634d54501b0c84d08680323ca", + "sha256_in_prefix": "ad0b35bbf5e665e90223499f8954bfcf36448b1634d54501b0c84d08680323ca", + "size_in_bytes": 3040 + }, + { + "_path": "include/python3.12/internal/pycore_pymem_init.h", + "path_type": "hardlink", + "sha256": "82a1418ee1867e5e9a2717e8a1acfec2e2ff3ef07225e30be7c8cd8f6e29a7ba", + "sha256_in_prefix": "82a1418ee1867e5e9a2717e8a1acfec2e2ff3ef07225e30be7c8cd8f6e29a7ba", + "size_in_bytes": 2654 + }, + { + "_path": "include/python3.12/internal/pycore_pystate.h", + "path_type": "hardlink", + "sha256": "c06823811bf5dd3d84f40d6a087452da5915e3ad277afef2202c9e86e833ce00", + "sha256_in_prefix": "c06823811bf5dd3d84f40d6a087452da5915e3ad277afef2202c9e86e833ce00", + "size_in_bytes": 4982 + }, + { + "_path": "include/python3.12/internal/pycore_pythread.h", + "path_type": "hardlink", + "sha256": "ba04eed4d18d6110982cc58800fda11f3899c61fed644ff9e52a4adedb7b750a", + "sha256_in_prefix": "ba04eed4d18d6110982cc58800fda11f3899c61fed644ff9e52a4adedb7b750a", + "size_in_bytes": 2075 + }, + { + "_path": "include/python3.12/internal/pycore_range.h", + "path_type": "hardlink", + "sha256": "824c5023a85a9c1c2dd50fecf442d12c7b2966e0e71a2d291f6f17f7fd8c29bc", + "sha256_in_prefix": "824c5023a85a9c1c2dd50fecf442d12c7b2966e0e71a2d291f6f17f7fd8c29bc", + "size_in_bytes": 346 + }, + { + "_path": "include/python3.12/internal/pycore_runtime.h", + "path_type": "hardlink", + "sha256": "d47fe4de4c245e2f90ce73792337565cae6ce95d8e2cd08bcda43ec92832b1ac", + "sha256_in_prefix": "d47fe4de4c245e2f90ce73792337565cae6ce95d8e2cd08bcda43ec92832b1ac", + "size_in_bytes": 8429 + }, + { + "_path": "include/python3.12/internal/pycore_runtime_init.h", + "path_type": "hardlink", + "sha256": "60d97c6edbd7eaf3841ce88d3f33794b4c3dfead870914f021e1425e11670321", + "sha256_in_prefix": "60d97c6edbd7eaf3841ce88d3f33794b4c3dfead870914f021e1425e11670321", + "size_in_bytes": 6087 + }, + { + "_path": "include/python3.12/internal/pycore_runtime_init_generated.h", + "path_type": "hardlink", + "sha256": "0c209438a3b41fbbfaffc76669325328d074be692d96c99eea255366689e4055", + "sha256_in_prefix": "0c209438a3b41fbbfaffc76669325328d074be692d96c99eea255366689e4055", + "size_in_bytes": 46045 + }, + { + "_path": "include/python3.12/internal/pycore_signal.h", + "path_type": "hardlink", + "sha256": "186835a8702a10bb1f3f63185d50874f24885716707717f620d3ffd0a2039679", + "sha256_in_prefix": "186835a8702a10bb1f3f63185d50874f24885716707717f620d3ffd0a2039679", + "size_in_bytes": 2611 + }, + { + "_path": "include/python3.12/internal/pycore_sliceobject.h", + "path_type": "hardlink", + "sha256": "e8b9ba794081a75bf73f0eb64089a766b5bd04b076d4368a14a83ff43ce909be", + "sha256_in_prefix": "e8b9ba794081a75bf73f0eb64089a766b5bd04b076d4368a14a83ff43ce909be", + "size_in_bytes": 414 + }, + { + "_path": "include/python3.12/internal/pycore_strhex.h", + "path_type": "hardlink", + "sha256": "45783d1137fc33a8d9e457692227e8395a93b27c76205f50ad7bd8f00fe7aefb", + "sha256_in_prefix": "45783d1137fc33a8d9e457692227e8395a93b27c76205f50ad7bd8f00fe7aefb", + "size_in_bytes": 937 + }, + { + "_path": "include/python3.12/internal/pycore_structseq.h", + "path_type": "hardlink", + "sha256": "e1c1be3681fec8c1146d5a084869c1bbabcbe68223382cdab8536c8b88958891", + "sha256_in_prefix": "e1c1be3681fec8c1146d5a084869c1bbabcbe68223382cdab8536c8b88958891", + "size_in_bytes": 923 + }, + { + "_path": "include/python3.12/internal/pycore_symtable.h", + "path_type": "hardlink", + "sha256": "15684455856daa80b67dd6e0abc322ad055c6bc64ef38d170f9aae26da54b83d", + "sha256_in_prefix": "15684455856daa80b67dd6e0abc322ad055c6bc64ef38d170f9aae26da54b83d", + "size_in_bytes": 6828 + }, + { + "_path": "include/python3.12/internal/pycore_sysmodule.h", + "path_type": "hardlink", + "sha256": "2c22c3f98c917dee3d954957f36713e2ddd96a27b076e05f7360c629f37e983d", + "sha256_in_prefix": "2c22c3f98c917dee3d954957f36713e2ddd96a27b076e05f7360c629f37e983d", + "size_in_bytes": 734 + }, + { + "_path": "include/python3.12/internal/pycore_time.h", + "path_type": "hardlink", + "sha256": "6838118a537e71edaf76290da15cbf2da19499df1ee4e30b15f35bb4b9257b70", + "sha256_in_prefix": "6838118a537e71edaf76290da15cbf2da19499df1ee4e30b15f35bb4b9257b70", + "size_in_bytes": 388 + }, + { + "_path": "include/python3.12/internal/pycore_token.h", + "path_type": "hardlink", + "sha256": "91c75ef718b8e8be2383fdcea502c1e63ebfa6d681afd45672e379ea7e5d3668", + "sha256_in_prefix": "91c75ef718b8e8be2383fdcea502c1e63ebfa6d681afd45672e379ea7e5d3668", + "size_in_bytes": 3050 + }, + { + "_path": "include/python3.12/internal/pycore_traceback.h", + "path_type": "hardlink", + "sha256": "3f9dfb009dc161f2d979f5af76d660611264b5d0b1b4adeeae10d30ee0999ede", + "sha256_in_prefix": "3f9dfb009dc161f2d979f5af76d660611264b5d0b1b4adeeae10d30ee0999ede", + "size_in_bytes": 3501 + }, + { + "_path": "include/python3.12/internal/pycore_tracemalloc.h", + "path_type": "hardlink", + "sha256": "61ac9b846ae579c667d20034c9c4004a07ab3ff039848ddeeec8d9c39ff1331a", + "sha256_in_prefix": "61ac9b846ae579c667d20034c9c4004a07ab3ff039848ddeeec8d9c39ff1331a", + "size_in_bytes": 3075 + }, + { + "_path": "include/python3.12/internal/pycore_tuple.h", + "path_type": "hardlink", + "sha256": "de5677ac0809abf2744ebdd94768b6974e75ea62cc2cee44c4f433e2b818f953", + "sha256_in_prefix": "de5677ac0809abf2744ebdd94768b6974e75ea62cc2cee44c4f433e2b818f953", + "size_in_bytes": 2197 + }, + { + "_path": "include/python3.12/internal/pycore_typeobject.h", + "path_type": "hardlink", + "sha256": "9af7c474e699753e6830949962176eab1f2e3ffa9616a24ab395001fc75db90b", + "sha256_in_prefix": "9af7c474e699753e6830949962176eab1f2e3ffa9616a24ab395001fc75db90b", + "size_in_bytes": 4669 + }, + { + "_path": "include/python3.12/internal/pycore_typevarobject.h", + "path_type": "hardlink", + "sha256": "b925204918e577bfb667a64f5f56e410cba0bc518207ed8535d1fcf1bdd6ab00", + "sha256_in_prefix": "b925204918e577bfb667a64f5f56e410cba0bc518207ed8535d1fcf1bdd6ab00", + "size_in_bytes": 763 + }, + { + "_path": "include/python3.12/internal/pycore_ucnhash.h", + "path_type": "hardlink", + "sha256": "6d9077e875703e5db7daf293a6c7ea3d43d1ee84dec137a950f17a26e9348eb5", + "sha256_in_prefix": "6d9077e875703e5db7daf293a6c7ea3d43d1ee84dec137a950f17a26e9348eb5", + "size_in_bytes": 898 + }, + { + "_path": "include/python3.12/internal/pycore_unicodeobject.h", + "path_type": "hardlink", + "sha256": "916e12522af51502be463a9e722e1e5017827e1d8da62ac68a03887185c1c278", + "sha256_in_prefix": "916e12522af51502be463a9e722e1e5017827e1d8da62ac68a03887185c1c278", + "size_in_bytes": 1966 + }, + { + "_path": "include/python3.12/internal/pycore_unicodeobject_generated.h", + "path_type": "hardlink", + "sha256": "40f9a9c1b38fff0c3b512dd518c8df9a34493775b3c2ffe14f5e854dc4660e06", + "sha256_in_prefix": "40f9a9c1b38fff0c3b512dd518c8df9a34493775b3c2ffe14f5e854dc4660e06", + "size_in_bytes": 91455 + }, + { + "_path": "include/python3.12/internal/pycore_unionobject.h", + "path_type": "hardlink", + "sha256": "f1c5bbdf5660e54872ff1555c179cf6c80f8e04cac41e974b7964e21f82be18c", + "sha256_in_prefix": "f1c5bbdf5660e54872ff1555c179cf6c80f8e04cac41e974b7964e21f82be18c", + "size_in_bytes": 682 + }, + { + "_path": "include/python3.12/internal/pycore_warnings.h", + "path_type": "hardlink", + "sha256": "3229b207245cb9442f09991df7084c8e4cb87cb073a14a2d520bd92634371fcb", + "sha256_in_prefix": "3229b207245cb9442f09991df7084c8e4cb87cb073a14a2d520bd92634371fcb", + "size_in_bytes": 740 + }, + { + "_path": "include/python3.12/interpreteridobject.h", + "path_type": "hardlink", + "sha256": "b497c869333bdf1f79a580a36e9a0ed64fee226daa1d2d45bdfe16c01e52d73c", + "sha256_in_prefix": "b497c869333bdf1f79a580a36e9a0ed64fee226daa1d2d45bdfe16c01e52d73c", + "size_in_bytes": 333 + }, + { + "_path": "include/python3.12/intrcheck.h", + "path_type": "hardlink", + "sha256": "696fe17618c579a8cbaad9b86175f60d43ea0b9e8aaaa1d65ad256d53dc163c1", + "sha256_in_prefix": "696fe17618c579a8cbaad9b86175f60d43ea0b9e8aaaa1d65ad256d53dc163c1", + "size_in_bytes": 772 + }, + { + "_path": "include/python3.12/iterobject.h", + "path_type": "hardlink", + "sha256": "6b16711d2bb6cee55e4288f84142d592eebf07321e32998a5abe2c06deeb77b0", + "sha256_in_prefix": "6b16711d2bb6cee55e4288f84142d592eebf07321e32998a5abe2c06deeb77b0", + "size_in_bytes": 597 + }, + { + "_path": "include/python3.12/listobject.h", + "path_type": "hardlink", + "sha256": "f4cad9a1f48d27a9a7f56702ab0fe785013eb336ea919197600d86a6e54fa5bf", + "sha256_in_prefix": "f4cad9a1f48d27a9a7f56702ab0fe785013eb336ea919197600d86a6e54fa5bf", + "size_in_bytes": 1782 + }, + { + "_path": "include/python3.12/longobject.h", + "path_type": "hardlink", + "sha256": "adf3d5af5dcf4ed3c465606678c7383cb8ddbef19af91851c90dc3db08c52ab4", + "sha256_in_prefix": "adf3d5af5dcf4ed3c465606678c7383cb8ddbef19af91851c90dc3db08c52ab4", + "size_in_bytes": 3275 + }, + { + "_path": "include/python3.12/marshal.h", + "path_type": "hardlink", + "sha256": "d7f5760ef6496776cee99aca5491789f6ab261a78b156b5758538ea15e1827e5", + "sha256_in_prefix": "d7f5760ef6496776cee99aca5491789f6ab261a78b156b5758538ea15e1827e5", + "size_in_bytes": 827 + }, + { + "_path": "include/python3.12/memoryobject.h", + "path_type": "hardlink", + "sha256": "efb734845a1366d77f6351cbb954c08681d4acfe6a53e41e82dd45fa881e0090", + "sha256_in_prefix": "efb734845a1366d77f6351cbb954c08681d4acfe6a53e41e82dd45fa881e0090", + "size_in_bytes": 1081 + }, + { + "_path": "include/python3.12/methodobject.h", + "path_type": "hardlink", + "sha256": "059e19bd8d418c8bf1481e301340f989317ba7b56de94729a19aae26fee3da62", + "sha256_in_prefix": "059e19bd8d418c8bf1481e301340f989317ba7b56de94729a19aae26fee3da62", + "size_in_bytes": 5076 + }, + { + "_path": "include/python3.12/modsupport.h", + "path_type": "hardlink", + "sha256": "064d1440d862d08f296c1cbe868e417af12b34f770be515461211f5beade04ff", + "sha256_in_prefix": "064d1440d862d08f296c1cbe868e417af12b34f770be515461211f5beade04ff", + "size_in_bytes": 6515 + }, + { + "_path": "include/python3.12/moduleobject.h", + "path_type": "hardlink", + "sha256": "5eb48f5d99322d7912a5c6f2b3a974e283c7a6045f79a503d7e09f3ac15b42ec", + "sha256_in_prefix": "5eb48f5d99322d7912a5c6f2b3a974e283c7a6045f79a503d7e09f3ac15b42ec", + "size_in_bytes": 3559 + }, + { + "_path": "include/python3.12/object.h", + "path_type": "hardlink", + "sha256": "33157179d385765172a160ce10e769196d3d8edf7a01ba3819c3259b57ffaee6", + "sha256_in_prefix": "33157179d385765172a160ce10e769196d3d8edf7a01ba3819c3259b57ffaee6", + "size_in_bytes": 37188 + }, + { + "_path": "include/python3.12/objimpl.h", + "path_type": "hardlink", + "sha256": "8828a8db3e9f14b5ca2d59b1d8c05f6bf54fae26736ae039b7420c886142dba2", + "sha256_in_prefix": "8828a8db3e9f14b5ca2d59b1d8c05f6bf54fae26736ae039b7420c886142dba2", + "size_in_bytes": 9238 + }, + { + "_path": "include/python3.12/opcode.h", + "path_type": "hardlink", + "sha256": "4e8c6eee859813845b3a9dfe9e08ca4cc607a7f884048f5a6cebef6bdcc5d33d", + "sha256_in_prefix": "4e8c6eee859813845b3a9dfe9e08ca4cc607a7f884048f5a6cebef6bdcc5d33d", + "size_in_bytes": 12808 + }, + { + "_path": "include/python3.12/osdefs.h", + "path_type": "hardlink", + "sha256": "8372e9c507949a88ed3cad5fd0a830190d60a1655e9a3f59ef4d0832c06a041c", + "sha256_in_prefix": "8372e9c507949a88ed3cad5fd0a830190d60a1655e9a3f59ef4d0832c06a041c", + "size_in_bytes": 737 + }, + { + "_path": "include/python3.12/osmodule.h", + "path_type": "hardlink", + "sha256": "c013935b48f48ca8ce249a4d482c55e3fb6f1cfe786c5a32a57969bb74a779d9", + "sha256_in_prefix": "c013935b48f48ca8ce249a4d482c55e3fb6f1cfe786c5a32a57969bb74a779d9", + "size_in_bytes": 291 + }, + { + "_path": "include/python3.12/patchlevel.h", + "path_type": "hardlink", + "sha256": "4b4224e30e11f6e0f37921f72acd4fa4336705f5e5dba36492782d636443d73a", + "sha256_in_prefix": "4b4224e30e11f6e0f37921f72acd4fa4336705f5e5dba36492782d636443d73a", + "size_in_bytes": 1299 + }, + { + "_path": "include/python3.12/py_curses.h", + "path_type": "hardlink", + "sha256": "1aa826cacb9f07611155906d711403a7675ce573d61c888786178bb574dc3087", + "sha256_in_prefix": "1aa826cacb9f07611155906d711403a7675ce573d61c888786178bb574dc3087", + "size_in_bytes": 2473 + }, + { + "_path": "include/python3.12/pybuffer.h", + "path_type": "hardlink", + "sha256": "c95edd830772e922f60f976ac0d98470b48a443ba198b0866a4096003c0740a4", + "sha256_in_prefix": "c95edd830772e922f60f976ac0d98470b48a443ba198b0866a4096003c0740a4", + "size_in_bytes": 5282 + }, + { + "_path": "include/python3.12/pycapsule.h", + "path_type": "hardlink", + "sha256": "6929a47483ea5bb1a7b9b490a876b21beefed11061c94b2963b2608b7f542728", + "sha256_in_prefix": "6929a47483ea5bb1a7b9b490a876b21beefed11061c94b2963b2608b7f542728", + "size_in_bytes": 1727 + }, + { + "_path": "include/python3.12/pyconfig.h", + "path_type": "hardlink", + "sha256": "334a03a783bac296567bb1810a219d8417cad11c18531b1447eb13c7c48502d8", + "sha256_in_prefix": "334a03a783bac296567bb1810a219d8417cad11c18531b1447eb13c7c48502d8", + "size_in_bytes": 56078 + }, + { + "_path": "include/python3.12/pydtrace.h", + "path_type": "hardlink", + "sha256": "7ac591e56e12936a32e3b0b85dae803f8f00bdc91abe01799ca2e4ce69548555", + "sha256_in_prefix": "7ac591e56e12936a32e3b0b85dae803f8f00bdc91abe01799ca2e4ce69548555", + "size_in_bytes": 2404 + }, + { + "_path": "include/python3.12/pyerrors.h", + "path_type": "hardlink", + "sha256": "59bf06c7ba877ec76d09a41aac75e385a2723545388b105864f48f295e2524e0", + "sha256_in_prefix": "59bf06c7ba877ec76d09a41aac75e385a2723545388b105864f48f295e2524e0", + "size_in_bytes": 13017 + }, + { + "_path": "include/python3.12/pyexpat.h", + "path_type": "hardlink", + "sha256": "4bde05b3b7d6dbff5b7565b71ef59a4ce1e796a549d28edb4c75a5cabd00fe96", + "sha256_in_prefix": "4bde05b3b7d6dbff5b7565b71ef59a4ce1e796a549d28edb4c75a5cabd00fe96", + "size_in_bytes": 2450 + }, + { + "_path": "include/python3.12/pyframe.h", + "path_type": "hardlink", + "sha256": "58513e7017805ee5c49a329a552f72a6be6d88ce2bcfa344f5130582fa75ecb6", + "sha256_in_prefix": "58513e7017805ee5c49a329a552f72a6be6d88ce2bcfa344f5130582fa75ecb6", + "size_in_bytes": 551 + }, + { + "_path": "include/python3.12/pyhash.h", + "path_type": "hardlink", + "sha256": "a6ea755ff42ec955feaf49b1d234a5c2935899309ea59925d1d30f3e62fed67d", + "sha256_in_prefix": "a6ea755ff42ec955feaf49b1d234a5c2935899309ea59925d1d30f3e62fed67d", + "size_in_bytes": 4154 + }, + { + "_path": "include/python3.12/pylifecycle.h", + "path_type": "hardlink", + "sha256": "d313c5f3fe805606061ea78982ca5d5a9f09e687210c8b0fbcb50db596106691", + "sha256_in_prefix": "d313c5f3fe805606061ea78982ca5d5a9f09e687210c8b0fbcb50db596106691", + "size_in_bytes": 2249 + }, + { + "_path": "include/python3.12/pymacconfig.h", + "path_type": "hardlink", + "sha256": "5dcd4fa505975be42c35a4707ab7cb5b6ddf2e896bb8fbb8c1fd9047e5183a3d", + "sha256_in_prefix": "5dcd4fa505975be42c35a4707ab7cb5b6ddf2e896bb8fbb8c1fd9047e5183a3d", + "size_in_bytes": 2810 + }, + { + "_path": "include/python3.12/pymacro.h", + "path_type": "hardlink", + "sha256": "30af4b1a8deb972e716f24d32985b79deadb7f638d0b576a46214962ac4055fa", + "sha256_in_prefix": "30af4b1a8deb972e716f24d32985b79deadb7f638d0b576a46214962ac4055fa", + "size_in_bytes": 6318 + }, + { + "_path": "include/python3.12/pymath.h", + "path_type": "hardlink", + "sha256": "eeea8396e1acd271ba83a568ba572ead47493e492ce998756fe1256bf917b3f9", + "sha256_in_prefix": "eeea8396e1acd271ba83a568ba572ead47493e492ce998756fe1256bf917b3f9", + "size_in_bytes": 1688 + }, + { + "_path": "include/python3.12/pymem.h", + "path_type": "hardlink", + "sha256": "54a5315d7861e989c5099f168d946f5a421337efcd5d44896201016e92a81348", + "sha256_in_prefix": "54a5315d7861e989c5099f168d946f5a421337efcd5d44896201016e92a81348", + "size_in_bytes": 3914 + }, + { + "_path": "include/python3.12/pyport.h", + "path_type": "hardlink", + "sha256": "40ff45246d7e02bd248172881ddcddd4d0fc237ed18ad1b2a63651a6e8757be6", + "sha256_in_prefix": "40ff45246d7e02bd248172881ddcddd4d0fc237ed18ad1b2a63651a6e8757be6", + "size_in_bytes": 25384 + }, + { + "_path": "include/python3.12/pystate.h", + "path_type": "hardlink", + "sha256": "065426aaa5fada90d61a17757fbc2e8ce3fb9cc203992990c4ca3cee7f9f80be", + "sha256_in_prefix": "065426aaa5fada90d61a17757fbc2e8ce3fb9cc203992990c4ca3cee7f9f80be", + "size_in_bytes": 4635 + }, + { + "_path": "include/python3.12/pystats.h", + "path_type": "hardlink", + "sha256": "b93db83e29f09ff06b15bf39a21e53de82858ba92cbf48332d1ada1ac028d6f8", + "sha256_in_prefix": "b93db83e29f09ff06b15bf39a21e53de82858ba92cbf48332d1ada1ac028d6f8", + "size_in_bytes": 2741 + }, + { + "_path": "include/python3.12/pystrcmp.h", + "path_type": "hardlink", + "sha256": "f401d8338fb6ecf5f12768ee95cd09c262f880b2ee522ca344b890dbdcde4c88", + "sha256_in_prefix": "f401d8338fb6ecf5f12768ee95cd09c262f880b2ee522ca344b890dbdcde4c88", + "size_in_bytes": 436 + }, + { + "_path": "include/python3.12/pystrtod.h", + "path_type": "hardlink", + "sha256": "8c8e9d1d279216f1c08f0aedac5de49a9b8852a3f838f21e298300e969474ef4", + "sha256_in_prefix": "8c8e9d1d279216f1c08f0aedac5de49a9b8852a3f838f21e298300e969474ef4", + "size_in_bytes": 1557 + }, + { + "_path": "include/python3.12/pythonrun.h", + "path_type": "hardlink", + "sha256": "4749ef95e910632a1d04b912c4f1d615c9d10567cbaf52a2ab2c68c7c3a38d94", + "sha256_in_prefix": "4749ef95e910632a1d04b912c4f1d615c9d10567cbaf52a2ab2c68c7c3a38d94", + "size_in_bytes": 1313 + }, + { + "_path": "include/python3.12/pythread.h", + "path_type": "hardlink", + "sha256": "cd063073710988ea21b54588473542e5f3b2be06f637dc5a028aefd5a7949144", + "sha256_in_prefix": "cd063073710988ea21b54588473542e5f3b2be06f637dc5a028aefd5a7949144", + "size_in_bytes": 4875 + }, + { + "_path": "include/python3.12/pytypedefs.h", + "path_type": "hardlink", + "sha256": "26d09a78c44998e8c0a74ed2d14e5346e4b922892eb79288049b7ac5b6a1e751", + "sha256_in_prefix": "26d09a78c44998e8c0a74ed2d14e5346e4b922892eb79288049b7ac5b6a1e751", + "size_in_bytes": 851 + }, + { + "_path": "include/python3.12/rangeobject.h", + "path_type": "hardlink", + "sha256": "36547ab5862e82b09cbed7b786a4cfc86af1dec5a3778c50825bb266c9a6aec9", + "sha256_in_prefix": "36547ab5862e82b09cbed7b786a4cfc86af1dec5a3778c50825bb266c9a6aec9", + "size_in_bytes": 630 + }, + { + "_path": "include/python3.12/setobject.h", + "path_type": "hardlink", + "sha256": "7ff1b984647598b19ff593b0fa40d44cf5d7bc37d386dd9fac059e560f4a31ca", + "sha256_in_prefix": "7ff1b984647598b19ff593b0fa40d44cf5d7bc37d386dd9fac059e560f4a31ca", + "size_in_bytes": 1557 + }, + { + "_path": "include/python3.12/sliceobject.h", + "path_type": "hardlink", + "sha256": "527719b92e4fa9d5b371c30bc87bc0304ec20099b18c446ad1aa49fd61e5e387", + "sha256_in_prefix": "527719b92e4fa9d5b371c30bc87bc0304ec20099b18c446ad1aa49fd61e5e387", + "size_in_bytes": 2518 + }, + { + "_path": "include/python3.12/structmember.h", + "path_type": "hardlink", + "sha256": "9d4c39dee96e228f60cc8a6960b9e7049875ddbee15541a75629c07777916342", + "sha256_in_prefix": "9d4c39dee96e228f60cc8a6960b9e7049875ddbee15541a75629c07777916342", + "size_in_bytes": 1645 + }, + { + "_path": "include/python3.12/structseq.h", + "path_type": "hardlink", + "sha256": "067f8663a922eb142a3fd12ff18eaa756553bef8a68eaa863f80419dbb8d1ffe", + "sha256_in_prefix": "067f8663a922eb142a3fd12ff18eaa756553bef8a68eaa863f80419dbb8d1ffe", + "size_in_bytes": 1398 + }, + { + "_path": "include/python3.12/sysmodule.h", + "path_type": "hardlink", + "sha256": "09b6f415d4054fee4eb8375a94a724e102bc9a40633d16a437960671b1a9a1b4", + "sha256_in_prefix": "09b6f415d4054fee4eb8375a94a724e102bc9a40633d16a437960671b1a9a1b4", + "size_in_bytes": 1729 + }, + { + "_path": "include/python3.12/traceback.h", + "path_type": "hardlink", + "sha256": "ea59d511687f7f8643c7b8b0996e26f2c92bcc954639c6f98d08f6564b61d06d", + "sha256_in_prefix": "ea59d511687f7f8643c7b8b0996e26f2c92bcc954639c6f98d08f6564b61d06d", + "size_in_bytes": 585 + }, + { + "_path": "include/python3.12/tracemalloc.h", + "path_type": "hardlink", + "sha256": "296084c2140af69ee39e672feab2027411c7b0397a5719aa513802cd6a849d93", + "sha256_in_prefix": "296084c2140af69ee39e672feab2027411c7b0397a5719aa513802cd6a849d93", + "size_in_bytes": 2192 + }, + { + "_path": "include/python3.12/tupleobject.h", + "path_type": "hardlink", + "sha256": "d8de8d64e4b5c466c3bdd04f5664f0eba64a9198b30b5a29409d74a5b5f1def7", + "sha256_in_prefix": "d8de8d64e4b5c466c3bdd04f5664f0eba64a9198b30b5a29409d74a5b5f1def7", + "size_in_bytes": 1615 + }, + { + "_path": "include/python3.12/typeslots.h", + "path_type": "hardlink", + "sha256": "77fe4a71f5e5974c40fd3485d3c9aeb8b7ccf33969cd26feb58c64eda5f86f1d", + "sha256_in_prefix": "77fe4a71f5e5974c40fd3485d3c9aeb8b7ccf33969cd26feb58c64eda5f86f1d", + "size_in_bytes": 2342 + }, + { + "_path": "include/python3.12/unicodeobject.h", + "path_type": "hardlink", + "sha256": "5cc1350da2b00f5187065004a1f5d66764e86a0f20f8faba7d0eadf913297d93", + "sha256_in_prefix": "5cc1350da2b00f5187065004a1f5d66764e86a0f20f8faba7d0eadf913297d93", + "size_in_bytes": 35164 + }, + { + "_path": "include/python3.12/warnings.h", + "path_type": "hardlink", + "sha256": "18fde34b12247460de805fc259ea7f14305fce4779d244c0a7bdc7c73b8f6b51", + "sha256_in_prefix": "18fde34b12247460de805fc259ea7f14305fce4779d244c0a7bdc7c73b8f6b51", + "size_in_bytes": 1129 + }, + { + "_path": "include/python3.12/weakrefobject.h", + "path_type": "hardlink", + "sha256": "031b4bc091cf442b4305f7c5ac9713f32101a5e40617f3cb56c632cb7b15fb5b", + "sha256_in_prefix": "031b4bc091cf442b4305f7c5ac9713f32101a5e40617f3cb56c632cb7b15fb5b", + "size_in_bytes": 1234 + }, + { + "_path": "lib/libpython3.12.dylib", + "file_mode": "binary", + "path_type": "hardlink", + "prefix_placeholder": "/Users/runner/miniforge3/conda-bld/python-split_1708115848844/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placeh", + "sha256": "af5de531a19e9779c0864b8353fe85dc72be348db57691346f10474fae384dbb", + "sha256_in_prefix": "5449481c81a6b1358eaf35c350446accfc396223a718c86f9f152fc3ac828899", + "size_in_bytes": 6440816 + }, + { + "_path": "lib/pkgconfig/python-3.12-embed.pc", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/Users/runner/miniforge3/conda-bld/python-split_1708115848844/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placeh", + "sha256": "6f1573b6bc2f8624c550a4131b95e315bb8859da61a0d958afad0b88c7fd8636", + "sha256_in_prefix": "7b8f6311fb9350f6dca6d75cbb1e63d1564f31b268ec06cd7aa60e3ba91295d3", + "size_in_bytes": 558 + }, + { + "_path": "lib/pkgconfig/python-3.12.pc", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/Users/runner/miniforge3/conda-bld/python-split_1708115848844/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placeh", + "sha256": "74d595e214a5a3903369097b315e4979451cd3309256f0d3b4afb7ae2632e706", + "sha256_in_prefix": "b92070be45dc96c9896da28d4ce767fca31d4c4e5582b71a429ec8d63d71e7e7", + "size_in_bytes": 544 + }, + { + "_path": "lib/pkgconfig/python3-embed.pc", + "path_type": "softlink", + "sha256": "6f1573b6bc2f8624c550a4131b95e315bb8859da61a0d958afad0b88c7fd8636", + "size_in_bytes": 558 + }, + { + "_path": "lib/pkgconfig/python3.pc", + "path_type": "softlink", + "sha256": "74d595e214a5a3903369097b315e4979451cd3309256f0d3b4afb7ae2632e706", + "size_in_bytes": 544 + }, + { + "_path": "lib/python3.1", + "path_type": "softlink", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size_in_bytes": 0 + }, + { + "_path": "lib/python3.12/LICENSE.txt", + "path_type": "hardlink", + "sha256": "3b2f81fe21d181c499c59a256c8e1968455d6689d269aa85373bfb6af41da3bf", + "sha256_in_prefix": "3b2f81fe21d181c499c59a256c8e1968455d6689d269aa85373bfb6af41da3bf", + "size_in_bytes": 13936 + }, + { + "_path": "lib/python3.12/__future__.py", + "path_type": "hardlink", + "sha256": "981d4c398849f9ebcab72300d9c1fe288fd6d7f28957b3b3fa3a493a5836d95c", + "sha256_in_prefix": "981d4c398849f9ebcab72300d9c1fe288fd6d7f28957b3b3fa3a493a5836d95c", + "size_in_bytes": 5218 + }, + { + "_path": "lib/python3.12/__hello__.py", + "path_type": "hardlink", + "sha256": "a8ce70b199497950f0f06def93115a6814daf1f961934457f59046909901487f", + "sha256_in_prefix": "a8ce70b199497950f0f06def93115a6814daf1f961934457f59046909901487f", + "size_in_bytes": 227 + }, + { + "_path": "lib/python3.12/__phello__/__init__.py", + "path_type": "hardlink", + "sha256": "56f7ed595e767c558ded05def14b682893105daf504500c3443b458ca2431bc6", + "sha256_in_prefix": "56f7ed595e767c558ded05def14b682893105daf504500c3443b458ca2431bc6", + "size_in_bytes": 97 + }, + { + "_path": "lib/python3.12/__phello__/__pycache__/__init__.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "0511c722097b19e473159cef1711e4941d7b2a97e72a6b4e17b5629a42a7e965", + "sha256_in_prefix": "0511c722097b19e473159cef1711e4941d7b2a97e72a6b4e17b5629a42a7e965", + "size_in_bytes": 623 + }, + { + "_path": "lib/python3.12/__phello__/__pycache__/spam.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "b988e2c80314516379c8fa31dde0e3b7a9de3ce8394f26d4cfcf8d91bde24e99", + "sha256_in_prefix": "b988e2c80314516379c8fa31dde0e3b7a9de3ce8394f26d4cfcf8d91bde24e99", + "size_in_bytes": 619 + }, + { + "_path": "lib/python3.12/__phello__/spam.py", + "path_type": "hardlink", + "sha256": "56f7ed595e767c558ded05def14b682893105daf504500c3443b458ca2431bc6", + "sha256_in_prefix": "56f7ed595e767c558ded05def14b682893105daf504500c3443b458ca2431bc6", + "size_in_bytes": 97 + }, + { + "_path": "lib/python3.12/__pycache__/__future__.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "ab3e46389aca2b5314271fe3396dcacf82612906e0f601cd8471f7b51584a0f3", + "sha256_in_prefix": "ab3e46389aca2b5314271fe3396dcacf82612906e0f601cd8471f7b51584a0f3", + "size_in_bytes": 4958 + }, + { + "_path": "lib/python3.12/__pycache__/__hello__.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "95470493eb68ff43f40a5235d6d6ba6c15950676c2e478ae3697bb78db6b1d25", + "sha256_in_prefix": "95470493eb68ff43f40a5235d6d6ba6c15950676c2e478ae3697bb78db6b1d25", + "size_in_bytes": 1124 + }, + { + "_path": "lib/python3.12/__pycache__/_aix_support.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "0deb8001f44f871d389702dd5db9b71d008dd972ee7f8f24efc810e7ecb4b0e8", + "sha256_in_prefix": "0deb8001f44f871d389702dd5db9b71d008dd972ee7f8f24efc810e7ecb4b0e8", + "size_in_bytes": 5013 + }, + { + "_path": "lib/python3.12/__pycache__/_collections_abc.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "b592a91d11f4e2219346e91e3786493b0d6722d9935782cdeca6347b3e605fa3", + "sha256_in_prefix": "b592a91d11f4e2219346e91e3786493b0d6722d9935782cdeca6347b3e605fa3", + "size_in_bytes": 46166 + }, + { + "_path": "lib/python3.12/__pycache__/_compat_pickle.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "eb9d1d53e5e91bdb57d1028df76d6214928b36450abbeb94887376eed1eb5e18", + "sha256_in_prefix": "eb9d1d53e5e91bdb57d1028df76d6214928b36450abbeb94887376eed1eb5e18", + "size_in_bytes": 7469 + }, + { + "_path": "lib/python3.12/__pycache__/_compression.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "9732636e0c2f79a67858ae6219bc46a42a806157f83ff73886ed63880d1e44db", + "sha256_in_prefix": "9732636e0c2f79a67858ae6219bc46a42a806157f83ff73886ed63880d1e44db", + "size_in_bytes": 7751 + }, + { + "_path": "lib/python3.12/__pycache__/_markupbase.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "d3ca5b1448f30e30d88009428015c1033954ee8985d2b964932be44c873b3315", + "sha256_in_prefix": "d3ca5b1448f30e30d88009428015c1033954ee8985d2b964932be44c873b3315", + "size_in_bytes": 12527 + }, + { + "_path": "lib/python3.12/__pycache__/_osx_support.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "12e7746b7b97bb8993f8336eda80425582a8c326a74f1e2e08b2922d24fa441a", + "sha256_in_prefix": "12e7746b7b97bb8993f8336eda80425582a8c326a74f1e2e08b2922d24fa441a", + "size_in_bytes": 17985 + }, + { + "_path": "lib/python3.12/__pycache__/_py_abc.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "a55fd2c5b55f160c0a51677111d2245b040e8163d1094fe115d0ba6f9f6fc6dc", + "sha256_in_prefix": "a55fd2c5b55f160c0a51677111d2245b040e8163d1094fe115d0ba6f9f6fc6dc", + "size_in_bytes": 7305 + }, + { + "_path": "lib/python3.12/__pycache__/_pydatetime.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "a216807aeac46dbb5f16ece05a3da09d5690d9876dc65920fdd182efc282780a", + "sha256_in_prefix": "a216807aeac46dbb5f16ece05a3da09d5690d9876dc65920fdd182efc282780a", + "size_in_bytes": 94311 + }, + { + "_path": "lib/python3.12/__pycache__/_pydecimal.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "24374a4faa1b667cb2c0fe011d12199dca68c6ddda8f75ed2c70e1245abfabea", + "sha256_in_prefix": "24374a4faa1b667cb2c0fe011d12199dca68c6ddda8f75ed2c70e1245abfabea", + "size_in_bytes": 228061 + }, + { + "_path": "lib/python3.12/__pycache__/_pyio.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "dbd28192395620ff24ec7d63e5952ee292a8c35cab9d389aa6c6289a59243fc2", + "sha256_in_prefix": "dbd28192395620ff24ec7d63e5952ee292a8c35cab9d389aa6c6289a59243fc2", + "size_in_bytes": 110486 + }, + { + "_path": "lib/python3.12/__pycache__/_pylong.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "1e48d0af6198506be1c5978d915c30ff3e4637e05b3fac63ac9ca592ddeacd01", + "sha256_in_prefix": "1e48d0af6198506be1c5978d915c30ff3e4637e05b3fac63ac9ca592ddeacd01", + "size_in_bytes": 10237 + }, + { + "_path": "lib/python3.12/__pycache__/_sitebuiltins.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "3699ce6f90865726f5ccb97e0783151264f1d230e582afc735b807e20ce74ab1", + "sha256_in_prefix": "3699ce6f90865726f5ccb97e0783151264f1d230e582afc735b807e20ce74ab1", + "size_in_bytes": 5014 + }, + { + "_path": "lib/python3.12/__pycache__/_strptime.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "8b9888c7db77b982f8b2f3f7dc3fa6104b586525880324b0fa43fdc3613764ad", + "sha256_in_prefix": "8b9888c7db77b982f8b2f3f7dc3fa6104b586525880324b0fa43fdc3613764ad", + "size_in_bytes": 24370 + }, + { + "_path": "lib/python3.12/__pycache__/_sysconfigdata__darwin_darwin.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "7f00b3ff3b26a5dc655e4560cc1eedc9fbee77cbe46a8b1587662d5bac8fe247", + "sha256_in_prefix": "7f00b3ff3b26a5dc655e4560cc1eedc9fbee77cbe46a8b1587662d5bac8fe247", + "size_in_bytes": 100455 + }, + { + "_path": "lib/python3.12/__pycache__/_sysconfigdata_arm64_apple_darwin20_0_0.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "b6952e252430a32f2d508461eeb723e45b016f8d8777f3ea0433785f2b3f17b6", + "sha256_in_prefix": "b6952e252430a32f2d508461eeb723e45b016f8d8777f3ea0433785f2b3f17b6", + "size_in_bytes": 99992 + }, + { + "_path": "lib/python3.12/__pycache__/_threading_local.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "a87b6d9314ad55cd9d4a9a9be8954238d2bcec17b2e8b5f44cd1ed3bba2ff466", + "sha256_in_prefix": "a87b6d9314ad55cd9d4a9a9be8954238d2bcec17b2e8b5f44cd1ed3bba2ff466", + "size_in_bytes": 8549 + }, + { + "_path": "lib/python3.12/__pycache__/_weakrefset.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "ece73739c1095d2213599bd2f284a3b4bb349a0593453afe5ef6ec0d2d418e8f", + "sha256_in_prefix": "ece73739c1095d2213599bd2f284a3b4bb349a0593453afe5ef6ec0d2d418e8f", + "size_in_bytes": 12005 + }, + { + "_path": "lib/python3.12/__pycache__/abc.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "6b32eb5d8df9d35ca9d6076bc6fcbe4c786ae53608295fb3addb728465ce16fc", + "sha256_in_prefix": "6b32eb5d8df9d35ca9d6076bc6fcbe4c786ae53608295fb3addb728465ce16fc", + "size_in_bytes": 8309 + }, + { + "_path": "lib/python3.12/__pycache__/aifc.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "3dffd5598308f8401c1704630738c0fdc05c6b3fe6f5bd0949a346111a3bc816", + "sha256_in_prefix": "3dffd5598308f8401c1704630738c0fdc05c6b3fe6f5bd0949a346111a3bc816", + "size_in_bytes": 43117 + }, + { + "_path": "lib/python3.12/__pycache__/antigravity.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "87b07e4c8f87d5f28d0247a133c6d7e1f1b6f677c559ef765be997bbc3fe4bcc", + "sha256_in_prefix": "87b07e4c8f87d5f28d0247a133c6d7e1f1b6f677c559ef765be997bbc3fe4bcc", + "size_in_bytes": 1257 + }, + { + "_path": "lib/python3.12/__pycache__/argparse.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "e9c0ec0a4e3dbad23e7cf31f9332b45423f5e65d9072644913edc97f34c84ff6", + "sha256_in_prefix": "e9c0ec0a4e3dbad23e7cf31f9332b45423f5e65d9072644913edc97f34c84ff6", + "size_in_bytes": 101085 + }, + { + "_path": "lib/python3.12/__pycache__/ast.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "e29cad14f8da27e8b0eb2c2d342f77f0c3aa26c1896a67a93f47ca15722fb5e1", + "sha256_in_prefix": "e29cad14f8da27e8b0eb2c2d342f77f0c3aa26c1896a67a93f47ca15722fb5e1", + "size_in_bytes": 100343 + }, + { + "_path": "lib/python3.12/__pycache__/base64.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "8ba49c3a87fb56962333d979384039ba19cf7087f3cecdfa3eb850b3e432e3b0", + "sha256_in_prefix": "8ba49c3a87fb56962333d979384039ba19cf7087f3cecdfa3eb850b3e432e3b0", + "size_in_bytes": 24654 + }, + { + "_path": "lib/python3.12/__pycache__/bdb.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "81a3a1fd27aeb06045e1f25bdb22e547b2578c186340acad02c2bde899fc2bfc", + "sha256_in_prefix": "81a3a1fd27aeb06045e1f25bdb22e547b2578c186340acad02c2bde899fc2bfc", + "size_in_bytes": 37613 + }, + { + "_path": "lib/python3.12/__pycache__/bisect.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "08f9ac95c6a737bec7ba978962ca7c8f57d331b7760b36c2be1959e6b69f3125", + "sha256_in_prefix": "08f9ac95c6a737bec7ba978962ca7c8f57d331b7760b36c2be1959e6b69f3125", + "size_in_bytes": 3895 + }, + { + "_path": "lib/python3.12/__pycache__/bz2.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "f43586adb2e944f3df876897ad45de08a1b188e2ab23bab3eaac3c6d74292d9c", + "sha256_in_prefix": "f43586adb2e944f3df876897ad45de08a1b188e2ab23bab3eaac3c6d74292d9c", + "size_in_bytes": 15387 + }, + { + "_path": "lib/python3.12/__pycache__/cProfile.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "486f00be02ffaef0d6b6ba97f484797ba74b3fa86d2b4c0ee30a49bda5b1e961", + "sha256_in_prefix": "486f00be02ffaef0d6b6ba97f484797ba74b3fa86d2b4c0ee30a49bda5b1e961", + "size_in_bytes": 8847 + }, + { + "_path": "lib/python3.12/__pycache__/calendar.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "307b1fe9beea69735a30864847592fc17899887c93acde72d341987c6fe168a7", + "sha256_in_prefix": "307b1fe9beea69735a30864847592fc17899887c93acde72d341987c6fe168a7", + "size_in_bytes": 39875 + }, + { + "_path": "lib/python3.12/__pycache__/cgi.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "34daec72bd48541833a2d9365cf0725f41dcd02c804a7f981145bff6076ae524", + "sha256_in_prefix": "34daec72bd48541833a2d9365cf0725f41dcd02c804a7f981145bff6076ae524", + "size_in_bytes": 40482 + }, + { + "_path": "lib/python3.12/__pycache__/cgitb.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "3f672cc4a236bea75bbc05377a4aa86b7dd4beabdb7dd6580689574ac0e15514", + "sha256_in_prefix": "3f672cc4a236bea75bbc05377a4aa86b7dd4beabdb7dd6580689574ac0e15514", + "size_in_bytes": 17586 + }, + { + "_path": "lib/python3.12/__pycache__/chunk.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "56c0f58f735d0b05cd01ebd0d95172e1fe81e556882654def2ecdd30a5640d8f", + "sha256_in_prefix": "56c0f58f735d0b05cd01ebd0d95172e1fe81e556882654def2ecdd30a5640d8f", + "size_in_bytes": 7564 + }, + { + "_path": "lib/python3.12/__pycache__/cmd.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "bee33714d892fd451ef5ff184a4c7bcb82b6351bb1bcc1043406677841a912b0", + "sha256_in_prefix": "bee33714d892fd451ef5ff184a4c7bcb82b6351bb1bcc1043406677841a912b0", + "size_in_bytes": 18873 + }, + { + "_path": "lib/python3.12/__pycache__/code.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "6213de09385cf206b6c640f54dde7fc29e0de38f7ec5d1478efa107ef5851914", + "sha256_in_prefix": "6213de09385cf206b6c640f54dde7fc29e0de38f7ec5d1478efa107ef5851914", + "size_in_bytes": 13305 + }, + { + "_path": "lib/python3.12/__pycache__/codecs.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "a883cb2f631c6d2c0429d16edc2efa4eea5054063c8e63581bf687cf089bd384", + "sha256_in_prefix": "a883cb2f631c6d2c0429d16edc2efa4eea5054063c8e63581bf687cf089bd384", + "size_in_bytes": 42528 + }, + { + "_path": "lib/python3.12/__pycache__/codeop.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "61aa2116223476f167d10b162e11a74fd6ad04ad13d1b7844def1b9cddc4e3fa", + "sha256_in_prefix": "61aa2116223476f167d10b162e11a74fd6ad04ad13d1b7844def1b9cddc4e3fa", + "size_in_bytes": 7170 + }, + { + "_path": "lib/python3.12/__pycache__/colorsys.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "84de0c074c2c10042faffdff8ab62dabb921e0dc7a8bfc256dc6d52a6a7ecf45", + "sha256_in_prefix": "84de0c074c2c10042faffdff8ab62dabb921e0dc7a8bfc256dc6d52a6a7ecf45", + "size_in_bytes": 4896 + }, + { + "_path": "lib/python3.12/__pycache__/compileall.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "84262c8cb1bd02f7d3bc8792bb3368f241ba08215392e33566419388412fcee8", + "sha256_in_prefix": "84262c8cb1bd02f7d3bc8792bb3368f241ba08215392e33566419388412fcee8", + "size_in_bytes": 20656 + }, + { + "_path": "lib/python3.12/__pycache__/configparser.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "98e48accc24bb4b8711fc00ade7a4367dcdaad48e5d719dc7420bc163a04c259", + "sha256_in_prefix": "98e48accc24bb4b8711fc00ade7a4367dcdaad48e5d719dc7420bc163a04c259", + "size_in_bytes": 63717 + }, + { + "_path": "lib/python3.12/__pycache__/contextlib.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "9b6fe2921536ea65f3dcb098ea97072e73cc6c383eb96555b29e5a52b274ef65", + "sha256_in_prefix": "9b6fe2921536ea65f3dcb098ea97072e73cc6c383eb96555b29e5a52b274ef65", + "size_in_bytes": 30628 + }, + { + "_path": "lib/python3.12/__pycache__/contextvars.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "05153cf6310051d94a303cf30afc01ab1ff45faa43e31fcc532bf85ccc8f8ff4", + "sha256_in_prefix": "05153cf6310051d94a303cf30afc01ab1ff45faa43e31fcc532bf85ccc8f8ff4", + "size_in_bytes": 515 + }, + { + "_path": "lib/python3.12/__pycache__/copy.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "4eb671c7543187dddeb329a1bbe5115245a766f57a374d72b01e93be4bc2884a", + "sha256_in_prefix": "4eb671c7543187dddeb329a1bbe5115245a766f57a374d72b01e93be4bc2884a", + "size_in_bytes": 10054 + }, + { + "_path": "lib/python3.12/__pycache__/copyreg.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "d4a2aa1833b4cff194068b1cb9afc09034dbf2d3c842bcbb54864d79809f15f3", + "sha256_in_prefix": "d4a2aa1833b4cff194068b1cb9afc09034dbf2d3c842bcbb54864d79809f15f3", + "size_in_bytes": 7666 + }, + { + "_path": "lib/python3.12/__pycache__/crypt.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "6c979937be4cb70199d8afa970a31318d17738f18eea5ece757bd7359ca461ce", + "sha256_in_prefix": "6c979937be4cb70199d8afa970a31318d17738f18eea5ece757bd7359ca461ce", + "size_in_bytes": 5615 + }, + { + "_path": "lib/python3.12/__pycache__/csv.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "8aa8fa7755c7333f66c88270a5ec2b1c95c0a083b63305eeeb49a6e41cc1cfa8", + "sha256_in_prefix": "8aa8fa7755c7333f66c88270a5ec2b1c95c0a083b63305eeeb49a6e41cc1cfa8", + "size_in_bytes": 18042 + }, + { + "_path": "lib/python3.12/__pycache__/dataclasses.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "cfc8cb74dde756d0df5f2633b442399b8b375d94914306e617d760c5fdd99000", + "sha256_in_prefix": "cfc8cb74dde756d0df5f2633b442399b8b375d94914306e617d760c5fdd99000", + "size_in_bytes": 44864 + }, + { + "_path": "lib/python3.12/__pycache__/datetime.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "2187448341b74034ede7b48b46d1526cc1f90b56f234b3dabfde826931ff1318", + "sha256_in_prefix": "2187448341b74034ede7b48b46d1526cc1f90b56f234b3dabfde826931ff1318", + "size_in_bytes": 663 + }, + { + "_path": "lib/python3.12/__pycache__/decimal.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "f128291aa5abc4f7f90c20231c4aa24f3c996e9fa7959c8f082678968efae13e", + "sha256_in_prefix": "f128291aa5abc4f7f90c20231c4aa24f3c996e9fa7959c8f082678968efae13e", + "size_in_bytes": 660 + }, + { + "_path": "lib/python3.12/__pycache__/difflib.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "f5ac2b81bde6c4411dd3e9b007d27d4c594f4bb83f782fbe3d73a49eae8fbd02", + "sha256_in_prefix": "f5ac2b81bde6c4411dd3e9b007d27d4c594f4bb83f782fbe3d73a49eae8fbd02", + "size_in_bytes": 75750 + }, + { + "_path": "lib/python3.12/__pycache__/dis.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "05b736ce1d357a46871b86ff952fc75874b217919a6d6c63ed3386b778939ea8", + "sha256_in_prefix": "05b736ce1d357a46871b86ff952fc75874b217919a6d6c63ed3386b778939ea8", + "size_in_bytes": 34812 + }, + { + "_path": "lib/python3.12/__pycache__/doctest.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "6d695063b4445390c6ef9882a739cf12274af61fcb27d99810aa2c040c88383f", + "sha256_in_prefix": "6d695063b4445390c6ef9882a739cf12274af61fcb27d99810aa2c040c88383f", + "size_in_bytes": 105875 + }, + { + "_path": "lib/python3.12/__pycache__/enum.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "554974a67556748b02b4bf2c886cc5dcdc3288d3c39d795d883d4a2488ffa2d3", + "sha256_in_prefix": "554974a67556748b02b4bf2c886cc5dcdc3288d3c39d795d883d4a2488ffa2d3", + "size_in_bytes": 79736 + }, + { + "_path": "lib/python3.12/__pycache__/filecmp.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "b91fdc07d36bb60feb09dbccb03bd0c03728e2b86c2e76ba90fb31f5228cdc26", + "sha256_in_prefix": "b91fdc07d36bb60feb09dbccb03bd0c03728e2b86c2e76ba90fb31f5228cdc26", + "size_in_bytes": 14915 + }, + { + "_path": "lib/python3.12/__pycache__/fileinput.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "065a78886e9594b4623ec8b5fa368fec8d64d8158ee2086f585e3a2b65896f7a", + "sha256_in_prefix": "065a78886e9594b4623ec8b5fa368fec8d64d8158ee2086f585e3a2b65896f7a", + "size_in_bytes": 20534 + }, + { + "_path": "lib/python3.12/__pycache__/fnmatch.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "c0541fd21cbaadb84aff3cfb54744233b292db766622a96056549ee935f0e1e8", + "sha256_in_prefix": "c0541fd21cbaadb84aff3cfb54744233b292db766622a96056549ee935f0e1e8", + "size_in_bytes": 6740 + }, + { + "_path": "lib/python3.12/__pycache__/fractions.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "7bd6ade821c25d4c0b7568f79eda3b11877e756bfb455d1f1b4d854740096ed9", + "sha256_in_prefix": "7bd6ade821c25d4c0b7568f79eda3b11877e756bfb455d1f1b4d854740096ed9", + "size_in_bytes": 36921 + }, + { + "_path": "lib/python3.12/__pycache__/ftplib.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "39d1064275202c5d207f133775999ec25e729e773a1ab1daf06b10bee2306d2c", + "sha256_in_prefix": "39d1064275202c5d207f133775999ec25e729e773a1ab1daf06b10bee2306d2c", + "size_in_bytes": 42890 + }, + { + "_path": "lib/python3.12/__pycache__/functools.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "42ce108558ebb7a787bad7b709187a7d63ad2aed33b047e55e4345d4b617cf9c", + "sha256_in_prefix": "42ce108558ebb7a787bad7b709187a7d63ad2aed33b047e55e4345d4b617cf9c", + "size_in_bytes": 40760 + }, + { + "_path": "lib/python3.12/__pycache__/genericpath.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "0e8a5ca34ed606fbc2d4b91d789ee08583ccddc94ba30fee100883322c27478b", + "sha256_in_prefix": "0e8a5ca34ed606fbc2d4b91d789ee08583ccddc94ba30fee100883322c27478b", + "size_in_bytes": 6447 + }, + { + "_path": "lib/python3.12/__pycache__/getopt.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "038b9c927889819977fb7a07bacb903c44d1a1afb874fe933209048d78150148", + "sha256_in_prefix": "038b9c927889819977fb7a07bacb903c44d1a1afb874fe933209048d78150148", + "size_in_bytes": 8614 + }, + { + "_path": "lib/python3.12/__pycache__/getpass.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "d890b021f7d90109e4f5f4da7470612e3ba53d63fb5433478446bc3c2417daa5", + "sha256_in_prefix": "d890b021f7d90109e4f5f4da7470612e3ba53d63fb5433478446bc3c2417daa5", + "size_in_bytes": 7104 + }, + { + "_path": "lib/python3.12/__pycache__/gettext.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "f9bad2381ba1cd7bf328f0a9714ae73bfd59cff51054e2d4ae5fcf648fb44e38", + "sha256_in_prefix": "f9bad2381ba1cd7bf328f0a9714ae73bfd59cff51054e2d4ae5fcf648fb44e38", + "size_in_bytes": 22106 + }, + { + "_path": "lib/python3.12/__pycache__/glob.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "13a5efb8c6aca9c9752cd1c6732f180d16c33aae0c9d89a33780dfee4d8d4db0", + "sha256_in_prefix": "13a5efb8c6aca9c9752cd1c6732f180d16c33aae0c9d89a33780dfee4d8d4db0", + "size_in_bytes": 10045 + }, + { + "_path": "lib/python3.12/__pycache__/graphlib.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "129f479b2a16807ca8f5a8e328e20abc406b215b8945cbc66b86f997187b44d3", + "sha256_in_prefix": "129f479b2a16807ca8f5a8e328e20abc406b215b8945cbc66b86f997187b44d3", + "size_in_bytes": 10579 + }, + { + "_path": "lib/python3.12/__pycache__/gzip.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "89c1e2340302bb23e4c2576cfae1bedb62c4619f245855a16cdffadd8b0b59da", + "sha256_in_prefix": "89c1e2340302bb23e4c2576cfae1bedb62c4619f245855a16cdffadd8b0b59da", + "size_in_bytes": 32269 + }, + { + "_path": "lib/python3.12/__pycache__/hashlib.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "4863740fa2cda13b28bd252d56e7ecee0ec12119f5642a548fc3bff43d81e438", + "sha256_in_prefix": "4863740fa2cda13b28bd252d56e7ecee0ec12119f5642a548fc3bff43d81e438", + "size_in_bytes": 8341 + }, + { + "_path": "lib/python3.12/__pycache__/heapq.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "80f90c3db903d41e4782e3eedad2c37f832377554c5b2f9ca3abfc8ed7637d6f", + "sha256_in_prefix": "80f90c3db903d41e4782e3eedad2c37f832377554c5b2f9ca3abfc8ed7637d6f", + "size_in_bytes": 18210 + }, + { + "_path": "lib/python3.12/__pycache__/hmac.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "c1bb903fe2b75fcc644b70c0d36ef76d709b6e070b58bb8ec1e82ead073a3b3b", + "sha256_in_prefix": "c1bb903fe2b75fcc644b70c0d36ef76d709b6e070b58bb8ec1e82ead073a3b3b", + "size_in_bytes": 10952 + }, + { + "_path": "lib/python3.12/__pycache__/imaplib.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "a385c42f106a389f2a8e918fe47cb3670314ce122c29b026aef84ef09c12fed5", + "sha256_in_prefix": "a385c42f106a389f2a8e918fe47cb3670314ce122c29b026aef84ef09c12fed5", + "size_in_bytes": 63143 + }, + { + "_path": "lib/python3.12/__pycache__/imghdr.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "41fd8233d6a6e05fc1f8346e6e25e3fe8afacf45a74c1295ea0f91b4b0ac3317", + "sha256_in_prefix": "41fd8233d6a6e05fc1f8346e6e25e3fe8afacf45a74c1295ea0f91b4b0ac3317", + "size_in_bytes": 7198 + }, + { + "_path": "lib/python3.12/__pycache__/inspect.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "39b556a01747a3ecaf7302894d8d21633d18c30b750c763e5ba9e08abfe12020", + "sha256_in_prefix": "39b556a01747a3ecaf7302894d8d21633d18c30b750c763e5ba9e08abfe12020", + "size_in_bytes": 133954 + }, + { + "_path": "lib/python3.12/__pycache__/io.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "7d98a2d0a46ab6a0e97b76e883143bfca90a4bd5e91b2e543cd433820a8c0136", + "sha256_in_prefix": "7d98a2d0a46ab6a0e97b76e883143bfca90a4bd5e91b2e543cd433820a8c0136", + "size_in_bytes": 4393 + }, + { + "_path": "lib/python3.12/__pycache__/ipaddress.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "30fae2de3e21bc31f9dd881987bdcd873fe62f1538aafad6adb9aa239308d931", + "sha256_in_prefix": "30fae2de3e21bc31f9dd881987bdcd873fe62f1538aafad6adb9aa239308d931", + "size_in_bytes": 88949 + }, + { + "_path": "lib/python3.12/__pycache__/keyword.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "b967ae5cd7a038a0e40f5a88b7c02b99392967a99f9e21fa937381eb5b9c1630", + "sha256_in_prefix": "b967ae5cd7a038a0e40f5a88b7c02b99392967a99f9e21fa937381eb5b9c1630", + "size_in_bytes": 1295 + }, + { + "_path": "lib/python3.12/__pycache__/linecache.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "804d24ebabfdb48a191e0644772254b9de5867171299ab93db18593a20f8f9fe", + "sha256_in_prefix": "804d24ebabfdb48a191e0644772254b9de5867171299ab93db18593a20f8f9fe", + "size_in_bytes": 6692 + }, + { + "_path": "lib/python3.12/__pycache__/locale.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "f508f0127cce5b4085d5292e1beaeb3dde180c8696bd7884f27c7f0876e02f1f", + "sha256_in_prefix": "f508f0127cce5b4085d5292e1beaeb3dde180c8696bd7884f27c7f0876e02f1f", + "size_in_bytes": 59801 + }, + { + "_path": "lib/python3.12/__pycache__/lzma.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "54e8552f731a28dee0560a58a1b2c3efe6ac6e416fd57e9897e5bc17c7de5763", + "sha256_in_prefix": "54e8552f731a28dee0560a58a1b2c3efe6ac6e416fd57e9897e5bc17c7de5763", + "size_in_bytes": 16109 + }, + { + "_path": "lib/python3.12/__pycache__/mailbox.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "2491041bc8f6bc5c4e16bb535db5f4c5bc1edb0f580c78876c92fbb311307699", + "sha256_in_prefix": "2491041bc8f6bc5c4e16bb535db5f4c5bc1edb0f580c78876c92fbb311307699", + "size_in_bytes": 111609 + }, + { + "_path": "lib/python3.12/__pycache__/mailcap.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "625904b23278217411e0a9a95f0cd6eac04df3993d16dd711a81858d4f74b43a", + "sha256_in_prefix": "625904b23278217411e0a9a95f0cd6eac04df3993d16dd711a81858d4f74b43a", + "size_in_bytes": 11409 + }, + { + "_path": "lib/python3.12/__pycache__/mimetypes.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "d70de3642ac02ef04f2b7f9c28103da6b0efb879287637bfc090bf0d589f7d8a", + "sha256_in_prefix": "d70de3642ac02ef04f2b7f9c28103da6b0efb879287637bfc090bf0d589f7d8a", + "size_in_bytes": 24150 + }, + { + "_path": "lib/python3.12/__pycache__/modulefinder.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "19e16fe033c41c7935e1b29536e52ab986764774351a749391c622efb7b9c1d0", + "sha256_in_prefix": "19e16fe033c41c7935e1b29536e52ab986764774351a749391c622efb7b9c1d0", + "size_in_bytes": 28189 + }, + { + "_path": "lib/python3.12/__pycache__/netrc.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "a2a96eb8b3b8c492f3a9f7b69bd5659b4247d4760d78e18187c94097ade92f53", + "sha256_in_prefix": "a2a96eb8b3b8c492f3a9f7b69bd5659b4247d4760d78e18187c94097ade92f53", + "size_in_bytes": 9157 + }, + { + "_path": "lib/python3.12/__pycache__/nntplib.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "9de83c2576777ae0593217888e21d43e91b67bb49944fe2731dc7f449b0ec58d", + "sha256_in_prefix": "9de83c2576777ae0593217888e21d43e91b67bb49944fe2731dc7f449b0ec58d", + "size_in_bytes": 45193 + }, + { + "_path": "lib/python3.12/__pycache__/ntpath.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "9157fdd203d9d91545e68cd731381e9f232a76bca126fa3fe62966f00a1becff", + "sha256_in_prefix": "9157fdd203d9d91545e68cd731381e9f232a76bca126fa3fe62966f00a1becff", + "size_in_bytes": 27348 + }, + { + "_path": "lib/python3.12/__pycache__/nturl2path.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "8c091c90ffcf5f53c6df54df65af936c995dbb23f42692d7c59a52c247aa19c3", + "sha256_in_prefix": "8c091c90ffcf5f53c6df54df65af936c995dbb23f42692d7c59a52c247aa19c3", + "size_in_bytes": 3288 + }, + { + "_path": "lib/python3.12/__pycache__/numbers.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "2756729556c19d9e3ad368a0795f7c3d40d5f035c7848a53598dfeb6120202e8", + "sha256_in_prefix": "2756729556c19d9e3ad368a0795f7c3d40d5f035c7848a53598dfeb6120202e8", + "size_in_bytes": 14221 + }, + { + "_path": "lib/python3.12/__pycache__/opcode.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "abb16419613313fb42bbe82797d8cf0a4490137a6542efa6dab3a399410134d4", + "sha256_in_prefix": "abb16419613313fb42bbe82797d8cf0a4490137a6542efa6dab3a399410134d4", + "size_in_bytes": 14968 + }, + { + "_path": "lib/python3.12/__pycache__/operator.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "40abc7dd3e28f51e87a1bdd0595e23dd2e1304a4fab1a4aaac18e9acb8858c9c", + "sha256_in_prefix": "40abc7dd3e28f51e87a1bdd0595e23dd2e1304a4fab1a4aaac18e9acb8858c9c", + "size_in_bytes": 17618 + }, + { + "_path": "lib/python3.12/__pycache__/optparse.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "b373470f27f1f71b8d07ada8e294c2209448ce9cab3802955003edf2c6eaac39", + "sha256_in_prefix": "b373470f27f1f71b8d07ada8e294c2209448ce9cab3802955003edf2c6eaac39", + "size_in_bytes": 67797 + }, + { + "_path": "lib/python3.12/__pycache__/os.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "3dbdaa0179db4d05533220466d69b90a4f49c56b8a3d782ada144b9129a059c1", + "sha256_in_prefix": "3dbdaa0179db4d05533220466d69b90a4f49c56b8a3d782ada144b9129a059c1", + "size_in_bytes": 43670 + }, + { + "_path": "lib/python3.12/__pycache__/pathlib.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "ee417be4ec3e343b9595f623edcac1a9cc42b1f83eec4cd5c8bbc6307081b354", + "sha256_in_prefix": "ee417be4ec3e343b9595f623edcac1a9cc42b1f83eec4cd5c8bbc6307081b354", + "size_in_bytes": 62316 + }, + { + "_path": "lib/python3.12/__pycache__/pdb.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "7a0faa405cfca9caa41c1b52c7932d681fa67d690ccddd4413c62be1c62bc442", + "sha256_in_prefix": "7a0faa405cfca9caa41c1b52c7932d681fa67d690ccddd4413c62be1c62bc442", + "size_in_bytes": 85503 + }, + { + "_path": "lib/python3.12/__pycache__/pickle.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "89e654a86a8a5ef02af71d5d7a40dc37f5d89b16e97c64b141a1208ff4604c84", + "sha256_in_prefix": "89e654a86a8a5ef02af71d5d7a40dc37f5d89b16e97c64b141a1208ff4604c84", + "size_in_bytes": 76419 + }, + { + "_path": "lib/python3.12/__pycache__/pickletools.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "c0590239a75606f3ee9cc342bbe6c2d7482effbd93ec39996f6aca5edf76f780", + "sha256_in_prefix": "c0590239a75606f3ee9cc342bbe6c2d7482effbd93ec39996f6aca5edf76f780", + "size_in_bytes": 81294 + }, + { + "_path": "lib/python3.12/__pycache__/pipes.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "ae410207052c537b3abe17910ca4efc41c387618c21a089cbf0d58cb15cfb632", + "sha256_in_prefix": "ae410207052c537b3abe17910ca4efc41c387618c21a089cbf0d58cb15cfb632", + "size_in_bytes": 11168 + }, + { + "_path": "lib/python3.12/__pycache__/pkgutil.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "74e16bd659842f0015ee2a4d5339f590ff958a87dd1ed0ab2c1d1fa84e4ce059", + "sha256_in_prefix": "74e16bd659842f0015ee2a4d5339f590ff958a87dd1ed0ab2c1d1fa84e4ce059", + "size_in_bytes": 20213 + }, + { + "_path": "lib/python3.12/__pycache__/platform.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "6b3504d4f30ef253c1a813d3aa6166cd3d7338a263d51dfe28d55c8a8848442f", + "sha256_in_prefix": "6b3504d4f30ef253c1a813d3aa6166cd3d7338a263d51dfe28d55c8a8848442f", + "size_in_bytes": 42108 + }, + { + "_path": "lib/python3.12/__pycache__/plistlib.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "8e2aa17ccdb13c391efcd0ea52ed7a7976c637b9818877c84994b50772a748d4", + "sha256_in_prefix": "8e2aa17ccdb13c391efcd0ea52ed7a7976c637b9818877c84994b50772a748d4", + "size_in_bytes": 41318 + }, + { + "_path": "lib/python3.12/__pycache__/poplib.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "df31d2aebad0bff5e4c94022013c8215a2226b44dbb20236b0a3f6aa5d9c8a93", + "sha256_in_prefix": "df31d2aebad0bff5e4c94022013c8215a2226b44dbb20236b0a3f6aa5d9c8a93", + "size_in_bytes": 18700 + }, + { + "_path": "lib/python3.12/__pycache__/posixpath.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "a7428f3217bfa011e60e7bcb8b848a7175a7b6bcce0a4d49c28a68970fafcfff", + "sha256_in_prefix": "a7428f3217bfa011e60e7bcb8b848a7175a7b6bcce0a4d49c28a68970fafcfff", + "size_in_bytes": 18285 + }, + { + "_path": "lib/python3.12/__pycache__/pprint.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "2e3d89d98fba891f000b3a0e1f5e4727e21d1b290fdc63243e1f81f4b9697615", + "sha256_in_prefix": "2e3d89d98fba891f000b3a0e1f5e4727e21d1b290fdc63243e1f81f4b9697615", + "size_in_bytes": 29724 + }, + { + "_path": "lib/python3.12/__pycache__/profile.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "0af90d6092b78b6f7a1526f636c11c34e1692b0846050355cd1fbb3d86c5ba43", + "sha256_in_prefix": "0af90d6092b78b6f7a1526f636c11c34e1692b0846050355cd1fbb3d86c5ba43", + "size_in_bytes": 22783 + }, + { + "_path": "lib/python3.12/__pycache__/pstats.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "3250e64180b85cf272b91bbd89f5c7630ad2acd548b7e77568bbe6505db75f7c", + "sha256_in_prefix": "3250e64180b85cf272b91bbd89f5c7630ad2acd548b7e77568bbe6505db75f7c", + "size_in_bytes": 38176 + }, + { + "_path": "lib/python3.12/__pycache__/pty.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "692df37cbc6bdf5ecbeb23d331c47d644175f9c9d767a8f6037f3d2327c1555b", + "sha256_in_prefix": "692df37cbc6bdf5ecbeb23d331c47d644175f9c9d767a8f6037f3d2327c1555b", + "size_in_bytes": 7617 + }, + { + "_path": "lib/python3.12/__pycache__/py_compile.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "432ea1d66e52edb36a77bf9e38b13d0d73205562ea607080ad8e6761ca860828", + "sha256_in_prefix": "432ea1d66e52edb36a77bf9e38b13d0d73205562ea607080ad8e6761ca860828", + "size_in_bytes": 10284 + }, + { + "_path": "lib/python3.12/__pycache__/pyclbr.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "1190eb77ed5190eb3b212fbccab99327da404483c305481ba9a222f38eaaff20", + "sha256_in_prefix": "1190eb77ed5190eb3b212fbccab99327da404483c305481ba9a222f38eaaff20", + "size_in_bytes": 15141 + }, + { + "_path": "lib/python3.12/__pycache__/pydoc.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "0391fc6f0cf6ec35fffae93fbf382c46a90105d526e41e7b56f15a9b0dad24fd", + "sha256_in_prefix": "0391fc6f0cf6ec35fffae93fbf382c46a90105d526e41e7b56f15a9b0dad24fd", + "size_in_bytes": 139211 + }, + { + "_path": "lib/python3.12/__pycache__/queue.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "8235b76dcf8495bcc1147c80ed8821a5bf233bb10df88074d982a01b363615f4", + "sha256_in_prefix": "8235b76dcf8495bcc1147c80ed8821a5bf233bb10df88074d982a01b363615f4", + "size_in_bytes": 14986 + }, + { + "_path": "lib/python3.12/__pycache__/quopri.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "ab8c9644dd0cbae5d94835d7e90ddfa222b4d891473f3e79f3bdecb17e25e90f", + "sha256_in_prefix": "ab8c9644dd0cbae5d94835d7e90ddfa222b4d891473f3e79f3bdecb17e25e90f", + "size_in_bytes": 9566 + }, + { + "_path": "lib/python3.12/__pycache__/random.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "e71439f5dd15687876613fe7e818d251eab57a48ecfe5e0c6163b47dd5d31e34", + "sha256_in_prefix": "e71439f5dd15687876613fe7e818d251eab57a48ecfe5e0c6163b47dd5d31e34", + "size_in_bytes": 33404 + }, + { + "_path": "lib/python3.12/__pycache__/reprlib.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "96d5dfa253644cb6da6f79a4cbeb88a83d7372fff5cda27b850815a97887d365", + "sha256_in_prefix": "96d5dfa253644cb6da6f79a4cbeb88a83d7372fff5cda27b850815a97887d365", + "size_in_bytes": 10163 + }, + { + "_path": "lib/python3.12/__pycache__/rlcompleter.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "b20790538d919664f364e09563f24bee1de4ae7dd4bf5074d7178fa03ad8f487", + "sha256_in_prefix": "b20790538d919664f364e09563f24bee1de4ae7dd4bf5074d7178fa03ad8f487", + "size_in_bytes": 8536 + }, + { + "_path": "lib/python3.12/__pycache__/runpy.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "8e1844eb88e51c6a8bc6708ef001e6d332f906bc941a8e8bbaa62567c58cf71c", + "sha256_in_prefix": "8e1844eb88e51c6a8bc6708ef001e6d332f906bc941a8e8bbaa62567c58cf71c", + "size_in_bytes": 14639 + }, + { + "_path": "lib/python3.12/__pycache__/sched.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "5234c418977ae98e6a69db915c7f43939b880bc14c26b6d51d9e527feee7ae05", + "sha256_in_prefix": "5234c418977ae98e6a69db915c7f43939b880bc14c26b6d51d9e527feee7ae05", + "size_in_bytes": 7989 + }, + { + "_path": "lib/python3.12/__pycache__/secrets.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "7b2af0280525bc6f9130bd98c93a2148919e53a91852640dc15fc3d396619132", + "sha256_in_prefix": "7b2af0280525bc6f9130bd98c93a2148919e53a91852640dc15fc3d396619132", + "size_in_bytes": 2810 + }, + { + "_path": "lib/python3.12/__pycache__/selectors.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "54ab36eace0b391247ad39eecb308bf389e32eed32814c603757e4b97e7f576d", + "sha256_in_prefix": "54ab36eace0b391247ad39eecb308bf389e32eed32814c603757e4b97e7f576d", + "size_in_bytes": 26382 + }, + { + "_path": "lib/python3.12/__pycache__/shelve.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "da4667dd5c663c5b4b93710581975ed80bc4346dc5729d7e2fbb25878c279c56", + "sha256_in_prefix": "da4667dd5c663c5b4b93710581975ed80bc4346dc5729d7e2fbb25878c279c56", + "size_in_bytes": 13167 + }, + { + "_path": "lib/python3.12/__pycache__/shlex.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "0c306d4eaaf59335994aad826cf837df1b9a693d9fbbe9d0750e9b1e1f9aa73e", + "sha256_in_prefix": "0c306d4eaaf59335994aad826cf837df1b9a693d9fbbe9d0750e9b1e1f9aa73e", + "size_in_bytes": 14416 + }, + { + "_path": "lib/python3.12/__pycache__/shutil.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "dbe5a7a14b3bcac8d622e9ec80c082c4cb6103ab78a17a616e8ceb51cdf36ce1", + "sha256_in_prefix": "dbe5a7a14b3bcac8d622e9ec80c082c4cb6103ab78a17a616e8ceb51cdf36ce1", + "size_in_bytes": 68260 + }, + { + "_path": "lib/python3.12/__pycache__/signal.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "a05d02da75e4e4d069b19a2152d89f8423b9f2190819d2aab474b1acfdcb3530", + "sha256_in_prefix": "a05d02da75e4e4d069b19a2152d89f8423b9f2190819d2aab474b1acfdcb3530", + "size_in_bytes": 4702 + }, + { + "_path": "lib/python3.12/__pycache__/site.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "5e0380c9116c09275f663a1ae59f1e67c95ca35ed437a28653ae149173c90096", + "sha256_in_prefix": "5e0380c9116c09275f663a1ae59f1e67c95ca35ed437a28653ae149173c90096", + "size_in_bytes": 28243 + }, + { + "_path": "lib/python3.12/__pycache__/smtplib.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "d1cda4d07093e21eb077265dd115828c031349ecbb256e78d9d5d7db94c5a71d", + "sha256_in_prefix": "d1cda4d07093e21eb077265dd115828c031349ecbb256e78d9d5d7db94c5a71d", + "size_in_bytes": 48472 + }, + { + "_path": "lib/python3.12/__pycache__/sndhdr.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "a16c65cc13bcef95a47a6c87bc9ca8ecef4ce8115899ff2045fe15c240b8b3e6", + "sha256_in_prefix": "a16c65cc13bcef95a47a6c87bc9ca8ecef4ce8115899ff2045fe15c240b8b3e6", + "size_in_bytes": 10966 + }, + { + "_path": "lib/python3.12/__pycache__/socket.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "9429349fb2fc4734cb6c2e2d897f6ed77cce7b5e29b5a38a17e8061b478794fe", + "sha256_in_prefix": "9429349fb2fc4734cb6c2e2d897f6ed77cce7b5e29b5a38a17e8061b478794fe", + "size_in_bytes": 42066 + }, + { + "_path": "lib/python3.12/__pycache__/socketserver.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "8936a0a80c4e82c86308691a4205dff2e75d0e822161d46f3043a9cf8efb88a2", + "sha256_in_prefix": "8936a0a80c4e82c86308691a4205dff2e75d0e822161d46f3043a9cf8efb88a2", + "size_in_bytes": 34512 + }, + { + "_path": "lib/python3.12/__pycache__/sre_compile.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "7de21c2faff7287ef099e8ac628281860726dd4f3d85a6a153bada6e3c805ef6", + "sha256_in_prefix": "7de21c2faff7287ef099e8ac628281860726dd4f3d85a6a153bada6e3c805ef6", + "size_in_bytes": 879 + }, + { + "_path": "lib/python3.12/__pycache__/sre_constants.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "fc93e6752aa58979aabc368ba59f044d6db4361ea328f725e029b37ef11c5d60", + "sha256_in_prefix": "fc93e6752aa58979aabc368ba59f044d6db4361ea328f725e029b37ef11c5d60", + "size_in_bytes": 882 + }, + { + "_path": "lib/python3.12/__pycache__/sre_parse.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "6a6db2e93c67a75b09d8dc6a79a65116450658ee6248669692ddff051e3b1d23", + "sha256_in_prefix": "6a6db2e93c67a75b09d8dc6a79a65116450658ee6248669692ddff051e3b1d23", + "size_in_bytes": 875 + }, + { + "_path": "lib/python3.12/__pycache__/ssl.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "72cbe990979c8af76ba34e1ee991c4c19ed79de4c174c66d4605aac034fd4504", + "sha256_in_prefix": "72cbe990979c8af76ba34e1ee991c4c19ed79de4c174c66d4605aac034fd4504", + "size_in_bytes": 63265 + }, + { + "_path": "lib/python3.12/__pycache__/stat.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "b5463859efa5268ecad3b6523d2ddaaff8b7c8dd3b4a140cc79567f1f4200ffe", + "sha256_in_prefix": "b5463859efa5268ecad3b6523d2ddaaff8b7c8dd3b4a140cc79567f1f4200ffe", + "size_in_bytes": 5485 + }, + { + "_path": "lib/python3.12/__pycache__/statistics.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "c89aafe350f75d54e9a145db5ea24b7c59f425bca1d7aa17156758e1723a199d", + "sha256_in_prefix": "c89aafe350f75d54e9a145db5ea24b7c59f425bca1d7aa17156758e1723a199d", + "size_in_bytes": 55666 + }, + { + "_path": "lib/python3.12/__pycache__/string.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "b5f4259126fa71ed1c9dc943f6ba404ea1812699414d9f9ffb058c9fed1d6e37", + "sha256_in_prefix": "b5f4259126fa71ed1c9dc943f6ba404ea1812699414d9f9ffb058c9fed1d6e37", + "size_in_bytes": 11736 + }, + { + "_path": "lib/python3.12/__pycache__/stringprep.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "61542d78f076df50c3513076409ca96d5c02367888032afca3835f42f14975ba", + "sha256_in_prefix": "61542d78f076df50c3513076409ca96d5c02367888032afca3835f42f14975ba", + "size_in_bytes": 25411 + }, + { + "_path": "lib/python3.12/__pycache__/struct.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "cfa7c1342400244201f824a419a014d74dbf5268016f309b6768c13c7a5a76cb", + "sha256_in_prefix": "cfa7c1342400244201f824a419a014d74dbf5268016f309b6768c13c7a5a76cb", + "size_in_bytes": 579 + }, + { + "_path": "lib/python3.12/__pycache__/subprocess.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "b36bc948a95d31fa0d5c10713cef015a13966133013156d94a7759904c4f2e5e", + "sha256_in_prefix": "b36bc948a95d31fa0d5c10713cef015a13966133013156d94a7759904c4f2e5e", + "size_in_bytes": 79403 + }, + { + "_path": "lib/python3.12/__pycache__/sunau.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "24557d131af9ef40edad20504794f068a0d5e4a5465382cecbd05ef400591790", + "sha256_in_prefix": "24557d131af9ef40edad20504794f068a0d5e4a5465382cecbd05ef400591790", + "size_in_bytes": 25677 + }, + { + "_path": "lib/python3.12/__pycache__/symtable.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "da9aef6a1ae28852edb30c254b2dca7cf6fece7cfc92f2e7983bb6fb6fad87a6", + "sha256_in_prefix": "da9aef6a1ae28852edb30c254b2dca7cf6fece7cfc92f2e7983bb6fb6fad87a6", + "size_in_bytes": 19033 + }, + { + "_path": "lib/python3.12/__pycache__/sysconfig.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "69b04e9dcd68923da1ba62d3f12eb0f5584bd69f0674981a83523adba3675f3d", + "sha256_in_prefix": "69b04e9dcd68923da1ba62d3f12eb0f5584bd69f0674981a83523adba3675f3d", + "size_in_bytes": 29456 + }, + { + "_path": "lib/python3.12/__pycache__/tabnanny.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "d3f666bb7b4bf69b3d0690e10b2bf1f30e5ed4bc0b9b4a3b6095f2f4e77b277c", + "sha256_in_prefix": "d3f666bb7b4bf69b3d0690e10b2bf1f30e5ed4bc0b9b4a3b6095f2f4e77b277c", + "size_in_bytes": 12410 + }, + { + "_path": "lib/python3.12/__pycache__/tarfile.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "b94641ac7911b28751c50b423354615506febcf15bf0a6960b9a98601125b9a1", + "sha256_in_prefix": "b94641ac7911b28751c50b423354615506febcf15bf0a6960b9a98601125b9a1", + "size_in_bytes": 119591 + }, + { + "_path": "lib/python3.12/__pycache__/telnetlib.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "4570087a57afe81a76bea4a600a421f92a1497fed3cc64fadf0b44e3d0b42efa", + "sha256_in_prefix": "4570087a57afe81a76bea4a600a421f92a1497fed3cc64fadf0b44e3d0b42efa", + "size_in_bytes": 28677 + }, + { + "_path": "lib/python3.12/__pycache__/tempfile.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "69149172f1071de6401f686792359895693a43305a5675769d7c218cfcdcd017", + "sha256_in_prefix": "69149172f1071de6401f686792359895693a43305a5675769d7c218cfcdcd017", + "size_in_bytes": 40652 + }, + { + "_path": "lib/python3.12/__pycache__/textwrap.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "28b4db074202163321cf7f69d4f4a0ce01cece3dd8aecef362bc29d2ac0a37cd", + "sha256_in_prefix": "28b4db074202163321cf7f69d4f4a0ce01cece3dd8aecef362bc29d2ac0a37cd", + "size_in_bytes": 18547 + }, + { + "_path": "lib/python3.12/__pycache__/this.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "d33cce775824c660093790d6a785e4c55a84776ab5ae67761ba5773e9ec3839a", + "sha256_in_prefix": "d33cce775824c660093790d6a785e4c55a84776ab5ae67761ba5773e9ec3839a", + "size_in_bytes": 1662 + }, + { + "_path": "lib/python3.12/__pycache__/threading.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "e72078e228aab377282e4215790bb339b61a0bc55382a3af9ee699a92b46c756", + "sha256_in_prefix": "e72078e228aab377282e4215790bb339b61a0bc55382a3af9ee699a92b46c756", + "size_in_bytes": 65561 + }, + { + "_path": "lib/python3.12/__pycache__/timeit.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "ad4e5ee3a092f8f422cf4feab2bf207e49c4872dd69e26cc358305447c5b57f6", + "sha256_in_prefix": "ad4e5ee3a092f8f422cf4feab2bf207e49c4872dd69e26cc358305447c5b57f6", + "size_in_bytes": 15118 + }, + { + "_path": "lib/python3.12/__pycache__/token.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "e859b421e1f95d815463fa0680b33186855f26e1ccde7e44e1a31a62e0bc1e11", + "sha256_in_prefix": "e859b421e1f95d815463fa0680b33186855f26e1ccde7e44e1a31a62e0bc1e11", + "size_in_bytes": 3811 + }, + { + "_path": "lib/python3.12/__pycache__/tokenize.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "b587b551ca144fdacc61e65d1d1f6e1e452ce299412db70d13dfad38a54bbf3a", + "sha256_in_prefix": "b587b551ca144fdacc61e65d1d1f6e1e452ce299412db70d13dfad38a54bbf3a", + "size_in_bytes": 23414 + }, + { + "_path": "lib/python3.12/__pycache__/trace.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "73dc439e1f4ff15da526996e97840c5c9f2fa47eefd645b39998d9e48067c938", + "sha256_in_prefix": "73dc439e1f4ff15da526996e97840c5c9f2fa47eefd645b39998d9e48067c938", + "size_in_bytes": 33278 + }, + { + "_path": "lib/python3.12/__pycache__/traceback.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "331df83f033d0adbbaa1fb51d119a9d02a11f39648c3ca36b4de6999a7fc2757", + "sha256_in_prefix": "331df83f033d0adbbaa1fb51d119a9d02a11f39648c3ca36b4de6999a7fc2757", + "size_in_bytes": 51771 + }, + { + "_path": "lib/python3.12/__pycache__/tracemalloc.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "0b7e0492b6346b67479699a70a14c0b3300cc98a00e1cf1feb48969a26d81baf", + "sha256_in_prefix": "0b7e0492b6346b67479699a70a14c0b3300cc98a00e1cf1feb48969a26d81baf", + "size_in_bytes": 27161 + }, + { + "_path": "lib/python3.12/__pycache__/tty.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "3b4fbce948c92596debabbccd086b6b022058494322dcd5c1507a83ade4d84a3", + "sha256_in_prefix": "3b4fbce948c92596debabbccd086b6b022058494322dcd5c1507a83ade4d84a3", + "size_in_bytes": 2922 + }, + { + "_path": "lib/python3.12/__pycache__/turtle.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "87b3d065e8b602937e5289e112fa2b750d322976d623aad93388e8de795b6bb4", + "sha256_in_prefix": "87b3d065e8b602937e5289e112fa2b750d322976d623aad93388e8de795b6bb4", + "size_in_bytes": 184886 + }, + { + "_path": "lib/python3.12/__pycache__/types.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "8d8320d33fa1cdefaf5e0093a3b05deae9f2e0b598af76730247420493d9c43c", + "sha256_in_prefix": "8d8320d33fa1cdefaf5e0093a3b05deae9f2e0b598af76730247420493d9c43c", + "size_in_bytes": 15193 + }, + { + "_path": "lib/python3.12/__pycache__/typing.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "126d524557aaf1a5a9e0137b94e92a469b8fc5e5346ea651476949838f520682", + "sha256_in_prefix": "126d524557aaf1a5a9e0137b94e92a469b8fc5e5346ea651476949838f520682", + "size_in_bytes": 141082 + }, + { + "_path": "lib/python3.12/__pycache__/uu.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "17a602f96847d9c1d7ca0aa3fa93148610db60ff91593897580dc061fd34f7dc", + "sha256_in_prefix": "17a602f96847d9c1d7ca0aa3fa93148610db60ff91593897580dc061fd34f7dc", + "size_in_bytes": 8070 + }, + { + "_path": "lib/python3.12/__pycache__/uuid.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "50ad45fa1da1babd4ef914709ad8532e9c4851a265afaef49f9312635da8c5f4", + "sha256_in_prefix": "50ad45fa1da1babd4ef914709ad8532e9c4851a265afaef49f9312635da8c5f4", + "size_in_bytes": 33256 + }, + { + "_path": "lib/python3.12/__pycache__/warnings.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "8d29385374212c86f5177daa02bf2f4739169489fbe99264fd970e43a3134c77", + "sha256_in_prefix": "8d29385374212c86f5177daa02bf2f4739169489fbe99264fd970e43a3134c77", + "size_in_bytes": 24018 + }, + { + "_path": "lib/python3.12/__pycache__/wave.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "6b4f4463d4048574b9a762b1e13f821d99d1e866e1dd5f021d164c3f16dcd5ad", + "sha256_in_prefix": "6b4f4463d4048574b9a762b1e13f821d99d1e866e1dd5f021d164c3f16dcd5ad", + "size_in_bytes": 32332 + }, + { + "_path": "lib/python3.12/__pycache__/weakref.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "5e9a7e796cecda687b75d7da0df7665179427439cbf8b1ae13db293420aab133", + "sha256_in_prefix": "5e9a7e796cecda687b75d7da0df7665179427439cbf8b1ae13db293420aab133", + "size_in_bytes": 31599 + }, + { + "_path": "lib/python3.12/__pycache__/webbrowser.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "71efc81e8c59220386b3d07d1546b028971abca026adcae7e86cd4c94236c58c", + "sha256_in_prefix": "71efc81e8c59220386b3d07d1546b028971abca026adcae7e86cd4c94236c58c", + "size_in_bytes": 26605 + }, + { + "_path": "lib/python3.12/__pycache__/xdrlib.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "0a911d6f6b570eac19194b570a121829e6a633f5a20c628173505370a79d2bf9", + "sha256_in_prefix": "0a911d6f6b570eac19194b570a121829e6a633f5a20c628173505370a79d2bf9", + "size_in_bytes": 12095 + }, + { + "_path": "lib/python3.12/__pycache__/zipapp.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "089e9e686a5235f7347c8c90eab80d88384116437339048a821fa8719c8a7731", + "sha256_in_prefix": "089e9e686a5235f7347c8c90eab80d88384116437339048a821fa8719c8a7731", + "size_in_bytes": 10231 + }, + { + "_path": "lib/python3.12/__pycache__/zipimport.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "272c0a510382434586210e994ff00f6fa7697fd3a04a07c65f0ccc8a59c929b2", + "sha256_in_prefix": "272c0a510382434586210e994ff00f6fa7697fd3a04a07c65f0ccc8a59c929b2", + "size_in_bytes": 24723 + }, + { + "_path": "lib/python3.12/_aix_support.py", + "path_type": "hardlink", + "sha256": "0982f187c62fbfc1e8d368c8eb4104b56df71009a6b2823565a699e7b4cd945c", + "sha256_in_prefix": "0982f187c62fbfc1e8d368c8eb4104b56df71009a6b2823565a699e7b4cd945c", + "size_in_bytes": 4021 + }, + { + "_path": "lib/python3.12/_collections_abc.py", + "path_type": "hardlink", + "sha256": "90324ee3e1c4ca5319f7242d4b7c1e90eb8418b3f999d07c853aa488356282e6", + "sha256_in_prefix": "90324ee3e1c4ca5319f7242d4b7c1e90eb8418b3f999d07c853aa488356282e6", + "size_in_bytes": 32082 + }, + { + "_path": "lib/python3.12/_compat_pickle.py", + "path_type": "hardlink", + "sha256": "12c8356a3d40bd0a336f13d7c6e2bed50d5c1a876563766a3175a6b328b5855e", + "sha256_in_prefix": "12c8356a3d40bd0a336f13d7c6e2bed50d5c1a876563766a3175a6b328b5855e", + "size_in_bytes": 8761 + }, + { + "_path": "lib/python3.12/_compression.py", + "path_type": "hardlink", + "sha256": "3ad5d60627477a60939ee44fc1bb3a05dbe8fb52f0f75039b8f5d8f1a278b981", + "sha256_in_prefix": "3ad5d60627477a60939ee44fc1bb3a05dbe8fb52f0f75039b8f5d8f1a278b981", + "size_in_bytes": 5681 + }, + { + "_path": "lib/python3.12/_markupbase.py", + "path_type": "hardlink", + "sha256": "cb14dd6f2e2439eb70b806cd49d19911363d424c2b6b9f4b73c9c08022d47030", + "sha256_in_prefix": "cb14dd6f2e2439eb70b806cd49d19911363d424c2b6b9f4b73c9c08022d47030", + "size_in_bytes": 14653 + }, + { + "_path": "lib/python3.12/_osx_support.py", + "path_type": "hardlink", + "sha256": "363d3240acbba18a270bd3161f1ddb478f8492dc14fc451b2dc314db5c5ee09c", + "sha256_in_prefix": "363d3240acbba18a270bd3161f1ddb478f8492dc14fc451b2dc314db5c5ee09c", + "size_in_bytes": 22023 + }, + { + "_path": "lib/python3.12/_py_abc.py", + "path_type": "hardlink", + "sha256": "f9c6fe3dd9b51bd7d93f867356e9d362600c924febfd903ee1c6e298860dca92", + "sha256_in_prefix": "f9c6fe3dd9b51bd7d93f867356e9d362600c924febfd903ee1c6e298860dca92", + "size_in_bytes": 6189 + }, + { + "_path": "lib/python3.12/_pydatetime.py", + "path_type": "hardlink", + "sha256": "8d5c6bb703d9b47f87bc20cb8003aaeee2dae7562a381e1623735f1ff8abccd3", + "sha256_in_prefix": "8d5c6bb703d9b47f87bc20cb8003aaeee2dae7562a381e1623735f1ff8abccd3", + "size_in_bytes": 92097 + }, + { + "_path": "lib/python3.12/_pydecimal.py", + "path_type": "hardlink", + "sha256": "c7108f0dc0beedb245daede78c9be602a64d47d3fb988e166e0474aa5bf317ea", + "sha256_in_prefix": "c7108f0dc0beedb245daede78c9be602a64d47d3fb988e166e0474aa5bf317ea", + "size_in_bytes": 229220 + }, + { + "_path": "lib/python3.12/_pyio.py", + "path_type": "hardlink", + "sha256": "0da5fe94519541c16bffd10992dbc2348a80701242b9eae4a21398052b9dd7f9", + "sha256_in_prefix": "0da5fe94519541c16bffd10992dbc2348a80701242b9eae4a21398052b9dd7f9", + "size_in_bytes": 93534 + }, + { + "_path": "lib/python3.12/_pylong.py", + "path_type": "hardlink", + "sha256": "79e219a7d1cab0b3d954fab7937c58ef965a3a132bdb885dda17bbb9fdfab16c", + "sha256_in_prefix": "79e219a7d1cab0b3d954fab7937c58ef965a3a132bdb885dda17bbb9fdfab16c", + "size_in_bytes": 9047 + }, + { + "_path": "lib/python3.12/_sitebuiltins.py", + "path_type": "hardlink", + "sha256": "b9388bc1d6d12ed6be12da420ab1feca40f99c0e33ec315d92b1e01cb69b25bc", + "sha256_in_prefix": "b9388bc1d6d12ed6be12da420ab1feca40f99c0e33ec315d92b1e01cb69b25bc", + "size_in_bytes": 3128 + }, + { + "_path": "lib/python3.12/_strptime.py", + "path_type": "hardlink", + "sha256": "302a4b9cf8fa7511c9142b110601f069fe195fec8217a49de46b340df2eafc32", + "sha256_in_prefix": "302a4b9cf8fa7511c9142b110601f069fe195fec8217a49de46b340df2eafc32", + "size_in_bytes": 24615 + }, + { + "_path": "lib/python3.12/_sysconfigdata__darwin_darwin.py", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/Users/runner/miniforge3/conda-bld/python-split_1708115848844/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placeh", + "sha256": "1dd578aa2ee9724e2c4e83cd0e4f991a4bd4899e613bb18b849f810d77f9c89f", + "sha256_in_prefix": "b81d9c9a98464f486fe81fdaf4fa52aa305218a4df2c179c7a21c040ab5b8d83", + "size_in_bytes": 104810 + }, + { + "_path": "lib/python3.12/_sysconfigdata__darwin_darwin.py.orig", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/Users/runner/miniforge3/conda-bld/python-split_1708115848844/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placeh", + "sha256": "894bee17f1519bbf1b9e5d792e9f55be3b07d0dc59edc5e0ebd12f07cefb40e0", + "sha256_in_prefix": "1fff0c5ab4cf976fe8bac215108cb108784e8e999c1f2895961a49bdf610800f", + "size_in_bytes": 119819 + }, + { + "_path": "lib/python3.12/_sysconfigdata_arm64_apple_darwin20_0_0.py", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/Users/runner/miniforge3/conda-bld/python-split_1708115848844/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placeh", + "sha256": "3cefabcf2fd4eb3eacd2da5585bab82946f74df228c30e59d0e5f82dafe04d49", + "sha256_in_prefix": "a62302673d8a71d473e88ea2b704c18ce4294377b0238f50704141b6a62e2bcc", + "size_in_bytes": 106879 + }, + { + "_path": "lib/python3.12/_threading_local.py", + "path_type": "hardlink", + "sha256": "e1bf3dae66d0bfa63c8bb8a1d10c611203c35c636f7f5191fd56105788ef29cb", + "sha256_in_prefix": "e1bf3dae66d0bfa63c8bb8a1d10c611203c35c636f7f5191fd56105788ef29cb", + "size_in_bytes": 7220 + }, + { + "_path": "lib/python3.12/_weakrefset.py", + "path_type": "hardlink", + "sha256": "91895a451d06e9f521a1171b31b9b19bc9740f35af00d4fa106338ab7167c9ac", + "sha256_in_prefix": "91895a451d06e9f521a1171b31b9b19bc9740f35af00d4fa106338ab7167c9ac", + "size_in_bytes": 5893 + }, + { + "_path": "lib/python3.12/abc.py", + "path_type": "hardlink", + "sha256": "e558702a95cdce3febd289da021715d2b92bc43995b8a1bc58dfa1c3d8010287", + "sha256_in_prefix": "e558702a95cdce3febd289da021715d2b92bc43995b8a1bc58dfa1c3d8010287", + "size_in_bytes": 6538 + }, + { + "_path": "lib/python3.12/aifc.py", + "path_type": "hardlink", + "sha256": "e027e8a33567890ad7f84fea3be423cc0f6e49a33a31bbf279c2d0f64b6f8345", + "sha256_in_prefix": "e027e8a33567890ad7f84fea3be423cc0f6e49a33a31bbf279c2d0f64b6f8345", + "size_in_bytes": 34211 + }, + { + "_path": "lib/python3.12/antigravity.py", + "path_type": "hardlink", + "sha256": "8a5ee63e1b79ba2733e7ff4290b6eefea60e7f3a1ccb6bb519535aaf92b44967", + "sha256_in_prefix": "8a5ee63e1b79ba2733e7ff4290b6eefea60e7f3a1ccb6bb519535aaf92b44967", + "size_in_bytes": 500 + }, + { + "_path": "lib/python3.12/argparse.py", + "path_type": "hardlink", + "sha256": "a2014aea48aa2260b7bafb4c64642da67bdb1dadb47046652c941b30972243a7", + "sha256_in_prefix": "a2014aea48aa2260b7bafb4c64642da67bdb1dadb47046652c941b30972243a7", + "size_in_bytes": 100862 + }, + { + "_path": "lib/python3.12/ast.py", + "path_type": "hardlink", + "sha256": "e1715db349b759971515776f665c2991189c8801340979667a1b1f07f85f0d51", + "sha256_in_prefix": "e1715db349b759971515776f665c2991189c8801340979667a1b1f07f85f0d51", + "size_in_bytes": 64165 + }, + { + "_path": "lib/python3.12/asyncio/__init__.py", + "path_type": "hardlink", + "sha256": "61102f2b5f8fb832f0558cb66391f227970b3dd34ea2a621455587b4295e89a1", + "sha256_in_prefix": "61102f2b5f8fb832f0558cb66391f227970b3dd34ea2a621455587b4295e89a1", + "size_in_bytes": 1220 + }, + { + "_path": "lib/python3.12/asyncio/__main__.py", + "path_type": "hardlink", + "sha256": "eb22d0fa0c480025270feb1e7f962510666287fe2ccaeb7f309d32637507d061", + "sha256_in_prefix": "eb22d0fa0c480025270feb1e7f962510666287fe2ccaeb7f309d32637507d061", + "size_in_bytes": 3343 + }, + { + "_path": "lib/python3.12/asyncio/__pycache__/__init__.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "7a94f1f1eea18902b0d4cd6bef8a50a516120ccfe577ca8a63d52320c55e7c71", + "sha256_in_prefix": "7a94f1f1eea18902b0d4cd6bef8a50a516120ccfe577ca8a63d52320c55e7c71", + "size_in_bytes": 1711 + }, + { + "_path": "lib/python3.12/asyncio/__pycache__/__main__.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "dde86f085b6800b708b26d9bb0f49b29555f94569577b0571ee94d7b2c298957", + "sha256_in_prefix": "dde86f085b6800b708b26d9bb0f49b29555f94569577b0571ee94d7b2c298957", + "size_in_bytes": 5429 + }, + { + "_path": "lib/python3.12/asyncio/__pycache__/base_events.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "11aefa2c2e242bb81f9fea53675e36953a772823ec0632c5eb01dc832d532b3c", + "sha256_in_prefix": "11aefa2c2e242bb81f9fea53675e36953a772823ec0632c5eb01dc832d532b3c", + "size_in_bytes": 86483 + }, + { + "_path": "lib/python3.12/asyncio/__pycache__/base_futures.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "33c8d55c56d9bb7a2858996a2f27d379be9b2031ffcf475bb339892f265e2c12", + "sha256_in_prefix": "33c8d55c56d9bb7a2858996a2f27d379be9b2031ffcf475bb339892f265e2c12", + "size_in_bytes": 3340 + }, + { + "_path": "lib/python3.12/asyncio/__pycache__/base_subprocess.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "32d2ce2692ffc7c3294d99c0070c9f0fc21ff7e499e0d994942de3a35b516d69", + "sha256_in_prefix": "32d2ce2692ffc7c3294d99c0070c9f0fc21ff7e499e0d994942de3a35b516d69", + "size_in_bytes": 16344 + }, + { + "_path": "lib/python3.12/asyncio/__pycache__/base_tasks.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "8911b67a72c354ac53337f321f43b89d2a51fde001a5ea84e1582a8701702475", + "sha256_in_prefix": "8911b67a72c354ac53337f321f43b89d2a51fde001a5ea84e1582a8701702475", + "size_in_bytes": 4341 + }, + { + "_path": "lib/python3.12/asyncio/__pycache__/constants.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "035ed09e0f601ed0897b6b51aa2980ca19c78749906c47edaf2df3b6900650f1", + "sha256_in_prefix": "035ed09e0f601ed0897b6b51aa2980ca19c78749906c47edaf2df3b6900650f1", + "size_in_bytes": 1209 + }, + { + "_path": "lib/python3.12/asyncio/__pycache__/coroutines.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "39b5ab5339bbcaa7c41fb11f3492ff5ec018dc0d91b04321a0322c785634d1af", + "sha256_in_prefix": "39b5ab5339bbcaa7c41fb11f3492ff5ec018dc0d91b04321a0322c785634d1af", + "size_in_bytes": 4020 + }, + { + "_path": "lib/python3.12/asyncio/__pycache__/events.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "0a3519efb71f4fbe2878f5a879a89148edd7ce29df7663d148863157516ac1a2", + "sha256_in_prefix": "0a3519efb71f4fbe2878f5a879a89148edd7ce29df7663d148863157516ac1a2", + "size_in_bytes": 37007 + }, + { + "_path": "lib/python3.12/asyncio/__pycache__/exceptions.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "0030cfa4a095328c41ca76563464d453861eb2b87cd4953b8d91cf8b5b431f5b", + "sha256_in_prefix": "0030cfa4a095328c41ca76563464d453861eb2b87cd4953b8d91cf8b5b431f5b", + "size_in_bytes": 3335 + }, + { + "_path": "lib/python3.12/asyncio/__pycache__/format_helpers.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "625ff2c85d2f2ccde844c7af8d70c29ab788b14862fc69f71b878819530a2079", + "sha256_in_prefix": "625ff2c85d2f2ccde844c7af8d70c29ab788b14862fc69f71b878819530a2079", + "size_in_bytes": 4119 + }, + { + "_path": "lib/python3.12/asyncio/__pycache__/futures.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "f5a7506d3031ac833683a21d32beef65793eb4422839ce414eee8b1a8b7c26d2", + "sha256_in_prefix": "f5a7506d3031ac833683a21d32beef65793eb4422839ce414eee8b1a8b7c26d2", + "size_in_bytes": 17501 + }, + { + "_path": "lib/python3.12/asyncio/__pycache__/locks.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "ac447fd1c9bda1d2203c9d036588e59fc95ccfeeb96647935e0148417c152287", + "sha256_in_prefix": "ac447fd1c9bda1d2203c9d036588e59fc95ccfeeb96647935e0148417c152287", + "size_in_bytes": 27756 + }, + { + "_path": "lib/python3.12/asyncio/__pycache__/log.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "f461e07cbeb05e6b5bcc5ceda0e5de0adf4e959744c8f32894594e842bf5c825", + "sha256_in_prefix": "f461e07cbeb05e6b5bcc5ceda0e5de0adf4e959744c8f32894594e842bf5c825", + "size_in_bytes": 535 + }, + { + "_path": "lib/python3.12/asyncio/__pycache__/mixins.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "94efea023440c556a9fe967115b8c14cb650cf0c4402b71ef62040c19b39cf9a", + "sha256_in_prefix": "94efea023440c556a9fe967115b8c14cb650cf0c4402b71ef62040c19b39cf9a", + "size_in_bytes": 1290 + }, + { + "_path": "lib/python3.12/asyncio/__pycache__/proactor_events.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "540136aeb9ab31ed7a99f7e3d6e7fc01643af36cbccede4c93ad207c8bbd8c80", + "sha256_in_prefix": "540136aeb9ab31ed7a99f7e3d6e7fc01643af36cbccede4c93ad207c8bbd8c80", + "size_in_bytes": 44777 + }, + { + "_path": "lib/python3.12/asyncio/__pycache__/protocols.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "eb4694d439aaffd69e1b4c93828660b7408488e67c6dfc741669bc176d247e44", + "sha256_in_prefix": "eb4694d439aaffd69e1b4c93828660b7408488e67c6dfc741669bc176d247e44", + "size_in_bytes": 9036 + }, + { + "_path": "lib/python3.12/asyncio/__pycache__/queues.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "fa09f286132d584096f8005391313f92a90a043f300d7f8bdba40842094cbe74", + "sha256_in_prefix": "fa09f286132d584096f8005391313f92a90a043f300d7f8bdba40842094cbe74", + "size_in_bytes": 12195 + }, + { + "_path": "lib/python3.12/asyncio/__pycache__/runners.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "045eb5175d197d557cf892accc210e6eac2e14cf5f9b913485a778ee02754676", + "sha256_in_prefix": "045eb5175d197d557cf892accc210e6eac2e14cf5f9b913485a778ee02754676", + "size_in_bytes": 10190 + }, + { + "_path": "lib/python3.12/asyncio/__pycache__/selector_events.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "ee20611d769f889b74905dc8359d7aefa939a5df401aa8dccace960a82e70d50", + "sha256_in_prefix": "ee20611d769f889b74905dc8359d7aefa939a5df401aa8dccace960a82e70d50", + "size_in_bytes": 63326 + }, + { + "_path": "lib/python3.12/asyncio/__pycache__/sslproto.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "8eaec36f92fdd6ab84beb5766b23e23fc034d382311a31cb819f4a001f4ef1f5", + "sha256_in_prefix": "8eaec36f92fdd6ab84beb5766b23e23fc034d382311a31cb819f4a001f4ef1f5", + "size_in_bytes": 41795 + }, + { + "_path": "lib/python3.12/asyncio/__pycache__/staggered.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "12e9aa645b452b4820d4d75ee85e6fb954f871850f90b2bd41133a1fa7284488", + "sha256_in_prefix": "12e9aa645b452b4820d4d75ee85e6fb954f871850f90b2bd41133a1fa7284488", + "size_in_bytes": 6485 + }, + { + "_path": "lib/python3.12/asyncio/__pycache__/streams.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "c7cafb5b43e6bea95247ba0de45290b1880801b9a0ed95ad8e99f5849ae445d0", + "sha256_in_prefix": "c7cafb5b43e6bea95247ba0de45290b1880801b9a0ed95ad8e99f5849ae445d0", + "size_in_bytes": 33619 + }, + { + "_path": "lib/python3.12/asyncio/__pycache__/subprocess.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "8670244a6aaf73bf4a3d0fef0d20613db9f041828bf5b8a5a3c7da3d26055eed", + "sha256_in_prefix": "8670244a6aaf73bf4a3d0fef0d20613db9f041828bf5b8a5a3c7da3d26055eed", + "size_in_bytes": 12348 + }, + { + "_path": "lib/python3.12/asyncio/__pycache__/taskgroups.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "f379b4e3124eae0f726cc6e0f9c4c1d4b191fd5b1b2b77752b4ad85be7564fe2", + "sha256_in_prefix": "f379b4e3124eae0f726cc6e0f9c4c1d4b191fd5b1b2b77752b4ad85be7564fe2", + "size_in_bytes": 8176 + }, + { + "_path": "lib/python3.12/asyncio/__pycache__/tasks.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "714383c35e7595e608bf2b22f6c5f5edd445be4b599553bee3939a41fee499ea", + "sha256_in_prefix": "714383c35e7595e608bf2b22f6c5f5edd445be4b599553bee3939a41fee499ea", + "size_in_bytes": 40619 + }, + { + "_path": "lib/python3.12/asyncio/__pycache__/threads.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "959508947e974246571b68bf9962bb482680b0829c2390873711af7a3543b222", + "sha256_in_prefix": "959508947e974246571b68bf9962bb482680b0829c2390873711af7a3543b222", + "size_in_bytes": 1512 + }, + { + "_path": "lib/python3.12/asyncio/__pycache__/timeouts.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "acb1e0dbacf090ac1ebb0e492f2f666cd9f189a4cb84036c0afd7d1961867096", + "sha256_in_prefix": "acb1e0dbacf090ac1ebb0e492f2f666cd9f189a4cb84036c0afd7d1961867096", + "size_in_bytes": 8045 + }, + { + "_path": "lib/python3.12/asyncio/__pycache__/transports.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "dca56373dcda5e0396040060fab8026a9c9ab6b500db31e06173a7091dd6ae8a", + "sha256_in_prefix": "dca56373dcda5e0396040060fab8026a9c9ab6b500db31e06173a7091dd6ae8a", + "size_in_bytes": 14255 + }, + { + "_path": "lib/python3.12/asyncio/__pycache__/trsock.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "98597f8ba6a5b0f7ce398f4a6fb902aa13aa7058c9a565b0b5ac85d26178ce49", + "sha256_in_prefix": "98597f8ba6a5b0f7ce398f4a6fb902aa13aa7058c9a565b0b5ac85d26178ce49", + "size_in_bytes": 5333 + }, + { + "_path": "lib/python3.12/asyncio/__pycache__/unix_events.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "091e1319a058017712fee791b8d2b1b418b775074adf34c50de3e47477f7a4a0", + "sha256_in_prefix": "091e1319a058017712fee791b8d2b1b418b775074adf34c50de3e47477f7a4a0", + "size_in_bytes": 68041 + }, + { + "_path": "lib/python3.12/asyncio/__pycache__/windows_events.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "a6d5e0077a1ad16a3e2a65316bffced7638d1586a40f10ee1e32c1ba3702b219", + "sha256_in_prefix": "a6d5e0077a1ad16a3e2a65316bffced7638d1586a40f10ee1e32c1ba3702b219", + "size_in_bytes": 41499 + }, + { + "_path": "lib/python3.12/asyncio/__pycache__/windows_utils.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "68a966863133562bb0a838d6e8465115846fa453cf7b1163b2e6ecc0e44bba84", + "sha256_in_prefix": "68a966863133562bb0a838d6e8465115846fa453cf7b1163b2e6ecc0e44bba84", + "size_in_bytes": 7586 + }, + { + "_path": "lib/python3.12/asyncio/base_events.py", + "path_type": "hardlink", + "sha256": "db26f1196c8be9a4a6dd78cf3ed883f18c9a7a59523e4da63bff417df0ee6c90", + "sha256_in_prefix": "db26f1196c8be9a4a6dd78cf3ed883f18c9a7a59523e4da63bff417df0ee6c90", + "size_in_bytes": 77816 + }, + { + "_path": "lib/python3.12/asyncio/base_futures.py", + "path_type": "hardlink", + "sha256": "2f3798c4b82f5ac77647908b157c924f734f36871d98970e72849ea9a9a07856", + "sha256_in_prefix": "2f3798c4b82f5ac77647908b157c924f734f36871d98970e72849ea9a9a07856", + "size_in_bytes": 1974 + }, + { + "_path": "lib/python3.12/asyncio/base_subprocess.py", + "path_type": "hardlink", + "sha256": "d69ba8f97bf8c89564cadce49427574ddb98103a5db6f04b98798240332e7adf", + "sha256_in_prefix": "d69ba8f97bf8c89564cadce49427574ddb98103a5db6f04b98798240332e7adf", + "size_in_bytes": 8869 + }, + { + "_path": "lib/python3.12/asyncio/base_tasks.py", + "path_type": "hardlink", + "sha256": "56efac65b63db927af336fa55eb5bda93c97a2defa4734ea8d695ed20fd6712a", + "sha256_in_prefix": "56efac65b63db927af336fa55eb5bda93c97a2defa4734ea8d695ed20fd6712a", + "size_in_bytes": 2672 + }, + { + "_path": "lib/python3.12/asyncio/constants.py", + "path_type": "hardlink", + "sha256": "873fc2f9e66313c3c19c337269e704f204b59f9e91d6ecbec59f68335484d338", + "sha256_in_prefix": "873fc2f9e66313c3c19c337269e704f204b59f9e91d6ecbec59f68335484d338", + "size_in_bytes": 1413 + }, + { + "_path": "lib/python3.12/asyncio/coroutines.py", + "path_type": "hardlink", + "sha256": "2feec17557c230a80cc2a6391bbb1c44b9f3341820b05667e36a4eb12b749436", + "sha256_in_prefix": "2feec17557c230a80cc2a6391bbb1c44b9f3341820b05667e36a4eb12b749436", + "size_in_bytes": 3342 + }, + { + "_path": "lib/python3.12/asyncio/events.py", + "path_type": "hardlink", + "sha256": "6a18b7eee5926622c146e61a7eb39726b4656e07ca41d36b06936ffb2354f0ed", + "sha256_in_prefix": "6a18b7eee5926622c146e61a7eb39726b4656e07ca41d36b06936ffb2354f0ed", + "size_in_bytes": 29339 + }, + { + "_path": "lib/python3.12/asyncio/exceptions.py", + "path_type": "hardlink", + "sha256": "a5971f88be14cd1417d59adf539ae48c5d818f95362a4e0eb00017e3690ab37b", + "sha256_in_prefix": "a5971f88be14cd1417d59adf539ae48c5d818f95362a4e0eb00017e3690ab37b", + "size_in_bytes": 1752 + }, + { + "_path": "lib/python3.12/asyncio/format_helpers.py", + "path_type": "hardlink", + "sha256": "6377b672b3f4ba8b6f0f7a5f0ea00cde24c8cddc0ca764e3329f302763477f59", + "sha256_in_prefix": "6377b672b3f4ba8b6f0f7a5f0ea00cde24c8cddc0ca764e3329f302763477f59", + "size_in_bytes": 2404 + }, + { + "_path": "lib/python3.12/asyncio/futures.py", + "path_type": "hardlink", + "sha256": "7308533f98987fd96acb2cef27d16e2b05ff3efad406db4b0d4d39a2a8f6971d", + "sha256_in_prefix": "7308533f98987fd96acb2cef27d16e2b05ff3efad406db4b0d4d39a2a8f6971d", + "size_in_bytes": 14210 + }, + { + "_path": "lib/python3.12/asyncio/locks.py", + "path_type": "hardlink", + "sha256": "808bece72e0a4c6ab34299ffe555c927a8db475066ce8dc4ba614588fff720db", + "sha256_in_prefix": "808bece72e0a4c6ab34299ffe555c927a8db475066ce8dc4ba614588fff720db", + "size_in_bytes": 18994 + }, + { + "_path": "lib/python3.12/asyncio/log.py", + "path_type": "hardlink", + "sha256": "80e4cc3ded4b138baba486519e7444801a23d6ac35f229d336a407a96af7e8d2", + "sha256_in_prefix": "80e4cc3ded4b138baba486519e7444801a23d6ac35f229d336a407a96af7e8d2", + "size_in_bytes": 124 + }, + { + "_path": "lib/python3.12/asyncio/mixins.py", + "path_type": "hardlink", + "sha256": "8f4a3e16eca845ebfba422550cbcee7340ec8166d2bff6b750a8ed0de6b9ae3c", + "sha256_in_prefix": "8f4a3e16eca845ebfba422550cbcee7340ec8166d2bff6b750a8ed0de6b9ae3c", + "size_in_bytes": 481 + }, + { + "_path": "lib/python3.12/asyncio/proactor_events.py", + "path_type": "hardlink", + "sha256": "199d554fda7ec1a7e6a53e78f3f00f6e84dff27f0ed74107846d63106c895955", + "sha256_in_prefix": "199d554fda7ec1a7e6a53e78f3f00f6e84dff27f0ed74107846d63106c895955", + "size_in_bytes": 33385 + }, + { + "_path": "lib/python3.12/asyncio/protocols.py", + "path_type": "hardlink", + "sha256": "1d1b49988c338b4ef06e30f9e92d9db2e00080c341f0a3f573bb8312deb8aff6", + "sha256_in_prefix": "1d1b49988c338b4ef06e30f9e92d9db2e00080c341f0a3f573bb8312deb8aff6", + "size_in_bytes": 6957 + }, + { + "_path": "lib/python3.12/asyncio/queues.py", + "path_type": "hardlink", + "sha256": "8f020744ebd1f557dcb051a1530b504447660df906c2127a94bbcc8450ea7ef9", + "sha256_in_prefix": "8f020744ebd1f557dcb051a1530b504447660df906c2127a94bbcc8450ea7ef9", + "size_in_bytes": 7974 + }, + { + "_path": "lib/python3.12/asyncio/runners.py", + "path_type": "hardlink", + "sha256": "005535b70acf976133dda890b7c7f9076401fd7b532afeb27a1a68e863219072", + "sha256_in_prefix": "005535b70acf976133dda890b7c7f9076401fd7b532afeb27a1a68e863219072", + "size_in_bytes": 7159 + }, + { + "_path": "lib/python3.12/asyncio/selector_events.py", + "path_type": "hardlink", + "sha256": "a32d9cc6afcc03d3004ce07379cc1875f749111d2e3478e59260a3b82256b9b6", + "sha256_in_prefix": "a32d9cc6afcc03d3004ce07379cc1875f749111d2e3478e59260a3b82256b9b6", + "size_in_bytes": 48241 + }, + { + "_path": "lib/python3.12/asyncio/sslproto.py", + "path_type": "hardlink", + "sha256": "c747273038c3d27d0447f84eace19faf6c0e2730a0aa89639f9a40af41b5d180", + "sha256_in_prefix": "c747273038c3d27d0447f84eace19faf6c0e2730a0aa89639f9a40af41b5d180", + "size_in_bytes": 31739 + }, + { + "_path": "lib/python3.12/asyncio/staggered.py", + "path_type": "hardlink", + "sha256": "ff289bdc20a50ad9620393479d785bc653e71c2e3298f53ab27907cd136498e9", + "sha256_in_prefix": "ff289bdc20a50ad9620393479d785bc653e71c2e3298f53ab27907cd136498e9", + "size_in_bytes": 5992 + }, + { + "_path": "lib/python3.12/asyncio/streams.py", + "path_type": "hardlink", + "sha256": "6ec5c70fd95b0d51cc1e81cd21e8abe8c1b69650148d6bb75ab4aa4797319bd4", + "sha256_in_prefix": "6ec5c70fd95b0d51cc1e81cd21e8abe8c1b69650148d6bb75ab4aa4797319bd4", + "size_in_bytes": 27619 + }, + { + "_path": "lib/python3.12/asyncio/subprocess.py", + "path_type": "hardlink", + "sha256": "7b70605716334f63cc482123b2aaa3b7c5bb7138eeab63a037bd8068d43307c1", + "sha256_in_prefix": "7b70605716334f63cc482123b2aaa3b7c5bb7138eeab63a037bd8068d43307c1", + "size_in_bytes": 7737 + }, + { + "_path": "lib/python3.12/asyncio/taskgroups.py", + "path_type": "hardlink", + "sha256": "04895039b4870219ba5b94d42f3dccf996b4bf26108a54c47f30326eae4af0cc", + "sha256_in_prefix": "04895039b4870219ba5b94d42f3dccf996b4bf26108a54c47f30326eae4af0cc", + "size_in_bytes": 8747 + }, + { + "_path": "lib/python3.12/asyncio/tasks.py", + "path_type": "hardlink", + "sha256": "6efe02c08631e9ef52066c2edd4b575257b7b902c196d2831de838f2170a41ef", + "sha256_in_prefix": "6efe02c08631e9ef52066c2edd4b575257b7b902c196d2831de838f2170a41ef", + "size_in_bytes": 37361 + }, + { + "_path": "lib/python3.12/asyncio/threads.py", + "path_type": "hardlink", + "sha256": "39d37295383641565f0c08bd992e2f661dc8051eb17e890b834fce96bde0910e", + "sha256_in_prefix": "39d37295383641565f0c08bd992e2f661dc8051eb17e890b834fce96bde0910e", + "size_in_bytes": 790 + }, + { + "_path": "lib/python3.12/asyncio/timeouts.py", + "path_type": "hardlink", + "sha256": "3e40ca0dca3e54776579797837cd4936d73d04aae09fe0cf83ce1e5449d00163", + "sha256_in_prefix": "3e40ca0dca3e54776579797837cd4936d73d04aae09fe0cf83ce1e5449d00163", + "size_in_bytes": 5321 + }, + { + "_path": "lib/python3.12/asyncio/transports.py", + "path_type": "hardlink", + "sha256": "940108bc133de399f38928cad3274f463096168d8a3ee5148f2478d3cb636f1c", + "sha256_in_prefix": "940108bc133de399f38928cad3274f463096168d8a3ee5148f2478d3cb636f1c", + "size_in_bytes": 10722 + }, + { + "_path": "lib/python3.12/asyncio/trsock.py", + "path_type": "hardlink", + "sha256": "c0eac37debcc51b702b808f6b7ed3e417343f5ff5f57125dad600a27eb082328", + "sha256_in_prefix": "c0eac37debcc51b702b808f6b7ed3e417343f5ff5f57125dad600a27eb082328", + "size_in_bytes": 2475 + }, + { + "_path": "lib/python3.12/asyncio/unix_events.py", + "path_type": "hardlink", + "sha256": "1fff06cce78763800f05f4d2bebfcdbc07ebf9564ca7e7222e0d91e39dee08c9", + "sha256_in_prefix": "1fff06cce78763800f05f4d2bebfcdbc07ebf9564ca7e7222e0d91e39dee08c9", + "size_in_bytes": 53124 + }, + { + "_path": "lib/python3.12/asyncio/windows_events.py", + "path_type": "hardlink", + "sha256": "c4c30238bda9e8abde7b677117117cc2531931237dc720983f520748ac6dbb51", + "sha256_in_prefix": "c4c30238bda9e8abde7b677117117cc2531931237dc720983f520748ac6dbb51", + "size_in_bytes": 32252 + }, + { + "_path": "lib/python3.12/asyncio/windows_utils.py", + "path_type": "hardlink", + "sha256": "e6fcffefa2521666bc2aed0f5caf8e862c1c1014ad12d2ab5fbce09c2df9c6f0", + "sha256_in_prefix": "e6fcffefa2521666bc2aed0f5caf8e862c1c1014ad12d2ab5fbce09c2df9c6f0", + "size_in_bytes": 5060 + }, + { + "_path": "lib/python3.12/base64.py", + "path_type": "hardlink", + "sha256": "8a07aa038a9a36984d07a6703aea20a477477fdd4f24dc2c8763e493adca653b", + "sha256_in_prefix": "8a07aa038a9a36984d07a6703aea20a477477fdd4f24dc2c8763e493adca653b", + "size_in_bytes": 20603 + }, + { + "_path": "lib/python3.12/bdb.py", + "path_type": "hardlink", + "sha256": "314d8bf11b4824d47471ad25dab64bda895e39673fb744e88e7f622a3dd374f2", + "sha256_in_prefix": "314d8bf11b4824d47471ad25dab64bda895e39673fb744e88e7f622a3dd374f2", + "size_in_bytes": 32463 + }, + { + "_path": "lib/python3.12/bisect.py", + "path_type": "hardlink", + "sha256": "f1cf7b85fc36b5da249813fc5ab97d9464f8cc1bc817f7146206fa2713e35999", + "sha256_in_prefix": "f1cf7b85fc36b5da249813fc5ab97d9464f8cc1bc817f7146206fa2713e35999", + "size_in_bytes": 3423 + }, + { + "_path": "lib/python3.12/bz2.py", + "path_type": "hardlink", + "sha256": "76ab3252924e71e859d7d90e8d3db13b6554975cfcac0fdadced4de7f8779330", + "sha256_in_prefix": "76ab3252924e71e859d7d90e8d3db13b6554975cfcac0fdadced4de7f8779330", + "size_in_bytes": 11847 + }, + { + "_path": "lib/python3.12/cProfile.py", + "path_type": "hardlink", + "sha256": "c4c3edb84862431dffd6c044f5c02bb27f94e5b79a708bce195a7981efcb43bc", + "sha256_in_prefix": "c4c3edb84862431dffd6c044f5c02bb27f94e5b79a708bce195a7981efcb43bc", + "size_in_bytes": 6556 + }, + { + "_path": "lib/python3.12/calendar.py", + "path_type": "hardlink", + "sha256": "fb3fbcc0a0c8f33941153c425e5c39aedae687c86fcb001bf3a9526a9584459c", + "sha256_in_prefix": "fb3fbcc0a0c8f33941153c425e5c39aedae687c86fcb001bf3a9526a9584459c", + "size_in_bytes": 25418 + }, + { + "_path": "lib/python3.12/cgi.py", + "path_type": "hardlink", + "sha256": "f132666784c29a3e275f50596f87bb8abc388a94fcdb70be130000e01a9a6b78", + "sha256_in_prefix": "f132666784c29a3e275f50596f87bb8abc388a94fcdb70be130000e01a9a6b78", + "size_in_bytes": 34420 + }, + { + "_path": "lib/python3.12/cgitb.py", + "path_type": "hardlink", + "sha256": "08bbcca13a431551da73a2144c13f21e68cb79ac82223fbe5e60fcf89ce10f9c", + "sha256_in_prefix": "08bbcca13a431551da73a2144c13f21e68cb79ac82223fbe5e60fcf89ce10f9c", + "size_in_bytes": 12421 + }, + { + "_path": "lib/python3.12/chunk.py", + "path_type": "hardlink", + "sha256": "4817eb94eeb8835c3325433f68f17e0ebbf7c96065ecf6aba3af7852f9a5314b", + "sha256_in_prefix": "4817eb94eeb8835c3325433f68f17e0ebbf7c96065ecf6aba3af7852f9a5314b", + "size_in_bytes": 5500 + }, + { + "_path": "lib/python3.12/cmd.py", + "path_type": "hardlink", + "sha256": "fb82a8c4e44e5b559c88d516d79051534cec69a463df97defe05ac8a261f0a0d", + "sha256_in_prefix": "fb82a8c4e44e5b559c88d516d79051534cec69a463df97defe05ac8a261f0a0d", + "size_in_bytes": 14873 + }, + { + "_path": "lib/python3.12/code.py", + "path_type": "hardlink", + "sha256": "b191c6d6190382bcbb2826d7faf5521479abd733deb25d3cf3fba879b65b6953", + "sha256_in_prefix": "b191c6d6190382bcbb2826d7faf5521479abd733deb25d3cf3fba879b65b6953", + "size_in_bytes": 10695 + }, + { + "_path": "lib/python3.12/codecs.py", + "path_type": "hardlink", + "sha256": "7b7839e53a77961153240aecfe11edc8054d05b1dedd83894450dae21ec05785", + "sha256_in_prefix": "7b7839e53a77961153240aecfe11edc8054d05b1dedd83894450dae21ec05785", + "size_in_bytes": 36870 + }, + { + "_path": "lib/python3.12/codeop.py", + "path_type": "hardlink", + "sha256": "3fb545862a1f9030c0d8f1ae6c72457d14a26d67a9b45de455e49900ff84a3a9", + "sha256_in_prefix": "3fb545862a1f9030c0d8f1ae6c72457d14a26d67a9b45de455e49900ff84a3a9", + "size_in_bytes": 5908 + }, + { + "_path": "lib/python3.12/collections/__init__.py", + "path_type": "hardlink", + "sha256": "d298975e5069d5944316e45d80fa68b495baccba504eb877a5ca3b0200c2b4a8", + "sha256_in_prefix": "d298975e5069d5944316e45d80fa68b495baccba504eb877a5ca3b0200c2b4a8", + "size_in_bytes": 52379 + }, + { + "_path": "lib/python3.12/collections/__pycache__/__init__.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "2b4f3ff2fa9d2c67a14317259ab8ab4dc373dabb53b8af83291c9a6449c3f29c", + "sha256_in_prefix": "2b4f3ff2fa9d2c67a14317259ab8ab4dc373dabb53b8af83291c9a6449c3f29c", + "size_in_bytes": 73344 + }, + { + "_path": "lib/python3.12/collections/__pycache__/abc.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "a6d6ff8424309327792c299d4d2bd92cae50068be93a607b7a86eb01633e9220", + "sha256_in_prefix": "a6d6ff8424309327792c299d4d2bd92cae50068be93a607b7a86eb01633e9220", + "size_in_bytes": 503 + }, + { + "_path": "lib/python3.12/collections/abc.py", + "path_type": "hardlink", + "sha256": "9cb4208f99128a0489b6c8e6c61637617dd7d4250c59e065491957eda084dd10", + "sha256_in_prefix": "9cb4208f99128a0489b6c8e6c61637617dd7d4250c59e065491957eda084dd10", + "size_in_bytes": 119 + }, + { + "_path": "lib/python3.12/colorsys.py", + "path_type": "hardlink", + "sha256": "d9800f8e81d46e63ca6f2e7d6ac5f344d85afb92c3cf6d103b5f977f1ad66ac2", + "sha256_in_prefix": "d9800f8e81d46e63ca6f2e7d6ac5f344d85afb92c3cf6d103b5f977f1ad66ac2", + "size_in_bytes": 4062 + }, + { + "_path": "lib/python3.12/compileall.py", + "path_type": "hardlink", + "sha256": "588f003bb5088ce380f3c335febaec1318811d275e5554b106655c4ceebabcfb", + "sha256_in_prefix": "588f003bb5088ce380f3c335febaec1318811d275e5554b106655c4ceebabcfb", + "size_in_bytes": 20507 + }, + { + "_path": "lib/python3.12/concurrent/__init__.py", + "path_type": "hardlink", + "sha256": "87ad5c8954dd56fbbca04517bf87477ff4dce575170c7dd1281d7ef1f4214ac8", + "sha256_in_prefix": "87ad5c8954dd56fbbca04517bf87477ff4dce575170c7dd1281d7ef1f4214ac8", + "size_in_bytes": 38 + }, + { + "_path": "lib/python3.12/concurrent/__pycache__/__init__.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "e49226863ba5eb750ea4b6497d16acad455c9293afe11bba90112d418981439b", + "sha256_in_prefix": "e49226863ba5eb750ea4b6497d16acad455c9293afe11bba90112d418981439b", + "size_in_bytes": 393 + }, + { + "_path": "lib/python3.12/concurrent/futures/__init__.py", + "path_type": "hardlink", + "sha256": "9bcec785db3eddc6d462883957ba6d3ff4370501fece505101444bae542883e8", + "sha256_in_prefix": "9bcec785db3eddc6d462883957ba6d3ff4370501fece505101444bae542883e8", + "size_in_bytes": 1558 + }, + { + "_path": "lib/python3.12/concurrent/futures/__pycache__/__init__.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "01dca458394e1947f257face60fc7bd7931afb85d45cf04f27b927b80b4a6bda", + "sha256_in_prefix": "01dca458394e1947f257face60fc7bd7931afb85d45cf04f27b927b80b4a6bda", + "size_in_bytes": 1504 + }, + { + "_path": "lib/python3.12/concurrent/futures/__pycache__/_base.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "f86b883e67bcb2eb69cd90fa0c9fb1a264a6548733cbc4a9955fc5a36152a91e", + "sha256_in_prefix": "f86b883e67bcb2eb69cd90fa0c9fb1a264a6548733cbc4a9955fc5a36152a91e", + "size_in_bytes": 32442 + }, + { + "_path": "lib/python3.12/concurrent/futures/__pycache__/process.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "112c83715590753541e70762d6a386eefa405482b7bb588834e20a08113722ab", + "sha256_in_prefix": "112c83715590753541e70762d6a386eefa405482b7bb588834e20a08113722ab", + "size_in_bytes": 35982 + }, + { + "_path": "lib/python3.12/concurrent/futures/__pycache__/thread.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "d9b2b9b432d1a6e82c4c8b785ba51fcfef7c30c059c27bea69270ffeded7f0d1", + "sha256_in_prefix": "d9b2b9b432d1a6e82c4c8b785ba51fcfef7c30c059c27bea69270ffeded7f0d1", + "size_in_bytes": 10455 + }, + { + "_path": "lib/python3.12/concurrent/futures/_base.py", + "path_type": "hardlink", + "sha256": "8c6d5f09f7c535d40fa1c30ebfcb35e0601c2abf32286a82cf151af7ddf72473", + "sha256_in_prefix": "8c6d5f09f7c535d40fa1c30ebfcb35e0601c2abf32286a82cf151af7ddf72473", + "size_in_bytes": 22833 + }, + { + "_path": "lib/python3.12/concurrent/futures/process.py", + "path_type": "hardlink", + "sha256": "d902a4365e8380d839b2dda00419e286b6d292ca17a00a56bee7b7dac8ad5aa7", + "sha256_in_prefix": "d902a4365e8380d839b2dda00419e286b6d292ca17a00a56bee7b7dac8ad5aa7", + "size_in_bytes": 36351 + }, + { + "_path": "lib/python3.12/concurrent/futures/thread.py", + "path_type": "hardlink", + "sha256": "33f69dd18c908992bce91ad3aa6bd809a42684e2b66caaa09ad4934ca0a29f58", + "sha256_in_prefix": "33f69dd18c908992bce91ad3aa6bd809a42684e2b66caaa09ad4934ca0a29f58", + "size_in_bytes": 8884 + }, + { + "_path": "lib/python3.12/config-3.12-darwin/Makefile", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/Users/runner/miniforge3/conda-bld/python-split_1708115848844/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placeh", + "sha256": "18968ebc96637010caadc2dafd0c40b9927a729fcba4b55373ee75ecf600dd31", + "sha256_in_prefix": "1ab71a3962ea808b5700f43346425d154977779b0206132c9d4c643c69b04c5f", + "size_in_bytes": 195578 + }, + { + "_path": "lib/python3.12/config-3.12-darwin/Setup", + "path_type": "hardlink", + "sha256": "17c83234ffe6302e7eaf62a363571fe6cc240b8b97bed7e503b85429fd10a5ca", + "sha256_in_prefix": "17c83234ffe6302e7eaf62a363571fe6cc240b8b97bed7e503b85429fd10a5ca", + "size_in_bytes": 11525 + }, + { + "_path": "lib/python3.12/config-3.12-darwin/Setup.bootstrap", + "path_type": "hardlink", + "sha256": "2917936af36bd7d641c737f72f68599fd13c26a28faebba7c07799879b1b9b31", + "sha256_in_prefix": "2917936af36bd7d641c737f72f68599fd13c26a28faebba7c07799879b1b9b31", + "size_in_bytes": 902 + }, + { + "_path": "lib/python3.12/config-3.12-darwin/Setup.local", + "path_type": "hardlink", + "sha256": "d29e734b34f3f8cb4a8c2b9305b6e7f378214ecd13928f2671db2c7ee0f7b378", + "sha256_in_prefix": "d29e734b34f3f8cb4a8c2b9305b6e7f378214ecd13928f2671db2c7ee0f7b378", + "size_in_bytes": 41 + }, + { + "_path": "lib/python3.12/config-3.12-darwin/Setup.stdlib", + "path_type": "hardlink", + "sha256": "cf8d0a99bb7be92fe01b8855a2a5612f5f321505661dff833401bd71c89330ee", + "sha256_in_prefix": "cf8d0a99bb7be92fe01b8855a2a5612f5f321505661dff833401bd71c89330ee", + "size_in_bytes": 6291 + }, + { + "_path": "lib/python3.12/config-3.12-darwin/__pycache__/python-config.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "ddcfd3d916451927c2d0c73c4fd85ba82831356931ee3f142316de6e688948cd", + "sha256_in_prefix": "ddcfd3d916451927c2d0c73c4fd85ba82831356931ee3f142316de6e688948cd", + "size_in_bytes": 3425 + }, + { + "_path": "lib/python3.12/config-3.12-darwin/config.c", + "path_type": "hardlink", + "sha256": "6b067dc2a1b43c7cf78fca8effe0e59560f3572cc4c97e911d9cd7719f0a8c2f", + "sha256_in_prefix": "6b067dc2a1b43c7cf78fca8effe0e59560f3572cc4c97e911d9cd7719f0a8c2f", + "size_in_bytes": 3477 + }, + { + "_path": "lib/python3.12/config-3.12-darwin/config.c.in", + "path_type": "hardlink", + "sha256": "5c76ef60a799f420b09b047dc1087728e5ed08ba82f6c7664c4d4f1d1d715b21", + "sha256_in_prefix": "5c76ef60a799f420b09b047dc1087728e5ed08ba82f6c7664c4d4f1d1d715b21", + "size_in_bytes": 1752 + }, + { + "_path": "lib/python3.12/config-3.12-darwin/install-sh", + "path_type": "hardlink", + "sha256": "3d7488bebd0cfc9b5c440c55d5b44f1c6e2e3d3e19894821bae4a27f9307f1d2", + "sha256_in_prefix": "3d7488bebd0cfc9b5c440c55d5b44f1c6e2e3d3e19894821bae4a27f9307f1d2", + "size_in_bytes": 15358 + }, + { + "_path": "lib/python3.12/config-3.12-darwin/makesetup", + "path_type": "hardlink", + "sha256": "0615264cbe9f3a4fce27de0054839ea814f2fe6f6091a0e17b18b5b15c665cfa", + "sha256_in_prefix": "0615264cbe9f3a4fce27de0054839ea814f2fe6f6091a0e17b18b5b15c665cfa", + "size_in_bytes": 9312 + }, + { + "_path": "lib/python3.12/config-3.12-darwin/python-config.py", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/Users/runner/miniforge3/conda-bld/python-split_1708115848844/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placeh", + "sha256": "d0ca9f1b59946e9c206eae18ff42521af18ada070a568d534c2e5f3ff4fe9598", + "sha256_in_prefix": "f0fbf2d550f63d4b6ca56d2609a89cb6647c71894010636fc6ddd305fd1c7cfb", + "size_in_bytes": 2289 + }, + { + "_path": "lib/python3.12/config-3.12-darwin/python.o", + "path_type": "hardlink", + "sha256": "04422f2f211798d0f48494358baf5fd99fb4cd20148e553cc9ff793f13a895bb", + "sha256_in_prefix": "04422f2f211798d0f48494358baf5fd99fb4cd20148e553cc9ff793f13a895bb", + "size_in_bytes": 2864 + }, + { + "_path": "lib/python3.12/configparser.py", + "path_type": "hardlink", + "sha256": "6a16889607e4e5eec6d8b336377417e70dd4ad3e944eb808d82a8145e428b145", + "sha256_in_prefix": "6a16889607e4e5eec6d8b336377417e70dd4ad3e944eb808d82a8145e428b145", + "size_in_bytes": 53383 + }, + { + "_path": "lib/python3.12/contextlib.py", + "path_type": "hardlink", + "sha256": "8b7a477f978a8532852fd81e241c78182516bc4975d672d580a5848a76e11eb6", + "sha256_in_prefix": "8b7a477f978a8532852fd81e241c78182516bc4975d672d580a5848a76e11eb6", + "size_in_bytes": 27637 + }, + { + "_path": "lib/python3.12/contextvars.py", + "path_type": "hardlink", + "sha256": "5ed260be8d1f4fe92261b7810b4bb1e8539c42093d7493f677d076e1a87f459a", + "sha256_in_prefix": "5ed260be8d1f4fe92261b7810b4bb1e8539c42093d7493f677d076e1a87f459a", + "size_in_bytes": 129 + }, + { + "_path": "lib/python3.12/copy.py", + "path_type": "hardlink", + "sha256": "cbd25547933176fcf6bb05c2adc9f4796d15ac20b9b82dcf890daea7203daeab", + "sha256_in_prefix": "cbd25547933176fcf6bb05c2adc9f4796d15ac20b9b82dcf890daea7203daeab", + "size_in_bytes": 8412 + }, + { + "_path": "lib/python3.12/copyreg.py", + "path_type": "hardlink", + "sha256": "c8eda41f05c6bf95a4da4726a530409d2485ae060b8d019b3a8034389a15d3e9", + "sha256_in_prefix": "c8eda41f05c6bf95a4da4726a530409d2485ae060b8d019b3a8034389a15d3e9", + "size_in_bytes": 7614 + }, + { + "_path": "lib/python3.12/crypt.py", + "path_type": "hardlink", + "sha256": "208df2ff33c19056345dcf5474abef1a58da799e2f3bab09d1d28b77ad3c623d", + "sha256_in_prefix": "208df2ff33c19056345dcf5474abef1a58da799e2f3bab09d1d28b77ad3c623d", + "size_in_bytes": 3913 + }, + { + "_path": "lib/python3.12/csv.py", + "path_type": "hardlink", + "sha256": "46004923196e98a67f87d30da64d070027c81f144f5ac91242fbfae33507dda8", + "sha256_in_prefix": "46004923196e98a67f87d30da64d070027c81f144f5ac91242fbfae33507dda8", + "size_in_bytes": 16386 + }, + { + "_path": "lib/python3.12/ctypes/__init__.py", + "path_type": "hardlink", + "sha256": "0782592567ad71097198a3afe985ac3e2ea0b9b5e75452402c9460c89a86318a", + "sha256_in_prefix": "0782592567ad71097198a3afe985ac3e2ea0b9b5e75452402c9460c89a86318a", + "size_in_bytes": 18182 + }, + { + "_path": "lib/python3.12/ctypes/__pycache__/__init__.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "0b13e28a4e9e2ab6835d7ea8c534a90fdd88ebb2c36082a3098931d1065d4581", + "sha256_in_prefix": "0b13e28a4e9e2ab6835d7ea8c534a90fdd88ebb2c36082a3098931d1065d4581", + "size_in_bytes": 23703 + }, + { + "_path": "lib/python3.12/ctypes/__pycache__/_aix.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "5eaab93f3287d337de44cdd5b977c23330c57e908f05217f88814091951149e7", + "sha256_in_prefix": "5eaab93f3287d337de44cdd5b977c23330c57e908f05217f88814091951149e7", + "size_in_bytes": 12605 + }, + { + "_path": "lib/python3.12/ctypes/__pycache__/_endian.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "f508706abda0fa08c4537a6c28f4c7e2e36be1dac0f09dbd347e635764900348", + "sha256_in_prefix": "f508706abda0fa08c4537a6c28f4c7e2e36be1dac0f09dbd347e635764900348", + "size_in_bytes": 3634 + }, + { + "_path": "lib/python3.12/ctypes/__pycache__/util.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "27e00bbddca19a763ac01efe11aff479d25b203a37d81b5f157ff324b4f9007d", + "sha256_in_prefix": "27e00bbddca19a763ac01efe11aff479d25b203a37d81b5f157ff324b4f9007d", + "size_in_bytes": 17503 + }, + { + "_path": "lib/python3.12/ctypes/__pycache__/wintypes.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "75694d23ef8c0e7a4dccf7342a7eee9baa67e77079584355f5f383cf492f86b2", + "sha256_in_prefix": "75694d23ef8c0e7a4dccf7342a7eee9baa67e77079584355f5f383cf492f86b2", + "size_in_bytes": 8749 + }, + { + "_path": "lib/python3.12/ctypes/_aix.py", + "path_type": "hardlink", + "sha256": "540e2821fa36981bde5c6ffb8f972474b06db4a37c1854c0e0e379b75d2b0fa3", + "sha256_in_prefix": "540e2821fa36981bde5c6ffb8f972474b06db4a37c1854c0e0e379b75d2b0fa3", + "size_in_bytes": 12505 + }, + { + "_path": "lib/python3.12/ctypes/_endian.py", + "path_type": "hardlink", + "sha256": "c5d692bdce10dfee242752620061bab684633bc72445a3def484961ef1bdbf3a", + "sha256_in_prefix": "c5d692bdce10dfee242752620061bab684633bc72445a3def484961ef1bdbf3a", + "size_in_bytes": 2535 + }, + { + "_path": "lib/python3.12/ctypes/macholib/README.ctypes", + "path_type": "hardlink", + "sha256": "dc29d1da83b6a0a09a41647e4111eee878ed079c2d6b54a98fd6d8b88dd581f2", + "sha256_in_prefix": "dc29d1da83b6a0a09a41647e4111eee878ed079c2d6b54a98fd6d8b88dd581f2", + "size_in_bytes": 296 + }, + { + "_path": "lib/python3.12/ctypes/macholib/__init__.py", + "path_type": "hardlink", + "sha256": "1e77c01eec8f167ed10b754f153c0c743c8e5196ae9c81dffc08f129ab56dbfd", + "sha256_in_prefix": "1e77c01eec8f167ed10b754f153c0c743c8e5196ae9c81dffc08f129ab56dbfd", + "size_in_bytes": 154 + }, + { + "_path": "lib/python3.12/ctypes/macholib/__pycache__/__init__.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "fdbc6a702ec04a1d30fd647c42c6bf79a6db1aa67e09ca601d3f2d42be1d92b4", + "sha256_in_prefix": "fdbc6a702ec04a1d30fd647c42c6bf79a6db1aa67e09ca601d3f2d42be1d92b4", + "size_in_bytes": 570 + }, + { + "_path": "lib/python3.12/ctypes/macholib/__pycache__/dyld.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "5085f76c7e5869f9d5d8d88008a30912634268e87721b5c7ee4008935a91f67b", + "sha256_in_prefix": "5085f76c7e5869f9d5d8d88008a30912634268e87721b5c7ee4008935a91f67b", + "size_in_bytes": 7232 + }, + { + "_path": "lib/python3.12/ctypes/macholib/__pycache__/dylib.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "b9688c779d516c51c1140fd5a934cbfc9d75b643b19fb4e326586117d39f51f9", + "sha256_in_prefix": "b9688c779d516c51c1140fd5a934cbfc9d75b643b19fb4e326586117d39f51f9", + "size_in_bytes": 1533 + }, + { + "_path": "lib/python3.12/ctypes/macholib/__pycache__/framework.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "8852f9e4c9294d552a95b4ff6da80f9476a754f3c0a3655c3f81760b4b2a0feb", + "sha256_in_prefix": "8852f9e4c9294d552a95b4ff6da80f9476a754f3c0a3655c3f81760b4b2a0feb", + "size_in_bytes": 1663 + }, + { + "_path": "lib/python3.12/ctypes/macholib/dyld.py", + "path_type": "hardlink", + "sha256": "f43f287127958d63815859486720c9a703ed9dd2371261e74e88cf7d9c45a2cd", + "sha256_in_prefix": "f43f287127958d63815859486720c9a703ed9dd2371261e74e88cf7d9c45a2cd", + "size_in_bytes": 5156 + }, + { + "_path": "lib/python3.12/ctypes/macholib/dylib.py", + "path_type": "hardlink", + "sha256": "f19ee056b18165cc6735efab0b4ca3508be9405b9646c38113316c15e8278a6f", + "sha256_in_prefix": "f19ee056b18165cc6735efab0b4ca3508be9405b9646c38113316c15e8278a6f", + "size_in_bytes": 960 + }, + { + "_path": "lib/python3.12/ctypes/macholib/fetch_macholib", + "path_type": "hardlink", + "sha256": "a9f6faacdb1aa00ac2f68043cd445171de9639a732b861bd5e64090a2865ab23", + "sha256_in_prefix": "a9f6faacdb1aa00ac2f68043cd445171de9639a732b861bd5e64090a2865ab23", + "size_in_bytes": 84 + }, + { + "_path": "lib/python3.12/ctypes/macholib/fetch_macholib.bat", + "path_type": "hardlink", + "sha256": "7497fbdbb98afca4ac455e3a057c59bcdebaf1280e25c94741dc301f05cb53e5", + "sha256_in_prefix": "7497fbdbb98afca4ac455e3a057c59bcdebaf1280e25c94741dc301f05cb53e5", + "size_in_bytes": 75 + }, + { + "_path": "lib/python3.12/ctypes/macholib/framework.py", + "path_type": "hardlink", + "sha256": "302439e40d9cbdd61b8b7cffd0b7e1278a6811b635044ee366a36e0d991f62da", + "sha256_in_prefix": "302439e40d9cbdd61b8b7cffd0b7e1278a6811b635044ee366a36e0d991f62da", + "size_in_bytes": 1105 + }, + { + "_path": "lib/python3.12/ctypes/util.py", + "path_type": "hardlink", + "sha256": "35e5eda9cac8f82b922bcc4a7d303a8dae9216444158a7c21f8b96b7309f3bc7", + "sha256_in_prefix": "35e5eda9cac8f82b922bcc4a7d303a8dae9216444158a7c21f8b96b7309f3bc7", + "size_in_bytes": 14936 + }, + { + "_path": "lib/python3.12/ctypes/wintypes.py", + "path_type": "hardlink", + "sha256": "5c4d9ba1a21683838ed1d1f007b6038304e42aacf34c576e820311d26cb243f3", + "sha256_in_prefix": "5c4d9ba1a21683838ed1d1f007b6038304e42aacf34c576e820311d26cb243f3", + "size_in_bytes": 5629 + }, + { + "_path": "lib/python3.12/curses/__init__.py", + "path_type": "hardlink", + "sha256": "d8730e360dd00ec046bdd85cae41fe83c907c6ae3716a964158fce8f31ab28b0", + "sha256_in_prefix": "d8730e360dd00ec046bdd85cae41fe83c907c6ae3716a964158fce8f31ab28b0", + "size_in_bytes": 3369 + }, + { + "_path": "lib/python3.12/curses/__pycache__/__init__.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "fa81e81043cd904d0223542e20f98be900329388745e5fa2058fba79342b848b", + "sha256_in_prefix": "fa81e81043cd904d0223542e20f98be900329388745e5fa2058fba79342b848b", + "size_in_bytes": 3055 + }, + { + "_path": "lib/python3.12/curses/__pycache__/ascii.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "05dc5dbdeeaecf8407425b6f928748bfe6231403e5d955e06269875e849effa9", + "sha256_in_prefix": "05dc5dbdeeaecf8407425b6f928748bfe6231403e5d955e06269875e849effa9", + "size_in_bytes": 5276 + }, + { + "_path": "lib/python3.12/curses/__pycache__/has_key.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "5d09e74a071a6e643d6ab9d2499a00d5003613e10f226fcadca6f430f2a2f0c7", + "sha256_in_prefix": "5d09e74a071a6e643d6ab9d2499a00d5003613e10f226fcadca6f430f2a2f0c7", + "size_in_bytes": 10629 + }, + { + "_path": "lib/python3.12/curses/__pycache__/panel.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "55b3a2d2adda4b2aeb2f1d8c4ec5f27e853333379576adfdb895cde8b368b16e", + "sha256_in_prefix": "55b3a2d2adda4b2aeb2f1d8c4ec5f27e853333379576adfdb895cde8b368b16e", + "size_in_bytes": 494 + }, + { + "_path": "lib/python3.12/curses/__pycache__/textpad.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "2f00ba810652ba1d8ddc40d764e9c674128f6b3db123e4861e2a7f66cc094c5c", + "sha256_in_prefix": "2f00ba810652ba1d8ddc40d764e9c674128f6b3db123e4861e2a7f66cc094c5c", + "size_in_bytes": 12483 + }, + { + "_path": "lib/python3.12/curses/ascii.py", + "path_type": "hardlink", + "sha256": "780dd8bbaf0ee7e832f164c1772953e694a9cd1031d1ab1471af65344d3645e6", + "sha256_in_prefix": "780dd8bbaf0ee7e832f164c1772953e694a9cd1031d1ab1471af65344d3645e6", + "size_in_bytes": 2543 + }, + { + "_path": "lib/python3.12/curses/has_key.py", + "path_type": "hardlink", + "sha256": "15a052812d9ae80124bb25b3f5b9ffae38e2b03073774e163abf3d773140cfb3", + "sha256_in_prefix": "15a052812d9ae80124bb25b3f5b9ffae38e2b03073774e163abf3d773140cfb3", + "size_in_bytes": 5634 + }, + { + "_path": "lib/python3.12/curses/panel.py", + "path_type": "hardlink", + "sha256": "13ef404a30da1825a612ca3e453db88c305d45deef4441c4c9e2ef7ee0ef50c7", + "sha256_in_prefix": "13ef404a30da1825a612ca3e453db88c305d45deef4441c4c9e2ef7ee0ef50c7", + "size_in_bytes": 87 + }, + { + "_path": "lib/python3.12/curses/textpad.py", + "path_type": "hardlink", + "sha256": "6fd91c3fd9f4a6f213979a2c1df6b737c49c95d9c3acf22cf40cfdb1f88fb737", + "sha256_in_prefix": "6fd91c3fd9f4a6f213979a2c1df6b737c49c95d9c3acf22cf40cfdb1f88fb737", + "size_in_bytes": 7754 + }, + { + "_path": "lib/python3.12/dataclasses.py", + "path_type": "hardlink", + "sha256": "35f052e9b71a18e9189e61d3453587d2d0b210bcf7f6be36bc3b134650a92f40", + "sha256_in_prefix": "35f052e9b71a18e9189e61d3453587d2d0b210bcf7f6be36bc3b134650a92f40", + "size_in_bytes": 61580 + }, + { + "_path": "lib/python3.12/datetime.py", + "path_type": "hardlink", + "sha256": "ef20dc6b3554cd585dddffdc573f1f9a7a54c522f2a3fb4576c44edbb1e14238", + "sha256_in_prefix": "ef20dc6b3554cd585dddffdc573f1f9a7a54c522f2a3fb4576c44edbb1e14238", + "size_in_bytes": 268 + }, + { + "_path": "lib/python3.12/dbm/__init__.py", + "path_type": "hardlink", + "sha256": "389407b292f30c38a334599d2546ca1fea316b038a5252f985bbccfce6c8453b", + "sha256_in_prefix": "389407b292f30c38a334599d2546ca1fea316b038a5252f985bbccfce6c8453b", + "size_in_bytes": 5882 + }, + { + "_path": "lib/python3.12/dbm/__pycache__/__init__.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "e30a6fc3e30694b11d152cc059ee8284562fd19859ba2ca6df7642c2f77faecb", + "sha256_in_prefix": "e30a6fc3e30694b11d152cc059ee8284562fd19859ba2ca6df7642c2f77faecb", + "size_in_bytes": 6510 + }, + { + "_path": "lib/python3.12/dbm/__pycache__/dumb.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "ee61266c3f7011a7cd9047ebadf3b0223d3b5bf2d1e8c67ea3bc9b65d7489b06", + "sha256_in_prefix": "ee61266c3f7011a7cd9047ebadf3b0223d3b5bf2d1e8c67ea3bc9b65d7489b06", + "size_in_bytes": 13270 + }, + { + "_path": "lib/python3.12/dbm/__pycache__/gnu.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "58708cac2d04d25d6a98a0ee0af94715a0c5d34c2a0c43dbd6925a633e1949b3", + "sha256_in_prefix": "58708cac2d04d25d6a98a0ee0af94715a0c5d34c2a0c43dbd6925a633e1949b3", + "size_in_bytes": 470 + }, + { + "_path": "lib/python3.12/dbm/__pycache__/ndbm.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "1727533a4e48a830d00564761a112805ba0bdad54b37688e22708a2691b3628d", + "sha256_in_prefix": "1727533a4e48a830d00564761a112805ba0bdad54b37688e22708a2691b3628d", + "size_in_bytes": 469 + }, + { + "_path": "lib/python3.12/dbm/dumb.py", + "path_type": "hardlink", + "sha256": "c99202d9eb4e25a023715a1b804c886fdb7d9f957730959bb071a57d607443b5", + "sha256_in_prefix": "c99202d9eb4e25a023715a1b804c886fdb7d9f957730959bb071a57d607443b5", + "size_in_bytes": 11594 + }, + { + "_path": "lib/python3.12/dbm/gnu.py", + "path_type": "hardlink", + "sha256": "36cd4904f50e00c4df4ad9d450b3970e150957425f47c00cf979ba73eff49778", + "sha256_in_prefix": "36cd4904f50e00c4df4ad9d450b3970e150957425f47c00cf979ba73eff49778", + "size_in_bytes": 72 + }, + { + "_path": "lib/python3.12/dbm/ndbm.py", + "path_type": "hardlink", + "sha256": "1bcc2d9b2fad1901f3421a174eeecb5b8ccc6763283b87bbe0705b404c71904b", + "sha256_in_prefix": "1bcc2d9b2fad1901f3421a174eeecb5b8ccc6763283b87bbe0705b404c71904b", + "size_in_bytes": 70 + }, + { + "_path": "lib/python3.12/decimal.py", + "path_type": "hardlink", + "sha256": "000c00bad31d126b054c6ec7f3e02b27c0f9a4d579f987d3c4f879cee1bacb81", + "sha256_in_prefix": "000c00bad31d126b054c6ec7f3e02b27c0f9a4d579f987d3c4f879cee1bacb81", + "size_in_bytes": 320 + }, + { + "_path": "lib/python3.12/difflib.py", + "path_type": "hardlink", + "sha256": "0c6afc23568d55b3e9ac914f9c5361e3033e778aa5b58d3cc82835fc5c638679", + "sha256_in_prefix": "0c6afc23568d55b3e9ac914f9c5361e3033e778aa5b58d3cc82835fc5c638679", + "size_in_bytes": 83308 + }, + { + "_path": "lib/python3.12/dis.py", + "path_type": "hardlink", + "sha256": "f6f02f5966fed0b1ce95768dc59d7905c64f60f454d79eed67fbeaa724069031", + "sha256_in_prefix": "f6f02f5966fed0b1ce95768dc59d7905c64f60f454d79eed67fbeaa724069031", + "size_in_bytes": 30209 + }, + { + "_path": "lib/python3.12/doctest.py", + "path_type": "hardlink", + "sha256": "9777b5a215ecef673c081310bb5a31853498d7b4d1a5c1bcc8e587395299139c", + "sha256_in_prefix": "9777b5a215ecef673c081310bb5a31853498d7b4d1a5c1bcc8e587395299139c", + "size_in_bytes": 106463 + }, + { + "_path": "lib/python3.12/email/__init__.py", + "path_type": "hardlink", + "sha256": "e4f46e3414c4602c9abb8b404a45e84412fc49dbe38a3d163f9575132dc7c93e", + "sha256_in_prefix": "e4f46e3414c4602c9abb8b404a45e84412fc49dbe38a3d163f9575132dc7c93e", + "size_in_bytes": 1764 + }, + { + "_path": "lib/python3.12/email/__pycache__/__init__.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "8ff78121d7ba7ccba0134bb31956b0a3aa195d4f0f17815e64f44f26f40d9c56", + "sha256_in_prefix": "8ff78121d7ba7ccba0134bb31956b0a3aa195d4f0f17815e64f44f26f40d9c56", + "size_in_bytes": 2173 + }, + { + "_path": "lib/python3.12/email/__pycache__/_encoded_words.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "86458bfd71ae56934b44654be026e95d94d1b66f73c0c7bb47c5554ba7179972", + "sha256_in_prefix": "86458bfd71ae56934b44654be026e95d94d1b66f73c0c7bb47c5554ba7179972", + "size_in_bytes": 8560 + }, + { + "_path": "lib/python3.12/email/__pycache__/_header_value_parser.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "4a6852a9452843de27165de82618b83a11168e20002b502b3036cab15a50ac22", + "sha256_in_prefix": "4a6852a9452843de27165de82618b83a11168e20002b502b3036cab15a50ac22", + "size_in_bytes": 131439 + }, + { + "_path": "lib/python3.12/email/__pycache__/_parseaddr.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "03bebd15dc78c73e6fcd9c0ff0871c389def0db670beb01c0af38ece999d5e71", + "sha256_in_prefix": "03bebd15dc78c73e6fcd9c0ff0871c389def0db670beb01c0af38ece999d5e71", + "size_in_bytes": 23519 + }, + { + "_path": "lib/python3.12/email/__pycache__/_policybase.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "9ae8defc5442e0e098a889f47df2c668805b18881dae26673f7b3f3444c780a3", + "sha256_in_prefix": "9ae8defc5442e0e098a889f47df2c668805b18881dae26673f7b3f3444c780a3", + "size_in_bytes": 18446 + }, + { + "_path": "lib/python3.12/email/__pycache__/base64mime.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "51ec796a0f79153df52560a1027a35f1330b244242c1c5da3cdcfcb8a7c9bb9e", + "sha256_in_prefix": "51ec796a0f79153df52560a1027a35f1330b244242c1c5da3cdcfcb8a7c9bb9e", + "size_in_bytes": 4204 + }, + { + "_path": "lib/python3.12/email/__pycache__/charset.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "82a89d38bdc58b2991e3e57d7f4ceb241567beffa75f652425dd62564afa6cb0", + "sha256_in_prefix": "82a89d38bdc58b2991e3e57d7f4ceb241567beffa75f652425dd62564afa6cb0", + "size_in_bytes": 15499 + }, + { + "_path": "lib/python3.12/email/__pycache__/contentmanager.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "4e832f796db300448313370dc6ef83afc168ae89db8dd004b83eba0c55bb02e7", + "sha256_in_prefix": "4e832f796db300448313370dc6ef83afc168ae89db8dd004b83eba0c55bb02e7", + "size_in_bytes": 12653 + }, + { + "_path": "lib/python3.12/email/__pycache__/encoders.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "f81dcd3579139b4c4702e2f009262370069908f2ce3959c083a057c2d5ff022f", + "sha256_in_prefix": "f81dcd3579139b4c4702e2f009262370069908f2ce3959c083a057c2d5ff022f", + "size_in_bytes": 2343 + }, + { + "_path": "lib/python3.12/email/__pycache__/errors.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "a78e5641d63b7dbf8d09a0118bc732dedf0d6974891a19e9f5ede2df1a2d9b24", + "sha256_in_prefix": "a78e5641d63b7dbf8d09a0118bc732dedf0d6974891a19e9f5ede2df1a2d9b24", + "size_in_bytes": 7094 + }, + { + "_path": "lib/python3.12/email/__pycache__/feedparser.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "92f55cff97f6beb5c11ab64300a145f1ff2e5368dbe8c7cdbccd45c2fd007abb", + "sha256_in_prefix": "92f55cff97f6beb5c11ab64300a145f1ff2e5368dbe8c7cdbccd45c2fd007abb", + "size_in_bytes": 20091 + }, + { + "_path": "lib/python3.12/email/__pycache__/generator.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "a0cd39901c8d446003c1a925f73b653d2581da3bbb619c492f05b572e2961c31", + "sha256_in_prefix": "a0cd39901c8d446003c1a925f73b653d2581da3bbb619c492f05b572e2961c31", + "size_in_bytes": 20162 + }, + { + "_path": "lib/python3.12/email/__pycache__/header.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "4c387db89495669a1a2fb2fbb06dab5c6c68f3574937b5deb4e7a77d219db911", + "sha256_in_prefix": "4c387db89495669a1a2fb2fbb06dab5c6c68f3574937b5deb4e7a77d219db911", + "size_in_bytes": 24828 + }, + { + "_path": "lib/python3.12/email/__pycache__/headerregistry.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "519a59a80241db8ccb6d937701451935712aff347133eb5c31caca62c4cb1300", + "sha256_in_prefix": "519a59a80241db8ccb6d937701451935712aff347133eb5c31caca62c4cb1300", + "size_in_bytes": 31211 + }, + { + "_path": "lib/python3.12/email/__pycache__/iterators.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "bb7272f002715a43c15bb80d5477d62171294b82bad9519d4c471d1c6e43fa5e", + "sha256_in_prefix": "bb7272f002715a43c15bb80d5477d62171294b82bad9519d4c471d1c6e43fa5e", + "size_in_bytes": 3073 + }, + { + "_path": "lib/python3.12/email/__pycache__/message.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "6b739e3ef4ca11748a4ed02306cdd66944e01362f7bd07923c5429db3ede14d3", + "sha256_in_prefix": "6b739e3ef4ca11748a4ed02306cdd66944e01362f7bd07923c5429db3ede14d3", + "size_in_bytes": 53283 + }, + { + "_path": "lib/python3.12/email/__pycache__/parser.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "8fddb4239c6107ad10bdc3629a7bf51c3c48488080bf95ae07e09a67f39d20b9", + "sha256_in_prefix": "8fddb4239c6107ad10bdc3629a7bf51c3c48488080bf95ae07e09a67f39d20b9", + "size_in_bytes": 7000 + }, + { + "_path": "lib/python3.12/email/__pycache__/policy.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "021acc2331f0b7a50f6b25475b416c5e3cb5ef271fbeaace65685e4ec3f946c3", + "sha256_in_prefix": "021acc2331f0b7a50f6b25475b416c5e3cb5ef271fbeaace65685e4ec3f946c3", + "size_in_bytes": 12032 + }, + { + "_path": "lib/python3.12/email/__pycache__/quoprimime.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "2ea8867c883b588879f403be15b0be342ac25851ff693f5ec1d1d334321389e3", + "sha256_in_prefix": "2ea8867c883b588879f403be15b0be342ac25851ff693f5ec1d1d334321389e3", + "size_in_bytes": 10222 + }, + { + "_path": "lib/python3.12/email/__pycache__/utils.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "49907fb7131b48dc3dc5e25a1628afd5323dec64068b2bdb93484be759a87cd4", + "sha256_in_prefix": "49907fb7131b48dc3dc5e25a1628afd5323dec64068b2bdb93484be759a87cd4", + "size_in_bytes": 13009 + }, + { + "_path": "lib/python3.12/email/_encoded_words.py", + "path_type": "hardlink", + "sha256": "4178321600c0a19ca04cfe8542ce44487f339d15d89a473b58cea63c0b230217", + "sha256_in_prefix": "4178321600c0a19ca04cfe8542ce44487f339d15d89a473b58cea63c0b230217", + "size_in_bytes": 8541 + }, + { + "_path": "lib/python3.12/email/_header_value_parser.py", + "path_type": "hardlink", + "sha256": "740b00a7d6d1dbbca260000907412e888f3f31c6d4ab0fccd24c21608c0ad7cf", + "sha256_in_prefix": "740b00a7d6d1dbbca260000907412e888f3f31c6d4ab0fccd24c21608c0ad7cf", + "size_in_bytes": 107244 + }, + { + "_path": "lib/python3.12/email/_parseaddr.py", + "path_type": "hardlink", + "sha256": "4308932872acbf4a674312a45a49b870e48026e3dfedc878ee2f512ddf2f30ba", + "sha256_in_prefix": "4308932872acbf4a674312a45a49b870e48026e3dfedc878ee2f512ddf2f30ba", + "size_in_bytes": 17821 + }, + { + "_path": "lib/python3.12/email/_policybase.py", + "path_type": "hardlink", + "sha256": "967a41672b54f3443eac096968ad189d75c77be7eb42611b4d81d12a41605be9", + "sha256_in_prefix": "967a41672b54f3443eac096968ad189d75c77be7eb42611b4d81d12a41605be9", + "size_in_bytes": 15073 + }, + { + "_path": "lib/python3.12/email/architecture.rst", + "path_type": "hardlink", + "sha256": "f2b2ba7497fd02d13abcfc2a98099283a94b09e8b4f2c1c822ecacde3bec3eae", + "sha256_in_prefix": "f2b2ba7497fd02d13abcfc2a98099283a94b09e8b4f2c1c822ecacde3bec3eae", + "size_in_bytes": 9561 + }, + { + "_path": "lib/python3.12/email/base64mime.py", + "path_type": "hardlink", + "sha256": "e2b4b87a5f42a8c5780e343f675513bbcc6abdd23fa14f8f1a7d4f7d72304770", + "sha256_in_prefix": "e2b4b87a5f42a8c5780e343f675513bbcc6abdd23fa14f8f1a7d4f7d72304770", + "size_in_bytes": 3551 + }, + { + "_path": "lib/python3.12/email/charset.py", + "path_type": "hardlink", + "sha256": "a90653f13a4dc5eb3205079dda1d62561a8bf9a7b45585f5dbf90aa31a966680", + "sha256_in_prefix": "a90653f13a4dc5eb3205079dda1d62561a8bf9a7b45585f5dbf90aa31a966680", + "size_in_bytes": 17063 + }, + { + "_path": "lib/python3.12/email/contentmanager.py", + "path_type": "hardlink", + "sha256": "2d81026aef17e4786b15d9ec0629304987e3f275a0fd0a421a81b4ed87234b2c", + "sha256_in_prefix": "2d81026aef17e4786b15d9ec0629304987e3f275a0fd0a421a81b4ed87234b2c", + "size_in_bytes": 10588 + }, + { + "_path": "lib/python3.12/email/encoders.py", + "path_type": "hardlink", + "sha256": "690b275529788cc48e8f541a2aef321dc31e92f75764ac7924896db72d8a9555", + "sha256_in_prefix": "690b275529788cc48e8f541a2aef321dc31e92f75764ac7924896db72d8a9555", + "size_in_bytes": 1778 + }, + { + "_path": "lib/python3.12/email/errors.py", + "path_type": "hardlink", + "sha256": "33fc889cbff57bb78c913bb6c24c5d52bd02f3cba0f4b1cb2913340294a6ec1a", + "sha256_in_prefix": "33fc889cbff57bb78c913bb6c24c5d52bd02f3cba0f4b1cb2913340294a6ec1a", + "size_in_bytes": 3735 + }, + { + "_path": "lib/python3.12/email/feedparser.py", + "path_type": "hardlink", + "sha256": "6046239fcdd6977d1c25841581cabedaeec8046cc5fedcb8ff2d6450a36442bd", + "sha256_in_prefix": "6046239fcdd6977d1c25841581cabedaeec8046cc5fedcb8ff2d6450a36442bd", + "size_in_bytes": 22796 + }, + { + "_path": "lib/python3.12/email/generator.py", + "path_type": "hardlink", + "sha256": "7bd82690e4112edf019458c79a497d54e741106d5d9e2c7b88ef3506a1bcfe23", + "sha256_in_prefix": "7bd82690e4112edf019458c79a497d54e741106d5d9e2c7b88ef3506a1bcfe23", + "size_in_bytes": 20190 + }, + { + "_path": "lib/python3.12/email/header.py", + "path_type": "hardlink", + "sha256": "4d9baa908ad5288dd8fad8cf20b3802ffac77ba1642727804a633b201c56e5ca", + "sha256_in_prefix": "4d9baa908ad5288dd8fad8cf20b3802ffac77ba1642727804a633b201c56e5ca", + "size_in_bytes": 24092 + }, + { + "_path": "lib/python3.12/email/headerregistry.py", + "path_type": "hardlink", + "sha256": "fada56c25b6a457c6a62af43f9f929bbc29424103ce65f40f114adb4fdf3d39f", + "sha256_in_prefix": "fada56c25b6a457c6a62af43f9f929bbc29424103ce65f40f114adb4fdf3d39f", + "size_in_bytes": 20819 + }, + { + "_path": "lib/python3.12/email/iterators.py", + "path_type": "hardlink", + "sha256": "1080a2d03779176d6d45f6ecd976dbe69f5579f7e4e83b75224c3f92fd258102", + "sha256_in_prefix": "1080a2d03779176d6d45f6ecd976dbe69f5579f7e4e83b75224c3f92fd258102", + "size_in_bytes": 2129 + }, + { + "_path": "lib/python3.12/email/message.py", + "path_type": "hardlink", + "sha256": "6b51945ff4891fdf72470eb9011b64adaa0c44d77eaa5b98787e0fef359af828", + "sha256_in_prefix": "6b51945ff4891fdf72470eb9011b64adaa0c44d77eaa5b98787e0fef359af828", + "size_in_bytes": 48091 + }, + { + "_path": "lib/python3.12/email/mime/__init__.py", + "path_type": "hardlink", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size_in_bytes": 0 + }, + { + "_path": "lib/python3.12/email/mime/__pycache__/__init__.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "b2be4ab35a359f547f5f2303d0090f9c8613cdbe7455c2481812bd665ff715d0", + "sha256_in_prefix": "b2be4ab35a359f547f5f2303d0090f9c8613cdbe7455c2481812bd665ff715d0", + "size_in_bytes": 393 + }, + { + "_path": "lib/python3.12/email/mime/__pycache__/application.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "3b904776ff924ac3e72788142c79cf244a1f4821646e19ab869c32e69929e162", + "sha256_in_prefix": "3b904776ff924ac3e72788142c79cf244a1f4821646e19ab869c32e69929e162", + "size_in_bytes": 1919 + }, + { + "_path": "lib/python3.12/email/mime/__pycache__/audio.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "d88e6182ab0d8705cb7a44ca5bf8ee3e72b00825bbac3fa9a18528a216d57257", + "sha256_in_prefix": "d88e6182ab0d8705cb7a44ca5bf8ee3e72b00825bbac3fa9a18528a216d57257", + "size_in_bytes": 3704 + }, + { + "_path": "lib/python3.12/email/mime/__pycache__/base.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "6913f6eca7d1b38933888a60193f089433728fc13dea86277554e6a5813467a7", + "sha256_in_prefix": "6913f6eca7d1b38933888a60193f089433728fc13dea86277554e6a5813467a7", + "size_in_bytes": 1552 + }, + { + "_path": "lib/python3.12/email/mime/__pycache__/image.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "05171a23a15dccfc1629e6ec6b8992f547a57b3bd391764cf8c02b6c4d45f5c2", + "sha256_in_prefix": "05171a23a15dccfc1629e6ec6b8992f547a57b3bd391764cf8c02b6c4d45f5c2", + "size_in_bytes": 5968 + }, + { + "_path": "lib/python3.12/email/mime/__pycache__/message.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "a53f84b2892a2ba22ffb1c39a68da50f6f1b82e343967dc81214a57a0ea13216", + "sha256_in_prefix": "a53f84b2892a2ba22ffb1c39a68da50f6f1b82e343967dc81214a57a0ea13216", + "size_in_bytes": 1816 + }, + { + "_path": "lib/python3.12/email/mime/__pycache__/multipart.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "4ce7ca956d09deb7a139a26aade86f723bc388a3b34f5a07978924b54ce4e6ad", + "sha256_in_prefix": "4ce7ca956d09deb7a139a26aade86f723bc388a3b34f5a07978924b54ce4e6ad", + "size_in_bytes": 1964 + }, + { + "_path": "lib/python3.12/email/mime/__pycache__/nonmultipart.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "c8efc6aec30c337956a1a780e3db11cba537e7d9010938a7768aa54fc1e61e43", + "sha256_in_prefix": "c8efc6aec30c337956a1a780e3db11cba537e7d9010938a7768aa54fc1e61e43", + "size_in_bytes": 1113 + }, + { + "_path": "lib/python3.12/email/mime/__pycache__/text.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "672b2190cf3a7e4d26783d3f9b833cdc44a658d79b915ddddbde510ffb0248ff", + "sha256_in_prefix": "672b2190cf3a7e4d26783d3f9b833cdc44a658d79b915ddddbde510ffb0248ff", + "size_in_bytes": 1751 + }, + { + "_path": "lib/python3.12/email/mime/application.py", + "path_type": "hardlink", + "sha256": "b82a944ccba03e7e7eec46232e50ffe4ce2c32f4b0e26662e6bde30d533584ae", + "sha256_in_prefix": "b82a944ccba03e7e7eec46232e50ffe4ce2c32f4b0e26662e6bde30d533584ae", + "size_in_bytes": 1321 + }, + { + "_path": "lib/python3.12/email/mime/audio.py", + "path_type": "hardlink", + "sha256": "856263b25a3384a7450a1a0b9869fb897b84f893b2e7147c7e045ae50d132cd3", + "sha256_in_prefix": "856263b25a3384a7450a1a0b9869fb897b84f893b2e7147c7e045ae50d132cd3", + "size_in_bytes": 3094 + }, + { + "_path": "lib/python3.12/email/mime/base.py", + "path_type": "hardlink", + "sha256": "9a7b36653b5657525a0aeeaa72d4a0b09f598e6edc29c139c2dc2612b7d29fb8", + "sha256_in_prefix": "9a7b36653b5657525a0aeeaa72d4a0b09f598e6edc29c139c2dc2612b7d29fb8", + "size_in_bytes": 914 + }, + { + "_path": "lib/python3.12/email/mime/image.py", + "path_type": "hardlink", + "sha256": "460be5b50cfcaab8e72a73f24f14ab062cedf1a40a775b8b0d80c13aed44bb5e", + "sha256_in_prefix": "460be5b50cfcaab8e72a73f24f14ab062cedf1a40a775b8b0d80c13aed44bb5e", + "size_in_bytes": 3726 + }, + { + "_path": "lib/python3.12/email/mime/message.py", + "path_type": "hardlink", + "sha256": "30fccea73b874b5ddaccbd3c64936833749ff039f08d40524c1b0b25b8e8e2b8", + "sha256_in_prefix": "30fccea73b874b5ddaccbd3c64936833749ff039f08d40524c1b0b25b8e8e2b8", + "size_in_bytes": 1315 + }, + { + "_path": "lib/python3.12/email/mime/multipart.py", + "path_type": "hardlink", + "sha256": "8bf2beca6de95d66f12968380a428d3bb0a28a8a6ea2078da521511e1ed80a38", + "sha256_in_prefix": "8bf2beca6de95d66f12968380a428d3bb0a28a8a6ea2078da521511e1ed80a38", + "size_in_bytes": 1619 + }, + { + "_path": "lib/python3.12/email/mime/nonmultipart.py", + "path_type": "hardlink", + "sha256": "4eb9ad32603d66fc9d55aebcc4d3cf759edd9e95a591d38690659afb2e57b050", + "sha256_in_prefix": "4eb9ad32603d66fc9d55aebcc4d3cf759edd9e95a591d38690659afb2e57b050", + "size_in_bytes": 689 + }, + { + "_path": "lib/python3.12/email/mime/text.py", + "path_type": "hardlink", + "sha256": "71c56a41675a36801259c9946f7b7bf838e6c29c453ba8c34d89401f2b972d6c", + "sha256_in_prefix": "71c56a41675a36801259c9946f7b7bf838e6c29c453ba8c34d89401f2b972d6c", + "size_in_bytes": 1394 + }, + { + "_path": "lib/python3.12/email/parser.py", + "path_type": "hardlink", + "sha256": "88890ea9994c55ff7d6c1fd570fece2785f51ed407ee95df4aff946e250bcd66", + "sha256_in_prefix": "88890ea9994c55ff7d6c1fd570fece2785f51ed407ee95df4aff946e250bcd66", + "size_in_bytes": 4975 + }, + { + "_path": "lib/python3.12/email/policy.py", + "path_type": "hardlink", + "sha256": "56a2a90d973c06668f6f113d67f26cf348af10b33eece2a6b812e34da45258d8", + "sha256_in_prefix": "56a2a90d973c06668f6f113d67f26cf348af10b33eece2a6b812e34da45258d8", + "size_in_bytes": 10519 + }, + { + "_path": "lib/python3.12/email/quoprimime.py", + "path_type": "hardlink", + "sha256": "77b454bd3ba3b5e3776be28ae3a0fd8de5d1e50d5b8ee10dd539c37c2bd68082", + "sha256_in_prefix": "77b454bd3ba3b5e3776be28ae3a0fd8de5d1e50d5b8ee10dd539c37c2bd68082", + "size_in_bytes": 9864 + }, + { + "_path": "lib/python3.12/email/utils.py", + "path_type": "hardlink", + "sha256": "b337be3534f81d662c0368e99cca165252f5b865bb1fb00cdef525bb2833e460", + "sha256_in_prefix": "b337be3534f81d662c0368e99cca165252f5b865bb1fb00cdef525bb2833e460", + "size_in_bytes": 12292 + }, + { + "_path": "lib/python3.12/encodings/__init__.py", + "path_type": "hardlink", + "sha256": "78c4744d407690f321565488710b5aaf6486b5afa8d185637aa1e7633ab59cd8", + "sha256_in_prefix": "78c4744d407690f321565488710b5aaf6486b5afa8d185637aa1e7633ab59cd8", + "size_in_bytes": 5884 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/__init__.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "aac1ba24998020a65a9286767da05af5a8c67a311a0e5d77284f5dfa4391317b", + "sha256_in_prefix": "aac1ba24998020a65a9286767da05af5a8c67a311a0e5d77284f5dfa4391317b", + "size_in_bytes": 6044 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/aliases.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "3bd62b9c06e7c8bdf5e287da27717dc5f181956175001bf7c8a073732de3b4c1", + "sha256_in_prefix": "3bd62b9c06e7c8bdf5e287da27717dc5f181956175001bf7c8a073732de3b4c1", + "size_in_bytes": 12662 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/ascii.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "3ec5ee5d8a2c0faa1caa7c1d5b062a8386986a8f4372b98731c167304dfd95bf", + "sha256_in_prefix": "3ec5ee5d8a2c0faa1caa7c1d5b062a8386986a8f4372b98731c167304dfd95bf", + "size_in_bytes": 2769 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/base64_codec.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "41a84bcf7606d6de52016c1b7a0acdf058d5afc3b636fe6eec9e281846f0dc5f", + "sha256_in_prefix": "41a84bcf7606d6de52016c1b7a0acdf058d5afc3b636fe6eec9e281846f0dc5f", + "size_in_bytes": 3231 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/big5.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "f1bd8fb019b5d203275aca614a23fec28a093d40b3a0a6f5f4511df18e54daa4", + "sha256_in_prefix": "f1bd8fb019b5d203275aca614a23fec28a093d40b3a0a6f5f4511df18e54daa4", + "size_in_bytes": 2244 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/big5hkscs.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "c6316f419b894b0c78152da9180d91772713642f309c7b5e79187d737b4e8f3b", + "sha256_in_prefix": "c6316f419b894b0c78152da9180d91772713642f309c7b5e79187d737b4e8f3b", + "size_in_bytes": 2254 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/bz2_codec.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "68310027d0edd00409e0bcd811a2680ee2d2415349814e648ae1be47981828c2", + "sha256_in_prefix": "68310027d0edd00409e0bcd811a2680ee2d2415349814e648ae1be47981828c2", + "size_in_bytes": 4579 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/charmap.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "aba1d1edbc3312fffec0cff67d4b21d6efcb7e7a0d068ec805ded1c9032ee068", + "sha256_in_prefix": "aba1d1edbc3312fffec0cff67d4b21d6efcb7e7a0d068ec805ded1c9032ee068", + "size_in_bytes": 4113 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/cp037.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "a2ebdeceddcb62c4c9f3d70fded1871736d88432c612420183314bb461fc780b", + "sha256_in_prefix": "a2ebdeceddcb62c4c9f3d70fded1871736d88432c612420183314bb461fc780b", + "size_in_bytes": 3361 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/cp1006.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "2a9fd04c6549684acf69db0de4cb30b32a4aa9ce59199d7fe0811bed6bd2b571", + "sha256_in_prefix": "2a9fd04c6549684acf69db0de4cb30b32a4aa9ce59199d7fe0811bed6bd2b571", + "size_in_bytes": 3437 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/cp1026.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "db263bc84d6319146d55b125855b050f3b11af16aa5a5947db758d076d059aa2", + "sha256_in_prefix": "db263bc84d6319146d55b125855b050f3b11af16aa5a5947db758d076d059aa2", + "size_in_bytes": 3365 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/cp1125.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "53b57331d5e77af89ff8168d3e6e06cf483abe2d31d32c68f08de703bb4b4c3f", + "sha256_in_prefix": "53b57331d5e77af89ff8168d3e6e06cf483abe2d31d32c68f08de703bb4b4c3f", + "size_in_bytes": 13905 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/cp1140.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "65a7bfe1ddafbb4be5aa485d482145354a55f053b61a45b24924be231bddd738", + "sha256_in_prefix": "65a7bfe1ddafbb4be5aa485d482145354a55f053b61a45b24924be231bddd738", + "size_in_bytes": 3351 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/cp1250.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "d3ebfd1ee9279139df89a9fd9ea625f7e6828330913ac5886d52376430199e8f", + "sha256_in_prefix": "d3ebfd1ee9279139df89a9fd9ea625f7e6828330913ac5886d52376430199e8f", + "size_in_bytes": 3388 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/cp1251.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "18348eca935f12070f2021d45bfbd8ff06788b6422666c5c1ff09b3aebfbcd8b", + "sha256_in_prefix": "18348eca935f12070f2021d45bfbd8ff06788b6422666c5c1ff09b3aebfbcd8b", + "size_in_bytes": 3385 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/cp1252.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "273a0d2721fb91cc4c351f73791d272a39b3db7c9dc5a47541ca5af6aeb527bc", + "sha256_in_prefix": "273a0d2721fb91cc4c351f73791d272a39b3db7c9dc5a47541ca5af6aeb527bc", + "size_in_bytes": 3388 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/cp1253.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "6c481c4ebf53bc3a9515469f81bd5bf48f536287b60da87d6a1dc5d54ea8745a", + "sha256_in_prefix": "6c481c4ebf53bc3a9515469f81bd5bf48f536287b60da87d6a1dc5d54ea8745a", + "size_in_bytes": 3401 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/cp1254.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "3b2dcb4ead3d66e6f741e5ddb55e24617a16c21cfc7037addd4b63b7a5f8a93d", + "sha256_in_prefix": "3b2dcb4ead3d66e6f741e5ddb55e24617a16c21cfc7037addd4b63b7a5f8a93d", + "size_in_bytes": 3390 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/cp1255.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "e10f3cff74776a1a14542c7bd2d50937f075dd22d7f0328bb97af64726480051", + "sha256_in_prefix": "e10f3cff74776a1a14542c7bd2d50937f075dd22d7f0328bb97af64726480051", + "size_in_bytes": 3409 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/cp1256.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "bc0208fc0e40881f8a7c8f2b648d8a43baafca55f1cc72fef18d3ce40649c1d4", + "sha256_in_prefix": "bc0208fc0e40881f8a7c8f2b648d8a43baafca55f1cc72fef18d3ce40649c1d4", + "size_in_bytes": 3387 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/cp1257.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "ce58c8048d6dda65817da86d77714d31362e6d0ce85c4c3232c848d2c7f29a06", + "sha256_in_prefix": "ce58c8048d6dda65817da86d77714d31362e6d0ce85c4c3232c848d2c7f29a06", + "size_in_bytes": 3395 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/cp1258.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "cef43f860627cc624f666d02a4118a24fc58fc10568976c3dfa1aa4034407e00", + "sha256_in_prefix": "cef43f860627cc624f666d02a4118a24fc58fc10568976c3dfa1aa4034407e00", + "size_in_bytes": 3393 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/cp273.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "edda93fe6cf4b5063a535fbbc553691c5151f5ab0cd1717d71d96dbec2e7db21", + "sha256_in_prefix": "edda93fe6cf4b5063a535fbbc553691c5151f5ab0cd1717d71d96dbec2e7db21", + "size_in_bytes": 3347 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/cp424.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "99fb2089fa562173542fe53dac37fb828efcf86e729b779c124ee6f7237cdfd7", + "sha256_in_prefix": "99fb2089fa562173542fe53dac37fb828efcf86e729b779c124ee6f7237cdfd7", + "size_in_bytes": 3391 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/cp437.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "bf406c23f558ba134ef0a81b4d049f0328a9a0e27005687ae576b3c1a7f2832d", + "sha256_in_prefix": "bf406c23f558ba134ef0a81b4d049f0328a9a0e27005687ae576b3c1a7f2832d", + "size_in_bytes": 13538 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/cp500.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "c8ed6385489d80f4bcfb1e276ac54ec1b130cecd1e11c8c3be64a60a3d00cb1f", + "sha256_in_prefix": "c8ed6385489d80f4bcfb1e276ac54ec1b130cecd1e11c8c3be64a60a3d00cb1f", + "size_in_bytes": 3361 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/cp720.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "d41f26eb176d92fa2cbf1f20660600a6d986c45819fb177bb5c009c102e045e1", + "sha256_in_prefix": "d41f26eb176d92fa2cbf1f20660600a6d986c45819fb177bb5c009c102e045e1", + "size_in_bytes": 3458 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/cp737.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "f9b11e394d3410f54bf83401a8f4cbedc4cd89fd2a513889a40a9b7226b68bb7", + "sha256_in_prefix": "f9b11e394d3410f54bf83401a8f4cbedc4cd89fd2a513889a40a9b7226b68bb7", + "size_in_bytes": 13940 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/cp775.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "bd81a47e78525965d91b39db2033af59837ddb7eb2e95b264b813fe5c68320f1", + "sha256_in_prefix": "bd81a47e78525965d91b39db2033af59837ddb7eb2e95b264b813fe5c68320f1", + "size_in_bytes": 13578 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/cp850.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "7eb20ef95c873df50778436a87d96d685189179dffece183c7311f2545d02874", + "sha256_in_prefix": "7eb20ef95c873df50778436a87d96d685189179dffece183c7311f2545d02874", + "size_in_bytes": 13119 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/cp852.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "2a71050497f7577e7fe44233184d4de36476281f608d0b7c1895d7ec7b6cbd79", + "sha256_in_prefix": "2a71050497f7577e7fe44233184d4de36476281f608d0b7c1895d7ec7b6cbd79", + "size_in_bytes": 13594 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/cp855.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "8c8914bc43d8b5e23ee05287a4c6c63da4fe0c30d5abcfab7c670048d226501d", + "sha256_in_prefix": "8c8914bc43d8b5e23ee05287a4c6c63da4fe0c30d5abcfab7c670048d226501d", + "size_in_bytes": 13907 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/cp856.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "1df52ecd407557bc4f3e22a62a01240ca82331231c81bf8bfd383b7111429e53", + "sha256_in_prefix": "1df52ecd407557bc4f3e22a62a01240ca82331231c81bf8bfd383b7111429e53", + "size_in_bytes": 3423 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/cp857.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "7ffa9a784acb487f93b84b316a4482616b110a25ce7448b0d16008363a0324d0", + "sha256_in_prefix": "7ffa9a784acb487f93b84b316a4482616b110a25ce7448b0d16008363a0324d0", + "size_in_bytes": 12920 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/cp858.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "eff6b40c600524b4201daa8cf43691096f45f1a598e886cbced20b3dbaf59f9e", + "sha256_in_prefix": "eff6b40c600524b4201daa8cf43691096f45f1a598e886cbced20b3dbaf59f9e", + "size_in_bytes": 13089 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/cp860.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "ad622e613497f42657144b9bf958ffcdea7a68d2ca26db6a4496b1816dd96922", + "sha256_in_prefix": "ad622e613497f42657144b9bf958ffcdea7a68d2ca26db6a4496b1816dd96922", + "size_in_bytes": 13509 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/cp861.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "8cae45a0bbb56f6945a440b317474cca2dca7087d34469e6ddb91409c8a994ff", + "sha256_in_prefix": "8cae45a0bbb56f6945a440b317474cca2dca7087d34469e6ddb91409c8a994ff", + "size_in_bytes": 13534 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/cp862.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "7d775679ca6a80c97f7744d20e846fc2f1d5c55fde898c1f056548a07bed442d", + "sha256_in_prefix": "7d775679ca6a80c97f7744d20e846fc2f1d5c55fde898c1f056548a07bed442d", + "size_in_bytes": 13767 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/cp863.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "e6ee7d5d404ad6557da932c7feaca31f44f5abf1766d26f3f37cfba74665498e", + "sha256_in_prefix": "e6ee7d5d404ad6557da932c7feaca31f44f5abf1766d26f3f37cfba74665498e", + "size_in_bytes": 13530 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/cp864.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "638424cc557238d8853dded4c2538f580d1e7ebb42ca3248aed0b8901d2b99c0", + "sha256_in_prefix": "638424cc557238d8853dded4c2538f580d1e7ebb42ca3248aed0b8901d2b99c0", + "size_in_bytes": 13575 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/cp865.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "0331594a4151c1ee13733524dceb90f245900f1487dcb566d56139ad930504f6", + "sha256_in_prefix": "0331594a4151c1ee13733524dceb90f245900f1487dcb566d56139ad930504f6", + "size_in_bytes": 13534 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/cp866.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "c661e650870cf4e5825ff9879196bed7e0ebac8cc213e8df01866ae4fcf02136", + "sha256_in_prefix": "c661e650870cf4e5825ff9879196bed7e0ebac8cc213e8df01866ae4fcf02136", + "size_in_bytes": 13947 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/cp869.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "c36e2be1e1cac4d93c1c676741bdd9110f345e7a2b9ef4322135a24cc5a3a92f", + "sha256_in_prefix": "c36e2be1e1cac4d93c1c676741bdd9110f345e7a2b9ef4322135a24cc5a3a92f", + "size_in_bytes": 13477 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/cp874.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "a923d648b4ea39e58f66141323379afb12ebd24730b8b00affede3187ff1aa3c", + "sha256_in_prefix": "a923d648b4ea39e58f66141323379afb12ebd24730b8b00affede3187ff1aa3c", + "size_in_bytes": 3489 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/cp875.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "90813678a273bc09a18c82f23a1e2248728342d7ffcf0a53453c3d9efe080846", + "sha256_in_prefix": "90813678a273bc09a18c82f23a1e2248728342d7ffcf0a53453c3d9efe080846", + "size_in_bytes": 3358 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/cp932.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "6a0f16be3f182b1785e698f47e9f50ebe4c148aee8cdce75611f26bd6d0f243b", + "sha256_in_prefix": "6a0f16be3f182b1785e698f47e9f50ebe4c148aee8cdce75611f26bd6d0f243b", + "size_in_bytes": 2246 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/cp949.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "ec59bac7f00c8ea4ce9cf50f3047076b70f7005c030b91d76de45cb192dd3f69", + "sha256_in_prefix": "ec59bac7f00c8ea4ce9cf50f3047076b70f7005c030b91d76de45cb192dd3f69", + "size_in_bytes": 2246 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/cp950.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "0c0fdfa0cbe1437c60babb030885580333dcab4359723fe6cda0d7797a0ae6ea", + "sha256_in_prefix": "0c0fdfa0cbe1437c60babb030885580333dcab4359723fe6cda0d7797a0ae6ea", + "size_in_bytes": 2246 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/euc_jis_2004.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "b471f726c52ec242f7c82f906ef00c56f36ab158528dbcfb935c54b60465ad1d", + "sha256_in_prefix": "b471f726c52ec242f7c82f906ef00c56f36ab158528dbcfb935c54b60465ad1d", + "size_in_bytes": 2260 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/euc_jisx0213.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "84b7bc06dc2ed55cf69006c6937ca9e336631e2e4b1e96a5a9518f1ed8bb4a70", + "sha256_in_prefix": "84b7bc06dc2ed55cf69006c6937ca9e336631e2e4b1e96a5a9518f1ed8bb4a70", + "size_in_bytes": 2260 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/euc_jp.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "9c18e6279d0c3605d0045a09484f4dfdd56fe37d1e11ae2e3c5e5384c464baca", + "sha256_in_prefix": "9c18e6279d0c3605d0045a09484f4dfdd56fe37d1e11ae2e3c5e5384c464baca", + "size_in_bytes": 2248 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/euc_kr.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "a5aee5371961e51d7c178c51bafcf54d43b390dd1535445e4cb677744f742925", + "sha256_in_prefix": "a5aee5371961e51d7c178c51bafcf54d43b390dd1535445e4cb677744f742925", + "size_in_bytes": 2248 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/gb18030.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "a98f721920818b7deeaf52dad89ffd09b1aab2d8412914df22e2b18eda2c2f9e", + "sha256_in_prefix": "a98f721920818b7deeaf52dad89ffd09b1aab2d8412914df22e2b18eda2c2f9e", + "size_in_bytes": 2250 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/gb2312.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "54d6603d46983c1c15ac0cceaad832948de8f57b229c7448e0f99056abc00e9d", + "sha256_in_prefix": "54d6603d46983c1c15ac0cceaad832948de8f57b229c7448e0f99056abc00e9d", + "size_in_bytes": 2248 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/gbk.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "360aa557a33f5c156e31a942f1764b3ca821edd6e5465b0b2be6074eba015ebf", + "sha256_in_prefix": "360aa557a33f5c156e31a942f1764b3ca821edd6e5465b0b2be6074eba015ebf", + "size_in_bytes": 2242 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/hex_codec.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "e61d34325c9a896264ade92beb573470fc0d50f09841d38d83916f87927d3fe7", + "sha256_in_prefix": "e61d34325c9a896264ade92beb573470fc0d50f09841d38d83916f87927d3fe7", + "size_in_bytes": 3218 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/hp_roman8.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "55f138d758b162a0bb7f6dbc0e320f8ad6717361461f94c8a18c230064a29ca3", + "sha256_in_prefix": "55f138d758b162a0bb7f6dbc0e320f8ad6717361461f94c8a18c230064a29ca3", + "size_in_bytes": 3562 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/hz.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "9d5fc2d727082ea860ea444c686818b749dd169506b2d186b234650c999d3571", + "sha256_in_prefix": "9d5fc2d727082ea860ea444c686818b749dd169506b2d186b234650c999d3571", + "size_in_bytes": 2240 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/idna.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "df19b219d75d4588c64f0ea6d92209b74b846f4a65f6ab64fc909880e3bc6a55", + "sha256_in_prefix": "df19b219d75d4588c64f0ea6d92209b74b846f4a65f6ab64fc909880e3bc6a55", + "size_in_bytes": 10170 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/iso2022_jp.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "56ef070f938c7ebe3bb1218fbe3100bab4c9aeccfbde92003d19d69a16b8221e", + "sha256_in_prefix": "56ef070f938c7ebe3bb1218fbe3100bab4c9aeccfbde92003d19d69a16b8221e", + "size_in_bytes": 2261 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/iso2022_jp_1.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "eea75cf050e0615201e9247435bf1603677ab445be68ec9f9e364bc6d82d3191", + "sha256_in_prefix": "eea75cf050e0615201e9247435bf1603677ab445be68ec9f9e364bc6d82d3191", + "size_in_bytes": 2265 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/iso2022_jp_2.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "a993e0806a359b2f113a3c91d0349ac2b9472c1b7e61f7827732e529a7c7b12b", + "sha256_in_prefix": "a993e0806a359b2f113a3c91d0349ac2b9472c1b7e61f7827732e529a7c7b12b", + "size_in_bytes": 2265 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/iso2022_jp_2004.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "a4860204823e1eb53febdc174c6f743aafd5c98ad7d9bfc74324733ea1f93d9e", + "sha256_in_prefix": "a4860204823e1eb53febdc174c6f743aafd5c98ad7d9bfc74324733ea1f93d9e", + "size_in_bytes": 2272 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/iso2022_jp_3.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "8c387be07a6949d43d8a499ffbfddb6f54ce5411d11f8d4f2918a8242aca6055", + "sha256_in_prefix": "8c387be07a6949d43d8a499ffbfddb6f54ce5411d11f8d4f2918a8242aca6055", + "size_in_bytes": 2265 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/iso2022_jp_ext.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "e5befae390e9bd49726e851b1afdd247644303da90e3cd432eaeeb484131a980", + "sha256_in_prefix": "e5befae390e9bd49726e851b1afdd247644303da90e3cd432eaeeb484131a980", + "size_in_bytes": 2270 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/iso2022_kr.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "96582053520f873dee2e186806c6d8d422255c8523a0a08ce8027a73abf0fbbd", + "sha256_in_prefix": "96582053520f873dee2e186806c6d8d422255c8523a0a08ce8027a73abf0fbbd", + "size_in_bytes": 2261 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/iso8859_1.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "d74b6f5e573de0399a5151dfc73b478a5368a854041c6e348507664a68dd4b16", + "sha256_in_prefix": "d74b6f5e573de0399a5151dfc73b478a5368a854041c6e348507664a68dd4b16", + "size_in_bytes": 3360 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/iso8859_10.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "26d7c6498097f6be8e7af8621d7fe2c17b0c2714a591d1941a516b4690986f1e", + "sha256_in_prefix": "26d7c6498097f6be8e7af8621d7fe2c17b0c2714a591d1941a516b4690986f1e", + "size_in_bytes": 3365 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/iso8859_11.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "80351b013332f9c5c5a6e8dfdc814a181ebaedfc2e891deeb4f3fff160e532b7", + "sha256_in_prefix": "80351b013332f9c5c5a6e8dfdc814a181ebaedfc2e891deeb4f3fff160e532b7", + "size_in_bytes": 3459 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/iso8859_13.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "532da04d2f60d73f6106f4e8b3a534d5beffdbf55e5fa570d42f99a90596c3b1", + "sha256_in_prefix": "532da04d2f60d73f6106f4e8b3a534d5beffdbf55e5fa570d42f99a90596c3b1", + "size_in_bytes": 3368 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/iso8859_14.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "04b926cfab5c67cac85a39d278926fc1a7a27fe7ec36c5c43ec5852db8998c9f", + "sha256_in_prefix": "04b926cfab5c67cac85a39d278926fc1a7a27fe7ec36c5c43ec5852db8998c9f", + "size_in_bytes": 3386 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/iso8859_15.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "1e3908885861f522d189809e853ef8c1cc497c5aa1bf02a5f12a3e8e3f5d68b3", + "sha256_in_prefix": "1e3908885861f522d189809e853ef8c1cc497c5aa1bf02a5f12a3e8e3f5d68b3", + "size_in_bytes": 3365 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/iso8859_16.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "d4222c4be42f60fd415dc6381c17bd4c6691dfe045dba41f8edd0b2f9fa5e89f", + "sha256_in_prefix": "d4222c4be42f60fd415dc6381c17bd4c6691dfe045dba41f8edd0b2f9fa5e89f", + "size_in_bytes": 3367 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/iso8859_2.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "2b268301c9df90bf5565d4d8a2200139343535270291d1198462064a7cb4e3c1", + "sha256_in_prefix": "2b268301c9df90bf5565d4d8a2200139343535270291d1198462064a7cb4e3c1", + "size_in_bytes": 3360 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/iso8859_3.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "cfef0ff3a18ac7b1b42382608aefdc2729145fe3910f7784cc2ca4b1af719a32", + "sha256_in_prefix": "cfef0ff3a18ac7b1b42382608aefdc2729145fe3910f7784cc2ca4b1af719a32", + "size_in_bytes": 3367 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/iso8859_4.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "b950105c64037005d5eeab4022cce0eee94780fd5e56fd7e1114521b76699bab", + "sha256_in_prefix": "b950105c64037005d5eeab4022cce0eee94780fd5e56fd7e1114521b76699bab", + "size_in_bytes": 3360 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/iso8859_5.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "ded46235a2a77cf80f973f38ae37cd8dc638873b83de8bf53e339f8d0e65e80d", + "sha256_in_prefix": "ded46235a2a77cf80f973f38ae37cd8dc638873b83de8bf53e339f8d0e65e80d", + "size_in_bytes": 3361 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/iso8859_6.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "8e1f322a1760237daa65406301c510e78617cbc6ec7a13c58576eee754144c12", + "sha256_in_prefix": "8e1f322a1760237daa65406301c510e78617cbc6ec7a13c58576eee754144c12", + "size_in_bytes": 3405 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/iso8859_7.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "32a4d7e7395e822acb2aed50fce59485869d2419c708056f73886ec4688a63c5", + "sha256_in_prefix": "32a4d7e7395e822acb2aed50fce59485869d2419c708056f73886ec4688a63c5", + "size_in_bytes": 3368 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/iso8859_8.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "ecf506f6a42825567c213344a0b1c692ff2a8efbd582cf68a0cf571aa79f092a", + "sha256_in_prefix": "ecf506f6a42825567c213344a0b1c692ff2a8efbd582cf68a0cf571aa79f092a", + "size_in_bytes": 3399 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/iso8859_9.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "e0b3c570a33405485f6caabdf67d69ef45d6bd2cbfff20d32ac9d212cbb00616", + "sha256_in_prefix": "e0b3c570a33405485f6caabdf67d69ef45d6bd2cbfff20d32ac9d212cbb00616", + "size_in_bytes": 3360 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/johab.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "6e7452e532ad765dfcca1bd204c9937deb17912e543353ecaefba63f64b7e46d", + "sha256_in_prefix": "6e7452e532ad765dfcca1bd204c9937deb17912e543353ecaefba63f64b7e46d", + "size_in_bytes": 2246 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/koi8_r.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "c36559de7d4f5289293404395fcf56afdc8472c8560da8342dde3452693a3e7a", + "sha256_in_prefix": "c36559de7d4f5289293404395fcf56afdc8472c8560da8342dde3452693a3e7a", + "size_in_bytes": 3412 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/koi8_t.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "39882cefeeefb5bdae4f4027d0f15b6ebe42235caba7caf5400a32dc65709c71", + "sha256_in_prefix": "39882cefeeefb5bdae4f4027d0f15b6ebe42235caba7caf5400a32dc65709c71", + "size_in_bytes": 3323 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/koi8_u.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "aefc1edb6571729b59e761eb9afde0b1da4146c7c4bec48621b51453bd3a380a", + "sha256_in_prefix": "aefc1edb6571729b59e761eb9afde0b1da4146c7c4bec48621b51453bd3a380a", + "size_in_bytes": 3398 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/kz1048.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "f57ab95f3eae9e161818a87e1068d3e46d52a9f8dda9ccc91d11b62995b13449", + "sha256_in_prefix": "f57ab95f3eae9e161818a87e1068d3e46d52a9f8dda9ccc91d11b62995b13449", + "size_in_bytes": 3375 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/latin_1.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "b7b4844f09fa6606fee7e03b2ee70169b2bc08f8f92ef1f33bd9046bbbbc95de", + "sha256_in_prefix": "b7b4844f09fa6606fee7e03b2ee70169b2bc08f8f92ef1f33bd9046bbbbc95de", + "size_in_bytes": 2781 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/mac_arabic.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "04439593121b61e608181928b6d42098eb84f02a61acc0b5de46c65ffb7cff8b", + "sha256_in_prefix": "04439593121b61e608181928b6d42098eb84f02a61acc0b5de46c65ffb7cff8b", + "size_in_bytes": 13424 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/mac_croatian.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "81c4738b43c142452cf092907557143e1e2ccbcdeba9880c067f1d17fb570210", + "sha256_in_prefix": "81c4738b43c142452cf092907557143e1e2ccbcdeba9880c067f1d17fb570210", + "size_in_bytes": 3407 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/mac_cyrillic.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "814f55c40301f7cbf5af6ed1df0b7497cb06991359ccc20bad748b5f32c9ed56", + "sha256_in_prefix": "814f55c40301f7cbf5af6ed1df0b7497cb06991359ccc20bad748b5f32c9ed56", + "size_in_bytes": 3397 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/mac_farsi.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "5ced0a8b3acb47a4253c03b36e7da93303820f435f5cc28d7669467db199c6f7", + "sha256_in_prefix": "5ced0a8b3acb47a4253c03b36e7da93303820f435f5cc28d7669467db199c6f7", + "size_in_bytes": 3341 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/mac_greek.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "0f6708e1ff9760762e99220e4da309e7d4ffd93790e6c871afd5654a1a1c95f5", + "sha256_in_prefix": "0f6708e1ff9760762e99220e4da309e7d4ffd93790e6c871afd5654a1a1c95f5", + "size_in_bytes": 3381 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/mac_iceland.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "a5931415e09f33c3f76260b525401f6a48654dfddc941769084386528e300f79", + "sha256_in_prefix": "a5931415e09f33c3f76260b525401f6a48654dfddc941769084386528e300f79", + "size_in_bytes": 3400 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/mac_latin2.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "61dc3c79526834623606109ef4c952e2c0e8d81a534a7b18654878d95264d24f", + "sha256_in_prefix": "61dc3c79526834623606109ef4c952e2c0e8d81a534a7b18654878d95264d24f", + "size_in_bytes": 3541 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/mac_roman.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "b4a54d65125caae6865736359fd0061ce39a8daabb3dc857f1cd5d8925c1960f", + "sha256_in_prefix": "b4a54d65125caae6865736359fd0061ce39a8daabb3dc857f1cd5d8925c1960f", + "size_in_bytes": 3398 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/mac_romanian.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "1fce4dbb16723b98495dbd674eb120110bd3c52d2d1ece3a63f307a765a4474e", + "sha256_in_prefix": "1fce4dbb16723b98495dbd674eb120110bd3c52d2d1ece3a63f307a765a4474e", + "size_in_bytes": 3408 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/mac_turkish.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "09df9773cff3a3f7a8e9e9060e2e2922e959fec495cb34dc77640b6e7f400749", + "sha256_in_prefix": "09df9773cff3a3f7a8e9e9060e2e2922e959fec495cb34dc77640b6e7f400749", + "size_in_bytes": 3401 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/mbcs.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "f56d3145850f816469cabbaa5ae43ae51142baf1e02d775fc192e8d830712382", + "sha256_in_prefix": "f56d3145850f816469cabbaa5ae43ae51142baf1e02d775fc192e8d830712382", + "size_in_bytes": 2345 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/oem.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "93ad8353abc6d17f60492fcdae71769d31deb0ea8e8fa3e22bae856bfcaa6399", + "sha256_in_prefix": "93ad8353abc6d17f60492fcdae71769d31deb0ea8e8fa3e22bae856bfcaa6399", + "size_in_bytes": 2158 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/palmos.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "69569e650bab8f85a5dc40bce3beb067568b2ee458ae100dde06f84cdc6792db", + "sha256_in_prefix": "69569e650bab8f85a5dc40bce3beb067568b2ee458ae100dde06f84cdc6792db", + "size_in_bytes": 3388 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/ptcp154.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "85259090adc1f7bddb4643f4caaca2eb495ac6c9cd8044d9afa2452b37310025", + "sha256_in_prefix": "85259090adc1f7bddb4643f4caaca2eb495ac6c9cd8044d9afa2452b37310025", + "size_in_bytes": 3482 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/punycode.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "59ed54cf4c3467706c2509490377056033ba2ad3c568bb93041f179a39bf3865", + "sha256_in_prefix": "59ed54cf4c3467706c2509490377056033ba2ad3c568bb93041f179a39bf3865", + "size_in_bytes": 9679 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/quopri_codec.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "dce4199cc06208d0b511e9381abfc9bc24da29755d5b53b251048336c6a6718e", + "sha256_in_prefix": "dce4199cc06208d0b511e9381abfc9bc24da29755d5b53b251048336c6a6718e", + "size_in_bytes": 3403 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/raw_unicode_escape.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "31481824837d24646b79cc40f0caeb1df9bf9d991e35e8a3c72e6d63975f58c6", + "sha256_in_prefix": "31481824837d24646b79cc40f0caeb1df9bf9d991e35e8a3c72e6d63975f58c6", + "size_in_bytes": 2836 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/rot_13.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "bbfcb3c8c612ed383bd0b36a76dae0741abc382113d15c85eb6c3c2bf6562e9f", + "sha256_in_prefix": "bbfcb3c8c612ed383bd0b36a76dae0741abc382113d15c85eb6c3c2bf6562e9f", + "size_in_bytes": 4656 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/shift_jis.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "85b887b9c040e3fb6d462edf81537e8684833b719cc2be861c5878910983d4bb", + "sha256_in_prefix": "85b887b9c040e3fb6d462edf81537e8684833b719cc2be861c5878910983d4bb", + "size_in_bytes": 2254 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/shift_jis_2004.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "1cd794810a14635829aae1709ac9220140b9b7233a7e4680a300a911ad5bb421", + "sha256_in_prefix": "1cd794810a14635829aae1709ac9220140b9b7233a7e4680a300a911ad5bb421", + "size_in_bytes": 2265 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/shift_jisx0213.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "a58f1be088ad8908da9bd4c24bb827504c41017c9e9bb3b6be120be2c4e2797a", + "sha256_in_prefix": "a58f1be088ad8908da9bd4c24bb827504c41017c9e9bb3b6be120be2c4e2797a", + "size_in_bytes": 2265 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/tis_620.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "0d7d4b997419934ae7551111b2d4297bfc670f0f380d1a8f4ce6e679b716139b", + "sha256_in_prefix": "0d7d4b997419934ae7551111b2d4297bfc670f0f380d1a8f4ce6e679b716139b", + "size_in_bytes": 3450 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/undefined.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "e12e2a6b52d5b7db1b594a144a295eed30a9caf933c82580dbbf0104eded303b", + "sha256_in_prefix": "e12e2a6b52d5b7db1b594a144a295eed30a9caf933c82580dbbf0104eded303b", + "size_in_bytes": 2776 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/unicode_escape.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "eaf535abb91bff4b0a616d58dd7bb873e7f7aab0dc00b269ed92fa875f458f17", + "sha256_in_prefix": "eaf535abb91bff4b0a616d58dd7bb873e7f7aab0dc00b269ed92fa875f458f17", + "size_in_bytes": 2816 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/utf_16.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "ca9f026b894f7e6ba0c0c2d6ca96030ae4822bdf1c857d9facfb30087f9076f2", + "sha256_in_prefix": "ca9f026b894f7e6ba0c0c2d6ca96030ae4822bdf1c857d9facfb30087f9076f2", + "size_in_bytes": 8036 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/utf_16_be.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "4b279086c43c5c6ce18f92637494033209d6b73599c9689e18b2df99e358fa06", + "sha256_in_prefix": "4b279086c43c5c6ce18f92637494033209d6b73599c9689e18b2df99e358fa06", + "size_in_bytes": 2421 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/utf_16_le.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "a12531cf37994c0e7fda35a8cd8da6e8b6a6860e9792cdca7695e6d490cc9b4c", + "sha256_in_prefix": "a12531cf37994c0e7fda35a8cd8da6e8b6a6860e9792cdca7695e6d490cc9b4c", + "size_in_bytes": 2421 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/utf_32.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "8af84e8e182cceeb3c345234fcbce6a99097b5d63889889ad57f3e31958de4e4", + "sha256_in_prefix": "8af84e8e182cceeb3c345234fcbce6a99097b5d63889889ad57f3e31958de4e4", + "size_in_bytes": 7929 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/utf_32_be.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "ae5e28f0a14df14d2d0d3966167893bb8fcfa0261fb0f7070afd13de655c2ad3", + "sha256_in_prefix": "ae5e28f0a14df14d2d0d3966167893bb8fcfa0261fb0f7070afd13de655c2ad3", + "size_in_bytes": 2314 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/utf_32_le.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "7f5dbca1a8149e4a326cfbf473960d06cd36a2fb1a4cf1e2a01c4419d938afb6", + "sha256_in_prefix": "7f5dbca1a8149e4a326cfbf473960d06cd36a2fb1a4cf1e2a01c4419d938afb6", + "size_in_bytes": 2314 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/utf_7.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "cb2e5d814189d43e9b3182522f9e0c13486c5825faff8b6ffedcb7d303934d01", + "sha256_in_prefix": "cb2e5d814189d43e9b3182522f9e0c13486c5825faff8b6ffedcb7d303934d01", + "size_in_bytes": 2342 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/utf_8.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "52ec86541db542b1e9fda7300e948970a5e207d64fe467910e3a3f1f3d8cca6e", + "sha256_in_prefix": "52ec86541db542b1e9fda7300e948970a5e207d64fe467910e3a3f1f3d8cca6e", + "size_in_bytes": 2401 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/utf_8_sig.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "4d566ad67ef9e2685f4828515b81e66f40a4939176869eb9397777e096d85824", + "sha256_in_prefix": "4d566ad67ef9e2685f4828515b81e66f40a4939176869eb9397777e096d85824", + "size_in_bytes": 6999 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/uu_codec.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "65b3f48f0c14aa4ee38a8959c0cf0ec612aa579dfa0f6aee0bbac9c64a046420", + "sha256_in_prefix": "65b3f48f0c14aa4ee38a8959c0cf0ec612aa579dfa0f6aee0bbac9c64a046420", + "size_in_bytes": 4869 + }, + { + "_path": "lib/python3.12/encodings/__pycache__/zlib_codec.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "3d25b03998e70420a072332284aa57912c4384122a9b63e9a901df1e3e8a65e6", + "sha256_in_prefix": "3d25b03998e70420a072332284aa57912c4384122a9b63e9a901df1e3e8a65e6", + "size_in_bytes": 4495 + }, + { + "_path": "lib/python3.12/encodings/aliases.py", + "path_type": "hardlink", + "sha256": "6fdcc49ba23a0203ae6cf28e608f8e6297d7c4d77d52e651db3cb49b9564c6d2", + "sha256_in_prefix": "6fdcc49ba23a0203ae6cf28e608f8e6297d7c4d77d52e651db3cb49b9564c6d2", + "size_in_bytes": 15677 + }, + { + "_path": "lib/python3.12/encodings/ascii.py", + "path_type": "hardlink", + "sha256": "578aa1173f7cc60dad2895071287fe6182bd14787b3fbf47a6c7983dfe3675e3", + "sha256_in_prefix": "578aa1173f7cc60dad2895071287fe6182bd14787b3fbf47a6c7983dfe3675e3", + "size_in_bytes": 1248 + }, + { + "_path": "lib/python3.12/encodings/base64_codec.py", + "path_type": "hardlink", + "sha256": "cf9ac7a464f541492486241d1b4bf33e37b45c6499275cc4d69c5a8e564e5976", + "sha256_in_prefix": "cf9ac7a464f541492486241d1b4bf33e37b45c6499275cc4d69c5a8e564e5976", + "size_in_bytes": 1533 + }, + { + "_path": "lib/python3.12/encodings/big5.py", + "path_type": "hardlink", + "sha256": "98fac6f86a20dd05da197e2058176ebfd47edee7074c3248f5f48fe0fb672d7c", + "sha256_in_prefix": "98fac6f86a20dd05da197e2058176ebfd47edee7074c3248f5f48fe0fb672d7c", + "size_in_bytes": 1019 + }, + { + "_path": "lib/python3.12/encodings/big5hkscs.py", + "path_type": "hardlink", + "sha256": "21d051a00fb5c6a86ba187e0c50e811d659ce00991fd5f5b408f71ebb2ef0f16", + "sha256_in_prefix": "21d051a00fb5c6a86ba187e0c50e811d659ce00991fd5f5b408f71ebb2ef0f16", + "size_in_bytes": 1039 + }, + { + "_path": "lib/python3.12/encodings/bz2_codec.py", + "path_type": "hardlink", + "sha256": "1181a2a89102a2b1d2b2f1f4473236d5d1ececdd0be8fdaa498a3dbe21a185ab", + "sha256_in_prefix": "1181a2a89102a2b1d2b2f1f4473236d5d1ececdd0be8fdaa498a3dbe21a185ab", + "size_in_bytes": 2249 + }, + { + "_path": "lib/python3.12/encodings/charmap.py", + "path_type": "hardlink", + "sha256": "1b8b5fdb36ce3becc62a6115ed904a17083949ec8aaef5a80f7078cec232f43b", + "sha256_in_prefix": "1b8b5fdb36ce3becc62a6115ed904a17083949ec8aaef5a80f7078cec232f43b", + "size_in_bytes": 2084 + }, + { + "_path": "lib/python3.12/encodings/cp037.py", + "path_type": "hardlink", + "sha256": "fda6ca994d710e4e0c760e0204c29a4273fc0f14ebe3169306d2eb54c9953f58", + "sha256_in_prefix": "fda6ca994d710e4e0c760e0204c29a4273fc0f14ebe3169306d2eb54c9953f58", + "size_in_bytes": 13121 + }, + { + "_path": "lib/python3.12/encodings/cp1006.py", + "path_type": "hardlink", + "sha256": "eaded38b427841bdf280e878f1e26da506e743eaa9429075332af60cce429473", + "sha256_in_prefix": "eaded38b427841bdf280e878f1e26da506e743eaa9429075332af60cce429473", + "size_in_bytes": 13568 + }, + { + "_path": "lib/python3.12/encodings/cp1026.py", + "path_type": "hardlink", + "sha256": "f5227237dd7ce5005b16a8e4d8342f0d193193c878e3cf35b9305d22b3b1aaf9", + "sha256_in_prefix": "f5227237dd7ce5005b16a8e4d8342f0d193193c878e3cf35b9305d22b3b1aaf9", + "size_in_bytes": 13113 + }, + { + "_path": "lib/python3.12/encodings/cp1125.py", + "path_type": "hardlink", + "sha256": "f84c7d30ce222e6a50cff1a4c9737173411da108cbd2c9bb57c854480103c470", + "sha256_in_prefix": "f84c7d30ce222e6a50cff1a4c9737173411da108cbd2c9bb57c854480103c470", + "size_in_bytes": 34597 + }, + { + "_path": "lib/python3.12/encodings/cp1140.py", + "path_type": "hardlink", + "sha256": "3379d78b244aa905ffe1171a968caaf41b9a0154d1ddc76c05a2abaca2b289fd", + "sha256_in_prefix": "3379d78b244aa905ffe1171a968caaf41b9a0154d1ddc76c05a2abaca2b289fd", + "size_in_bytes": 13105 + }, + { + "_path": "lib/python3.12/encodings/cp1250.py", + "path_type": "hardlink", + "sha256": "ebcec1adf9167863fb0bab29708c546300c80a77ef07838c9e0437a59e265970", + "sha256_in_prefix": "ebcec1adf9167863fb0bab29708c546300c80a77ef07838c9e0437a59e265970", + "size_in_bytes": 13686 + }, + { + "_path": "lib/python3.12/encodings/cp1251.py", + "path_type": "hardlink", + "sha256": "d57f8cfa34494c5acb6692ddb31f616ae2dd89a075d2af6d36b0b7ec2ffe7af1", + "sha256_in_prefix": "d57f8cfa34494c5acb6692ddb31f616ae2dd89a075d2af6d36b0b7ec2ffe7af1", + "size_in_bytes": 13361 + }, + { + "_path": "lib/python3.12/encodings/cp1252.py", + "path_type": "hardlink", + "sha256": "19aa5bee667f5fb387924a813aec9fa1dda47769d09e8483a748bdb202be6a84", + "sha256_in_prefix": "19aa5bee667f5fb387924a813aec9fa1dda47769d09e8483a748bdb202be6a84", + "size_in_bytes": 13511 + }, + { + "_path": "lib/python3.12/encodings/cp1253.py", + "path_type": "hardlink", + "sha256": "8c27696dcfb6894b378869bc89f113703fbd1e9b13a83934463d5999b055d1e8", + "sha256_in_prefix": "8c27696dcfb6894b378869bc89f113703fbd1e9b13a83934463d5999b055d1e8", + "size_in_bytes": 13094 + }, + { + "_path": "lib/python3.12/encodings/cp1254.py", + "path_type": "hardlink", + "sha256": "06517ec2f74f1c6562d0a1a500c48ba43f2e6e9d0c3d28356d747f274f1a4c8d", + "sha256_in_prefix": "06517ec2f74f1c6562d0a1a500c48ba43f2e6e9d0c3d28356d747f274f1a4c8d", + "size_in_bytes": 13502 + }, + { + "_path": "lib/python3.12/encodings/cp1255.py", + "path_type": "hardlink", + "sha256": "54a1b5087578fa78e5bdd0afa6a9e80e8c5467c1e4226cf6e586cfe7a674a653", + "sha256_in_prefix": "54a1b5087578fa78e5bdd0afa6a9e80e8c5467c1e4226cf6e586cfe7a674a653", + "size_in_bytes": 12466 + }, + { + "_path": "lib/python3.12/encodings/cp1256.py", + "path_type": "hardlink", + "sha256": "ad3768ac2fef2a646b3301c20af705f4d4a1544f22fa8a84241bada27ab84133", + "sha256_in_prefix": "ad3768ac2fef2a646b3301c20af705f4d4a1544f22fa8a84241bada27ab84133", + "size_in_bytes": 12814 + }, + { + "_path": "lib/python3.12/encodings/cp1257.py", + "path_type": "hardlink", + "sha256": "d9149d2925b3f719809ef2297e541461079f15c658af207a3e498be314ab2c6b", + "sha256_in_prefix": "d9149d2925b3f719809ef2297e541461079f15c658af207a3e498be314ab2c6b", + "size_in_bytes": 13374 + }, + { + "_path": "lib/python3.12/encodings/cp1258.py", + "path_type": "hardlink", + "sha256": "672e05b51952a82c8dbd5603769195fcedf565e457bb86c0d5bae04955d04630", + "sha256_in_prefix": "672e05b51952a82c8dbd5603769195fcedf565e457bb86c0d5bae04955d04630", + "size_in_bytes": 13364 + }, + { + "_path": "lib/python3.12/encodings/cp273.py", + "path_type": "hardlink", + "sha256": "6c6aec3b213ea3aebc2c526dd4d121c95d4a25a2fc928a87cd80f8448988185f", + "sha256_in_prefix": "6c6aec3b213ea3aebc2c526dd4d121c95d4a25a2fc928a87cd80f8448988185f", + "size_in_bytes": 14132 + }, + { + "_path": "lib/python3.12/encodings/cp424.py", + "path_type": "hardlink", + "sha256": "30414c2186ea0802bbf3db034122ddec1f8a10061b97c50871e14b74ee36d0ca", + "sha256_in_prefix": "30414c2186ea0802bbf3db034122ddec1f8a10061b97c50871e14b74ee36d0ca", + "size_in_bytes": 12055 + }, + { + "_path": "lib/python3.12/encodings/cp437.py", + "path_type": "hardlink", + "sha256": "5c2a5015cd36cf7f561269f33dec4c323093d3d88b0673969accdabdcb9ce2cb", + "sha256_in_prefix": "5c2a5015cd36cf7f561269f33dec4c323093d3d88b0673969accdabdcb9ce2cb", + "size_in_bytes": 34564 + }, + { + "_path": "lib/python3.12/encodings/cp500.py", + "path_type": "hardlink", + "sha256": "630f503f9110d98ea3e1529f2f965ebc275a2f78d3de47f8e9b69d35589d764b", + "sha256_in_prefix": "630f503f9110d98ea3e1529f2f965ebc275a2f78d3de47f8e9b69d35589d764b", + "size_in_bytes": 13121 + }, + { + "_path": "lib/python3.12/encodings/cp720.py", + "path_type": "hardlink", + "sha256": "395496001271b92efe5df07fc0ae7c3410d1dd2bdfebbd3e4d8e806c8166beb0", + "sha256_in_prefix": "395496001271b92efe5df07fc0ae7c3410d1dd2bdfebbd3e4d8e806c8166beb0", + "size_in_bytes": 13686 + }, + { + "_path": "lib/python3.12/encodings/cp737.py", + "path_type": "hardlink", + "sha256": "be3ca1785a3970ec62310710eaf7de82932181b04d06fe4528f8adaba9fb8c4b", + "sha256_in_prefix": "be3ca1785a3970ec62310710eaf7de82932181b04d06fe4528f8adaba9fb8c4b", + "size_in_bytes": 34681 + }, + { + "_path": "lib/python3.12/encodings/cp775.py", + "path_type": "hardlink", + "sha256": "e0dba85b99329d7f16907e620adada06be5216abcb964406c827b569b2cf1aeb", + "sha256_in_prefix": "e0dba85b99329d7f16907e620adada06be5216abcb964406c827b569b2cf1aeb", + "size_in_bytes": 34476 + }, + { + "_path": "lib/python3.12/encodings/cp850.py", + "path_type": "hardlink", + "sha256": "257e29f235e2a8790dd68cee45668776648bab809ce8584f893cdd8fd007993c", + "sha256_in_prefix": "257e29f235e2a8790dd68cee45668776648bab809ce8584f893cdd8fd007993c", + "size_in_bytes": 34105 + }, + { + "_path": "lib/python3.12/encodings/cp852.py", + "path_type": "hardlink", + "sha256": "cc6faaa9dc4a933127da0aaacd1dc7a44c09266051af56bfe3215ff228636b6b", + "sha256_in_prefix": "cc6faaa9dc4a933127da0aaacd1dc7a44c09266051af56bfe3215ff228636b6b", + "size_in_bytes": 35002 + }, + { + "_path": "lib/python3.12/encodings/cp855.py", + "path_type": "hardlink", + "sha256": "7b25c61c9e8c47b218d3fbb801541a2861926ac712843d2113fff90e2074f5ba", + "sha256_in_prefix": "7b25c61c9e8c47b218d3fbb801541a2861926ac712843d2113fff90e2074f5ba", + "size_in_bytes": 33850 + }, + { + "_path": "lib/python3.12/encodings/cp856.py", + "path_type": "hardlink", + "sha256": "2e52ec5cb1eafa6739b5569b0b98ee89df5f7358b84ccdc8da64e86f017d359f", + "sha256_in_prefix": "2e52ec5cb1eafa6739b5569b0b98ee89df5f7358b84ccdc8da64e86f017d359f", + "size_in_bytes": 12423 + }, + { + "_path": "lib/python3.12/encodings/cp857.py", + "path_type": "hardlink", + "sha256": "8d1b769058bfccdb3c6c70c49a104f5081a2fcc9fad68f7b5eb3e4f67f0b33da", + "sha256_in_prefix": "8d1b769058bfccdb3c6c70c49a104f5081a2fcc9fad68f7b5eb3e4f67f0b33da", + "size_in_bytes": 33908 + }, + { + "_path": "lib/python3.12/encodings/cp858.py", + "path_type": "hardlink", + "sha256": "a24930c4a6ad0ff66dde9a69f2027e4b92c2c9c61dcda2992e940654c606577b", + "sha256_in_prefix": "a24930c4a6ad0ff66dde9a69f2027e4b92c2c9c61dcda2992e940654c606577b", + "size_in_bytes": 34015 + }, + { + "_path": "lib/python3.12/encodings/cp860.py", + "path_type": "hardlink", + "sha256": "2dfae7e31d3d9aa3013cff44a4d7ad842f257ac63765a9998436701b629cd86a", + "sha256_in_prefix": "2dfae7e31d3d9aa3013cff44a4d7ad842f257ac63765a9998436701b629cd86a", + "size_in_bytes": 34681 + }, + { + "_path": "lib/python3.12/encodings/cp861.py", + "path_type": "hardlink", + "sha256": "701930d77a2177497586e99bc3fe60f2d4beffb645608f167c76874a72ff405e", + "sha256_in_prefix": "701930d77a2177497586e99bc3fe60f2d4beffb645608f167c76874a72ff405e", + "size_in_bytes": 34633 + }, + { + "_path": "lib/python3.12/encodings/cp862.py", + "path_type": "hardlink", + "sha256": "15a2844b6ed9544c6400cf7299b42d0c2bef93c9bee70a9e89f66b8610ad6d6d", + "sha256_in_prefix": "15a2844b6ed9544c6400cf7299b42d0c2bef93c9bee70a9e89f66b8610ad6d6d", + "size_in_bytes": 33370 + }, + { + "_path": "lib/python3.12/encodings/cp863.py", + "path_type": "hardlink", + "sha256": "a3d57f61fce1b98fc81ea8e4ebebaf402fae40bbcdd35d4b8297b9bb49a79aa2", + "sha256_in_prefix": "a3d57f61fce1b98fc81ea8e4ebebaf402fae40bbcdd35d4b8297b9bb49a79aa2", + "size_in_bytes": 34252 + }, + { + "_path": "lib/python3.12/encodings/cp864.py", + "path_type": "hardlink", + "sha256": "15ad8f1fdfdd842c7522241372e7eddda7df687e815692a89157c5f256f21a08", + "sha256_in_prefix": "15ad8f1fdfdd842c7522241372e7eddda7df687e815692a89157c5f256f21a08", + "size_in_bytes": 33663 + }, + { + "_path": "lib/python3.12/encodings/cp865.py", + "path_type": "hardlink", + "sha256": "bdbaded987242ed2a8de7133ec2f61ddcc1c2e9de27816ab7cd0a4c678a3a907", + "sha256_in_prefix": "bdbaded987242ed2a8de7133ec2f61ddcc1c2e9de27816ab7cd0a4c678a3a907", + "size_in_bytes": 34618 + }, + { + "_path": "lib/python3.12/encodings/cp866.py", + "path_type": "hardlink", + "sha256": "9efcc8e85bbd1687272a0991f6d0429a4c06679db2d114b2ac95db27a70f9d13", + "sha256_in_prefix": "9efcc8e85bbd1687272a0991f6d0429a4c06679db2d114b2ac95db27a70f9d13", + "size_in_bytes": 34396 + }, + { + "_path": "lib/python3.12/encodings/cp869.py", + "path_type": "hardlink", + "sha256": "52582d9fb769b24eac7154f18d7dae856588297d6da98f37fb5efd8da883826d", + "sha256_in_prefix": "52582d9fb769b24eac7154f18d7dae856588297d6da98f37fb5efd8da883826d", + "size_in_bytes": 32965 + }, + { + "_path": "lib/python3.12/encodings/cp874.py", + "path_type": "hardlink", + "sha256": "fe4752fa2e65741e08a563a31ff914fe71068942ce9c6f4070b1dfd7b25e5e7f", + "sha256_in_prefix": "fe4752fa2e65741e08a563a31ff914fe71068942ce9c6f4070b1dfd7b25e5e7f", + "size_in_bytes": 12595 + }, + { + "_path": "lib/python3.12/encodings/cp875.py", + "path_type": "hardlink", + "sha256": "2fe72632015db2cba2bb4367055551da6fe22051b96d170c7b96fa271c46b257", + "sha256_in_prefix": "2fe72632015db2cba2bb4367055551da6fe22051b96d170c7b96fa271c46b257", + "size_in_bytes": 12854 + }, + { + "_path": "lib/python3.12/encodings/cp932.py", + "path_type": "hardlink", + "sha256": "99748e28113d2d49f5d666b49b78accd2c6e10a7852f7dd6dece9b5b71aa83c4", + "sha256_in_prefix": "99748e28113d2d49f5d666b49b78accd2c6e10a7852f7dd6dece9b5b71aa83c4", + "size_in_bytes": 1023 + }, + { + "_path": "lib/python3.12/encodings/cp949.py", + "path_type": "hardlink", + "sha256": "950a7d29467ce0590b4a1137830d43d88d8f20e4035dcaaa8b2a5c3c3f1de962", + "sha256_in_prefix": "950a7d29467ce0590b4a1137830d43d88d8f20e4035dcaaa8b2a5c3c3f1de962", + "size_in_bytes": 1023 + }, + { + "_path": "lib/python3.12/encodings/cp950.py", + "path_type": "hardlink", + "sha256": "27811178b450731fc955b1247656a605d04e5ee98e0d585e4596b94b703a27f6", + "sha256_in_prefix": "27811178b450731fc955b1247656a605d04e5ee98e0d585e4596b94b703a27f6", + "size_in_bytes": 1023 + }, + { + "_path": "lib/python3.12/encodings/euc_jis_2004.py", + "path_type": "hardlink", + "sha256": "9fa426cd9f17629f6320700ed18baa94839304cf1bcabbee7edb501747dc055d", + "sha256_in_prefix": "9fa426cd9f17629f6320700ed18baa94839304cf1bcabbee7edb501747dc055d", + "size_in_bytes": 1051 + }, + { + "_path": "lib/python3.12/encodings/euc_jisx0213.py", + "path_type": "hardlink", + "sha256": "e28315910da20218dae8b7d5becd81de1e283dfd8b0415a4980d67065de73a0b", + "sha256_in_prefix": "e28315910da20218dae8b7d5becd81de1e283dfd8b0415a4980d67065de73a0b", + "size_in_bytes": 1051 + }, + { + "_path": "lib/python3.12/encodings/euc_jp.py", + "path_type": "hardlink", + "sha256": "b453a439787b0efa031e43416a7d852a6be705c985e1200693eb96d87ea79cdc", + "sha256_in_prefix": "b453a439787b0efa031e43416a7d852a6be705c985e1200693eb96d87ea79cdc", + "size_in_bytes": 1027 + }, + { + "_path": "lib/python3.12/encodings/euc_kr.py", + "path_type": "hardlink", + "sha256": "633a1a5504bfad04b1ec9c96d44d4ebb3bb99066a218318e7d67d866e20887a6", + "sha256_in_prefix": "633a1a5504bfad04b1ec9c96d44d4ebb3bb99066a218318e7d67d866e20887a6", + "size_in_bytes": 1027 + }, + { + "_path": "lib/python3.12/encodings/gb18030.py", + "path_type": "hardlink", + "sha256": "6c10b4dc49bc63724e539137ede6936304fcca1c97c28d16d89f381e10849521", + "sha256_in_prefix": "6c10b4dc49bc63724e539137ede6936304fcca1c97c28d16d89f381e10849521", + "size_in_bytes": 1031 + }, + { + "_path": "lib/python3.12/encodings/gb2312.py", + "path_type": "hardlink", + "sha256": "3d2d567d8d079b78f3f3b566ed52ad2f38af61bf832b7dc28858b0039a032d6b", + "sha256_in_prefix": "3d2d567d8d079b78f3f3b566ed52ad2f38af61bf832b7dc28858b0039a032d6b", + "size_in_bytes": 1027 + }, + { + "_path": "lib/python3.12/encodings/gbk.py", + "path_type": "hardlink", + "sha256": "eff9b8cbc9ad2ef2e10e96afa83d3db1f775ea044aed275b7a35574ae0d8645b", + "sha256_in_prefix": "eff9b8cbc9ad2ef2e10e96afa83d3db1f775ea044aed275b7a35574ae0d8645b", + "size_in_bytes": 1015 + }, + { + "_path": "lib/python3.12/encodings/hex_codec.py", + "path_type": "hardlink", + "sha256": "fc5f0a31b59efe990b86efb98936769f33dd91d912ce55b49a5a4cfc516cd047", + "sha256_in_prefix": "fc5f0a31b59efe990b86efb98936769f33dd91d912ce55b49a5a4cfc516cd047", + "size_in_bytes": 1508 + }, + { + "_path": "lib/python3.12/encodings/hp_roman8.py", + "path_type": "hardlink", + "sha256": "c43cce763d12e8f71a63dbc16641bd87147eaf5f9d9054ea856864b216b2735b", + "sha256_in_prefix": "c43cce763d12e8f71a63dbc16641bd87147eaf5f9d9054ea856864b216b2735b", + "size_in_bytes": 13475 + }, + { + "_path": "lib/python3.12/encodings/hz.py", + "path_type": "hardlink", + "sha256": "025a9531e3046e52d3e039c0be04f9a5a74651d7683a13c7c7ebd4c7dfb5996a", + "sha256_in_prefix": "025a9531e3046e52d3e039c0be04f9a5a74651d7683a13c7c7ebd4c7dfb5996a", + "size_in_bytes": 1011 + }, + { + "_path": "lib/python3.12/encodings/idna.py", + "path_type": "hardlink", + "sha256": "9ca58e82d12b171f25d57239ad237dae5c44214a70f2f4f39358c2759b8b9013", + "sha256_in_prefix": "9ca58e82d12b171f25d57239ad237dae5c44214a70f2f4f39358c2759b8b9013", + "size_in_bytes": 9710 + }, + { + "_path": "lib/python3.12/encodings/iso2022_jp.py", + "path_type": "hardlink", + "sha256": "461a0e7f72eccb8b29f351c4e7926cfbda58e0edd6d0770bd82e0b36c5febe77", + "sha256_in_prefix": "461a0e7f72eccb8b29f351c4e7926cfbda58e0edd6d0770bd82e0b36c5febe77", + "size_in_bytes": 1053 + }, + { + "_path": "lib/python3.12/encodings/iso2022_jp_1.py", + "path_type": "hardlink", + "sha256": "63bacad13a979a5519fcaa4f1e1e07b2c7415005167fac3a689408c7d886fabd", + "sha256_in_prefix": "63bacad13a979a5519fcaa4f1e1e07b2c7415005167fac3a689408c7d886fabd", + "size_in_bytes": 1061 + }, + { + "_path": "lib/python3.12/encodings/iso2022_jp_2.py", + "path_type": "hardlink", + "sha256": "5d4248181548b0fc89a9f5ee9cf52ebecb235708ba87d47896ad14130884ef9f", + "sha256_in_prefix": "5d4248181548b0fc89a9f5ee9cf52ebecb235708ba87d47896ad14130884ef9f", + "size_in_bytes": 1061 + }, + { + "_path": "lib/python3.12/encodings/iso2022_jp_2004.py", + "path_type": "hardlink", + "sha256": "b4d1468bcd608b46f38cb0c6ef115510dcf9aa0f71e590792f407efc6e165164", + "sha256_in_prefix": "b4d1468bcd608b46f38cb0c6ef115510dcf9aa0f71e590792f407efc6e165164", + "size_in_bytes": 1073 + }, + { + "_path": "lib/python3.12/encodings/iso2022_jp_3.py", + "path_type": "hardlink", + "sha256": "3aceaa5661909de14e2861d864443b8472460ce39b99cce5c6965346d47aa5ac", + "sha256_in_prefix": "3aceaa5661909de14e2861d864443b8472460ce39b99cce5c6965346d47aa5ac", + "size_in_bytes": 1061 + }, + { + "_path": "lib/python3.12/encodings/iso2022_jp_ext.py", + "path_type": "hardlink", + "sha256": "f4c9ed8f3031995faa224bcb10153d2b6144944477d1f27d1a6cc4a879fac34c", + "sha256_in_prefix": "f4c9ed8f3031995faa224bcb10153d2b6144944477d1f27d1a6cc4a879fac34c", + "size_in_bytes": 1069 + }, + { + "_path": "lib/python3.12/encodings/iso2022_kr.py", + "path_type": "hardlink", + "sha256": "1c86362e17944f0bcf68db02f4995bdeea605867795fff7ab4079073f96705e4", + "sha256_in_prefix": "1c86362e17944f0bcf68db02f4995bdeea605867795fff7ab4079073f96705e4", + "size_in_bytes": 1053 + }, + { + "_path": "lib/python3.12/encodings/iso8859_1.py", + "path_type": "hardlink", + "sha256": "b5cebd515e057d670bf54e10b8a6f162ef3daa7f21b146aee3249160caf3c32d", + "sha256_in_prefix": "b5cebd515e057d670bf54e10b8a6f162ef3daa7f21b146aee3249160caf3c32d", + "size_in_bytes": 13176 + }, + { + "_path": "lib/python3.12/encodings/iso8859_10.py", + "path_type": "hardlink", + "sha256": "54c886b41819ebb7f4fb34b8dbae1c45f4fc0864f019ecd772676ccfac5fae7b", + "sha256_in_prefix": "54c886b41819ebb7f4fb34b8dbae1c45f4fc0864f019ecd772676ccfac5fae7b", + "size_in_bytes": 13589 + }, + { + "_path": "lib/python3.12/encodings/iso8859_11.py", + "path_type": "hardlink", + "sha256": "ed5a964470a241b4da7a6cfb718e4149d09644933af38f0497602baab6e563ef", + "sha256_in_prefix": "ed5a964470a241b4da7a6cfb718e4149d09644933af38f0497602baab6e563ef", + "size_in_bytes": 12335 + }, + { + "_path": "lib/python3.12/encodings/iso8859_13.py", + "path_type": "hardlink", + "sha256": "7312237e8e5d201d920b4130f057cfdf1b0be9baafaa246826e6d93204fcc206", + "sha256_in_prefix": "7312237e8e5d201d920b4130f057cfdf1b0be9baafaa246826e6d93204fcc206", + "size_in_bytes": 13271 + }, + { + "_path": "lib/python3.12/encodings/iso8859_14.py", + "path_type": "hardlink", + "sha256": "82778b995a0ee87c5f1180fcc52900359eee15bd9a6e3a0e25f0d963e0b2a343", + "sha256_in_prefix": "82778b995a0ee87c5f1180fcc52900359eee15bd9a6e3a0e25f0d963e0b2a343", + "size_in_bytes": 13652 + }, + { + "_path": "lib/python3.12/encodings/iso8859_15.py", + "path_type": "hardlink", + "sha256": "01976a81811873dc9a0c79db9fc00d1c30103487f3c6bc3a6d81b4043cd48e02", + "sha256_in_prefix": "01976a81811873dc9a0c79db9fc00d1c30103487f3c6bc3a6d81b4043cd48e02", + "size_in_bytes": 13212 + }, + { + "_path": "lib/python3.12/encodings/iso8859_16.py", + "path_type": "hardlink", + "sha256": "b5ac8f5a5d8f84c0f903b2b7c342184758d590d8bcf810d561f942fe5b372d66", + "sha256_in_prefix": "b5ac8f5a5d8f84c0f903b2b7c342184758d590d8bcf810d561f942fe5b372d66", + "size_in_bytes": 13557 + }, + { + "_path": "lib/python3.12/encodings/iso8859_2.py", + "path_type": "hardlink", + "sha256": "2b57cab6111cae9021505e3ae1b2adbbfc344ec48165fda322f6b069fbb18adc", + "sha256_in_prefix": "2b57cab6111cae9021505e3ae1b2adbbfc344ec48165fda322f6b069fbb18adc", + "size_in_bytes": 13404 + }, + { + "_path": "lib/python3.12/encodings/iso8859_3.py", + "path_type": "hardlink", + "sha256": "4ffdf89004bf0c5230caa7079f7ca3142fc112f8b923ddb2c7358369d2d3c242", + "sha256_in_prefix": "4ffdf89004bf0c5230caa7079f7ca3142fc112f8b923ddb2c7358369d2d3c242", + "size_in_bytes": 13089 + }, + { + "_path": "lib/python3.12/encodings/iso8859_4.py", + "path_type": "hardlink", + "sha256": "87bd130daa0eaef3e4cb465e10cffb2bcd194ff74097e0c186b4b8eb7be41ac5", + "sha256_in_prefix": "87bd130daa0eaef3e4cb465e10cffb2bcd194ff74097e0c186b4b8eb7be41ac5", + "size_in_bytes": 13376 + }, + { + "_path": "lib/python3.12/encodings/iso8859_5.py", + "path_type": "hardlink", + "sha256": "9961d96cc7b9fdf011ebcaaeaeca7b50b8670fadbd7b75fde66192f8c1f68f30", + "sha256_in_prefix": "9961d96cc7b9fdf011ebcaaeaeca7b50b8670fadbd7b75fde66192f8c1f68f30", + "size_in_bytes": 13015 + }, + { + "_path": "lib/python3.12/encodings/iso8859_6.py", + "path_type": "hardlink", + "sha256": "4840e68014346517680f593ca22f67133c39ba7e46f34b9be62c980a728448c6", + "sha256_in_prefix": "4840e68014346517680f593ca22f67133c39ba7e46f34b9be62c980a728448c6", + "size_in_bytes": 10833 + }, + { + "_path": "lib/python3.12/encodings/iso8859_7.py", + "path_type": "hardlink", + "sha256": "b352eca3b819488f64fb3338fd93f39c1e30f32bb13f2f9c577925e58f2960e4", + "sha256_in_prefix": "b352eca3b819488f64fb3338fd93f39c1e30f32bb13f2f9c577925e58f2960e4", + "size_in_bytes": 12844 + }, + { + "_path": "lib/python3.12/encodings/iso8859_8.py", + "path_type": "hardlink", + "sha256": "4cf9e8a8bbe04accb1c1a80853efb19ae0772d18f81e270adefc1b2386cb368e", + "sha256_in_prefix": "4cf9e8a8bbe04accb1c1a80853efb19ae0772d18f81e270adefc1b2386cb368e", + "size_in_bytes": 11036 + }, + { + "_path": "lib/python3.12/encodings/iso8859_9.py", + "path_type": "hardlink", + "sha256": "84d9b15263e81685f7513c5ab45caf80b2f73c301c68e659f7162c1b1882d359", + "sha256_in_prefix": "84d9b15263e81685f7513c5ab45caf80b2f73c301c68e659f7162c1b1882d359", + "size_in_bytes": 13156 + }, + { + "_path": "lib/python3.12/encodings/johab.py", + "path_type": "hardlink", + "sha256": "9586615917afd3d848c1c4328656603b2834af6115f2aec932fccc935e1a60fb", + "sha256_in_prefix": "9586615917afd3d848c1c4328656603b2834af6115f2aec932fccc935e1a60fb", + "size_in_bytes": 1023 + }, + { + "_path": "lib/python3.12/encodings/koi8_r.py", + "path_type": "hardlink", + "sha256": "4d4e353aee8039bb71e2145a6e68fe1e6833a1b4250b70ee0ac5ec70bbb8c51d", + "sha256_in_prefix": "4d4e353aee8039bb71e2145a6e68fe1e6833a1b4250b70ee0ac5ec70bbb8c51d", + "size_in_bytes": 13779 + }, + { + "_path": "lib/python3.12/encodings/koi8_t.py", + "path_type": "hardlink", + "sha256": "9c9043814abdbe7dc39ff98f3857d5d110a84c978ad2304158d810a4e9eacef1", + "sha256_in_prefix": "9c9043814abdbe7dc39ff98f3857d5d110a84c978ad2304158d810a4e9eacef1", + "size_in_bytes": 13193 + }, + { + "_path": "lib/python3.12/encodings/koi8_u.py", + "path_type": "hardlink", + "sha256": "d449f9858e357fa8c2edbd4b9fe739337e9f201cac3ded20f99bfcecd4970ff7", + "sha256_in_prefix": "d449f9858e357fa8c2edbd4b9fe739337e9f201cac3ded20f99bfcecd4970ff7", + "size_in_bytes": 13762 + }, + { + "_path": "lib/python3.12/encodings/kz1048.py", + "path_type": "hardlink", + "sha256": "76beb30e98a911f72f97609a2373782573c17c88a5fb3537db338aa382979ffc", + "sha256_in_prefix": "76beb30e98a911f72f97609a2373782573c17c88a5fb3537db338aa382979ffc", + "size_in_bytes": 13723 + }, + { + "_path": "lib/python3.12/encodings/latin_1.py", + "path_type": "hardlink", + "sha256": "b75503e532a27c636477396c855209ff5f3036536d2a4bede0a576c89382b60c", + "sha256_in_prefix": "b75503e532a27c636477396c855209ff5f3036536d2a4bede0a576c89382b60c", + "size_in_bytes": 1264 + }, + { + "_path": "lib/python3.12/encodings/mac_arabic.py", + "path_type": "hardlink", + "sha256": "5eafd9a3136abfbd8ed52df9c90203c7a283e7429ed60502a87a02511e0fb777", + "sha256_in_prefix": "5eafd9a3136abfbd8ed52df9c90203c7a283e7429ed60502a87a02511e0fb777", + "size_in_bytes": 36467 + }, + { + "_path": "lib/python3.12/encodings/mac_croatian.py", + "path_type": "hardlink", + "sha256": "a880cd05c82a8d11a29c65ee86a396def3344465dd71441b0bb4a73826024953", + "sha256_in_prefix": "a880cd05c82a8d11a29c65ee86a396def3344465dd71441b0bb4a73826024953", + "size_in_bytes": 13633 + }, + { + "_path": "lib/python3.12/encodings/mac_cyrillic.py", + "path_type": "hardlink", + "sha256": "83616786a1c6308b03a0dc82536908d24d0974b2248d67393d613fe558cea4bd", + "sha256_in_prefix": "83616786a1c6308b03a0dc82536908d24d0974b2248d67393d613fe558cea4bd", + "size_in_bytes": 13454 + }, + { + "_path": "lib/python3.12/encodings/mac_farsi.py", + "path_type": "hardlink", + "sha256": "f5763c38fb4ab0423fafe2fdca34d6f9932ac7f1a74c0cd8109d60234c7dc624", + "sha256_in_prefix": "f5763c38fb4ab0423fafe2fdca34d6f9932ac7f1a74c0cd8109d60234c7dc624", + "size_in_bytes": 15170 + }, + { + "_path": "lib/python3.12/encodings/mac_greek.py", + "path_type": "hardlink", + "sha256": "63016a323ddf98cb3aa9cfa78f3bab4768bedbfe9a5262a36a5aecb13d291f6e", + "sha256_in_prefix": "63016a323ddf98cb3aa9cfa78f3bab4768bedbfe9a5262a36a5aecb13d291f6e", + "size_in_bytes": 13721 + }, + { + "_path": "lib/python3.12/encodings/mac_iceland.py", + "path_type": "hardlink", + "sha256": "753cc1ac635caa7e1b4630fbcebef8db8db332c098154a5b11f652912bf64f37", + "sha256_in_prefix": "753cc1ac635caa7e1b4630fbcebef8db8db332c098154a5b11f652912bf64f37", + "size_in_bytes": 13498 + }, + { + "_path": "lib/python3.12/encodings/mac_latin2.py", + "path_type": "hardlink", + "sha256": "31670da18ce8b5394cd53fe6bf216268e7e8eae4c0247532e420e2e103727d50", + "sha256_in_prefix": "31670da18ce8b5394cd53fe6bf216268e7e8eae4c0247532e420e2e103727d50", + "size_in_bytes": 14118 + }, + { + "_path": "lib/python3.12/encodings/mac_roman.py", + "path_type": "hardlink", + "sha256": "230367d96aef8e8d7f185b4acfb84923714f39ddbcbf9cf38a06bf6f5d621c22", + "sha256_in_prefix": "230367d96aef8e8d7f185b4acfb84923714f39ddbcbf9cf38a06bf6f5d621c22", + "size_in_bytes": 13480 + }, + { + "_path": "lib/python3.12/encodings/mac_romanian.py", + "path_type": "hardlink", + "sha256": "49630cf035c19e896a123ed6e5fee18b5e485123daf2f15da38bf727ff387bee", + "sha256_in_prefix": "49630cf035c19e896a123ed6e5fee18b5e485123daf2f15da38bf727ff387bee", + "size_in_bytes": 13661 + }, + { + "_path": "lib/python3.12/encodings/mac_turkish.py", + "path_type": "hardlink", + "sha256": "99758a5cad2825cb3be3fa5d031e0821e4eba910a46f417fd890207b9b6be77b", + "sha256_in_prefix": "99758a5cad2825cb3be3fa5d031e0821e4eba910a46f417fd890207b9b6be77b", + "size_in_bytes": 13513 + }, + { + "_path": "lib/python3.12/encodings/mbcs.py", + "path_type": "hardlink", + "sha256": "f6ed445ed537c9f856d8defe8b56505727737d0dc9348d0a877abedab4bdd864", + "sha256_in_prefix": "f6ed445ed537c9f856d8defe8b56505727737d0dc9348d0a877abedab4bdd864", + "size_in_bytes": 1211 + }, + { + "_path": "lib/python3.12/encodings/oem.py", + "path_type": "hardlink", + "sha256": "481656d3a35f792d0e5109e3f821e6dbfcf097163a19b0cdfcbff3b3db99292f", + "sha256_in_prefix": "481656d3a35f792d0e5109e3f821e6dbfcf097163a19b0cdfcbff3b3db99292f", + "size_in_bytes": 1019 + }, + { + "_path": "lib/python3.12/encodings/palmos.py", + "path_type": "hardlink", + "sha256": "eccf7418adefcc2a59e9a07fc4e34363bd62f7e878d48c8a02730a8ed1c584c8", + "sha256_in_prefix": "eccf7418adefcc2a59e9a07fc4e34363bd62f7e878d48c8a02730a8ed1c584c8", + "size_in_bytes": 13519 + }, + { + "_path": "lib/python3.12/encodings/ptcp154.py", + "path_type": "hardlink", + "sha256": "0eabcb2c287d335e86b71b0abe5718bd6ddc9aaee234f0f0f2363845d2926d8d", + "sha256_in_prefix": "0eabcb2c287d335e86b71b0abe5718bd6ddc9aaee234f0f0f2363845d2926d8d", + "size_in_bytes": 14015 + }, + { + "_path": "lib/python3.12/encodings/punycode.py", + "path_type": "hardlink", + "sha256": "34edc8fb1c50e4d1cbaa1e008bb491cd7c12116c316e51974f333fe7b628eb7c", + "sha256_in_prefix": "34edc8fb1c50e4d1cbaa1e008bb491cd7c12116c316e51974f333fe7b628eb7c", + "size_in_bytes": 6883 + }, + { + "_path": "lib/python3.12/encodings/quopri_codec.py", + "path_type": "hardlink", + "sha256": "502a213c34c05a94ed063ee03f47680bd6efbb35036e06fb4dc809bf398cfa64", + "sha256_in_prefix": "502a213c34c05a94ed063ee03f47680bd6efbb35036e06fb4dc809bf398cfa64", + "size_in_bytes": 1525 + }, + { + "_path": "lib/python3.12/encodings/raw_unicode_escape.py", + "path_type": "hardlink", + "sha256": "fa6328486b8f5a5cbd10e377e80adb8cf94acbbe19c38b4e1bf708d831a80a3a", + "sha256_in_prefix": "fa6328486b8f5a5cbd10e377e80adb8cf94acbbe19c38b4e1bf708d831a80a3a", + "size_in_bytes": 1332 + }, + { + "_path": "lib/python3.12/encodings/rot_13.py", + "path_type": "hardlink", + "sha256": "14767f475acdc0bf48e6272280dd15b80efaecafb93c06be21136f83dd1ee7e4", + "sha256_in_prefix": "14767f475acdc0bf48e6272280dd15b80efaecafb93c06be21136f83dd1ee7e4", + "size_in_bytes": 2448 + }, + { + "_path": "lib/python3.12/encodings/shift_jis.py", + "path_type": "hardlink", + "sha256": "ad4ac50ebf58294304e412cc0f1b12980988dd6edc414e4110029c0a1abbe966", + "sha256_in_prefix": "ad4ac50ebf58294304e412cc0f1b12980988dd6edc414e4110029c0a1abbe966", + "size_in_bytes": 1039 + }, + { + "_path": "lib/python3.12/encodings/shift_jis_2004.py", + "path_type": "hardlink", + "sha256": "d21c5930f21063ea78fea3b0f76dfb8fd92858d2a4a200064a52126a43dd1a99", + "sha256_in_prefix": "d21c5930f21063ea78fea3b0f76dfb8fd92858d2a4a200064a52126a43dd1a99", + "size_in_bytes": 1059 + }, + { + "_path": "lib/python3.12/encodings/shift_jisx0213.py", + "path_type": "hardlink", + "sha256": "2c8d0b93bb36edf31c1236b1b4d1c0008553868bd2fc9137570115b96b834f2e", + "sha256_in_prefix": "2c8d0b93bb36edf31c1236b1b4d1c0008553868bd2fc9137570115b96b834f2e", + "size_in_bytes": 1059 + }, + { + "_path": "lib/python3.12/encodings/tis_620.py", + "path_type": "hardlink", + "sha256": "647c4719e2c1a7375105e15a89b377c66f6b699977dcabbb71d923a4607b7902", + "sha256_in_prefix": "647c4719e2c1a7375105e15a89b377c66f6b699977dcabbb71d923a4607b7902", + "size_in_bytes": 12300 + }, + { + "_path": "lib/python3.12/encodings/undefined.py", + "path_type": "hardlink", + "sha256": "85bba5c5e1007cd8c1ade5c0214bcc825396d2bbd02054e62a9f162104748b64", + "sha256_in_prefix": "85bba5c5e1007cd8c1ade5c0214bcc825396d2bbd02054e62a9f162104748b64", + "size_in_bytes": 1299 + }, + { + "_path": "lib/python3.12/encodings/unicode_escape.py", + "path_type": "hardlink", + "sha256": "507e7ca8f18df639fd823d7cc23ce4028a3550ceefdfa40b3c76f81d1a94531d", + "sha256_in_prefix": "507e7ca8f18df639fd823d7cc23ce4028a3550ceefdfa40b3c76f81d1a94531d", + "size_in_bytes": 1304 + }, + { + "_path": "lib/python3.12/encodings/utf_16.py", + "path_type": "hardlink", + "sha256": "6c36257f7b8d214473560d195e71bccef0c69a53e1e52d2800b7a7890aad7e58", + "sha256_in_prefix": "6c36257f7b8d214473560d195e71bccef0c69a53e1e52d2800b7a7890aad7e58", + "size_in_bytes": 5236 + }, + { + "_path": "lib/python3.12/encodings/utf_16_be.py", + "path_type": "hardlink", + "sha256": "3357196f3fa52433326a6626880e34964e00c5570aee50e9a0a0a7c6d86f6e4f", + "sha256_in_prefix": "3357196f3fa52433326a6626880e34964e00c5570aee50e9a0a0a7c6d86f6e4f", + "size_in_bytes": 1037 + }, + { + "_path": "lib/python3.12/encodings/utf_16_le.py", + "path_type": "hardlink", + "sha256": "3aedaf3eb49769282daef1eaedfd4fa1c31fe5eebeff67fe2307c89dc2e2fd80", + "sha256_in_prefix": "3aedaf3eb49769282daef1eaedfd4fa1c31fe5eebeff67fe2307c89dc2e2fd80", + "size_in_bytes": 1037 + }, + { + "_path": "lib/python3.12/encodings/utf_32.py", + "path_type": "hardlink", + "sha256": "2072eece5f6026ad2d3549ab193a9e38894ea15ca9d5b3cd408fd6b116acc0c2", + "sha256_in_prefix": "2072eece5f6026ad2d3549ab193a9e38894ea15ca9d5b3cd408fd6b116acc0c2", + "size_in_bytes": 5129 + }, + { + "_path": "lib/python3.12/encodings/utf_32_be.py", + "path_type": "hardlink", + "sha256": "cbba20e1f6d0879c7c4293446c371a9f79e7c90bf3c78a77a9b8fc72b18915dd", + "sha256_in_prefix": "cbba20e1f6d0879c7c4293446c371a9f79e7c90bf3c78a77a9b8fc72b18915dd", + "size_in_bytes": 930 + }, + { + "_path": "lib/python3.12/encodings/utf_32_le.py", + "path_type": "hardlink", + "sha256": "9134b91047d85b442898d59effe23e7e0cf4167ca341ae31119a731dbf880a7b", + "sha256_in_prefix": "9134b91047d85b442898d59effe23e7e0cf4167ca341ae31119a731dbf880a7b", + "size_in_bytes": 930 + }, + { + "_path": "lib/python3.12/encodings/utf_7.py", + "path_type": "hardlink", + "sha256": "9ff32314f4f1fa074f206bbf7fdb851504e5313128636d73b4bf75b886e4a87d", + "sha256_in_prefix": "9ff32314f4f1fa074f206bbf7fdb851504e5313128636d73b4bf75b886e4a87d", + "size_in_bytes": 946 + }, + { + "_path": "lib/python3.12/encodings/utf_8.py", + "path_type": "hardlink", + "sha256": "ba0cac060269583523ca9506473a755203037c57d466a11aa89a30a5f6756f3d", + "sha256_in_prefix": "ba0cac060269583523ca9506473a755203037c57d466a11aa89a30a5f6756f3d", + "size_in_bytes": 1005 + }, + { + "_path": "lib/python3.12/encodings/utf_8_sig.py", + "path_type": "hardlink", + "sha256": "1ef3da8d8aa08149e7f274dc64dbfce2155da812e5258ca8e8f832428d3b5c2d", + "sha256_in_prefix": "1ef3da8d8aa08149e7f274dc64dbfce2155da812e5258ca8e8f832428d3b5c2d", + "size_in_bytes": 4133 + }, + { + "_path": "lib/python3.12/encodings/uu_codec.py", + "path_type": "hardlink", + "sha256": "45ba92000718abf85f158563c755205e100356ce1b4ab9444b4d0a3d21f061a3", + "sha256_in_prefix": "45ba92000718abf85f158563c755205e100356ce1b4ab9444b4d0a3d21f061a3", + "size_in_bytes": 2851 + }, + { + "_path": "lib/python3.12/encodings/zlib_codec.py", + "path_type": "hardlink", + "sha256": "6ef01e8d3a5fe1cc52f7b5ae008df12f1dbce7304111bf8d4758f1bfc0115759", + "sha256_in_prefix": "6ef01e8d3a5fe1cc52f7b5ae008df12f1dbce7304111bf8d4758f1bfc0115759", + "size_in_bytes": 2204 + }, + { + "_path": "lib/python3.12/ensurepip/__init__.py", + "path_type": "hardlink", + "sha256": "02ee7ac7c72ea6f2f9124842f9fc242f4f836a547719ce12f8ac3018e0409f56", + "sha256_in_prefix": "02ee7ac7c72ea6f2f9124842f9fc242f4f836a547719ce12f8ac3018e0409f56", + "size_in_bytes": 9443 + }, + { + "_path": "lib/python3.12/ensurepip/__main__.py", + "path_type": "hardlink", + "sha256": "ee735f518d0fc4dfec81f7aa3da1e052372ed4202c0da4eddd2587840beaecd7", + "sha256_in_prefix": "ee735f518d0fc4dfec81f7aa3da1e052372ed4202c0da4eddd2587840beaecd7", + "size_in_bytes": 88 + }, + { + "_path": "lib/python3.12/ensurepip/__pycache__/__init__.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "725d964acad1b2836f097097f0cd6289f5c2fcc14a2f91541f46c31160f8e7a3", + "sha256_in_prefix": "725d964acad1b2836f097097f0cd6289f5c2fcc14a2f91541f46c31160f8e7a3", + "size_in_bytes": 9774 + }, + { + "_path": "lib/python3.12/ensurepip/__pycache__/__main__.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "26c404920d0ead55a22cec1f485ac9d978a44d912ef36fab4a7fb911d4d91165", + "sha256_in_prefix": "26c404920d0ead55a22cec1f485ac9d978a44d912ef36fab4a7fb911d4d91165", + "size_in_bytes": 579 + }, + { + "_path": "lib/python3.12/ensurepip/__pycache__/_uninstall.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "2c395a59e417498da4ec75a59c78f4da79d88528e3c7d49ef39496cc337bf84c", + "sha256_in_prefix": "2c395a59e417498da4ec75a59c78f4da79d88528e3c7d49ef39496cc337bf84c", + "size_in_bytes": 1592 + }, + { + "_path": "lib/python3.12/ensurepip/_bundled/pip-24.0-py3-none-any.whl", + "path_type": "hardlink", + "sha256": "ba0d021a166865d2265246961bec0152ff124de910c5cc39f1156ce3fa7c69dc", + "sha256_in_prefix": "ba0d021a166865d2265246961bec0152ff124de910c5cc39f1156ce3fa7c69dc", + "size_in_bytes": 2110226 + }, + { + "_path": "lib/python3.12/ensurepip/_uninstall.py", + "path_type": "hardlink", + "sha256": "3a6e95d01c45e2e47c05df3c81073b895c97c1eb0e5b90ab175d6d9263fc81f2", + "sha256_in_prefix": "3a6e95d01c45e2e47c05df3c81073b895c97c1eb0e5b90ab175d6d9263fc81f2", + "size_in_bytes": 808 + }, + { + "_path": "lib/python3.12/enum.py", + "path_type": "hardlink", + "sha256": "278c5c37df86dc49adfd078b109f483205b4da475a2d9d32077a392cc0bd427f", + "sha256_in_prefix": "278c5c37df86dc49adfd078b109f483205b4da475a2d9d32077a392cc0bd427f", + "size_in_bytes": 80591 + }, + { + "_path": "lib/python3.12/filecmp.py", + "path_type": "hardlink", + "sha256": "7ecc32ce8f6f3c19a2dd21bbefe48e9054d01ca9d6ae6e30832a65f530b1223a", + "sha256_in_prefix": "7ecc32ce8f6f3c19a2dd21bbefe48e9054d01ca9d6ae6e30832a65f530b1223a", + "size_in_bytes": 10187 + }, + { + "_path": "lib/python3.12/fileinput.py", + "path_type": "hardlink", + "sha256": "b0cd2a3f01c96f594b6038e52bd83d489bfa081cc757103c70aab4e5b2c4fe1f", + "sha256_in_prefix": "b0cd2a3f01c96f594b6038e52bd83d489bfa081cc757103c70aab4e5b2c4fe1f", + "size_in_bytes": 15714 + }, + { + "_path": "lib/python3.12/fnmatch.py", + "path_type": "hardlink", + "sha256": "6683da36e47af523f3f41e18ad244d837783e19e98911cc0b7415dea81494ebc", + "sha256_in_prefix": "6683da36e47af523f3f41e18ad244d837783e19e98911cc0b7415dea81494ebc", + "size_in_bytes": 5999 + }, + { + "_path": "lib/python3.12/fractions.py", + "path_type": "hardlink", + "sha256": "cf33568f7b767f66896995a7a81cc662e8be226f2e58efb61d2028f64eb5d231", + "sha256_in_prefix": "cf33568f7b767f66896995a7a81cc662e8be226f2e58efb61d2028f64eb5d231", + "size_in_bytes": 38067 + }, + { + "_path": "lib/python3.12/ftplib.py", + "path_type": "hardlink", + "sha256": "d46af0c591299d304747c661da2fd4fe417cb7e057eee56a1789c54e2ce083bd", + "sha256_in_prefix": "d46af0c591299d304747c661da2fd4fe417cb7e057eee56a1789c54e2ce083bd", + "size_in_bytes": 34735 + }, + { + "_path": "lib/python3.12/functools.py", + "path_type": "hardlink", + "sha256": "cca971c456e1bec8b751aecdf41466f34dbf72321ee0840627280ba2ccf9d033", + "sha256_in_prefix": "cca971c456e1bec8b751aecdf41466f34dbf72321ee0840627280ba2ccf9d033", + "size_in_bytes": 38126 + }, + { + "_path": "lib/python3.12/genericpath.py", + "path_type": "hardlink", + "sha256": "6a271770c5e0c0a594075cc0063c807421fac3474df05d91a01c91d12c36eb5f", + "sha256_in_prefix": "6a271770c5e0c0a594075cc0063c807421fac3474df05d91a01c91d12c36eb5f", + "size_in_bytes": 5301 + }, + { + "_path": "lib/python3.12/getopt.py", + "path_type": "hardlink", + "sha256": "0ce875700c8798193b8e2748f7a27fc542cc4d525a1e6fc403767450ec92be99", + "sha256_in_prefix": "0ce875700c8798193b8e2748f7a27fc542cc4d525a1e6fc403767450ec92be99", + "size_in_bytes": 7488 + }, + { + "_path": "lib/python3.12/getpass.py", + "path_type": "hardlink", + "sha256": "e74fd445337ff503223dd8aa4bdd7d04917067d00c796a10bedb7a1381a4960a", + "sha256_in_prefix": "e74fd445337ff503223dd8aa4bdd7d04917067d00c796a10bedb7a1381a4960a", + "size_in_bytes": 5990 + }, + { + "_path": "lib/python3.12/gettext.py", + "path_type": "hardlink", + "sha256": "a5c249a522b6b8e3aa6f1b12a8bcc09508b99ad612b58d2fc973db27ea3b7cc3", + "sha256_in_prefix": "a5c249a522b6b8e3aa6f1b12a8bcc09508b99ad612b58d2fc973db27ea3b7cc3", + "size_in_bytes": 21320 + }, + { + "_path": "lib/python3.12/glob.py", + "path_type": "hardlink", + "sha256": "fa579f8a50a66313d34d339f10be0821c9b4fed6207e8ba8e29ed1c5e119f740", + "sha256_in_prefix": "fa579f8a50a66313d34d339f10be0821c9b4fed6207e8ba8e29ed1c5e119f740", + "size_in_bytes": 8681 + }, + { + "_path": "lib/python3.12/graphlib.py", + "path_type": "hardlink", + "sha256": "7bd338c5a475d1101064603d3baa5507446d3c5e73f741f6d6e77c6204c1eb65", + "sha256_in_prefix": "7bd338c5a475d1101064603d3baa5507446d3c5e73f741f6d6e77c6204c1eb65", + "size_in_bytes": 9656 + }, + { + "_path": "lib/python3.12/gzip.py", + "path_type": "hardlink", + "sha256": "31e7275c5c20d1b414063c28088b68e7a3e657af60c9c23435bf92e77a1fd1e5", + "sha256_in_prefix": "31e7275c5c20d1b414063c28088b68e7a3e657af60c9c23435bf92e77a1fd1e5", + "size_in_bytes": 24859 + }, + { + "_path": "lib/python3.12/hashlib.py", + "path_type": "hardlink", + "sha256": "6dbdebf270868b391080e21dc9687eddfaf321c965ad979f68d3f5c423c613ab", + "sha256_in_prefix": "6dbdebf270868b391080e21dc9687eddfaf321c965ad979f68d3f5c423c613ab", + "size_in_bytes": 9349 + }, + { + "_path": "lib/python3.12/heapq.py", + "path_type": "hardlink", + "sha256": "6d43277e5c76fc0f073cd388fcff852d14d068f6bb6d4886c340f8b75a1229a9", + "sha256_in_prefix": "6d43277e5c76fc0f073cd388fcff852d14d068f6bb6d4886c340f8b75a1229a9", + "size_in_bytes": 23024 + }, + { + "_path": "lib/python3.12/hmac.py", + "path_type": "hardlink", + "sha256": "7facd1330e5487ed995eda5c8619df0d3e32f69cb619f97662372fb76325746e", + "sha256_in_prefix": "7facd1330e5487ed995eda5c8619df0d3e32f69cb619f97662372fb76325746e", + "size_in_bytes": 7716 + }, + { + "_path": "lib/python3.12/html/__init__.py", + "path_type": "hardlink", + "sha256": "923d82d821e75e8d235392c10c145ab8587927b3faf9c952bbd48081eebd8522", + "sha256_in_prefix": "923d82d821e75e8d235392c10c145ab8587927b3faf9c952bbd48081eebd8522", + "size_in_bytes": 4775 + }, + { + "_path": "lib/python3.12/html/__pycache__/__init__.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "27a9f4abcab000805753e31b11e0d9819d447ab979730426a9e281658dfd9973", + "sha256_in_prefix": "27a9f4abcab000805753e31b11e0d9819d447ab979730426a9e281658dfd9973", + "size_in_bytes": 4640 + }, + { + "_path": "lib/python3.12/html/__pycache__/entities.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "fb040d9f9f6d0cf40d49e15d5c0b560b18910f60e3d29329babd6dc0238da1fd", + "sha256_in_prefix": "fb040d9f9f6d0cf40d49e15d5c0b560b18910f60e3d29329babd6dc0238da1fd", + "size_in_bytes": 97924 + }, + { + "_path": "lib/python3.12/html/__pycache__/parser.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "de91b6f3128fe780b0f78c3d2bea6fbdc807876d1077fd0c96542620b5154187", + "sha256_in_prefix": "de91b6f3128fe780b0f78c3d2bea6fbdc807876d1077fd0c96542620b5154187", + "size_in_bytes": 17412 + }, + { + "_path": "lib/python3.12/html/entities.py", + "path_type": "hardlink", + "sha256": "d9c65fb2828dbc1f3e399058a341d51e9375ec5bca95a8e92599c41bd5b78bde", + "sha256_in_prefix": "d9c65fb2828dbc1f3e399058a341d51e9375ec5bca95a8e92599c41bd5b78bde", + "size_in_bytes": 75512 + }, + { + "_path": "lib/python3.12/html/parser.py", + "path_type": "hardlink", + "sha256": "ab5a0a2fce2bec75d969dbe057b490ef574f9ac57cce9e0eaaf7a220b301e838", + "sha256_in_prefix": "ab5a0a2fce2bec75d969dbe057b490ef574f9ac57cce9e0eaaf7a220b301e838", + "size_in_bytes": 17054 + }, + { + "_path": "lib/python3.12/http/__init__.py", + "path_type": "hardlink", + "sha256": "17f4f6832cfc84b5b9600414bab80b77e67ccb611bdfed10a3f2beca9d0d568b", + "sha256_in_prefix": "17f4f6832cfc84b5b9600414bab80b77e67ccb611bdfed10a3f2beca9d0d568b", + "size_in_bytes": 8308 + }, + { + "_path": "lib/python3.12/http/__pycache__/__init__.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "c1074e91a8d6e177cbfa17d94b2b6854158d23b4c90a9121f46b8f275c36744e", + "sha256_in_prefix": "c1074e91a8d6e177cbfa17d94b2b6854158d23b4c90a9121f46b8f275c36744e", + "size_in_bytes": 9741 + }, + { + "_path": "lib/python3.12/http/__pycache__/client.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "3a48694c8c52526a3bc95975a5c4b1e04921ff183fdf6453e6da9f1ee5106c80", + "sha256_in_prefix": "3a48694c8c52526a3bc95975a5c4b1e04921ff183fdf6453e6da9f1ee5106c80", + "size_in_bytes": 57109 + }, + { + "_path": "lib/python3.12/http/__pycache__/cookiejar.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "b6d72faef8ac4058330fa4407d120732b7064d3b19bb566035ba5a0c2ade3e31", + "sha256_in_prefix": "b6d72faef8ac4058330fa4407d120732b7064d3b19bb566035ba5a0c2ade3e31", + "size_in_bytes": 81869 + }, + { + "_path": "lib/python3.12/http/__pycache__/cookies.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "1eacfed315b7d1100d26734dff9a0755200b3034efa79ea8e612d3b450ca9d6f", + "sha256_in_prefix": "1eacfed315b7d1100d26734dff9a0755200b3034efa79ea8e612d3b450ca9d6f", + "size_in_bytes": 21786 + }, + { + "_path": "lib/python3.12/http/__pycache__/server.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "7c8314e75d18641892a523b73be9a37bff788a751ea9f871e3bc8919970cadcf", + "sha256_in_prefix": "7c8314e75d18641892a523b73be9a37bff788a751ea9f871e3bc8919970cadcf", + "size_in_bytes": 55855 + }, + { + "_path": "lib/python3.12/http/client.py", + "path_type": "hardlink", + "sha256": "66eabd4953a4a63589bb1067264405ecdbf7392836d0e65d17ed4619d3a21689", + "sha256_in_prefix": "66eabd4953a4a63589bb1067264405ecdbf7392836d0e65d17ed4619d3a21689", + "size_in_bytes": 57080 + }, + { + "_path": "lib/python3.12/http/cookiejar.py", + "path_type": "hardlink", + "sha256": "2a64dbc46edd0173600f32d195531741de562522da28bc76c2f97dccceb37ddb", + "sha256_in_prefix": "2a64dbc46edd0173600f32d195531741de562522da28bc76c2f97dccceb37ddb", + "size_in_bytes": 77438 + }, + { + "_path": "lib/python3.12/http/cookies.py", + "path_type": "hardlink", + "sha256": "a4712e985f8d892e290e8317d0d4d692313a39d5b0bd22fc640b885a79043ff7", + "sha256_in_prefix": "a4712e985f8d892e290e8317d0d4d692313a39d5b0bd22fc640b885a79043ff7", + "size_in_bytes": 20482 + }, + { + "_path": "lib/python3.12/http/server.py", + "path_type": "hardlink", + "sha256": "6ef28116c245a8e5e7f2d57f17607b7df706fd86110cf1c5a2b8416151b41248", + "sha256_in_prefix": "6ef28116c245a8e5e7f2d57f17607b7df706fd86110cf1c5a2b8416151b41248", + "size_in_bytes": 48516 + }, + { + "_path": "lib/python3.12/idlelib/CREDITS.txt", + "path_type": "hardlink", + "sha256": "33e6a36056667d40e26f195c14371567470f53324c3fec43aec29e09d7d2a60b", + "sha256_in_prefix": "33e6a36056667d40e26f195c14371567470f53324c3fec43aec29e09d7d2a60b", + "size_in_bytes": 2152 + }, + { + "_path": "lib/python3.12/idlelib/ChangeLog", + "path_type": "hardlink", + "sha256": "b7f42699e5e5a7c82ebdf2a2962946b7228c933ece0ea7c0d7789f21a7dd7e64", + "sha256_in_prefix": "b7f42699e5e5a7c82ebdf2a2962946b7228c933ece0ea7c0d7789f21a7dd7e64", + "size_in_bytes": 56360 + }, + { + "_path": "lib/python3.12/idlelib/HISTORY.txt", + "path_type": "hardlink", + "sha256": "531067a78ad392f25631aba1d885f40786cf5f47854577162c9f90ff1f33164c", + "sha256_in_prefix": "531067a78ad392f25631aba1d885f40786cf5f47854577162c9f90ff1f33164c", + "size_in_bytes": 10312 + }, + { + "_path": "lib/python3.12/idlelib/Icons/README.txt", + "path_type": "hardlink", + "sha256": "60399d6129e3e486ce6b437bbf614ff4838bd4e7f42d461c3e5467cf3b4fa272", + "sha256_in_prefix": "60399d6129e3e486ce6b437bbf614ff4838bd4e7f42d461c3e5467cf3b4fa272", + "size_in_bytes": 443 + }, + { + "_path": "lib/python3.12/idlelib/Icons/folder.gif", + "path_type": "hardlink", + "sha256": "7c98d566a13fd599d1c11a375f387fef69b6c595c4f18c5d88c188a860be0e55", + "sha256_in_prefix": "7c98d566a13fd599d1c11a375f387fef69b6c595c4f18c5d88c188a860be0e55", + "size_in_bytes": 120 + }, + { + "_path": "lib/python3.12/idlelib/Icons/idle.ico", + "path_type": "hardlink", + "sha256": "7f13eeb5dca39d05e24b9eb069c6dcb2748633822d67288a8bf8b7e21cdddf55", + "sha256_in_prefix": "7f13eeb5dca39d05e24b9eb069c6dcb2748633822d67288a8bf8b7e21cdddf55", + "size_in_bytes": 57746 + }, + { + "_path": "lib/python3.12/idlelib/Icons/idle_16.gif", + "path_type": "hardlink", + "sha256": "fe3af292b38660a8a58b1a8b4fa4240aa190602e7e9a700ea0536b3181fc968e", + "sha256_in_prefix": "fe3af292b38660a8a58b1a8b4fa4240aa190602e7e9a700ea0536b3181fc968e", + "size_in_bytes": 634 + }, + { + "_path": "lib/python3.12/idlelib/Icons/idle_16.png", + "path_type": "hardlink", + "sha256": "78fb3fb0ec11f61bc6cf0947f3c3923aa18e1c6513684058ed0fa01ac858143e", + "sha256_in_prefix": "78fb3fb0ec11f61bc6cf0947f3c3923aa18e1c6513684058ed0fa01ac858143e", + "size_in_bytes": 1031 + }, + { + "_path": "lib/python3.12/idlelib/Icons/idle_256.png", + "path_type": "hardlink", + "sha256": "3f517467d12e0e3ecf20f9bd68ce4bd18a2b8088f32308fd978fd80e87d3628b", + "sha256_in_prefix": "3f517467d12e0e3ecf20f9bd68ce4bd18a2b8088f32308fd978fd80e87d3628b", + "size_in_bytes": 39205 + }, + { + "_path": "lib/python3.12/idlelib/Icons/idle_32.gif", + "path_type": "hardlink", + "sha256": "fe70991cfccd1267922e94d91e02e9a58d2d29fd3382a2f4975280b9023cb7b9", + "sha256_in_prefix": "fe70991cfccd1267922e94d91e02e9a58d2d29fd3382a2f4975280b9023cb7b9", + "size_in_bytes": 1019 + }, + { + "_path": "lib/python3.12/idlelib/Icons/idle_32.png", + "path_type": "hardlink", + "sha256": "797cd05f1964d57c4c6c248ac7f7ea6a38019ada32a9ab7e6c28d060f87b03de", + "sha256_in_prefix": "797cd05f1964d57c4c6c248ac7f7ea6a38019ada32a9ab7e6c28d060f87b03de", + "size_in_bytes": 2036 + }, + { + "_path": "lib/python3.12/idlelib/Icons/idle_48.gif", + "path_type": "hardlink", + "sha256": "37484901eb40eefa846308e1da3ff6f240ea98f769a2afc3cf4fdba00327ecbe", + "sha256_in_prefix": "37484901eb40eefa846308e1da3ff6f240ea98f769a2afc3cf4fdba00327ecbe", + "size_in_bytes": 1388 + }, + { + "_path": "lib/python3.12/idlelib/Icons/idle_48.png", + "path_type": "hardlink", + "sha256": "a09f433197c8870b12bb7859cc4c3fe2068908cb1ddbd4880ab0f6fee91b6c23", + "sha256_in_prefix": "a09f433197c8870b12bb7859cc4c3fe2068908cb1ddbd4880ab0f6fee91b6c23", + "size_in_bytes": 3977 + }, + { + "_path": "lib/python3.12/idlelib/Icons/minusnode.gif", + "path_type": "hardlink", + "sha256": "efa5aa1d1e3439ab85425bd2aa3a25b9e6c21309e672690cfb32219e1eb7a7f3", + "sha256_in_prefix": "efa5aa1d1e3439ab85425bd2aa3a25b9e6c21309e672690cfb32219e1eb7a7f3", + "size_in_bytes": 75 + }, + { + "_path": "lib/python3.12/idlelib/Icons/openfolder.gif", + "path_type": "hardlink", + "sha256": "9a59e2abf1840156e9db8f85a38822fd56ab79a139eb95ec86f1fba1bb87326b", + "sha256_in_prefix": "9a59e2abf1840156e9db8f85a38822fd56ab79a139eb95ec86f1fba1bb87326b", + "size_in_bytes": 125 + }, + { + "_path": "lib/python3.12/idlelib/Icons/plusnode.gif", + "path_type": "hardlink", + "sha256": "6ace9e90a2bcb16d06c4d78837137f2c14bc26b3bd9f24b7b6afeadb689bdafb", + "sha256_in_prefix": "6ace9e90a2bcb16d06c4d78837137f2c14bc26b3bd9f24b7b6afeadb689bdafb", + "size_in_bytes": 78 + }, + { + "_path": "lib/python3.12/idlelib/Icons/python.gif", + "path_type": "hardlink", + "sha256": "158c31382f8e5b41fded0c2aa9cc66a382928b003cdd8b5b0518836ad9c89377", + "sha256_in_prefix": "158c31382f8e5b41fded0c2aa9cc66a382928b003cdd8b5b0518836ad9c89377", + "size_in_bytes": 380 + }, + { + "_path": "lib/python3.12/idlelib/Icons/tk.gif", + "path_type": "hardlink", + "sha256": "7f16cb2e322891dbd9101302c09ffda0c2a3a72d053bb8c0927d507414c59cad", + "sha256_in_prefix": "7f16cb2e322891dbd9101302c09ffda0c2a3a72d053bb8c0927d507414c59cad", + "size_in_bytes": 72 + }, + { + "_path": "lib/python3.12/idlelib/NEWS2x.txt", + "path_type": "hardlink", + "sha256": "c89a3b513501ebace8e428aea68dce39d0af9f29196e08fc9ea49c99605e79e7", + "sha256_in_prefix": "c89a3b513501ebace8e428aea68dce39d0af9f29196e08fc9ea49c99605e79e7", + "size_in_bytes": 27172 + }, + { + "_path": "lib/python3.12/idlelib/News3.txt", + "path_type": "hardlink", + "sha256": "5b20beec21d162146baefd500b56821250472923c3fa75ee15e794b88c505ba3", + "sha256_in_prefix": "5b20beec21d162146baefd500b56821250472923c3fa75ee15e794b88c505ba3", + "size_in_bytes": 55514 + }, + { + "_path": "lib/python3.12/idlelib/README.txt", + "path_type": "hardlink", + "sha256": "4f2dc8ffdbfc7837b60edc32ac2f593a220f4abf0ea00cc477382ad8ecf8eb3d", + "sha256_in_prefix": "4f2dc8ffdbfc7837b60edc32ac2f593a220f4abf0ea00cc477382ad8ecf8eb3d", + "size_in_bytes": 11653 + }, + { + "_path": "lib/python3.12/idlelib/TODO.txt", + "path_type": "hardlink", + "sha256": "f88e0fb30fa0ab5d0dc3030442ed92713f34170336c4dd2623723dc34829df89", + "sha256_in_prefix": "f88e0fb30fa0ab5d0dc3030442ed92713f34170336c4dd2623723dc34829df89", + "size_in_bytes": 8478 + }, + { + "_path": "lib/python3.12/idlelib/__init__.py", + "path_type": "hardlink", + "sha256": "3f8058df4fec56eb20ff67ff84c86fd3d9697e2384c5a290ed696f6d3187aa45", + "sha256_in_prefix": "3f8058df4fec56eb20ff67ff84c86fd3d9697e2384c5a290ed696f6d3187aa45", + "size_in_bytes": 396 + }, + { + "_path": "lib/python3.12/idlelib/__main__.py", + "path_type": "hardlink", + "sha256": "f8f55514d26791588de02fe685af0ab129174b32ab93efa39faf6140b6795d9d", + "sha256_in_prefix": "f8f55514d26791588de02fe685af0ab129174b32ab93efa39faf6140b6795d9d", + "size_in_bytes": 159 + }, + { + "_path": "lib/python3.12/idlelib/__pycache__/__init__.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "6b0c2c70b7f2d7ab94e67c2054ea7aed7422e33f675a368d9ad1d02cee414432", + "sha256_in_prefix": "6b0c2c70b7f2d7ab94e67c2054ea7aed7422e33f675a368d9ad1d02cee414432", + "size_in_bytes": 773 + }, + { + "_path": "lib/python3.12/idlelib/__pycache__/__main__.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "46698841c8537180804c54ab96aa2ba64fc71e2e264a345427b4eb3758ade196", + "sha256_in_prefix": "46698841c8537180804c54ab96aa2ba64fc71e2e264a345427b4eb3758ade196", + "size_in_bytes": 588 + }, + { + "_path": "lib/python3.12/idlelib/__pycache__/autocomplete.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "a35caf158a9a66c2a69b4279cf11097abce89f639b6586a756c36935679c3f45", + "sha256_in_prefix": "a35caf158a9a66c2a69b4279cf11097abce89f639b6586a756c36935679c3f45", + "size_in_bytes": 11172 + }, + { + "_path": "lib/python3.12/idlelib/__pycache__/autocomplete_w.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "3504db39560ea3a31217c4f2f1e23626d42d3a192bddda7a8aba0eb28ba89dad", + "sha256_in_prefix": "3504db39560ea3a31217c4f2f1e23626d42d3a192bddda7a8aba0eb28ba89dad", + "size_in_bytes": 23970 + }, + { + "_path": "lib/python3.12/idlelib/__pycache__/autoexpand.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "0535a58590113a8e214fdc28d19f041bd7195ed5c239b6ae8e8debd318704784", + "sha256_in_prefix": "0535a58590113a8e214fdc28d19f041bd7195ed5c239b6ae8e8debd318704784", + "size_in_bytes": 4808 + }, + { + "_path": "lib/python3.12/idlelib/__pycache__/browser.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "ef8b0e0a2004d78af666ca17c7ef5c41afe80c1943d1522457ad5d77f4188800", + "sha256_in_prefix": "ef8b0e0a2004d78af666ca17c7ef5c41afe80c1943d1522457ad5d77f4188800", + "size_in_bytes": 13586 + }, + { + "_path": "lib/python3.12/idlelib/__pycache__/calltip.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "6c404867cba69e6dd66de130ac7b98649e541332b5301811fd4524b5b856bf9f", + "sha256_in_prefix": "6c404867cba69e6dd66de130ac7b98649e541332b5301811fd4524b5b856bf9f", + "size_in_bytes": 8618 + }, + { + "_path": "lib/python3.12/idlelib/__pycache__/calltip_w.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "fb8fb29e33445a5aa41fd4b0e6368ac17dcb0ad1138c93f486033d9fd0f76075", + "sha256_in_prefix": "fb8fb29e33445a5aa41fd4b0e6368ac17dcb0ad1138c93f486033d9fd0f76075", + "size_in_bytes": 10536 + }, + { + "_path": "lib/python3.12/idlelib/__pycache__/codecontext.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "0158e91c94c074f8e94cbbc200b456ca817017050b7987bffc9f3e9b0e39c204", + "sha256_in_prefix": "0158e91c94c074f8e94cbbc200b456ca817017050b7987bffc9f3e9b0e39c204", + "size_in_bytes": 13819 + }, + { + "_path": "lib/python3.12/idlelib/__pycache__/colorizer.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "d12dadc17f5943aa9b565cbf3143e44a8a5ed3974316c8f546e85bdcfbbbb293", + "sha256_in_prefix": "d12dadc17f5943aa9b565cbf3143e44a8a5ed3974316c8f546e85bdcfbbbb293", + "size_in_bytes": 17957 + }, + { + "_path": "lib/python3.12/idlelib/__pycache__/config.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "bb5bc739027a050ab2851918c06d22d522725ef7a4c0f4943cb97b94c04bd7aa", + "sha256_in_prefix": "bb5bc739027a050ab2851918c06d22d522725ef7a4c0f4943cb97b94c04bd7aa", + "size_in_bytes": 41737 + }, + { + "_path": "lib/python3.12/idlelib/__pycache__/config_key.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "c06207e48a4228c5c82566c4484c6f51f9f623b27331b85b6539cf1515d9fd86", + "sha256_in_prefix": "c06207e48a4228c5c82566c4484c6f51f9f623b27331b85b6539cf1515d9fd86", + "size_in_bytes": 20143 + }, + { + "_path": "lib/python3.12/idlelib/__pycache__/configdialog.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "8b256de4f6a746611a98604a3c6f093fd191c8d437a47afbce0e39b06808beda", + "sha256_in_prefix": "8b256de4f6a746611a98604a3c6f093fd191c8d437a47afbce0e39b06808beda", + "size_in_bytes": 125619 + }, + { + "_path": "lib/python3.12/idlelib/__pycache__/debugger.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "eb65fbce904a01cbac5fd88bbd6d72eeb2245d4066907f6bb4332f5617669b6c", + "sha256_in_prefix": "eb65fbce904a01cbac5fd88bbd6d72eeb2245d4066907f6bb4332f5617669b6c", + "size_in_bytes": 28441 + }, + { + "_path": "lib/python3.12/idlelib/__pycache__/debugger_r.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "63eb0f79966cbae14e97cc4f3badd1c82bc6f1485e5cd7978330e5a8cc46db9e", + "sha256_in_prefix": "63eb0f79966cbae14e97cc4f3badd1c82bc6f1485e5cd7978330e5a8cc46db9e", + "size_in_bytes": 19029 + }, + { + "_path": "lib/python3.12/idlelib/__pycache__/debugobj.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "68c6738f290b14937d6cd95f33d66f036593e961c1a7fd9a4f0259be0f81b26f", + "sha256_in_prefix": "68c6738f290b14937d6cd95f33d66f036593e961c1a7fd9a4f0259be0f81b26f", + "size_in_bytes": 7845 + }, + { + "_path": "lib/python3.12/idlelib/__pycache__/debugobj_r.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "12289ea765f3a49e28bdd345c28eb61cc65b73645a91b40561afd4eac4a1a6c4", + "sha256_in_prefix": "12289ea765f3a49e28bdd345c28eb61cc65b73645a91b40561afd4eac4a1a6c4", + "size_in_bytes": 2777 + }, + { + "_path": "lib/python3.12/idlelib/__pycache__/delegator.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "7ebea8ddd943d4e8c1525c2a94fb82e2631905fdfc0a373e46e30ea07fa67e6b", + "sha256_in_prefix": "7ebea8ddd943d4e8c1525c2a94fb82e2631905fdfc0a373e46e30ea07fa67e6b", + "size_in_bytes": 1983 + }, + { + "_path": "lib/python3.12/idlelib/__pycache__/dynoption.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "cca26d654c8393300da14bd9f2db72275d816b53912485bd93e8d8b027c4bc83", + "sha256_in_prefix": "cca26d654c8393300da14bd9f2db72275d816b53912485bd93e8d8b027c4bc83", + "size_in_bytes": 3512 + }, + { + "_path": "lib/python3.12/idlelib/__pycache__/editor.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "6c6989b6c9cd42e563fdc31079465996cf51ba6121fb9d3052f548cc4c00cffd", + "sha256_in_prefix": "6c6989b6c9cd42e563fdc31079465996cf51ba6121fb9d3052f548cc4c00cffd", + "size_in_bytes": 86598 + }, + { + "_path": "lib/python3.12/idlelib/__pycache__/filelist.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "bfe3e4bcd644c759ed84f663ce1ad00b12022d7d5830b5e560d6980593696f07", + "sha256_in_prefix": "bfe3e4bcd644c759ed84f663ce1ad00b12022d7d5830b5e560d6980593696f07", + "size_in_bytes": 5900 + }, + { + "_path": "lib/python3.12/idlelib/__pycache__/format.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "249356cdf01a23f557645199175398901e2506ecd1d5de2949f68f78dddf00cb", + "sha256_in_prefix": "249356cdf01a23f557645199175398901e2506ecd1d5de2949f68f78dddf00cb", + "size_in_bytes": 20985 + }, + { + "_path": "lib/python3.12/idlelib/__pycache__/grep.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "4f3dab06dd194ec3eae41f0ae692c98d697ec12cea5537e467cab0c2b81bd0b1", + "sha256_in_prefix": "4f3dab06dd194ec3eae41f0ae692c98d697ec12cea5537e467cab0c2b81bd0b1", + "size_in_bytes": 11441 + }, + { + "_path": "lib/python3.12/idlelib/__pycache__/help.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "73d4e8719b18b3f9afda4aec1eaa0aa80824410d2bea7500cdd0b466ae7ace46", + "sha256_in_prefix": "73d4e8719b18b3f9afda4aec1eaa0aa80824410d2bea7500cdd0b466ae7ace46", + "size_in_bytes": 16492 + }, + { + "_path": "lib/python3.12/idlelib/__pycache__/help_about.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "e41226f873790f2dd1115117d4d8d15217f29216e51caccda71505f8def95e83", + "sha256_in_prefix": "e41226f873790f2dd1115117d4d8d15217f29216e51caccda71505f8def95e83", + "size_in_bytes": 12922 + }, + { + "_path": "lib/python3.12/idlelib/__pycache__/history.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "eb25d0ba512daa159d07741ef5df34d5d8cab0012d058f23f5d1df808c00775b", + "sha256_in_prefix": "eb25d0ba512daa159d07741ef5df34d5d8cab0012d058f23f5d1df808c00775b", + "size_in_bytes": 5436 + }, + { + "_path": "lib/python3.12/idlelib/__pycache__/hyperparser.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "dff36fd84f5c24a6ec1a2a5e04e758e6c6a428b6631148556969683fc690d652", + "sha256_in_prefix": "dff36fd84f5c24a6ec1a2a5e04e758e6c6a428b6631148556969683fc690d652", + "size_in_bytes": 12491 + }, + { + "_path": "lib/python3.12/idlelib/__pycache__/idle.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "aa2fb9c4b153a7234021f93ed48117605e6ad9333cce4c59d0c21ac8310e7fa7", + "sha256_in_prefix": "aa2fb9c4b153a7234021f93ed48117605e6ad9333cce4c59d0c21ac8310e7fa7", + "size_in_bytes": 861 + }, + { + "_path": "lib/python3.12/idlelib/__pycache__/iomenu.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "46c685dc1ca1deb646245c64537a5dc92e28a464a40da2d6b4e68111ed9d8a0b", + "sha256_in_prefix": "46c685dc1ca1deb646245c64537a5dc92e28a464a40da2d6b4e68111ed9d8a0b", + "size_in_bytes": 21597 + }, + { + "_path": "lib/python3.12/idlelib/__pycache__/macosx.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "0fdb3c624f5bf8d729b6678a997ce9201e99efd294db1879c131810d983f1a67", + "sha256_in_prefix": "0fdb3c624f5bf8d729b6678a997ce9201e99efd294db1879c131810d983f1a67", + "size_in_bytes": 10019 + }, + { + "_path": "lib/python3.12/idlelib/__pycache__/mainmenu.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "e8b41a87cb2d9cd87938fecfb41d9b2a0ec8feef0e52dd05feae190cdb748b05", + "sha256_in_prefix": "e8b41a87cb2d9cd87938fecfb41d9b2a0ec8feef0e52dd05feae190cdb748b05", + "size_in_bytes": 3788 + }, + { + "_path": "lib/python3.12/idlelib/__pycache__/multicall.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "3a7f5127aed49232e5c587ceef688afbb48345c0aa611c2210ff93653826a21b", + "sha256_in_prefix": "3a7f5127aed49232e5c587ceef688afbb48345c0aa611c2210ff93653826a21b", + "size_in_bytes": 22033 + }, + { + "_path": "lib/python3.12/idlelib/__pycache__/outwin.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "78cb9c9af59f40491b60b830849a2ddd60bf7dc9faa8e08fd3aee1a0cf684607", + "sha256_in_prefix": "78cb9c9af59f40491b60b830849a2ddd60bf7dc9faa8e08fd3aee1a0cf684607", + "size_in_bytes": 7950 + }, + { + "_path": "lib/python3.12/idlelib/__pycache__/parenmatch.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "c6c496c42cb8d2d250411b4dd6418d288c7a2b21c774d6c882658168acd2787d", + "sha256_in_prefix": "c6c496c42cb8d2d250411b4dd6418d288c7a2b21c774d6c882658168acd2787d", + "size_in_bytes": 9792 + }, + { + "_path": "lib/python3.12/idlelib/__pycache__/pathbrowser.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "e9816e1a01011fce9a7b96bbf13daccbb29453827d33891c9e355e675e641d8b", + "sha256_in_prefix": "e9816e1a01011fce9a7b96bbf13daccbb29453827d33891c9e355e675e641d8b", + "size_in_bytes": 5909 + }, + { + "_path": "lib/python3.12/idlelib/__pycache__/percolator.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "71e89853c0168788c4f82612972355def0d8eace5f78c92c4215c42d76a4a867", + "sha256_in_prefix": "71e89853c0168788c4f82612972355def0d8eace5f78c92c4215c42d76a4a867", + "size_in_bytes": 7120 + }, + { + "_path": "lib/python3.12/idlelib/__pycache__/pyparse.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "e07814f987df5d4873d27ce364cc7a03abadaa35cb3f8b96ecfc49b302723ca6", + "sha256_in_prefix": "e07814f987df5d4873d27ce364cc7a03abadaa35cb3f8b96ecfc49b302723ca6", + "size_in_bytes": 18327 + }, + { + "_path": "lib/python3.12/idlelib/__pycache__/pyshell.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "d01355674fdc6ce49ba0020082e8c2f48159723f71ee583c3ae3e0b0cd22c6b8", + "sha256_in_prefix": "d01355674fdc6ce49ba0020082e8c2f48159723f71ee583c3ae3e0b0cd22c6b8", + "size_in_bytes": 81534 + }, + { + "_path": "lib/python3.12/idlelib/__pycache__/query.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "7bdb2c1b38863fd205ebc55d6cc702656a3f5a551d9b2c7cc84c90a3590972e5", + "sha256_in_prefix": "7bdb2c1b38863fd205ebc55d6cc702656a3f5a551d9b2c7cc84c90a3590972e5", + "size_in_bytes": 19774 + }, + { + "_path": "lib/python3.12/idlelib/__pycache__/redirector.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "05cc71ac182e1a791a4b02879513c45c0b55b781dff93f139f200251700957c6", + "sha256_in_prefix": "05cc71ac182e1a791a4b02879513c45c0b55b781dff93f139f200251700957c6", + "size_in_bytes": 9165 + }, + { + "_path": "lib/python3.12/idlelib/__pycache__/replace.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "2d95133ac8c0f3805c83f8ff995d31e846029572d25a889aa1a22b05bb0a7a66", + "sha256_in_prefix": "2d95133ac8c0f3805c83f8ff995d31e846029572d25a889aa1a22b05bb0a7a66", + "size_in_bytes": 14501 + }, + { + "_path": "lib/python3.12/idlelib/__pycache__/rpc.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "b98373b05e738f886c605d4c918987dd162177c87d8596b940961d817dcc3b8e", + "sha256_in_prefix": "b98373b05e738f886c605d4c918987dd162177c87d8596b940961d817dcc3b8e", + "size_in_bytes": 30270 + }, + { + "_path": "lib/python3.12/idlelib/__pycache__/run.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "a2493f68a6a128da2292ed778a2b6da6083892753f31f2ba2d905e768edf560f", + "sha256_in_prefix": "a2493f68a6a128da2292ed778a2b6da6083892753f31f2ba2d905e768edf560f", + "size_in_bytes": 29751 + }, + { + "_path": "lib/python3.12/idlelib/__pycache__/runscript.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "e75348273e7735ab43d5316cbe0bc4871698855c081de03adccde3a4ec826706", + "sha256_in_prefix": "e75348273e7735ab43d5316cbe0bc4871698855c081de03adccde3a4ec826706", + "size_in_bytes": 11170 + }, + { + "_path": "lib/python3.12/idlelib/__pycache__/scrolledlist.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "8d9983e2116eb9fc01981371f0e7723b0f4c019eacfd4f2fd3d3aa0974ccfe3c", + "sha256_in_prefix": "8d9983e2116eb9fc01981371f0e7723b0f4c019eacfd4f2fd3d3aa0974ccfe3c", + "size_in_bytes": 9271 + }, + { + "_path": "lib/python3.12/idlelib/__pycache__/search.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "497b4ad7b3bb1e0b02eb286f8d14db4e1632250b4d4f7c5ff89b6438f62fd082", + "sha256_in_prefix": "497b4ad7b3bb1e0b02eb286f8d14db4e1632250b4d4f7c5ff89b6438f62fd082", + "size_in_bytes": 8293 + }, + { + "_path": "lib/python3.12/idlelib/__pycache__/searchbase.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "88c1e4084b6dd3552eae1e8863f25a016efee714b2350364cf1f3cd700affe17", + "sha256_in_prefix": "88c1e4084b6dd3552eae1e8863f25a016efee714b2350364cf1f3cd700affe17", + "size_in_bytes": 12451 + }, + { + "_path": "lib/python3.12/idlelib/__pycache__/searchengine.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "4a7f3b6c4c8121812ea49df810d95b3dd811ca50b3420e9534c9d77a9e12d27f", + "sha256_in_prefix": "4a7f3b6c4c8121812ea49df810d95b3dd811ca50b3420e9534c9d77a9e12d27f", + "size_in_bytes": 10216 + }, + { + "_path": "lib/python3.12/idlelib/__pycache__/sidebar.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "a8ea9d170266b187f50096b72dd0504ed89e33fb977fe77e658d2b7dc0cddba6", + "sha256_in_prefix": "a8ea9d170266b187f50096b72dd0504ed89e33fb977fe77e658d2b7dc0cddba6", + "size_in_bytes": 29047 + }, + { + "_path": "lib/python3.12/idlelib/__pycache__/squeezer.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "25472aae8ec35b47381762d3eda9356f1f65965e6564fc12401a802608267f1f", + "sha256_in_prefix": "25472aae8ec35b47381762d3eda9356f1f65965e6564fc12401a802608267f1f", + "size_in_bytes": 14747 + }, + { + "_path": "lib/python3.12/idlelib/__pycache__/stackviewer.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "2d9e249579d125a1686ce49ee5fb309c78779826fe74a1e4bc495ad9a99370bb", + "sha256_in_prefix": "2d9e249579d125a1686ce49ee5fb309c78779826fe74a1e4bc495ad9a99370bb", + "size_in_bytes": 7498 + }, + { + "_path": "lib/python3.12/idlelib/__pycache__/statusbar.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "93721fdaac9e3c9dfa17e26a0f062e8ad1b3aebe450b1b869a31e2ba694b1a44", + "sha256_in_prefix": "93721fdaac9e3c9dfa17e26a0f062e8ad1b3aebe450b1b869a31e2ba694b1a44", + "size_in_bytes": 3201 + }, + { + "_path": "lib/python3.12/idlelib/__pycache__/textview.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "b74a514ce6260a989c8e1a33c0ab0a4e45dfc97347bdf3fa31a57c2c2b52a606", + "sha256_in_prefix": "b74a514ce6260a989c8e1a33c0ab0a4e45dfc97347bdf3fa31a57c2c2b52a606", + "size_in_bytes": 10137 + }, + { + "_path": "lib/python3.12/idlelib/__pycache__/tooltip.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "707f7136079b8861e0028fe87ef033f9d6846e04aa0403f5d365334d7caeadc3", + "sha256_in_prefix": "707f7136079b8861e0028fe87ef033f9d6846e04aa0403f5d365334d7caeadc3", + "size_in_bytes": 9671 + }, + { + "_path": "lib/python3.12/idlelib/__pycache__/tree.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "66f196e4bac7aaa7f36e7d35637f26a9a0ce042c9a28b9aab415376827a845f1", + "sha256_in_prefix": "66f196e4bac7aaa7f36e7d35637f26a9a0ce042c9a28b9aab415376827a845f1", + "size_in_bytes": 28354 + }, + { + "_path": "lib/python3.12/idlelib/__pycache__/undo.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "56a06f986b0c04e3283d1ab7b70b2c08d7d33ae1fca8965975f38fcf3288ad42", + "sha256_in_prefix": "56a06f986b0c04e3283d1ab7b70b2c08d7d33ae1fca8965975f38fcf3288ad42", + "size_in_bytes": 18725 + }, + { + "_path": "lib/python3.12/idlelib/__pycache__/util.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "d1ebdfc8feb5fa841025a3b3b89c7a12592b5aeb49cd9fac64345a9946afea1f", + "sha256_in_prefix": "d1ebdfc8feb5fa841025a3b3b89c7a12592b5aeb49cd9fac64345a9946afea1f", + "size_in_bytes": 1073 + }, + { + "_path": "lib/python3.12/idlelib/__pycache__/window.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "fa4d2785f7789adca17623e349159594d742a1d8dd79fad58e84a5cbcf009f98", + "sha256_in_prefix": "fa4d2785f7789adca17623e349159594d742a1d8dd79fad58e84a5cbcf009f98", + "size_in_bytes": 5118 + }, + { + "_path": "lib/python3.12/idlelib/__pycache__/zoomheight.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "776f4008cf98cb05a5940122b4a31e8d2f815f0f09b2e96dc8e702f93b15b7b7", + "sha256_in_prefix": "776f4008cf98cb05a5940122b4a31e8d2f815f0f09b2e96dc8e702f93b15b7b7", + "size_in_bytes": 4720 + }, + { + "_path": "lib/python3.12/idlelib/__pycache__/zzdummy.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "be162af4097c9768ceb6f743636b0dd89be63f99fdbe61c1e527014f0436fd9c", + "sha256_in_prefix": "be162af4097c9768ceb6f743636b0dd89be63f99fdbe61c1e527014f0436fd9c", + "size_in_bytes": 3524 + }, + { + "_path": "lib/python3.12/idlelib/autocomplete.py", + "path_type": "hardlink", + "sha256": "0d36f7694a50cbaa22d9bf03b91fa0658a147bd90dd867714a9b411febb36427", + "sha256_in_prefix": "0d36f7694a50cbaa22d9bf03b91fa0658a147bd90dd867714a9b411febb36427", + "size_in_bytes": 9354 + }, + { + "_path": "lib/python3.12/idlelib/autocomplete_w.py", + "path_type": "hardlink", + "sha256": "91170b060749d0b3c8f2ab31499104028bedf971e5575155d43392d5c8dae5d6", + "sha256_in_prefix": "91170b060749d0b3c8f2ab31499104028bedf971e5575155d43392d5c8dae5d6", + "size_in_bytes": 20863 + }, + { + "_path": "lib/python3.12/idlelib/autoexpand.py", + "path_type": "hardlink", + "sha256": "c8eb28ef7addf5a664a7e3addfbfebe29040a8695e1db515828305aacba2ee4e", + "sha256_in_prefix": "c8eb28ef7addf5a664a7e3addfbfebe29040a8695e1db515828305aacba2ee4e", + "size_in_bytes": 3216 + }, + { + "_path": "lib/python3.12/idlelib/browser.py", + "path_type": "hardlink", + "sha256": "b607102a6e2ff7de241744008144a5480e2925098694be2a46003d8f60da0f52", + "sha256_in_prefix": "b607102a6e2ff7de241744008144a5480e2925098694be2a46003d8f60da0f52", + "size_in_bytes": 8588 + }, + { + "_path": "lib/python3.12/idlelib/calltip.py", + "path_type": "hardlink", + "sha256": "3a723fdf88c0018dfadd19757142a643b01b785c6df17a50bbe21463663ab590", + "sha256_in_prefix": "3a723fdf88c0018dfadd19757142a643b01b785c6df17a50bbe21463663ab590", + "size_in_bytes": 7267 + }, + { + "_path": "lib/python3.12/idlelib/calltip_w.py", + "path_type": "hardlink", + "sha256": "077e9d0d95946296077d5c95f343e242a7d250a6efece4afc58759b5e984e6c3", + "sha256_in_prefix": "077e9d0d95946296077d5c95f343e242a7d250a6efece4afc58759b5e984e6c3", + "size_in_bytes": 7083 + }, + { + "_path": "lib/python3.12/idlelib/codecontext.py", + "path_type": "hardlink", + "sha256": "628a13325b3bf2f76dea9254b20178b3232261f83c660f0e33785e6215dd6492", + "sha256_in_prefix": "628a13325b3bf2f76dea9254b20178b3232261f83c660f0e33785e6215dd6492", + "size_in_bytes": 11420 + }, + { + "_path": "lib/python3.12/idlelib/colorizer.py", + "path_type": "hardlink", + "sha256": "4de77a632286cf7cb616a2cf50dcd16a99d452fe7b16bf94c34950be97f293c2", + "sha256_in_prefix": "4de77a632286cf7cb616a2cf50dcd16a99d452fe7b16bf94c34950be97f293c2", + "size_in_bytes": 14783 + }, + { + "_path": "lib/python3.12/idlelib/config-extensions.def", + "path_type": "hardlink", + "sha256": "e75df0b77ff61253be457af636d5eb7c55a3ff2b6a733beea844d2b294972ebf", + "sha256_in_prefix": "e75df0b77ff61253be457af636d5eb7c55a3ff2b6a733beea844d2b294972ebf", + "size_in_bytes": 2266 + }, + { + "_path": "lib/python3.12/idlelib/config-highlight.def", + "path_type": "hardlink", + "sha256": "609eada44ff4aa9d5cd10ad8b4c29bb76db8ebc74912a0ae86f5ea3cd19b7547", + "sha256_in_prefix": "609eada44ff4aa9d5cd10ad8b4c29bb76db8ebc74912a0ae86f5ea3cd19b7547", + "size_in_bytes": 2864 + }, + { + "_path": "lib/python3.12/idlelib/config-keys.def", + "path_type": "hardlink", + "sha256": "bee81ba5c5abec1e35e313268f8d8fe72d305d0ad73abfba3d2ea1e2b2308710", + "sha256_in_prefix": "bee81ba5c5abec1e35e313268f8d8fe72d305d0ad73abfba3d2ea1e2b2308710", + "size_in_bytes": 10910 + }, + { + "_path": "lib/python3.12/idlelib/config-main.def", + "path_type": "hardlink", + "sha256": "e783704ad5cd9b3f44c026f55c98be2c52190bf9b7832251283f3e953ba80f87", + "sha256_in_prefix": "e783704ad5cd9b3f44c026f55c98be2c52190bf9b7832251283f3e953ba80f87", + "size_in_bytes": 3168 + }, + { + "_path": "lib/python3.12/idlelib/config.py", + "path_type": "hardlink", + "sha256": "226d4259cf50e32bb1c2b76b90e6914a9d1790171363d82d1c4c47ed9673aa9b", + "sha256_in_prefix": "226d4259cf50e32bb1c2b76b90e6914a9d1790171363d82d1c4c47ed9673aa9b", + "size_in_bytes": 38387 + }, + { + "_path": "lib/python3.12/idlelib/config_key.py", + "path_type": "hardlink", + "sha256": "856bd4b2c1fd7275856d3869cad8975f7770edbf021a93c64816a41c2322c2fa", + "sha256_in_prefix": "856bd4b2c1fd7275856d3869cad8975f7770edbf021a93c64816a41c2322c2fa", + "size_in_bytes": 15230 + }, + { + "_path": "lib/python3.12/idlelib/configdialog.py", + "path_type": "hardlink", + "sha256": "68a6a9470476408acdce5e3a8816196e025f8cccd0845bf1da579db19a5bba8c", + "sha256_in_prefix": "68a6a9470476408acdce5e3a8816196e025f8cccd0845bf1da579db19a5bba8c", + "size_in_bytes": 105314 + }, + { + "_path": "lib/python3.12/idlelib/debugger.py", + "path_type": "hardlink", + "sha256": "6e595d5a388e46b6b6e24490e970a3d355ec116a16a064bfca6ed86d4b17dcb4", + "sha256_in_prefix": "6e595d5a388e46b6b6e24490e970a3d355ec116a16a064bfca6ed86d4b17dcb4", + "size_in_bytes": 20991 + }, + { + "_path": "lib/python3.12/idlelib/debugger_r.py", + "path_type": "hardlink", + "sha256": "ddc797740231f068ca7c7c8610e799d72ad11af670d9bc0b6f9e04fe2ba222d1", + "sha256_in_prefix": "ddc797740231f068ca7c7c8610e799d72ad11af670d9bc0b6f9e04fe2ba222d1", + "size_in_bytes": 12115 + }, + { + "_path": "lib/python3.12/idlelib/debugobj.py", + "path_type": "hardlink", + "sha256": "aae9e2468a3d05366480864dc56689c65896757faf3b0364b8eef9feb4876a43", + "sha256_in_prefix": "aae9e2468a3d05366480864dc56689c65896757faf3b0364b8eef9feb4876a43", + "size_in_bytes": 4177 + }, + { + "_path": "lib/python3.12/idlelib/debugobj_r.py", + "path_type": "hardlink", + "sha256": "4e583b43fdf9bd4a731d70e074ee597aba03f3c8c36302bdc7e74650fb1fcc11", + "sha256_in_prefix": "4e583b43fdf9bd4a731d70e074ee597aba03f3c8c36302bdc7e74650fb1fcc11", + "size_in_bytes": 1082 + }, + { + "_path": "lib/python3.12/idlelib/delegator.py", + "path_type": "hardlink", + "sha256": "c2b31919d27056fc3aaa8f4ef798fbdf162665175fa9216d665f58ba2e4a464d", + "sha256_in_prefix": "c2b31919d27056fc3aaa8f4ef798fbdf162665175fa9216d665f58ba2e4a464d", + "size_in_bytes": 1044 + }, + { + "_path": "lib/python3.12/idlelib/dynoption.py", + "path_type": "hardlink", + "sha256": "29933f56722b2efb5cf451825a7fe50f357983e68f6a261afdf89b52f778e488", + "sha256_in_prefix": "29933f56722b2efb5cf451825a7fe50f357983e68f6a261afdf89b52f778e488", + "size_in_bytes": 1993 + }, + { + "_path": "lib/python3.12/idlelib/editor.py", + "path_type": "hardlink", + "sha256": "694c8e8c109e4bba220ef2cb62d038c67060b224f9deb5db3237d73bed8c81ba", + "sha256_in_prefix": "694c8e8c109e4bba220ef2cb62d038c67060b224f9deb5db3237d73bed8c81ba", + "size_in_bytes": 69155 + }, + { + "_path": "lib/python3.12/idlelib/extend.txt", + "path_type": "hardlink", + "sha256": "5bceaf660c46faf8f9fbf2be5e23389d6e6477d1e458fee680e606bcc95d2853", + "sha256_in_prefix": "5bceaf660c46faf8f9fbf2be5e23389d6e6477d1e458fee680e606bcc95d2853", + "size_in_bytes": 3631 + }, + { + "_path": "lib/python3.12/idlelib/filelist.py", + "path_type": "hardlink", + "sha256": "64e194e4514141414ecb231ac165ed861749bb0d31d0758c7c3a823ce154abe1", + "sha256_in_prefix": "64e194e4514141414ecb231ac165ed861749bb0d31d0758c7c3a823ce154abe1", + "size_in_bytes": 3871 + }, + { + "_path": "lib/python3.12/idlelib/format.py", + "path_type": "hardlink", + "sha256": "dc2b00fb239f38543bf973d94daef2c52457b905d4d89c640993823127b7923c", + "sha256_in_prefix": "dc2b00fb239f38543bf973d94daef2c52457b905d4d89c640993823127b7923c", + "size_in_bytes": 15777 + }, + { + "_path": "lib/python3.12/idlelib/grep.py", + "path_type": "hardlink", + "sha256": "f5a9327c83e7aecec64efb81bf9f4542a4f3e0a13d0b6443e8eca5dfbb509835", + "sha256_in_prefix": "f5a9327c83e7aecec64efb81bf9f4542a4f3e0a13d0b6443e8eca5dfbb509835", + "size_in_bytes": 7526 + }, + { + "_path": "lib/python3.12/idlelib/help.html", + "path_type": "hardlink", + "sha256": "ac81ab586d33514ce0f303cf02d04bc9a2184569c82f4c85fed7c16b209e6dbb", + "sha256_in_prefix": "ac81ab586d33514ce0f303cf02d04bc9a2184569c82f4c85fed7c16b209e6dbb", + "size_in_bytes": 78525 + }, + { + "_path": "lib/python3.12/idlelib/help.py", + "path_type": "hardlink", + "sha256": "35f26243be00070246751349d864ffc576242b38aa559ed536e7b635819ea847", + "sha256_in_prefix": "35f26243be00070246751349d864ffc576242b38aa559ed536e7b635819ea847", + "size_in_bytes": 11902 + }, + { + "_path": "lib/python3.12/idlelib/help_about.py", + "path_type": "hardlink", + "sha256": "93aec712aa0f1899597c52697d859cf26c63163ee355e456f0e20b984dcfdfdf", + "sha256_in_prefix": "93aec712aa0f1899597c52697d859cf26c63163ee355e456f0e20b984dcfdfdf", + "size_in_bytes": 8910 + }, + { + "_path": "lib/python3.12/idlelib/history.py", + "path_type": "hardlink", + "sha256": "f91f1568d083bdbc856d38ef48493bcb138c6a492d523385b300a5bac30133e6", + "sha256_in_prefix": "f91f1568d083bdbc856d38ef48493bcb138c6a492d523385b300a5bac30133e6", + "size_in_bytes": 4065 + }, + { + "_path": "lib/python3.12/idlelib/hyperparser.py", + "path_type": "hardlink", + "sha256": "18563d2b4c248aed70b7f29fd903fd51d1b5aceb3dc93c23f9a54141eed7a9b0", + "sha256_in_prefix": "18563d2b4c248aed70b7f29fd903fd51d1b5aceb3dc93c23f9a54141eed7a9b0", + "size_in_bytes": 12889 + }, + { + "_path": "lib/python3.12/idlelib/idle.bat", + "path_type": "hardlink", + "sha256": "15a3977f0d2c6a8e87db2ef7050ea10afb3a88b064bf5ef95439924e42464114", + "sha256_in_prefix": "15a3977f0d2c6a8e87db2ef7050ea10afb3a88b064bf5ef95439924e42464114", + "size_in_bytes": 177 + }, + { + "_path": "lib/python3.12/idlelib/idle.py", + "path_type": "hardlink", + "sha256": "33ffa2f718e123fd1c4e536bb4a471978515787ee9fbf7806a92073a787a733a", + "sha256_in_prefix": "33ffa2f718e123fd1c4e536bb4a471978515787ee9fbf7806a92073a787a733a", + "size_in_bytes": 454 + }, + { + "_path": "lib/python3.12/idlelib/idle.pyw", + "path_type": "hardlink", + "sha256": "26101d297127132c5e9634499f41ad00e125ea308343a20b278bee9e9225eb5c", + "sha256_in_prefix": "26101d297127132c5e9634499f41ad00e125ea308343a20b278bee9e9225eb5c", + "size_in_bytes": 570 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/README.txt", + "path_type": "hardlink", + "sha256": "94cca8aab706b6ceb5d9ed44cad93127988c9370cdde250a53bec9b132261f05", + "sha256_in_prefix": "94cca8aab706b6ceb5d9ed44cad93127988c9370cdde250a53bec9b132261f05", + "size_in_bytes": 8880 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__init__.py", + "path_type": "hardlink", + "sha256": "0a7370f8ab516e0944f381fcecee02ac660926551b3eb543f88ace3ef024ca70", + "sha256_in_prefix": "0a7370f8ab516e0944f381fcecee02ac660926551b3eb543f88ace3ef024ca70", + "size_in_bytes": 1250 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/__init__.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "7789af9e2606f3672299ac0ddb29bc670e74a1099319bcbcc70331e252dd81da", + "sha256_in_prefix": "7789af9e2606f3672299ac0ddb29bc670e74a1099319bcbcc70331e252dd81da", + "size_in_bytes": 1209 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/htest.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "c51fc731cc4e6664333db308495d70c6980f5f133aa7bc93751f8b4437cdbadb", + "sha256_in_prefix": "c51fc731cc4e6664333db308495d70c6980f5f133aa7bc93751f8b4437cdbadb", + "size_in_bytes": 16627 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/mock_idle.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "ef28aa780e2cbe398c0762e6a389de440672b83762bbadfd50637f1de1763f1f", + "sha256_in_prefix": "ef28aa780e2cbe398c0762e6a389de440672b83762bbadfd50637f1de1763f1f", + "size_in_bytes": 3431 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/mock_tk.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "12ec87b589ee513321a14efa0d95dcfe43070b1a82edbb553a5c1225b3e71443", + "sha256_in_prefix": "12ec87b589ee513321a14efa0d95dcfe43070b1a82edbb553a5c1225b3e71443", + "size_in_bytes": 14332 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/template.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "b98111435c90b783ebd2ef73d2c0b260822606d82fbe110b1206f20d3168830f", + "sha256_in_prefix": "b98111435c90b783ebd2ef73d2c0b260822606d82fbe110b1206f20d3168830f", + "size_in_bytes": 1715 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/test_autocomplete.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "b19c08e516de509fc1d6ebd953cea6767ba6e0c60f13129c8f839969e52782bc", + "sha256_in_prefix": "b19c08e516de509fc1d6ebd953cea6767ba6e0c60f13129c8f839969e52782bc", + "size_in_bytes": 18932 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/test_autocomplete_w.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "bae39b77fcecb413b63c0db1a302a7df962301e34a555977cf3f7465ec662614", + "sha256_in_prefix": "bae39b77fcecb413b63c0db1a302a7df962301e34a555977cf3f7465ec662614", + "size_in_bytes": 2183 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/test_autoexpand.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "c5889d236016c97f47470e75a9e48570d7714989ead48ec088a6d22569ee537a", + "sha256_in_prefix": "c5889d236016c97f47470e75a9e48570d7714989ead48ec088a6d22569ee537a", + "size_in_bytes": 7244 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/test_browser.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "134bc0690027724e1e4fa0e63248e4b9fbc53286876532f62879d95989449949", + "sha256_in_prefix": "134bc0690027724e1e4fa0e63248e4b9fbc53286876532f62879d95989449949", + "size_in_bytes": 17306 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/test_calltip.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "b8648008b1dba12d488df4dfefcff2f1a4250701b018138161daf84eb5da2238", + "sha256_in_prefix": "b8648008b1dba12d488df4dfefcff2f1a4250701b018138161daf84eb5da2238", + "size_in_bytes": 26852 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/test_calltip_w.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "301493a59487a97c20d9aebc77e05b8522c5855ddf2fb4d53f898b5f4c6c9211", + "sha256_in_prefix": "301493a59487a97c20d9aebc77e05b8522c5855ddf2fb4d53f898b5f4c6c9211", + "size_in_bytes": 2123 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/test_codecontext.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "9a589156d0f3c1c3d162307f1f6683a143bca5fb5d58c8817efebdf711c5c0a2", + "sha256_in_prefix": "9a589156d0f3c1c3d162307f1f6683a143bca5fb5d58c8817efebdf711c5c0a2", + "size_in_bytes": 21889 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/test_colorizer.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "4b71f7a27529b75a419f14b49a13875f21809c3babe710e61417c47a0cb27ec7", + "sha256_in_prefix": "4b71f7a27529b75a419f14b49a13875f21809c3babe710e61417c47a0cb27ec7", + "size_in_bytes": 32109 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/test_config.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "ea917864b2fb5b8cfa8c5bb9179fd24a685e949fbb4413ae1ece64e97b0f372f", + "sha256_in_prefix": "ea917864b2fb5b8cfa8c5bb9179fd24a685e949fbb4413ae1ece64e97b0f372f", + "size_in_bytes": 48479 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/test_config_key.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "98d60e47c3ae39d792f78e9944c3d3d566bbda6e632a47bac8ff2fb9fe67a32d", + "sha256_in_prefix": "98d60e47c3ae39d792f78e9944c3d3d566bbda6e632a47bac8ff2fb9fe67a32d", + "size_in_bytes": 22327 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/test_configdialog.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "0fcf50b74e2b70630603f1142f33b66ec65c921dd308e29e237d6061a06f1429", + "sha256_in_prefix": "0fcf50b74e2b70630603f1142f33b66ec65c921dd308e29e237d6061a06f1429", + "size_in_bytes": 91381 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/test_debugger.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "d263e228ec6d6e787e5a190897e47ebcd0856db5863f2318e91c3b72f5724d31", + "sha256_in_prefix": "d263e228ec6d6e787e5a190897e47ebcd0856db5863f2318e91c3b72f5724d31", + "size_in_bytes": 18399 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/test_debugger_r.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "ad4f7d0ae2a7ab64145371a4e14be9e64418360c9423b3a4585a809b38323559", + "sha256_in_prefix": "ad4f7d0ae2a7ab64145371a4e14be9e64418360c9423b3a4585a809b38323559", + "size_in_bytes": 1771 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/test_debugobj.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "ad132d8f40db855c03f4dde155846770a4f510dff1e0e8faa3c511792830cf5d", + "sha256_in_prefix": "ad132d8f40db855c03f4dde155846770a4f510dff1e0e8faa3c511792830cf5d", + "size_in_bytes": 4376 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/test_debugobj_r.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "4cfca7ceb007c3af9a3c83cf0b4b6ada498ff85d777a90b081614a09e8912499", + "sha256_in_prefix": "4cfca7ceb007c3af9a3c83cf0b4b6ada498ff85d777a90b081614a09e8912499", + "size_in_bytes": 1832 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/test_delegator.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "639cf1e724405c51863eb40a5ab73908ae9c4320b262f3cefd35f3b12af64a79", + "sha256_in_prefix": "639cf1e724405c51863eb40a5ab73908ae9c4320b262f3cefd35f3b12af64a79", + "size_in_bytes": 2347 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/test_editmenu.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "4fa51db7d044f0eca116499596b96414ec23163390dfb2255aa57d9c287687ba", + "sha256_in_prefix": "4fa51db7d044f0eca116499596b96414ec23163390dfb2255aa57d9c287687ba", + "size_in_bytes": 4894 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/test_editor.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "9693c6a2f3beb94cd03bb2f794d13358f01c11e54db9ae91ab7930f3e98da5fc", + "sha256_in_prefix": "9693c6a2f3beb94cd03bb2f794d13358f01c11e54db9ae91ab7930f3e98da5fc", + "size_in_bytes": 11434 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/test_filelist.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "4101cc991397f6e41b60530921619c08ef371df50e3295508dd9842b9aa3fd45", + "sha256_in_prefix": "4101cc991397f6e41b60530921619c08ef371df50e3295508dd9842b9aa3fd45", + "size_in_bytes": 2394 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/test_format.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "20e40058df6747b690738fd1f90a5d4b493ec5a7cb367f412660dff6da0d4416", + "sha256_in_prefix": "20e40058df6747b690738fd1f90a5d4b493ec5a7cb367f412660dff6da0d4416", + "size_in_bytes": 33239 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/test_grep.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "32e312f537124e30478be2f7f6d5e8d2be125a4bb7514651a85d7e3d51b05247", + "sha256_in_prefix": "32e312f537124e30478be2f7f6d5e8d2be125a4bb7514651a85d7e3d51b05247", + "size_in_bytes": 8731 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/test_help.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "faae073d73767df6bce7a3ff50689193f40adf9c171752bd6d472209bacd5c96", + "sha256_in_prefix": "faae073d73767df6bce7a3ff50689193f40adf9c171752bd6d472209bacd5c96", + "size_in_bytes": 2429 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/test_help_about.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "0374bfc6b6839767ffac012dfb754a0d04e33b0f193986b46cc279903e1f5f8c", + "sha256_in_prefix": "0374bfc6b6839767ffac012dfb754a0d04e33b0f193986b46cc279903e1f5f8c", + "size_in_bytes": 11586 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/test_history.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "2bb989d1cf4d65d7445c8092dd31980d946364a1388871a21168a17dbbfa57ea", + "sha256_in_prefix": "2bb989d1cf4d65d7445c8092dd31980d946364a1388871a21168a17dbbfa57ea", + "size_in_bytes": 11087 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/test_hyperparser.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "2c55529e5bec557f4bd57864c2e8f9a266ec38787e688fdbf77769340f081d0d", + "sha256_in_prefix": "2c55529e5bec557f4bd57864c2e8f9a266ec38787e688fdbf77769340f081d0d", + "size_in_bytes": 14900 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/test_iomenu.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "b3faadc8991fb9bc0ca0273ad1d82e5a357e755d1ddcb08429c7d9a1c9b19412", + "sha256_in_prefix": "b3faadc8991fb9bc0ca0273ad1d82e5a357e755d1ddcb08429c7d9a1c9b19412", + "size_in_bytes": 5243 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/test_macosx.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "3158fb5ce741ddb7a3ca1e42d27786f9e40d822fcfa8358e0cf84f9364722861", + "sha256_in_prefix": "3158fb5ce741ddb7a3ca1e42d27786f9e40d822fcfa8358e0cf84f9364722861", + "size_in_bytes": 6953 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/test_mainmenu.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "099bdf1330b5e688de83b0cb5515069dc0d3ab4fc11a90b60aada8845170d70d", + "sha256_in_prefix": "099bdf1330b5e688de83b0cb5515069dc0d3ab4fc11a90b60aada8845170d70d", + "size_in_bytes": 2698 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/test_multicall.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "893e56873a0d7eaa3545d2f823af0e473f88b8dd512233965c97cb27c8c890ef", + "sha256_in_prefix": "893e56873a0d7eaa3545d2f823af0e473f88b8dd512233965c97cb27c8c890ef", + "size_in_bytes": 3140 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/test_outwin.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "b0bb046e373fe4d0575d6c20a86417ea1087f0fe5e26c2f5913ad2e9dd4a5f4e", + "sha256_in_prefix": "b0bb046e373fe4d0575d6c20a86417ea1087f0fe5e26c2f5913ad2e9dd4a5f4e", + "size_in_bytes": 9474 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/test_parenmatch.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "a517577b5f6aaf6a1285fd2df701e09ed9094f7523c4f5f4b293bc418cea1f4d", + "sha256_in_prefix": "a517577b5f6aaf6a1285fd2df701e09ed9094f7523c4f5f4b293bc418cea1f4d", + "size_in_bytes": 6387 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/test_pathbrowser.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "511c0ecc700fe29277f1c9cff547ad55df1bc6fe0e041044dd17256f506cc6a6", + "sha256_in_prefix": "511c0ecc700fe29277f1c9cff547ad55df1bc6fe0e041044dd17256f506cc6a6", + "size_in_bytes": 6045 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/test_percolator.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "d7d1ee05e930e4492abf1874d17b3acb8f6f4d679a19bf22bfbf21217745e73c", + "sha256_in_prefix": "d7d1ee05e930e4492abf1874d17b3acb8f6f4d679a19bf22bfbf21217745e73c", + "size_in_bytes": 9380 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/test_pyparse.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "a6e994a89184edf7a03f68211420eb6866197002ddaa75d17f35b17cc7b87784", + "sha256_in_prefix": "a6e994a89184edf7a03f68211420eb6866197002ddaa75d17f35b17cc7b87784", + "size_in_bytes": 23331 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/test_pyshell.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "723d27a392de7c9ad034754869fadc1b5a2ce81af362c882ab3fb82332da190a", + "sha256_in_prefix": "723d27a392de7c9ad034754869fadc1b5a2ce81af362c882ab3fb82332da190a", + "size_in_bytes": 9386 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/test_query.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "12d804c7430b1faab607ccd15d9588bede88ee3ead19ef0ff553e390a6c18cbf", + "sha256_in_prefix": "12d804c7430b1faab607ccd15d9588bede88ee3ead19ef0ff553e390a6c18cbf", + "size_in_bytes": 32097 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/test_redirector.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "c5ac40ec3be9cda632ea8c04a5bb4fe86289839f3d54cdae1b36d79cc546df8d", + "sha256_in_prefix": "c5ac40ec3be9cda632ea8c04a5bb4fe86289839f3d54cdae1b36d79cc546df8d", + "size_in_bytes": 9761 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/test_replace.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "709699d533acd6c74415a1f2f92efd681fae903956e1593183412d847b56f78e", + "sha256_in_prefix": "709699d533acd6c74415a1f2f92efd681fae903956e1593183412d847b56f78e", + "size_in_bytes": 15553 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/test_rpc.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "f45f4104e574d5b6e9b31db8ac40bd9cf7d4b11932f866f003ffd366638310e7", + "sha256_in_prefix": "f45f4104e574d5b6e9b31db8ac40bd9cf7d4b11932f866f003ffd366638310e7", + "size_in_bytes": 2554 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/test_run.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "320ad957dfeef571587afa183d597aa6534392c6cfe96b9c945cbfbc6b70b46a", + "sha256_in_prefix": "320ad957dfeef571587afa183d597aa6534392c6cfe96b9c945cbfbc6b70b46a", + "size_in_bytes": 31172 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/test_runscript.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "10b2581d857a8bbe62a90d28bacaf3190bee4bea7a4a9af7a111387566b3fb3e", + "sha256_in_prefix": "10b2581d857a8bbe62a90d28bacaf3190bee4bea7a4a9af7a111387566b3fb3e", + "size_in_bytes": 2227 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/test_scrolledlist.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "c2c2ca6de48797fb22d1394afd7a6646de4d557bda7853f6d162a72e57877bb3", + "sha256_in_prefix": "c2c2ca6de48797fb22d1394afd7a6646de4d557bda7853f6d162a72e57877bb3", + "size_in_bytes": 1636 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/test_search.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "02a8821d1cf394d3274f1133362872ebc2b5d72c715505de80d83373d4ab2918", + "sha256_in_prefix": "02a8821d1cf394d3274f1133362872ebc2b5d72c715505de80d83373d4ab2918", + "size_in_bytes": 4939 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/test_searchbase.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "2c31ddacfda94aa2f5a3831e754188bbeac5bd67481509ba9c86e549a5fa34cf", + "sha256_in_prefix": "2c31ddacfda94aa2f5a3831e754188bbeac5bd67481509ba9c86e549a5fa34cf", + "size_in_bytes": 10495 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/test_searchengine.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "1c28857142c796fb94eda5bb05b0a1dd2729233a5b9a0a51ab3de58aa196b644", + "sha256_in_prefix": "1c28857142c796fb94eda5bb05b0a1dd2729233a5b9a0a51ab3de58aa196b644", + "size_in_bytes": 18039 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/test_sidebar.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "8de58812693a764ac0c01e913ad3fa127e7e13bca6948973c1e02ccf6c648983", + "sha256_in_prefix": "8de58812693a764ac0c01e913ad3fa127e7e13bca6948973c1e02ccf6c648983", + "size_in_bytes": 45873 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/test_squeezer.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "0d8db58702420185f44a77c742fdcb0d0c44b87cdf08e9436c7685926d3d6da9", + "sha256_in_prefix": "0d8db58702420185f44a77c742fdcb0d0c44b87cdf08e9436c7685926d3d6da9", + "size_in_bytes": 27423 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/test_stackviewer.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "1e8241e3f3a2aa5a06e58aa3d3d50272857fac9ec07c06ab9bfb115a9995f1ba", + "sha256_in_prefix": "1e8241e3f3a2aa5a06e58aa3d3d50272857fac9ec07c06ab9bfb115a9995f1ba", + "size_in_bytes": 2386 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/test_statusbar.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "61f326aa0e8052a5da03cf1bd60d35f5e792a1faecbd9ca8e48160d8c8973c7a", + "sha256_in_prefix": "61f326aa0e8052a5da03cf1bd60d35f5e792a1faecbd9ca8e48160d8c8973c7a", + "size_in_bytes": 2808 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/test_text.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "081fdc8296f611c7e9d984efb9b90817e499172564827a2f5d56f6856c16b29f", + "sha256_in_prefix": "081fdc8296f611c7e9d984efb9b90817e499172564827a2f5d56f6856c16b29f", + "size_in_bytes": 11692 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/test_textview.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "70a2bf5033578b1872bde7a8fee04c0fe842ca797af7ac1a461b5df0b30b8cfc", + "sha256_in_prefix": "70a2bf5033578b1872bde7a8fee04c0fe842ca797af7ac1a461b5df0b30b8cfc", + "size_in_bytes": 15855 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/test_tooltip.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "a0b2473240e85bcf3965aec9e33bdb876d2e3a14bb54837b26e7f0a2f0cd3cbd", + "sha256_in_prefix": "a0b2473240e85bcf3965aec9e33bdb876d2e3a14bb54837b26e7f0a2f0cd3cbd", + "size_in_bytes": 10073 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/test_tree.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "e00e0a19c85092717e35de176e5327739373330f49a8d3923926b2b08cec8fff", + "sha256_in_prefix": "e00e0a19c85092717e35de176e5327739373330f49a8d3923926b2b08cec8fff", + "size_in_bytes": 4100 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/test_undo.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "fa94c52fb91317068db89dad89d2e5c0964a9ae14d92ce710dabd77570bc2f50", + "sha256_in_prefix": "fa94c52fb91317068db89dad89d2e5c0964a9ae14d92ce710dabd77570bc2f50", + "size_in_bytes": 8301 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/test_util.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "1f969d64e017aee4ee52fce8289f66ae4a2c4507691e8976a90ae6f94f666d73", + "sha256_in_prefix": "1f969d64e017aee4ee52fce8289f66ae4a2c4507691e8976a90ae6f94f666d73", + "size_in_bytes": 1137 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/test_warning.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "245fc4633ca593860304e512d74e4265336905353cfcae99ef5850ebae6acc5a", + "sha256_in_prefix": "245fc4633ca593860304e512d74e4265336905353cfcae99ef5850ebae6acc5a", + "size_in_bytes": 4599 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/test_window.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "3d17317cda405a779af392f0883a67dae2396bec3dcc3b58ed007349c05a4e9f", + "sha256_in_prefix": "3d17317cda405a779af392f0883a67dae2396bec3dcc3b58ed007349c05a4e9f", + "size_in_bytes": 2751 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/test_zoomheight.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "0cd27aa7081975411d7d3ef118a9ae73b9cdd6bde1a7b0e22b05919dce5d3f38", + "sha256_in_prefix": "0cd27aa7081975411d7d3ef118a9ae73b9cdd6bde1a7b0e22b05919dce5d3f38", + "size_in_bytes": 2658 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/test_zzdummy.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "b87d05b5b406783643abff78f2e78dac49a5ee30374290244a15a3563703af0b", + "sha256_in_prefix": "b87d05b5b406783643abff78f2e78dac49a5ee30374290244a15a3563703af0b", + "size_in_bytes": 8518 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/__pycache__/tkinter_testing_utils.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "4edbb99dd995ef85b5d6c1750c839c9516354237cf2b0376a8eeb02be38ed86b", + "sha256_in_prefix": "4edbb99dd995ef85b5d6c1750c839c9516354237cf2b0376a8eeb02be38ed86b", + "size_in_bytes": 2915 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/example_noext", + "path_type": "hardlink", + "sha256": "526edff5d21fd1f1421f5ab6a706cb51732edcae235b9895f93a8f46e25505fe", + "sha256_in_prefix": "526edff5d21fd1f1421f5ab6a706cb51732edcae235b9895f93a8f46e25505fe", + "size_in_bytes": 68 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/example_stub.pyi", + "path_type": "hardlink", + "sha256": "e89a8196b490fe728f31af590b3bbca69bddc7aec8cbf09d2a5ae0953240ac56", + "sha256_in_prefix": "e89a8196b490fe728f31af590b3bbca69bddc7aec8cbf09d2a5ae0953240ac56", + "size_in_bytes": 154 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/htest.py", + "path_type": "hardlink", + "sha256": "8c0413ab3067d28fe93f40e2e1da410414095ab278f63fc578a9d8452f98eb5c", + "sha256_in_prefix": "8c0413ab3067d28fe93f40e2e1da410414095ab278f63fc578a9d8452f98eb5c", + "size_in_bytes": 15313 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/mock_idle.py", + "path_type": "hardlink", + "sha256": "637d74d26089c582fb784c2920f5bcb41e5b1fc8b9e0931ddc1cc8d92becbff4", + "sha256_in_prefix": "637d74d26089c582fb784c2920f5bcb41e5b1fc8b9e0931ddc1cc8d92becbff4", + "size_in_bytes": 1943 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/mock_tk.py", + "path_type": "hardlink", + "sha256": "7d60a26e82fd0469a95e02c2adda6607363a51ab67d5851cc323a58a595f74a7", + "sha256_in_prefix": "7d60a26e82fd0469a95e02c2adda6607363a51ab67d5851cc323a58a595f74a7", + "size_in_bytes": 11693 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/template.py", + "path_type": "hardlink", + "sha256": "43421286ad234a4240f8d4bc09f67bb58da0bf9d9b07bf93010989ef2c17f2f8", + "sha256_in_prefix": "43421286ad234a4240f8d4bc09f67bb58da0bf9d9b07bf93010989ef2c17f2f8", + "size_in_bytes": 642 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/test_autocomplete.py", + "path_type": "hardlink", + "sha256": "0ee1af80bb645bd57e6f6383f5e5473f901e9d40524992abf9c48a4163997eef", + "sha256_in_prefix": "0ee1af80bb645bd57e6f6383f5e5473f901e9d40524992abf9c48a4163997eef", + "size_in_bytes": 11093 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/test_autocomplete_w.py", + "path_type": "hardlink", + "sha256": "f8cd80196c2841f65f53ca5ae1c4fb99c7c215b29cf88774e0b189c99e4cee79", + "sha256_in_prefix": "f8cd80196c2841f65f53ca5ae1c4fb99c7c215b29cf88774e0b189c99e4cee79", + "size_in_bytes": 720 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/test_autoexpand.py", + "path_type": "hardlink", + "sha256": "85f913f8cbd5dfd5d52d3b7d00eedec231ec3e4ee7d117db4a2bb714eb1a7243", + "sha256_in_prefix": "85f913f8cbd5dfd5d52d3b7d00eedec231ec3e4ee7d117db4a2bb714eb1a7243", + "size_in_bytes": 4638 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/test_browser.py", + "path_type": "hardlink", + "sha256": "bdfd3bd9ab02ee535e77f3233920f80891eb84d7042f7db381afc7766b3702eb", + "sha256_in_prefix": "bdfd3bd9ab02ee535e77f3233920f80891eb84d7042f7db381afc7766b3702eb", + "size_in_bytes": 8420 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/test_calltip.py", + "path_type": "hardlink", + "sha256": "a67efd1c92e824321254f615d35a72508ee09d75e1058c3d01ad7d8bf3be1ebf", + "sha256_in_prefix": "a67efd1c92e824321254f615d35a72508ee09d75e1058c3d01ad7d8bf3be1ebf", + "size_in_bytes": 13658 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/test_calltip_w.py", + "path_type": "hardlink", + "sha256": "7462c048c689f82c3ae6b5782a18776762f88055b80ae77a92243b6c0606e004", + "sha256_in_prefix": "7462c048c689f82c3ae6b5782a18776762f88055b80ae77a92243b6c0606e004", + "size_in_bytes": 686 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/test_codecontext.py", + "path_type": "hardlink", + "sha256": "84e6b890b22b2abcc0865c691162b93c6ffb9b4e17f05011bdaffa770a52fcf0", + "sha256_in_prefix": "84e6b890b22b2abcc0865c691162b93c6ffb9b4e17f05011bdaffa770a52fcf0", + "size_in_bytes": 16082 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/test_colorizer.py", + "path_type": "hardlink", + "sha256": "6a3fbb630e0ecc7aafc9c8bc56ece3462911c733aa3bb4c52ee55c1d897301d4", + "sha256_in_prefix": "6a3fbb630e0ecc7aafc9c8bc56ece3462911c733aa3bb4c52ee55c1d897301d4", + "size_in_bytes": 22882 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/test_config.py", + "path_type": "hardlink", + "sha256": "02546eb557e57b1654da9016cf56f1826869f3e6c78bcafffb8a89013641c1a1", + "sha256_in_prefix": "02546eb557e57b1654da9016cf56f1826869f3e6c78bcafffb8a89013641c1a1", + "size_in_bytes": 32091 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/test_config_key.py", + "path_type": "hardlink", + "sha256": "54d0c65e1f66d37c415d3fe533c8db891974f08e8fca6374596280d64db86586", + "sha256_in_prefix": "54d0c65e1f66d37c415d3fe533c8db891974f08e8fca6374596280d64db86586", + "size_in_bytes": 11462 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/test_configdialog.py", + "path_type": "hardlink", + "sha256": "56685b99d406c974ffce84260b08b06476b1e98f701d0675c378d86c8f19f579", + "sha256_in_prefix": "56685b99d406c974ffce84260b08b06476b1e98f701d0675c378d86c8f19f579", + "size_in_bytes": 55389 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/test_debugger.py", + "path_type": "hardlink", + "sha256": "8117fa37bf2c4266809f3a41c7c37c603c6a390b235801504123ea533c55d7cc", + "sha256_in_prefix": "8117fa37bf2c4266809f3a41c7c37c603c6a390b235801504123ea533c55d7cc", + "size_in_bytes": 9727 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/test_debugger_r.py", + "path_type": "hardlink", + "sha256": "ccc0ba5e03ee1df449f78a164efdc6739f5a530315ab3971ac05c652bc779cea", + "sha256_in_prefix": "ccc0ba5e03ee1df449f78a164efdc6739f5a530315ab3971ac05c652bc779cea", + "size_in_bytes": 965 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/test_debugobj.py", + "path_type": "hardlink", + "sha256": "5427a574cfcfd36a48e365f6f8864b226ee8d7eb48702ff1496570302b1d9acc", + "sha256_in_prefix": "5427a574cfcfd36a48e365f6f8864b226ee8d7eb48702ff1496570302b1d9acc", + "size_in_bytes": 1611 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/test_debugobj_r.py", + "path_type": "hardlink", + "sha256": "22d74368ba175175b9c14315f9d82fd7ddde60ae93d2e5572e9a647de7e869eb", + "sha256_in_prefix": "22d74368ba175175b9c14315f9d82fd7ddde60ae93d2e5572e9a647de7e869eb", + "size_in_bytes": 545 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/test_delegator.py", + "path_type": "hardlink", + "sha256": "559d39df8c1ff38d177943f245b87f5379ee5ea93399fd6b5f7bfa882e6ed8ca", + "sha256_in_prefix": "559d39df8c1ff38d177943f245b87f5379ee5ea93399fd6b5f7bfa882e6ed8ca", + "size_in_bytes": 1567 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/test_editmenu.py", + "path_type": "hardlink", + "sha256": "ed3800137d48ffcf86ecb71afe5a24cd9ed381571f23036438ba8a97f502326a", + "sha256_in_prefix": "ed3800137d48ffcf86ecb71afe5a24cd9ed381571f23036438ba8a97f502326a", + "size_in_bytes": 2564 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/test_editor.py", + "path_type": "hardlink", + "sha256": "654ae5ca7f747a4a88d2868de48c7bff1f35b26098075f840722e955fe4cb83e", + "sha256_in_prefix": "654ae5ca7f747a4a88d2868de48c7bff1f35b26098075f840722e955fe4cb83e", + "size_in_bytes": 8151 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/test_filelist.py", + "path_type": "hardlink", + "sha256": "d4cea5fdba68fb9e361541820d44eed003c317f4ef14bb9df3406b8d2c53ef7c", + "sha256_in_prefix": "d4cea5fdba68fb9e361541820d44eed003c317f4ef14bb9df3406b8d2c53ef7c", + "size_in_bytes": 795 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/test_format.py", + "path_type": "hardlink", + "sha256": "b356a2a8f5fe14c39c6af73623484df4ed930cc16ef4605f3b04fd9b618867a6", + "sha256_in_prefix": "b356a2a8f5fe14c39c6af73623484df4ed930cc16ef4605f3b04fd9b618867a6", + "size_in_bytes": 23610 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/test_grep.py", + "path_type": "hardlink", + "sha256": "ca64de882b5608e016b7df8f739089c9f262643bce09979b76399cc4be1ea12c", + "sha256_in_prefix": "ca64de882b5608e016b7df8f739089c9f262643bce09979b76399cc4be1ea12c", + "size_in_bytes": 5072 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/test_help.py", + "path_type": "hardlink", + "sha256": "0513a2872307b45ea7869b7e07dc437d7e8c69524073513b96374397f371b32a", + "sha256_in_prefix": "0513a2872307b45ea7869b7e07dc437d7e8c69524073513b96374397f371b32a", + "size_in_bytes": 863 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/test_help_about.py", + "path_type": "hardlink", + "sha256": "47663dfbcddced35ad97631cebb690a30ab3aa724bde0a7174d11290ac79eb02", + "sha256_in_prefix": "47663dfbcddced35ad97631cebb690a30ab3aa724bde0a7174d11290ac79eb02", + "size_in_bytes": 5904 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/test_history.py", + "path_type": "hardlink", + "sha256": "6319fe7810ed91786b503de80701a291a4f9abe54c9e101c19c0917b709e62f3", + "sha256_in_prefix": "6319fe7810ed91786b503de80701a291a4f9abe54c9e101c19c0917b709e62f3", + "size_in_bytes": 5517 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/test_hyperparser.py", + "path_type": "hardlink", + "sha256": "cd2fbc788d4d75b514e53951dc90d00d41a8a87baad31bc1e380b7449bfcf183", + "sha256_in_prefix": "cd2fbc788d4d75b514e53951dc90d00d41a8a87baad31bc1e380b7449bfcf183", + "size_in_bytes": 9082 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/test_iomenu.py", + "path_type": "hardlink", + "sha256": "8250eb60ea1d7760589febf38c171c8c6e202e527a680030233539db59439d8d", + "sha256_in_prefix": "8250eb60ea1d7760589febf38c171c8c6e202e527a680030233539db59439d8d", + "size_in_bytes": 2457 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/test_macosx.py", + "path_type": "hardlink", + "sha256": "975e48ab453711c5072988e2e66a7fe51e716ac64e494f022a5ff82781ccd368", + "sha256_in_prefix": "975e48ab453711c5072988e2e66a7fe51e716ac64e494f022a5ff82781ccd368", + "size_in_bytes": 3444 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/test_mainmenu.py", + "path_type": "hardlink", + "sha256": "faa064ffd9c8e30b1205e46bb4ede816c74b7948cfa34c7795ed19c35eac10d5", + "sha256_in_prefix": "faa064ffd9c8e30b1205e46bb4ede816c74b7948cfa34c7795ed19c35eac10d5", + "size_in_bytes": 1638 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/test_multicall.py", + "path_type": "hardlink", + "sha256": "1bfb51912275d8e346dce0a40ab84316b15e3f142e66529a8c9cfd52210c1a1f", + "sha256_in_prefix": "1bfb51912275d8e346dce0a40ab84316b15e3f142e66529a8c9cfd52210c1a1f", + "size_in_bytes": 1317 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/test_outwin.py", + "path_type": "hardlink", + "sha256": "4f0590e1fe9af387fa627cb8a40cd7618da5d2a46ce4b33446d54f6fbcce2105", + "sha256_in_prefix": "4f0590e1fe9af387fa627cb8a40cd7618da5d2a46ce4b33446d54f6fbcce2105", + "size_in_bytes": 5417 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/test_parenmatch.py", + "path_type": "hardlink", + "sha256": "5e0ba86116e28d46e7db9ed33d85cf7caa837e1779e1b8feb5f6b6b4a837551e", + "sha256_in_prefix": "5e0ba86116e28d46e7db9ed33d85cf7caa837e1779e1b8feb5f6b6b4a837551e", + "size_in_bytes": 3544 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/test_pathbrowser.py", + "path_type": "hardlink", + "sha256": "a7d9c5085ff5c64232897f6ee0a09258a41a35f153f47ff0f3b8fa97ec67be9e", + "sha256_in_prefix": "a7d9c5085ff5c64232897f6ee0a09258a41a35f153f47ff0f3b8fa97ec67be9e", + "size_in_bytes": 2422 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/test_percolator.py", + "path_type": "hardlink", + "sha256": "133b134a46b23cf2c635be3116415fd388e3a1c1581bf1a77d7f7f0aff3a725b", + "sha256_in_prefix": "133b134a46b23cf2c635be3116415fd388e3a1c1581bf1a77d7f7f0aff3a725b", + "size_in_bytes": 4065 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/test_pyparse.py", + "path_type": "hardlink", + "sha256": "8f386a9f535369afb495322e104077c66c5a3abb91917ec69f868b405120cf35", + "sha256_in_prefix": "8f386a9f535369afb495322e104077c66c5a3abb91917ec69f868b405120cf35", + "size_in_bytes": 19365 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/test_pyshell.py", + "path_type": "hardlink", + "sha256": "ff47aecd0657edbd7bc920473fe2e55b0bb0db6f347dc52f5e81b767897d3bc5", + "sha256_in_prefix": "ff47aecd0657edbd7bc920473fe2e55b0bb0db6f347dc52f5e81b767897d3bc5", + "size_in_bytes": 4965 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/test_query.py", + "path_type": "hardlink", + "sha256": "632c2dc13a158a5902e5b758166151ffa377db7f5a0c368bc3b0741a237876c3", + "sha256_in_prefix": "632c2dc13a158a5902e5b758166151ffa377db7f5a0c368bc3b0741a237876c3", + "size_in_bytes": 15454 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/test_redirector.py", + "path_type": "hardlink", + "sha256": "517c1fe16da359e01f3cdfdf3f7aead4283e8b8e1107522b72f59d4c4f3ade4c", + "sha256_in_prefix": "517c1fe16da359e01f3cdfdf3f7aead4283e8b8e1107522b72f59d4c4f3ade4c", + "size_in_bytes": 4176 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/test_replace.py", + "path_type": "hardlink", + "sha256": "321333b3eaad9ecbf633186bc625d4a60c4c736def0fa00665add2ab899eecb1", + "sha256_in_prefix": "321333b3eaad9ecbf633186bc625d4a60c4c736def0fa00665add2ab899eecb1", + "size_in_bytes": 8299 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/test_rpc.py", + "path_type": "hardlink", + "sha256": "1e2d997f442002389b3dadb47ed8134947c664a32ef637f43afdcbd1b5c13823", + "sha256_in_prefix": "1e2d997f442002389b3dadb47ed8134947c664a32ef637f43afdcbd1b5c13823", + "size_in_bytes": 805 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/test_run.py", + "path_type": "hardlink", + "sha256": "3cbd9ab33ef7ad8e575f798cc205988d5f106d8be0df20e12b794394c3342b9e", + "sha256_in_prefix": "3cbd9ab33ef7ad8e575f798cc205988d5f106d8be0df20e12b794394c3342b9e", + "size_in_bytes": 15756 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/test_runscript.py", + "path_type": "hardlink", + "sha256": "4264a834dc230d397725f398d905d0746321d543c56644e5c89af59fe3fedb61", + "sha256_in_prefix": "4264a834dc230d397725f398d905d0746321d543c56644e5c89af59fe3fedb61", + "size_in_bytes": 777 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/test_scrolledlist.py", + "path_type": "hardlink", + "sha256": "a84ec601c8786daf0564e978c97c0e14095c23f9a08bb64950f9cb541b074b3a", + "sha256_in_prefix": "a84ec601c8786daf0564e978c97c0e14095c23f9a08bb64950f9cb541b074b3a", + "size_in_bytes": 496 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/test_search.py", + "path_type": "hardlink", + "sha256": "c0550b241c99a566f61929515ca97aedf99f73568df3dfe93078ed22cb54892b", + "sha256_in_prefix": "c0550b241c99a566f61929515ca97aedf99f73568df3dfe93078ed22cb54892b", + "size_in_bytes": 2459 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/test_searchbase.py", + "path_type": "hardlink", + "sha256": "2b8550dd411b75c6152c4da90843e1221094400080f9a1752e383d0b776f775b", + "sha256_in_prefix": "2b8550dd411b75c6152c4da90843e1221094400080f9a1752e383d0b776f775b", + "size_in_bytes": 5691 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/test_searchengine.py", + "path_type": "hardlink", + "sha256": "519ddd5633eb8732539594f79ed21a6544f65e599a0d5c8c84db3a488ccdad97", + "sha256_in_prefix": "519ddd5633eb8732539594f79ed21a6544f65e599a0d5c8c84db3a488ccdad97", + "size_in_bytes": 11588 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/test_sidebar.py", + "path_type": "hardlink", + "sha256": "262977182301b015c9d5051d8ac9861eb286f03b4126d3b01e4d6fe36d866f09", + "sha256_in_prefix": "262977182301b015c9d5051d8ac9861eb286f03b4126d3b01e4d6fe36d866f09", + "size_in_bytes": 26854 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/test_squeezer.py", + "path_type": "hardlink", + "sha256": "fd5f695e2b1c296719e0a5b494a93184cc7e28cca22e9265def8171b23276b6c", + "sha256_in_prefix": "fd5f695e2b1c296719e0a5b494a93184cc7e28cca22e9265def8171b23276b6c", + "size_in_bytes": 19656 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/test_stackviewer.py", + "path_type": "hardlink", + "sha256": "15eaeabf43bbaf7d7bc795fb3dfd59c92f3691c73a20548513dcadef8d45b8bf", + "sha256_in_prefix": "15eaeabf43bbaf7d7bc795fb3dfd59c92f3691c73a20548513dcadef8d45b8bf", + "size_in_bytes": 991 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/test_statusbar.py", + "path_type": "hardlink", + "sha256": "0e9b262b9ad0046cbb0af1101a651fcb88cd1cba38e474b863abbb074b260a02", + "sha256_in_prefix": "0e9b262b9ad0046cbb0af1101a651fcb88cd1cba38e474b863abbb074b260a02", + "size_in_bytes": 1133 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/test_text.py", + "path_type": "hardlink", + "sha256": "55abe8a9d0bdb45efecb879207f1259702cdcf47dbc636d7cca8dd458f0dc70f", + "sha256_in_prefix": "55abe8a9d0bdb45efecb879207f1259702cdcf47dbc636d7cca8dd458f0dc70f", + "size_in_bytes": 6970 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/test_textview.py", + "path_type": "hardlink", + "sha256": "e45b199106608c7c981c149d3b4ccf092e7a2e7e9430cc76887cd769b9aaf533", + "sha256_in_prefix": "e45b199106608c7c981c149d3b4ccf092e7a2e7e9430cc76887cd769b9aaf533", + "size_in_bytes": 7364 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/test_tooltip.py", + "path_type": "hardlink", + "sha256": "b9a82e57761bbca3d4e07193652e8294895765092ef8a651f4dcf63acec7f153", + "sha256_in_prefix": "b9a82e57761bbca3d4e07193652e8294895765092ef8a651f4dcf63acec7f153", + "size_in_bytes": 5385 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/test_tree.py", + "path_type": "hardlink", + "sha256": "62ae68d64105485107e8173f94ce09739f276004bc8fa65efa5add2c6188e166", + "sha256_in_prefix": "62ae68d64105485107e8173f94ce09739f276004bc8fa65efa5add2c6188e166", + "size_in_bytes": 1752 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/test_undo.py", + "path_type": "hardlink", + "sha256": "c5178b2dd77d794938fa52adce719d4948a92ba1a689068cec1fb6888d033e0e", + "sha256_in_prefix": "c5178b2dd77d794938fa52adce719d4948a92ba1a689068cec1fb6888d033e0e", + "size_in_bytes": 4228 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/test_util.py", + "path_type": "hardlink", + "sha256": "300f627fc2199deb246ec793ef47b032de742d763a4170c8bb15e19ccbf602a5", + "sha256_in_prefix": "300f627fc2199deb246ec793ef47b032de742d763a4170c8bb15e19ccbf602a5", + "size_in_bytes": 308 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/test_warning.py", + "path_type": "hardlink", + "sha256": "d1efc442b3fb93de89fb0988c73f8536fc5099afb761d2b69ec101c239c8c193", + "sha256_in_prefix": "d1efc442b3fb93de89fb0988c73f8536fc5099afb761d2b69ec101c239c8c193", + "size_in_bytes": 2740 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/test_window.py", + "path_type": "hardlink", + "sha256": "336f2b6994f5aacca9689f32249db20a8dac36934314b7d5ba391d94169d63c6", + "sha256_in_prefix": "336f2b6994f5aacca9689f32249db20a8dac36934314b7d5ba391d94169d63c6", + "size_in_bytes": 1075 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/test_zoomheight.py", + "path_type": "hardlink", + "sha256": "6300aa47014a5c2dfc9bc0d6c3fb234dff4e4b60a6527d4cdfbb8c416f99df44", + "sha256_in_prefix": "6300aa47014a5c2dfc9bc0d6c3fb234dff4e4b60a6527d4cdfbb8c416f99df44", + "size_in_bytes": 999 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/test_zzdummy.py", + "path_type": "hardlink", + "sha256": "4502524aaa1923393725c04e6b2f27077399190e42bc8903415e95718c5f3c6f", + "sha256_in_prefix": "4502524aaa1923393725c04e6b2f27077399190e42bc8903415e95718c5f3c6f", + "size_in_bytes": 4455 + }, + { + "_path": "lib/python3.12/idlelib/idle_test/tkinter_testing_utils.py", + "path_type": "hardlink", + "sha256": "ece147cef65152a54b0a3d4319bdf8ed82d9a6310273b0056cc17a2de4d744cd", + "sha256_in_prefix": "ece147cef65152a54b0a3d4319bdf8ed82d9a6310273b0056cc17a2de4d744cd", + "size_in_bytes": 2333 + }, + { + "_path": "lib/python3.12/idlelib/iomenu.py", + "path_type": "hardlink", + "sha256": "7004f1ab2cfa5994e453f426507170ec37c1c4a5b9837ba319e5eaebf1a29c34", + "sha256_in_prefix": "7004f1ab2cfa5994e453f426507170ec37c1c4a5b9837ba319e5eaebf1a29c34", + "size_in_bytes": 16159 + }, + { + "_path": "lib/python3.12/idlelib/macosx.py", + "path_type": "hardlink", + "sha256": "e6c687754bb60cd1015a413073b4d85b5e5bc7993c1acbfbc92d70600a83132e", + "sha256_in_prefix": "e6c687754bb60cd1015a413073b4d85b5e5bc7993c1acbfbc92d70600a83132e", + "size_in_bytes": 9290 + }, + { + "_path": "lib/python3.12/idlelib/mainmenu.py", + "path_type": "hardlink", + "sha256": "092fad4454f593d7bf2e5e1e746acade92bb346d06476ba527f162f843ae3208", + "sha256_in_prefix": "092fad4454f593d7bf2e5e1e746acade92bb346d06476ba527f162f843ae3208", + "size_in_bytes": 3938 + }, + { + "_path": "lib/python3.12/idlelib/multicall.py", + "path_type": "hardlink", + "sha256": "efb7d9bddcae17fab2108cb714c240c82d1368087b6d2b91e02ec224ddebce12", + "sha256_in_prefix": "efb7d9bddcae17fab2108cb714c240c82d1368087b6d2b91e02ec224ddebce12", + "size_in_bytes": 18652 + }, + { + "_path": "lib/python3.12/idlelib/outwin.py", + "path_type": "hardlink", + "sha256": "e1946c1a25a020a48843b2ed528bcdd6df29b2af117472b7e2627997b1339b84", + "sha256_in_prefix": "e1946c1a25a020a48843b2ed528bcdd6df29b2af117472b7e2627997b1339b84", + "size_in_bytes": 5715 + }, + { + "_path": "lib/python3.12/idlelib/parenmatch.py", + "path_type": "hardlink", + "sha256": "f122e13c385a135cbbbe8b1d87efeed43ddd3e0be9ddd8aa24b267b61fac4287", + "sha256_in_prefix": "f122e13c385a135cbbbe8b1d87efeed43ddd3e0be9ddd8aa24b267b61fac4287", + "size_in_bytes": 7204 + }, + { + "_path": "lib/python3.12/idlelib/pathbrowser.py", + "path_type": "hardlink", + "sha256": "42a4e008922c991049f1b42ca18700b65f2f8d0ab6dd12cc22671771e90c2065", + "sha256_in_prefix": "42a4e008922c991049f1b42ca18700b65f2f8d0ab6dd12cc22671771e90c2065", + "size_in_bytes": 3093 + }, + { + "_path": "lib/python3.12/idlelib/percolator.py", + "path_type": "hardlink", + "sha256": "42fe72c167eb3a2795cbe64c498d7cbe1de05132be29a99a58226ae83efb31d4", + "sha256_in_prefix": "42fe72c167eb3a2795cbe64c498d7cbe1de05132be29a99a58226ae83efb31d4", + "size_in_bytes": 3568 + }, + { + "_path": "lib/python3.12/idlelib/pyparse.py", + "path_type": "hardlink", + "sha256": "21c6bf43370998d5a5a6670f7b13409335e9a2c1a350ed586bbe63be5f226648", + "sha256_in_prefix": "21c6bf43370998d5a5a6670f7b13409335e9a2c1a350ed586bbe63be5f226648", + "size_in_bytes": 19864 + }, + { + "_path": "lib/python3.12/idlelib/pyshell.py", + "path_type": "hardlink", + "sha256": "1c1a2257ac73dda641843ff8abb8c26f250a5d6ea121cd42b8bc8c4784fcab77", + "sha256_in_prefix": "1c1a2257ac73dda641843ff8abb8c26f250a5d6ea121cd42b8bc8c4784fcab77", + "size_in_bytes": 62533 + }, + { + "_path": "lib/python3.12/idlelib/query.py", + "path_type": "hardlink", + "sha256": "faea5edd6b8693e6a32107054ad0de3be4d28e6aacb7792f86cbbe146131373b", + "sha256_in_prefix": "faea5edd6b8693e6a32107054ad0de3be4d28e6aacb7792f86cbbe146131373b", + "size_in_bytes": 15067 + }, + { + "_path": "lib/python3.12/idlelib/redirector.py", + "path_type": "hardlink", + "sha256": "7911a7534eb0c73ee3e2464c5f8498109653f73ebed8fa903780c5fd7ca00754", + "sha256_in_prefix": "7911a7534eb0c73ee3e2464c5f8498109653f73ebed8fa903780c5fd7ca00754", + "size_in_bytes": 6777 + }, + { + "_path": "lib/python3.12/idlelib/replace.py", + "path_type": "hardlink", + "sha256": "ea13db39aa89df369b36200c7301874a5636403e8270b1862f946e2fff081b84", + "sha256_in_prefix": "ea13db39aa89df369b36200c7301874a5636403e8270b1862f946e2fff081b84", + "size_in_bytes": 9841 + }, + { + "_path": "lib/python3.12/idlelib/rpc.py", + "path_type": "hardlink", + "sha256": "8d0cb6e11c8dcc5dbda89b9a582bfaa74fe2b661dde442b02eb61b8fc47d9eb3", + "sha256_in_prefix": "8d0cb6e11c8dcc5dbda89b9a582bfaa74fe2b661dde442b02eb61b8fc47d9eb3", + "size_in_bytes": 21078 + }, + { + "_path": "lib/python3.12/idlelib/run.py", + "path_type": "hardlink", + "sha256": "f892ec4391871cfec444e719a198fa020673e6513a397be3465ff95fd8d165d1", + "sha256_in_prefix": "f892ec4391871cfec444e719a198fa020673e6513a397be3465ff95fd8d165d1", + "size_in_bytes": 21462 + }, + { + "_path": "lib/python3.12/idlelib/runscript.py", + "path_type": "hardlink", + "sha256": "b92740fddc7b1d603b1736a135bd15518081f20c0db1e1a779cab715ee9120fe", + "sha256_in_prefix": "b92740fddc7b1d603b1736a135bd15518081f20c0db1e1a779cab715ee9120fe", + "size_in_bytes": 8273 + }, + { + "_path": "lib/python3.12/idlelib/scrolledlist.py", + "path_type": "hardlink", + "sha256": "25b0ad247977f6079226052e2b76dd4c127bf50f2f5e8ffbd1fe10bc631bfca9", + "sha256_in_prefix": "25b0ad247977f6079226052e2b76dd4c127bf50f2f5e8ffbd1fe10bc631bfca9", + "size_in_bytes": 4478 + }, + { + "_path": "lib/python3.12/idlelib/search.py", + "path_type": "hardlink", + "sha256": "c53ff4d4814d97d0d95b7e15030d3ae8c732366ed84c2b300183e933270df724", + "sha256_in_prefix": "c53ff4d4814d97d0d95b7e15030d3ae8c732366ed84c2b300183e933270df724", + "size_in_bytes": 5567 + }, + { + "_path": "lib/python3.12/idlelib/searchbase.py", + "path_type": "hardlink", + "sha256": "5e13c99d9f264166d9204eeff0492d43d03f2afd8f66494b3e110d7665ab29cc", + "sha256_in_prefix": "5e13c99d9f264166d9204eeff0492d43d03f2afd8f66494b3e110d7665ab29cc", + "size_in_bytes": 7856 + }, + { + "_path": "lib/python3.12/idlelib/searchengine.py", + "path_type": "hardlink", + "sha256": "11b0c8df926e4f6bd2e26d0264b2d902c41bcc70d68a4a830df1ea2da2c2a6cc", + "sha256_in_prefix": "11b0c8df926e4f6bd2e26d0264b2d902c41bcc70d68a4a830df1ea2da2c2a6cc", + "size_in_bytes": 7415 + }, + { + "_path": "lib/python3.12/idlelib/sidebar.py", + "path_type": "hardlink", + "sha256": "760f14ebb0312adb289cda0562c9eff70982a0acde5d9d9d0b591390cd4a581e", + "sha256_in_prefix": "760f14ebb0312adb289cda0562c9eff70982a0acde5d9d9d0b591390cd4a581e", + "size_in_bytes": 20338 + }, + { + "_path": "lib/python3.12/idlelib/squeezer.py", + "path_type": "hardlink", + "sha256": "112221334fee94a88cba2ca7ac455e1bd6ab796397cbe036b1e8a98bc0787e30", + "sha256_in_prefix": "112221334fee94a88cba2ca7ac455e1bd6ab796397cbe036b1e8a98bc0787e30", + "size_in_bytes": 12834 + }, + { + "_path": "lib/python3.12/idlelib/stackviewer.py", + "path_type": "hardlink", + "sha256": "ee053a65298e2ec2f4628d8269a33362816271fd81fab4e550a621493c26a76f", + "sha256_in_prefix": "ee053a65298e2ec2f4628d8269a33362816271fd81fab4e550a621493c26a76f", + "size_in_bytes": 4016 + }, + { + "_path": "lib/python3.12/idlelib/statusbar.py", + "path_type": "hardlink", + "sha256": "3f4dc0f27b0c23e488d022abe8461529ce8a1b4eaf9dbfd97123ef2c502f684e", + "sha256_in_prefix": "3f4dc0f27b0c23e488d022abe8461529ce8a1b4eaf9dbfd97123ef2c502f684e", + "size_in_bytes": 1474 + }, + { + "_path": "lib/python3.12/idlelib/textview.py", + "path_type": "hardlink", + "sha256": "eace58159e9636bb1456885c21f5ed474e203090139e5dd3457ac72ad5552006", + "sha256_in_prefix": "eace58159e9636bb1456885c21f5ed474e203090139e5dd3457ac72ad5552006", + "size_in_bytes": 6808 + }, + { + "_path": "lib/python3.12/idlelib/tooltip.py", + "path_type": "hardlink", + "sha256": "73dfad0e6652bcd67f7fccdface2e4cd8d5f3c6ffe2ef1c2e86ca0cb12d5d034", + "sha256_in_prefix": "73dfad0e6652bcd67f7fccdface2e4cd8d5f3c6ffe2ef1c2e86ca0cb12d5d034", + "size_in_bytes": 6471 + }, + { + "_path": "lib/python3.12/idlelib/tree.py", + "path_type": "hardlink", + "sha256": "dd594fd0f47ed3cb956d6bc77f72f200144aca13a3c3b9ecd7f472fcefc9256a", + "sha256_in_prefix": "dd594fd0f47ed3cb956d6bc77f72f200144aca13a3c3b9ecd7f472fcefc9256a", + "size_in_bytes": 16483 + }, + { + "_path": "lib/python3.12/idlelib/undo.py", + "path_type": "hardlink", + "sha256": "291fda98995bb4688fbe05fd3fa689e21aade3627c4c16e8971ed353f6cc3107", + "sha256_in_prefix": "291fda98995bb4688fbe05fd3fa689e21aade3627c4c16e8971ed353f6cc3107", + "size_in_bytes": 11016 + }, + { + "_path": "lib/python3.12/idlelib/util.py", + "path_type": "hardlink", + "sha256": "a80958a9f028ed987daf18cd55d78f6db3aff12e9c5629323d992829c0737413", + "sha256_in_prefix": "a80958a9f028ed987daf18cd55d78f6db3aff12e9c5629323d992829c0737413", + "size_in_bytes": 731 + }, + { + "_path": "lib/python3.12/idlelib/window.py", + "path_type": "hardlink", + "sha256": "ca31d8c01c9b468fcad0a4e529c8e205c1e4ecf30520545db654d466bd7158bd", + "sha256_in_prefix": "ca31d8c01c9b468fcad0a4e529c8e205c1e4ecf30520545db654d466bd7158bd", + "size_in_bytes": 2616 + }, + { + "_path": "lib/python3.12/idlelib/zoomheight.py", + "path_type": "hardlink", + "sha256": "5f6ff83cb0df3ee5e7d997ffe23efb341b994bfbaf00b79a4832d54231a095dd", + "sha256_in_prefix": "5f6ff83cb0df3ee5e7d997ffe23efb341b994bfbaf00b79a4832d54231a095dd", + "size_in_bytes": 4203 + }, + { + "_path": "lib/python3.12/idlelib/zzdummy.py", + "path_type": "hardlink", + "sha256": "5e248f0ea4f35052d23bb2c43564aa567b8cebaf91fd63ba0be8fef2f4167945", + "sha256_in_prefix": "5e248f0ea4f35052d23bb2c43564aa567b8cebaf91fd63ba0be8fef2f4167945", + "size_in_bytes": 2005 + }, + { + "_path": "lib/python3.12/imaplib.py", + "path_type": "hardlink", + "sha256": "81a8a1705087119d7ba1eba17bac27fdb49ed9127a28c6f7678f6013257ce0dd", + "sha256_in_prefix": "81a8a1705087119d7ba1eba17bac27fdb49ed9127a28c6f7678f6013257ce0dd", + "size_in_bytes": 53688 + }, + { + "_path": "lib/python3.12/imghdr.py", + "path_type": "hardlink", + "sha256": "c1bb52ea0816db4c5f3420655ab4a476fb3829709141e91f1a56b9c6fe286d56", + "sha256_in_prefix": "c1bb52ea0816db4c5f3420655ab4a476fb3829709141e91f1a56b9c6fe286d56", + "size_in_bytes": 4398 + }, + { + "_path": "lib/python3.12/importlib/__init__.py", + "path_type": "hardlink", + "sha256": "c9e1b3dbc619ac31e7017ac43668a20200872c1c0e79ae379c0dab6ed399b730", + "sha256_in_prefix": "c9e1b3dbc619ac31e7017ac43668a20200872c1c0e79ae379c0dab6ed399b730", + "size_in_bytes": 4774 + }, + { + "_path": "lib/python3.12/importlib/__pycache__/__init__.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "d9806fa3c93f64715e2f5b096a74f1bb6da97037b2ffde546f2ff7d4555514cb", + "sha256_in_prefix": "d9806fa3c93f64715e2f5b096a74f1bb6da97037b2ffde546f2ff7d4555514cb", + "size_in_bytes": 4819 + }, + { + "_path": "lib/python3.12/importlib/__pycache__/_abc.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "280f9f0f8a10c7571ab828f798b7e03ec1f71adb28ae9338ca7ddf066b0f8c34", + "sha256_in_prefix": "280f9f0f8a10c7571ab828f798b7e03ec1f71adb28ae9338ca7ddf066b0f8c34", + "size_in_bytes": 1897 + }, + { + "_path": "lib/python3.12/importlib/__pycache__/_bootstrap.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "5bf229629dddd3f28bd9c2f0299ce6339b5eefb5d6c7639a25a46e2665692f9c", + "sha256_in_prefix": "5bf229629dddd3f28bd9c2f0299ce6339b5eefb5d6c7639a25a46e2665692f9c", + "size_in_bytes": 56034 + }, + { + "_path": "lib/python3.12/importlib/__pycache__/_bootstrap_external.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "268ee56b568d6337b636f5c519b4552306973f1939fe4569bc2bb591fcd92010", + "sha256_in_prefix": "268ee56b568d6337b636f5c519b4552306973f1939fe4569bc2bb591fcd92010", + "size_in_bytes": 61750 + }, + { + "_path": "lib/python3.12/importlib/__pycache__/abc.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "f2bfd696cb6f8af1cb2ae5c1b9d867847925c99153c21afecb754f55197b2d01", + "sha256_in_prefix": "f2bfd696cb6f8af1cb2ae5c1b9d867847925c99153c21afecb754f55197b2d01", + "size_in_bytes": 10670 + }, + { + "_path": "lib/python3.12/importlib/__pycache__/machinery.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "c9666aed1ce52f437f3f16f1f755a5fe90d46afc198c20222ca593259446910a", + "sha256_in_prefix": "c9666aed1ce52f437f3f16f1f755a5fe90d46afc198c20222ca593259446910a", + "size_in_bytes": 1309 + }, + { + "_path": "lib/python3.12/importlib/__pycache__/readers.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "a9d6481225306223914368cb991a920071390def4f06a1f5d1737ef0fdd3c7c9", + "sha256_in_prefix": "a9d6481225306223914368cb991a920071390def4f06a1f5d1737ef0fdd3c7c9", + "size_in_bytes": 716 + }, + { + "_path": "lib/python3.12/importlib/__pycache__/simple.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "5175c9535fd55acb4c5f75043fea8ee6e57bd040864afbe96aeba88d1c9915d0", + "sha256_in_prefix": "5175c9535fd55acb4c5f75043fea8ee6e57bd040864afbe96aeba88d1c9915d0", + "size_in_bytes": 723 + }, + { + "_path": "lib/python3.12/importlib/__pycache__/util.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "56d459516693c0c112d5159b431bffa3745183425740f1928f2234ba6fa26159", + "sha256_in_prefix": "56d459516693c0c112d5159b431bffa3745183425740f1928f2234ba6fa26159", + "size_in_bytes": 11515 + }, + { + "_path": "lib/python3.12/importlib/_abc.py", + "path_type": "hardlink", + "sha256": "80aab7931dc999dee581c8b8b56fcd973fe156335a96ceeaf6acfc03cebf10e8", + "sha256_in_prefix": "80aab7931dc999dee581c8b8b56fcd973fe156335a96ceeaf6acfc03cebf10e8", + "size_in_bytes": 1354 + }, + { + "_path": "lib/python3.12/importlib/_bootstrap.py", + "path_type": "hardlink", + "sha256": "9653944363a4773cc32bbb34426024597a9d2ee4cd42e7912b4daf8cadfb53ed", + "sha256_in_prefix": "9653944363a4773cc32bbb34426024597a9d2ee4cd42e7912b4daf8cadfb53ed", + "size_in_bytes": 57056 + }, + { + "_path": "lib/python3.12/importlib/_bootstrap_external.py", + "path_type": "hardlink", + "sha256": "625a077defd004aa9b23f8d1b6952ff94018875baef71f2b8a3f1383ae27d8f5", + "sha256_in_prefix": "625a077defd004aa9b23f8d1b6952ff94018875baef71f2b8a3f1383ae27d8f5", + "size_in_bytes": 69069 + }, + { + "_path": "lib/python3.12/importlib/abc.py", + "path_type": "hardlink", + "sha256": "5f9cb36ca1bce9d5df00bc8d4d7f46b7ea2353dfa99292ad7f099affddfb5d03", + "sha256_in_prefix": "5f9cb36ca1bce9d5df00bc8d4d7f46b7ea2353dfa99292ad7f099affddfb5d03", + "size_in_bytes": 7612 + }, + { + "_path": "lib/python3.12/importlib/machinery.py", + "path_type": "hardlink", + "sha256": "d045cd7ecf2a12b6ecbfbef79eb114e87ef2ebd756f5b705f73e6f3266e3dede", + "sha256_in_prefix": "d045cd7ecf2a12b6ecbfbef79eb114e87ef2ebd756f5b705f73e6f3266e3dede", + "size_in_bytes": 880 + }, + { + "_path": "lib/python3.12/importlib/metadata/__init__.py", + "path_type": "hardlink", + "sha256": "b37ac52c704b3b0cd038f335723d4d91903e51bd4c34ed0bb7544dcc6b46d50d", + "sha256_in_prefix": "b37ac52c704b3b0cd038f335723d4d91903e51bd4c34ed0bb7544dcc6b46d50d", + "size_in_bytes": 28726 + }, + { + "_path": "lib/python3.12/importlib/metadata/__pycache__/__init__.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "72f1b00f2ce7f14d85f8a112b1df43d8887b7c04c8da140a2ca899a648378b04", + "sha256_in_prefix": "72f1b00f2ce7f14d85f8a112b1df43d8887b7c04c8da140a2ca899a648378b04", + "size_in_bytes": 48713 + }, + { + "_path": "lib/python3.12/importlib/metadata/__pycache__/_adapters.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "365b0dc09925d60d774ca2eb27d9f526ed753b9b3ba95db42e3f0be26dc65d33", + "sha256_in_prefix": "365b0dc09925d60d774ca2eb27d9f526ed753b9b3ba95db42e3f0be26dc65d33", + "size_in_bytes": 4089 + }, + { + "_path": "lib/python3.12/importlib/metadata/__pycache__/_collections.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "b96d6b415ad0d4c92bbedc6b90c3a89d8eed198550ebf7c931c6773f06dfb8e8", + "sha256_in_prefix": "b96d6b415ad0d4c92bbedc6b90c3a89d8eed198550ebf7c931c6773f06dfb8e8", + "size_in_bytes": 2137 + }, + { + "_path": "lib/python3.12/importlib/metadata/__pycache__/_functools.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "fc7e38a92103fbe3d531ad95f291b50bb0a2d0c21b2a590594fc726aabaca9b2", + "sha256_in_prefix": "fc7e38a92103fbe3d531ad95f291b50bb0a2d0c21b2a590594fc726aabaca9b2", + "size_in_bytes": 3695 + }, + { + "_path": "lib/python3.12/importlib/metadata/__pycache__/_itertools.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "fab2f22878cd516a2a50818f1125c47ae2b6640794e53c75678324d3c6dceaaf", + "sha256_in_prefix": "fab2f22878cd516a2a50818f1125c47ae2b6640794e53c75678324d3c6dceaaf", + "size_in_bytes": 2619 + }, + { + "_path": "lib/python3.12/importlib/metadata/__pycache__/_meta.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "7519ddb992b6e6bcf3b6f79bf9926f327a9f8611afef7eda8e1827ad4f263889", + "sha256_in_prefix": "7519ddb992b6e6bcf3b6f79bf9926f327a9f8611afef7eda8e1827ad4f263889", + "size_in_bytes": 3535 + }, + { + "_path": "lib/python3.12/importlib/metadata/__pycache__/_text.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "cecb58aac9a1483a9619bcc1e1b1664cddf7fec40af5954bc56db3a20a356e2e", + "sha256_in_prefix": "cecb58aac9a1483a9619bcc1e1b1664cddf7fec40af5954bc56db3a20a356e2e", + "size_in_bytes": 4096 + }, + { + "_path": "lib/python3.12/importlib/metadata/_adapters.py", + "path_type": "hardlink", + "sha256": "de9a880abc4513af1b69ce150cd5a5093201c39131717cdc2ba6b19f4364c163", + "sha256_in_prefix": "de9a880abc4513af1b69ce150cd5a5093201c39131717cdc2ba6b19f4364c163", + "size_in_bytes": 2406 + }, + { + "_path": "lib/python3.12/importlib/metadata/_collections.py", + "path_type": "hardlink", + "sha256": "089d0e4c21c88d6034648552e2fa0e440b27d91e11d9c40112d3ec6442690126", + "sha256_in_prefix": "089d0e4c21c88d6034648552e2fa0e440b27d91e11d9c40112d3ec6442690126", + "size_in_bytes": 743 + }, + { + "_path": "lib/python3.12/importlib/metadata/_functools.py", + "path_type": "hardlink", + "sha256": "3ec636fb8aeb297e1155e442d681a9d65075a660bd78a37cf3f7fe6c3f6e3a80", + "sha256_in_prefix": "3ec636fb8aeb297e1155e442d681a9d65075a660bd78a37cf3f7fe6c3f6e3a80", + "size_in_bytes": 2895 + }, + { + "_path": "lib/python3.12/importlib/metadata/_itertools.py", + "path_type": "hardlink", + "sha256": "72faffdaff0145bc5c225e71e6575fa9d1e3848f188bcb3cca4e741bf9e6ea34", + "sha256_in_prefix": "72faffdaff0145bc5c225e71e6575fa9d1e3848f188bcb3cca4e741bf9e6ea34", + "size_in_bytes": 2068 + }, + { + "_path": "lib/python3.12/importlib/metadata/_meta.py", + "path_type": "hardlink", + "sha256": "bd3504040497cd049e6b529bde0b461f63cd2be3070f2d0815d4dd7609b266c8", + "sha256_in_prefix": "bd3504040497cd049e6b529bde0b461f63cd2be3070f2d0815d4dd7609b266c8", + "size_in_bytes": 1590 + }, + { + "_path": "lib/python3.12/importlib/metadata/_text.py", + "path_type": "hardlink", + "sha256": "1c2b0592c66924b7933f734493f9e0ac079755146d4ebb7287d78e001a113f80", + "sha256_in_prefix": "1c2b0592c66924b7933f734493f9e0ac079755146d4ebb7287d78e001a113f80", + "size_in_bytes": 2166 + }, + { + "_path": "lib/python3.12/importlib/readers.py", + "path_type": "hardlink", + "sha256": "d0d57d118d64916f7e6edb04f8bd1a760a1abb879125899ef50a36d09ef54df4", + "sha256_in_prefix": "d0d57d118d64916f7e6edb04f8bd1a760a1abb879125899ef50a36d09ef54df4", + "size_in_bytes": 327 + }, + { + "_path": "lib/python3.12/importlib/resources/__init__.py", + "path_type": "hardlink", + "sha256": "7af3e6d7690b818a939bea5bce6eb46cebae9ae993f08a41356169d2e332af31", + "sha256_in_prefix": "7af3e6d7690b818a939bea5bce6eb46cebae9ae993f08a41356169d2e332af31", + "size_in_bytes": 506 + }, + { + "_path": "lib/python3.12/importlib/resources/__pycache__/__init__.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "b7e75a5d29b9ba57a0fde076260abbdc02d85ca07886827dacb02431698a40b3", + "sha256_in_prefix": "b7e75a5d29b9ba57a0fde076260abbdc02d85ca07886827dacb02431698a40b3", + "size_in_bytes": 869 + }, + { + "_path": "lib/python3.12/importlib/resources/__pycache__/_adapters.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "e8ad5b703433879fbf79623c7c0cce0611c5ecd5387f5f839a9f6a09a61febdb", + "sha256_in_prefix": "e8ad5b703433879fbf79623c7c0cce0611c5ecd5387f5f839a9f6a09a61febdb", + "size_in_bytes": 9880 + }, + { + "_path": "lib/python3.12/importlib/resources/__pycache__/_common.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "2c2b9c86fd91a5be884b4ddad969eb67b4ace0937536785672f15ff5de7d8789", + "sha256_in_prefix": "2c2b9c86fd91a5be884b4ddad969eb67b4ace0937536785672f15ff5de7d8789", + "size_in_bytes": 8963 + }, + { + "_path": "lib/python3.12/importlib/resources/__pycache__/_itertools.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "1a57e6f3f5fa60b03f9aed8d70d2dfa08e8bd2dfb38060be8667909b97115dd6", + "sha256_in_prefix": "1a57e6f3f5fa60b03f9aed8d70d2dfa08e8bd2dfb38060be8667909b97115dd6", + "size_in_bytes": 1793 + }, + { + "_path": "lib/python3.12/importlib/resources/__pycache__/_legacy.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "edf6f8beb0581f621698b0ec4b4b02cb3a121757210a321142b84ad3a96feeec", + "sha256_in_prefix": "edf6f8beb0581f621698b0ec4b4b02cb3a121757210a321142b84ad3a96feeec", + "size_in_bytes": 5997 + }, + { + "_path": "lib/python3.12/importlib/resources/__pycache__/abc.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "855fc4766b811f29c2bebaa21441ce62cf5da5536f95fa326bb94ba6041d6964", + "sha256_in_prefix": "855fc4766b811f29c2bebaa21441ce62cf5da5536f95fa326bb94ba6041d6964", + "size_in_bytes": 9175 + }, + { + "_path": "lib/python3.12/importlib/resources/__pycache__/readers.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "4775cfdb5a850e6004e40028575b939f57e820c30bd03782adc2134d3a45660f", + "sha256_in_prefix": "4775cfdb5a850e6004e40028575b939f57e820c30bd03782adc2134d3a45660f", + "size_in_bytes": 9148 + }, + { + "_path": "lib/python3.12/importlib/resources/__pycache__/simple.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "02d4f4a142edc85672898b1d33caad1e1464cd70dc3dcee49a6f3a0763a5bf95", + "sha256_in_prefix": "02d4f4a142edc85672898b1d33caad1e1464cd70dc3dcee49a6f3a0763a5bf95", + "size_in_bytes": 5705 + }, + { + "_path": "lib/python3.12/importlib/resources/_adapters.py", + "path_type": "hardlink", + "sha256": "be9ac919b51e1db6a35fa5c2b8c3fa27794caea0a2f8ffcc4e5ce225447b8df9", + "sha256_in_prefix": "be9ac919b51e1db6a35fa5c2b8c3fa27794caea0a2f8ffcc4e5ce225447b8df9", + "size_in_bytes": 4482 + }, + { + "_path": "lib/python3.12/importlib/resources/_common.py", + "path_type": "hardlink", + "sha256": "9bfef8de14579936e96c0e921e934a3f4f56b4e32d3cfacc12f3e24436fc37b4", + "sha256_in_prefix": "9bfef8de14579936e96c0e921e934a3f4f56b4e32d3cfacc12f3e24436fc37b4", + "size_in_bytes": 5459 + }, + { + "_path": "lib/python3.12/importlib/resources/_itertools.py", + "path_type": "hardlink", + "sha256": "7838ac57a46a88d64ea202d25dfe8b3861ce61cefd14680faca34bcc52e60ab5", + "sha256_in_prefix": "7838ac57a46a88d64ea202d25dfe8b3861ce61cefd14680faca34bcc52e60ab5", + "size_in_bytes": 1277 + }, + { + "_path": "lib/python3.12/importlib/resources/_legacy.py", + "path_type": "hardlink", + "sha256": "d1329d662c712d603ec70b40670e07729a899a3e17a6bc7566472dcb48134596", + "sha256_in_prefix": "d1329d662c712d603ec70b40670e07729a899a3e17a6bc7566472dcb48134596", + "size_in_bytes": 3481 + }, + { + "_path": "lib/python3.12/importlib/resources/abc.py", + "path_type": "hardlink", + "sha256": "a726c48590b21ba5532f0c654735991571bc0ecafe88145cb8891d82cd364e5e", + "sha256_in_prefix": "a726c48590b21ba5532f0c654735991571bc0ecafe88145cb8891d82cd364e5e", + "size_in_bytes": 5203 + }, + { + "_path": "lib/python3.12/importlib/resources/readers.py", + "path_type": "hardlink", + "sha256": "231e0c485123729f26b706e54b1810d4294d3bd7182a2355b14b8318bd4ecf8e", + "sha256_in_prefix": "231e0c485123729f26b706e54b1810d4294d3bd7182a2355b14b8318bd4ecf8e", + "size_in_bytes": 4303 + }, + { + "_path": "lib/python3.12/importlib/resources/simple.py", + "path_type": "hardlink", + "sha256": "d3fff64d0053428aa46a362634fb751f11117117804fa6e854a240df6f29af4e", + "sha256_in_prefix": "d3fff64d0053428aa46a362634fb751f11117117804fa6e854a240df6f29af4e", + "size_in_bytes": 2576 + }, + { + "_path": "lib/python3.12/importlib/simple.py", + "path_type": "hardlink", + "sha256": "8e687aeeb1db537d2717cb0352c5f126ff7d4095c6de6dc7f00d5103f3009c40", + "sha256_in_prefix": "8e687aeeb1db537d2717cb0352c5f126ff7d4095c6de6dc7f00d5103f3009c40", + "size_in_bytes": 354 + }, + { + "_path": "lib/python3.12/importlib/util.py", + "path_type": "hardlink", + "sha256": "9f3e638fab0ce5825edd78ac09f326ca80bd757bdf61be1658bf2a2b0cae5d69", + "sha256_in_prefix": "9f3e638fab0ce5825edd78ac09f326ca80bd757bdf61be1658bf2a2b0cae5d69", + "size_in_bytes": 9610 + }, + { + "_path": "lib/python3.12/inspect.py", + "path_type": "hardlink", + "sha256": "2cc3b3e41032cd523110607a7d7cad966106e58d0a4dc5869b20185a097213ad", + "sha256_in_prefix": "2cc3b3e41032cd523110607a7d7cad966106e58d0a4dc5869b20185a097213ad", + "size_in_bytes": 126247 + }, + { + "_path": "lib/python3.12/io.py", + "path_type": "hardlink", + "sha256": "7cec3cb8ac004058dd0a5af246e6d950fb59c7ddd0058fda48bcb3fcb98d8822", + "sha256_in_prefix": "7cec3cb8ac004058dd0a5af246e6d950fb59c7ddd0058fda48bcb3fcb98d8822", + "size_in_bytes": 3582 + }, + { + "_path": "lib/python3.12/ipaddress.py", + "path_type": "hardlink", + "sha256": "687e343fa31d6470a3856d825e410509b24f7117be12ccba8a704d88214e206a", + "sha256_in_prefix": "687e343fa31d6470a3856d825e410509b24f7117be12ccba8a704d88214e206a", + "size_in_bytes": 75012 + }, + { + "_path": "lib/python3.12/json/__init__.py", + "path_type": "hardlink", + "sha256": "d5d41e2c29049515d295d81a6d40b4890fbec8d8482cfb401630f8ef2f77e4d5", + "sha256_in_prefix": "d5d41e2c29049515d295d81a6d40b4890fbec8d8482cfb401630f8ef2f77e4d5", + "size_in_bytes": 14020 + }, + { + "_path": "lib/python3.12/json/__pycache__/__init__.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "7c6d6f98db7b4417c4dccc2d3604e2427055990ba036ad997bb9e2828492b5f8", + "sha256_in_prefix": "7c6d6f98db7b4417c4dccc2d3604e2427055990ba036ad997bb9e2828492b5f8", + "size_in_bytes": 13874 + }, + { + "_path": "lib/python3.12/json/__pycache__/decoder.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "a15b91358f94d4b058167656c4e4fb9a44b0661b5dcd289b3251a67900c02183", + "sha256_in_prefix": "a15b91358f94d4b058167656c4e4fb9a44b0661b5dcd289b3251a67900c02183", + "size_in_bytes": 14079 + }, + { + "_path": "lib/python3.12/json/__pycache__/encoder.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "4799e0b1e576011a09cdfe851c8f8bd131605303c642f1f80ce49ec35505c9d9", + "sha256_in_prefix": "4799e0b1e576011a09cdfe851c8f8bd131605303c642f1f80ce49ec35505c9d9", + "size_in_bytes": 15362 + }, + { + "_path": "lib/python3.12/json/__pycache__/scanner.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "31b0b96b6adc5b2ffbf60bc664b993055be6a0682623526454400a97cca68593", + "sha256_in_prefix": "31b0b96b6adc5b2ffbf60bc664b993055be6a0682623526454400a97cca68593", + "size_in_bytes": 3575 + }, + { + "_path": "lib/python3.12/json/__pycache__/tool.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "8f410f195ea4b74b00be4d1fbf4edfe97b0da4b8789d5067c2bbe0e64deeb6ee", + "sha256_in_prefix": "8f410f195ea4b74b00be4d1fbf4edfe97b0da4b8789d5067c2bbe0e64deeb6ee", + "size_in_bytes": 4556 + }, + { + "_path": "lib/python3.12/json/decoder.py", + "path_type": "hardlink", + "sha256": "9f02654649816145bc76f8c210a5fe3ba1de142d4d97a1c93105732e747c285b", + "sha256_in_prefix": "9f02654649816145bc76f8c210a5fe3ba1de142d4d97a1c93105732e747c285b", + "size_in_bytes": 12473 + }, + { + "_path": "lib/python3.12/json/encoder.py", + "path_type": "hardlink", + "sha256": "7c358788fbb2a6a07f66f1f8446c52396f35fc201108f666d5be002d86f31af2", + "sha256_in_prefix": "7c358788fbb2a6a07f66f1f8446c52396f35fc201108f666d5be002d86f31af2", + "size_in_bytes": 16080 + }, + { + "_path": "lib/python3.12/json/scanner.py", + "path_type": "hardlink", + "sha256": "8604d9d03786d0d509abb49e9f069337278ea988c244069ae8ca2c89acc2cb08", + "sha256_in_prefix": "8604d9d03786d0d509abb49e9f069337278ea988c244069ae8ca2c89acc2cb08", + "size_in_bytes": 2425 + }, + { + "_path": "lib/python3.12/json/tool.py", + "path_type": "hardlink", + "sha256": "d5174b728b376a12cff3f17472d6b9b609c1d3926f7ee02d74d60c80afd60c77", + "sha256_in_prefix": "d5174b728b376a12cff3f17472d6b9b609c1d3926f7ee02d74d60c80afd60c77", + "size_in_bytes": 3339 + }, + { + "_path": "lib/python3.12/keyword.py", + "path_type": "hardlink", + "sha256": "18c2be738c04ad20ad375f6a71db34b3823c7f40b0340f5294d0e89f3c9b093b", + "sha256_in_prefix": "18c2be738c04ad20ad375f6a71db34b3823c7f40b0340f5294d0e89f3c9b093b", + "size_in_bytes": 1073 + }, + { + "_path": "lib/python3.12/lib-dynload/_asyncio.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "c89cefdc9f6a011938e9d9bb9bded27dbecbbd6770c7a90082df9c9e4d1ba3cc", + "sha256_in_prefix": "c89cefdc9f6a011938e9d9bb9bded27dbecbbd6770c7a90082df9c9e4d1ba3cc", + "size_in_bytes": 100080 + }, + { + "_path": "lib/python3.12/lib-dynload/_bisect.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "f4656cdef8be5eaac895481b8ab3c798f71d33f534e0ff323c4e4fb0a1d18898", + "sha256_in_prefix": "f4656cdef8be5eaac895481b8ab3c798f71d33f534e0ff323c4e4fb0a1d18898", + "size_in_bytes": 53984 + }, + { + "_path": "lib/python3.12/lib-dynload/_blake2.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "20f0328bb1c1be443a02cfbb66f37e25a97a799bc1db73c27113ef2076ecc4d3", + "sha256_in_prefix": "20f0328bb1c1be443a02cfbb66f37e25a97a799bc1db73c27113ef2076ecc4d3", + "size_in_bytes": 72784 + }, + { + "_path": "lib/python3.12/lib-dynload/_bz2.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "e119679f41d1fd3763f6e3bafdff8466c58a9360755a4d0ceec6eb815e7c9f3a", + "sha256_in_prefix": "e119679f41d1fd3763f6e3bafdff8466c58a9360755a4d0ceec6eb815e7c9f3a", + "size_in_bytes": 56144 + }, + { + "_path": "lib/python3.12/lib-dynload/_codecs_cn.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "ac12e1f043a7cddc5f642eabee253830482cdf604733dd43c92c60bee7361d70", + "sha256_in_prefix": "ac12e1f043a7cddc5f642eabee253830482cdf604733dd43c92c60bee7361d70", + "size_in_bytes": 169088 + }, + { + "_path": "lib/python3.12/lib-dynload/_codecs_hk.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "a44a2a7f07da8cf0b53a4e40d4d6095382274f376a8141a258d16e0710f2bb1e", + "sha256_in_prefix": "a44a2a7f07da8cf0b53a4e40d4d6095382274f376a8141a258d16e0710f2bb1e", + "size_in_bytes": 185680 + }, + { + "_path": "lib/python3.12/lib-dynload/_codecs_iso2022.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "3ade05a9af7f029bcd7b46278bf83b372111567999ac2b667c351d063eb49b0a", + "sha256_in_prefix": "3ade05a9af7f029bcd7b46278bf83b372111567999ac2b667c351d063eb49b0a", + "size_in_bytes": 55152 + }, + { + "_path": "lib/python3.12/lib-dynload/_codecs_jp.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "fe26ba9ac10eaf481ae11da44f2d540b61070f7283e22b41d6ec6f873ea6fb16", + "sha256_in_prefix": "fe26ba9ac10eaf481ae11da44f2d540b61070f7283e22b41d6ec6f873ea6fb16", + "size_in_bytes": 285600 + }, + { + "_path": "lib/python3.12/lib-dynload/_codecs_kr.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "f58cb94e90925ce685e4d3e0ecf1a4cb87395dd938193b1b3fe181af74cb4c5a", + "sha256_in_prefix": "f58cb94e90925ce685e4d3e0ecf1a4cb87395dd938193b1b3fe181af74cb4c5a", + "size_in_bytes": 152656 + }, + { + "_path": "lib/python3.12/lib-dynload/_codecs_tw.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "ae8c5528343cb56bc50d5f2039b67c827b633cbeca798398ffae422594acbc36", + "sha256_in_prefix": "ae8c5528343cb56bc50d5f2039b67c827b633cbeca798398ffae422594acbc36", + "size_in_bytes": 152160 + }, + { + "_path": "lib/python3.12/lib-dynload/_contextvars.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "59bee12d6689491c65ce2bf45fbac9dbd335c77cc62a35badc4604ad2f6fbf10", + "sha256_in_prefix": "59bee12d6689491c65ce2bf45fbac9dbd335c77cc62a35badc4604ad2f6fbf10", + "size_in_bytes": 51696 + }, + { + "_path": "lib/python3.12/lib-dynload/_crypt.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "f0c244c96f4c0554c8bba75cceb49d862e52c1b1e7f77533018486a1202f6ff1", + "sha256_in_prefix": "f0c244c96f4c0554c8bba75cceb49d862e52c1b1e7f77533018486a1202f6ff1", + "size_in_bytes": 51984 + }, + { + "_path": "lib/python3.12/lib-dynload/_csv.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "e10919b3feee4eabfa6830e99362d5810e41f5e7b6d7118c3e5dcfb522ff2bc1", + "sha256_in_prefix": "e10919b3feee4eabfa6830e99362d5810e41f5e7b6d7118c3e5dcfb522ff2bc1", + "size_in_bytes": 74592 + }, + { + "_path": "lib/python3.12/lib-dynload/_ctypes.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "bb593e13795dd4768fa1072d1cdfd0d682e763cdda1b1465239dfb82c0dd9bda", + "sha256_in_prefix": "bb593e13795dd4768fa1072d1cdfd0d682e763cdda1b1465239dfb82c0dd9bda", + "size_in_bytes": 141120 + }, + { + "_path": "lib/python3.12/lib-dynload/_ctypes_test.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "e717c2c5ac5016b94f7028a34437fbd178a0140385b47e1cec719a2937231821", + "sha256_in_prefix": "e717c2c5ac5016b94f7028a34437fbd178a0140385b47e1cec719a2937231821", + "size_in_bytes": 57392 + }, + { + "_path": "lib/python3.12/lib-dynload/_curses.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "1e3bd2c721ba83c6a73a388323d21fc455b35ebc5e46ab2d3597ca15751d771d", + "sha256_in_prefix": "1e3bd2c721ba83c6a73a388323d21fc455b35ebc5e46ab2d3597ca15751d771d", + "size_in_bytes": 158800 + }, + { + "_path": "lib/python3.12/lib-dynload/_curses_panel.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "d2267baec769db7a1d76a779c3965a8b082f2efa76f09b969e02eb90cb7ec066", + "sha256_in_prefix": "d2267baec769db7a1d76a779c3965a8b082f2efa76f09b969e02eb90cb7ec066", + "size_in_bytes": 56352 + }, + { + "_path": "lib/python3.12/lib-dynload/_datetime.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "2c995a7388df907056bfd2100d011e52ae9a4636aa5f6d9f7dc49f240cbafdc8", + "sha256_in_prefix": "2c995a7388df907056bfd2100d011e52ae9a4636aa5f6d9f7dc49f240cbafdc8", + "size_in_bytes": 132672 + }, + { + "_path": "lib/python3.12/lib-dynload/_dbm.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "0244a210c5c7b7e0f938fb6776d0e6cd4b833ec968afa82ef349901dc970a054", + "sha256_in_prefix": "0244a210c5c7b7e0f938fb6776d0e6cd4b833ec968afa82ef349901dc970a054", + "size_in_bytes": 55088 + }, + { + "_path": "lib/python3.12/lib-dynload/_decimal.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "2d63736924403f339350d77c794d809d1e44c24133283257f2526bb02ffd1382", + "sha256_in_prefix": "2d63736924403f339350d77c794d809d1e44c24133283257f2526bb02ffd1382", + "size_in_bytes": 325936 + }, + { + "_path": "lib/python3.12/lib-dynload/_elementtree.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "f0b6f7165bd632cee2358f11fa0aa5e5a932c6dfb87f348e2a54e20301d3c014", + "sha256_in_prefix": "f0b6f7165bd632cee2358f11fa0aa5e5a932c6dfb87f348e2a54e20301d3c014", + "size_in_bytes": 100912 + }, + { + "_path": "lib/python3.12/lib-dynload/_hashlib.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "e473a715d4f827eb5f1db40421120eac4d7ec46458b18e34a2b96dffc6761e19", + "sha256_in_prefix": "e473a715d4f827eb5f1db40421120eac4d7ec46458b18e34a2b96dffc6761e19", + "size_in_bytes": 80928 + }, + { + "_path": "lib/python3.12/lib-dynload/_heapq.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "d0c475d46f61bfcb2949c61cff4f2983f08c28e2acf121487dfea77ced192c8f", + "sha256_in_prefix": "d0c475d46f61bfcb2949c61cff4f2983f08c28e2acf121487dfea77ced192c8f", + "size_in_bytes": 52864 + }, + { + "_path": "lib/python3.12/lib-dynload/_json.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "06f830210bea960630d66f046e4c60a38dcae37209c0fe475b9aec6a5fedb4b5", + "sha256_in_prefix": "06f830210bea960630d66f046e4c60a38dcae37209c0fe475b9aec6a5fedb4b5", + "size_in_bytes": 73648 + }, + { + "_path": "lib/python3.12/lib-dynload/_lsprof.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "d3094f8b25e8125020c420ab1ec7ccc92e913bdc01dcf4fa1fda1962b0a63322", + "sha256_in_prefix": "d3094f8b25e8125020c420ab1ec7ccc92e913bdc01dcf4fa1fda1962b0a63322", + "size_in_bytes": 55904 + }, + { + "_path": "lib/python3.12/lib-dynload/_lzma.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "6780d012bb31edf487c86158fe96a10313a839572c53b654ca899711b789095b", + "sha256_in_prefix": "6780d012bb31edf487c86158fe96a10313a839572c53b654ca899711b789095b", + "size_in_bytes": 75920 + }, + { + "_path": "lib/python3.12/lib-dynload/_md5.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "a0c37e32da7caa098be8a2be56bceb8bf71e8ac33bcf62fd20114ba162dd4422", + "sha256_in_prefix": "a0c37e32da7caa098be8a2be56bceb8bf71e8ac33bcf62fd20114ba162dd4422", + "size_in_bytes": 54544 + }, + { + "_path": "lib/python3.12/lib-dynload/_multibytecodec.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "a940004319594e7efb087aff56d4fa05d365619b86a012db43a22b4032a96ed6", + "sha256_in_prefix": "a940004319594e7efb087aff56d4fa05d365619b86a012db43a22b4032a96ed6", + "size_in_bytes": 79296 + }, + { + "_path": "lib/python3.12/lib-dynload/_multiprocessing.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "3eb6fd2c7961b99e0a93039205bd0bf5ad11ec8a6fc33b448db91679a9865fbe", + "sha256_in_prefix": "3eb6fd2c7961b99e0a93039205bd0bf5ad11ec8a6fc33b448db91679a9865fbe", + "size_in_bytes": 56496 + }, + { + "_path": "lib/python3.12/lib-dynload/_opcode.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "ac407c32bb39406125b45e88c2cc0116e067cea739344c4fcbf382915a09f4da", + "sha256_in_prefix": "ac407c32bb39406125b45e88c2cc0116e067cea739344c4fcbf382915a09f4da", + "size_in_bytes": 52304 + }, + { + "_path": "lib/python3.12/lib-dynload/_pickle.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "63074055ace2be2539b025d75139baf0da00edf18b72d84b98864ba0bd1812f7", + "sha256_in_prefix": "63074055ace2be2539b025d75139baf0da00edf18b72d84b98864ba0bd1812f7", + "size_in_bytes": 151376 + }, + { + "_path": "lib/python3.12/lib-dynload/_posixshmem.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "f7a529633e78d495c8afd4e62296ae348e858df5802f4ea376fd26333e51e0d9", + "sha256_in_prefix": "f7a529633e78d495c8afd4e62296ae348e858df5802f4ea376fd26333e51e0d9", + "size_in_bytes": 52672 + }, + { + "_path": "lib/python3.12/lib-dynload/_posixsubprocess.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "7b504fccb47acdcb31f3525345e13d85a2a1e1bf87b423abb5bee4c9750f7fd9", + "sha256_in_prefix": "7b504fccb47acdcb31f3525345e13d85a2a1e1bf87b423abb5bee4c9750f7fd9", + "size_in_bytes": 55520 + }, + { + "_path": "lib/python3.12/lib-dynload/_queue.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "dadd461d48840a3b626b6b7782db8d0a6025d59cbe47b098bd28883756f340dd", + "sha256_in_prefix": "dadd461d48840a3b626b6b7782db8d0a6025d59cbe47b098bd28883756f340dd", + "size_in_bytes": 55456 + }, + { + "_path": "lib/python3.12/lib-dynload/_random.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "9db9d38102925d913e09e545e8aaac1bdf526e3d80c1e5a74c835687481b9e96", + "sha256_in_prefix": "9db9d38102925d913e09e545e8aaac1bdf526e3d80c1e5a74c835687481b9e96", + "size_in_bytes": 54784 + }, + { + "_path": "lib/python3.12/lib-dynload/_scproxy.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "a93c04d25efc3aa237a71b4e84d55ba1c1632db5a8657251e33a0136f0356413", + "sha256_in_prefix": "a93c04d25efc3aa237a71b4e84d55ba1c1632db5a8657251e33a0136f0356413", + "size_in_bytes": 54432 + }, + { + "_path": "lib/python3.12/lib-dynload/_sha1.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "803f19aa0bebe110a3c48d9c2b94bf7a4dba57003098b681a446ac52312e1cbf", + "sha256_in_prefix": "803f19aa0bebe110a3c48d9c2b94bf7a4dba57003098b681a446ac52312e1cbf", + "size_in_bytes": 54576 + }, + { + "_path": "lib/python3.12/lib-dynload/_sha2.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "f6ade0de09f97cf08e8b6fd49c698c0258a8bbf1f5fda27b1a572249e525c507", + "sha256_in_prefix": "f6ade0de09f97cf08e8b6fd49c698c0258a8bbf1f5fda27b1a572249e525c507", + "size_in_bytes": 72368 + }, + { + "_path": "lib/python3.12/lib-dynload/_sha3.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "d5a61b7f91fea785dda01c995c6b62e2f7015dc94bbd3e241bd47455dde7c9f1", + "sha256_in_prefix": "d5a61b7f91fea785dda01c995c6b62e2f7015dc94bbd3e241bd47455dde7c9f1", + "size_in_bytes": 72480 + }, + { + "_path": "lib/python3.12/lib-dynload/_socket.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "45201cd9a0a2ed4e86faab9a7f52c1ed13d3782808e2ee1766c202ca984c62b5", + "sha256_in_prefix": "45201cd9a0a2ed4e86faab9a7f52c1ed13d3782808e2ee1766c202ca984c62b5", + "size_in_bytes": 115168 + }, + { + "_path": "lib/python3.12/lib-dynload/_sqlite3.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "a04a1e10cdb6a42dea427640d1ef2a647b6504b6ccbab19b1c91aa553cce61ca", + "sha256_in_prefix": "a04a1e10cdb6a42dea427640d1ef2a647b6504b6ccbab19b1c91aa553cce61ca", + "size_in_bytes": 144144 + }, + { + "_path": "lib/python3.12/lib-dynload/_ssl.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "3fe5709fa26962dfa9f498c743520273d0de9009ea84e21dfc621a439a481841", + "sha256_in_prefix": "3fe5709fa26962dfa9f498c743520273d0de9009ea84e21dfc621a439a481841", + "size_in_bytes": 201104 + }, + { + "_path": "lib/python3.12/lib-dynload/_statistics.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "5d8c4d56e4c571a7b4282f21c0b7ba25cc07fd1acdfd36a122d76fa403855249", + "sha256_in_prefix": "5d8c4d56e4c571a7b4282f21c0b7ba25cc07fd1acdfd36a122d76fa403855249", + "size_in_bytes": 51856 + }, + { + "_path": "lib/python3.12/lib-dynload/_struct.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "73f08f7bee74f11215d5f8ea4ae07c0b10dd472c27107ff70f1f37ade1cc1fc3", + "sha256_in_prefix": "73f08f7bee74f11215d5f8ea4ae07c0b10dd472c27107ff70f1f37ade1cc1fc3", + "size_in_bytes": 77952 + }, + { + "_path": "lib/python3.12/lib-dynload/_testbuffer.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "854fa73c220a9dc618c02e68c0452717c0972653a4eb1ed08c77f950b16194ae", + "sha256_in_prefix": "854fa73c220a9dc618c02e68c0452717c0972653a4eb1ed08c77f950b16194ae", + "size_in_bytes": 75168 + }, + { + "_path": "lib/python3.12/lib-dynload/_testcapi.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "2e69a44487f0422fd108642ed0a9209a6467b7352daa96ffde43b41e92177150", + "sha256_in_prefix": "2e69a44487f0422fd108642ed0a9209a6467b7352daa96ffde43b41e92177150", + "size_in_bytes": 358864 + }, + { + "_path": "lib/python3.12/lib-dynload/_testclinic.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "770a1356bfb35261a5602dca4d32d97920813b478c3f4ccc3c3c360fa99b35f1", + "sha256_in_prefix": "770a1356bfb35261a5602dca4d32d97920813b478c3f4ccc3c3c360fa99b35f1", + "size_in_bytes": 96032 + }, + { + "_path": "lib/python3.12/lib-dynload/_testimportmultiple.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "29fd4a8a10956a3f6463af6103d4c879b5828ab901e3ccc3a5ac7428bb0f0b3e", + "sha256_in_prefix": "29fd4a8a10956a3f6463af6103d4c879b5828ab901e3ccc3a5ac7428bb0f0b3e", + "size_in_bytes": 51344 + }, + { + "_path": "lib/python3.12/lib-dynload/_testinternalcapi.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "f1e576eb2f151afe032186fabb5f9891b45697cd90ebcd3ef909a7b4aec69632", + "sha256_in_prefix": "f1e576eb2f151afe032186fabb5f9891b45697cd90ebcd3ef909a7b4aec69632", + "size_in_bytes": 76976 + }, + { + "_path": "lib/python3.12/lib-dynload/_testmultiphase.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "19881be175fb67690af2fb5784e0f5d89be422bdd764b2e73dbe565a4ec8e511", + "sha256_in_prefix": "19881be175fb67690af2fb5784e0f5d89be422bdd764b2e73dbe565a4ec8e511", + "size_in_bytes": 60096 + }, + { + "_path": "lib/python3.12/lib-dynload/_testsinglephase.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "5e7103a052592cacc94e73bc3fb92bb788082c4a792a780b93af4654b30708c1", + "sha256_in_prefix": "5e7103a052592cacc94e73bc3fb92bb788082c4a792a780b93af4654b30708c1", + "size_in_bytes": 53456 + }, + { + "_path": "lib/python3.12/lib-dynload/_tkinter.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "6076c2ba18b7fa775341805e03e4b556d9d6617cd5609b854d335984389098c3", + "sha256_in_prefix": "6076c2ba18b7fa775341805e03e4b556d9d6617cd5609b854d335984389098c3", + "size_in_bytes": 100576 + }, + { + "_path": "lib/python3.12/lib-dynload/_uuid.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "5d2e95f7d6dbeb4dddc9a6f16fd4271d79dcc8f3a588801454bdf8e1e8d8b476", + "sha256_in_prefix": "5d2e95f7d6dbeb4dddc9a6f16fd4271d79dcc8f3a588801454bdf8e1e8d8b476", + "size_in_bytes": 51648 + }, + { + "_path": "lib/python3.12/lib-dynload/_xxinterpchannels.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "73473b1458aa4bd75e433e87afc23346548d3fcf75518d8615a5a8ac598beab9", + "sha256_in_prefix": "73473b1458aa4bd75e433e87afc23346548d3fcf75518d8615a5a8ac598beab9", + "size_in_bytes": 74224 + }, + { + "_path": "lib/python3.12/lib-dynload/_xxsubinterpreters.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "983c832e71357fc0f392a8bff80271c31337d6a0a50376af20d8528d8e29ace8", + "sha256_in_prefix": "983c832e71357fc0f392a8bff80271c31337d6a0a50376af20d8528d8e29ace8", + "size_in_bytes": 56960 + }, + { + "_path": "lib/python3.12/lib-dynload/_xxtestfuzz.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "0be6c1ae120929048217291fa7963dc55b719409f4be03aba5c7a145001e06f5", + "sha256_in_prefix": "0be6c1ae120929048217291fa7963dc55b719409f4be03aba5c7a145001e06f5", + "size_in_bytes": 54384 + }, + { + "_path": "lib/python3.12/lib-dynload/_zoneinfo.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "d9e054f9025d883ad005b814198ec64d034517cfda8873aa42b9c4e96abc21af", + "sha256_in_prefix": "d9e054f9025d883ad005b814198ec64d034517cfda8873aa42b9c4e96abc21af", + "size_in_bytes": 74912 + }, + { + "_path": "lib/python3.12/lib-dynload/array.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "ceeee17c1065018c4ddcbfd4635913ee79fcaa99acf33c20a91bf71a122a2ea2", + "sha256_in_prefix": "ceeee17c1065018c4ddcbfd4635913ee79fcaa99acf33c20a91bf71a122a2ea2", + "size_in_bytes": 96736 + }, + { + "_path": "lib/python3.12/lib-dynload/audioop.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "316e0d291fd0c7f47fe7f6ae752993dca4a1bb32df8e8271e04961813bf678bf", + "sha256_in_prefix": "316e0d291fd0c7f47fe7f6ae752993dca4a1bb32df8e8271e04961813bf678bf", + "size_in_bytes": 72736 + }, + { + "_path": "lib/python3.12/lib-dynload/binascii.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "efaf8bb203739accedaaf51f0bfc21de00e112438477591311a4c5644a716654", + "sha256_in_prefix": "efaf8bb203739accedaaf51f0bfc21de00e112438477591311a4c5644a716654", + "size_in_bytes": 72048 + }, + { + "_path": "lib/python3.12/lib-dynload/cmath.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "68ffe96da886357b59a98993bbf78d7e157fd541883dce54a0be1807186ef6a5", + "sha256_in_prefix": "68ffe96da886357b59a98993bbf78d7e157fd541883dce54a0be1807186ef6a5", + "size_in_bytes": 72064 + }, + { + "_path": "lib/python3.12/lib-dynload/fcntl.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "ec0ab681e2e2fc101b6101715d1f2ae6bf41a757ee690bdfbc095d29e5a5e536", + "sha256_in_prefix": "ec0ab681e2e2fc101b6101715d1f2ae6bf41a757ee690bdfbc095d29e5a5e536", + "size_in_bytes": 53456 + }, + { + "_path": "lib/python3.12/lib-dynload/grp.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "cfb02814ea98450d824c2c6b0c1406a76a8be7825679ff3ec4de3c7b229e300c", + "sha256_in_prefix": "cfb02814ea98450d824c2c6b0c1406a76a8be7825679ff3ec4de3c7b229e300c", + "size_in_bytes": 53856 + }, + { + "_path": "lib/python3.12/lib-dynload/math.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "f9a354f6b25bbb5649aff05605ecdbf2cdc8374ee6732614318d6767dc0a22bb", + "sha256_in_prefix": "f9a354f6b25bbb5649aff05605ecdbf2cdc8374ee6732614318d6767dc0a22bb", + "size_in_bytes": 94848 + }, + { + "_path": "lib/python3.12/lib-dynload/mmap.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "348fdad4b45a697582d9849457376b18a9ab18137dbda0c39dda294f63dc2ae4", + "sha256_in_prefix": "348fdad4b45a697582d9849457376b18a9ab18137dbda0c39dda294f63dc2ae4", + "size_in_bytes": 56640 + }, + { + "_path": "lib/python3.12/lib-dynload/nis.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "dc27a7bb04e13ee9d2046705b712fb0842845dcae004bcae6cf987ce7f91a49e", + "sha256_in_prefix": "dc27a7bb04e13ee9d2046705b712fb0842845dcae004bcae6cf987ce7f91a49e", + "size_in_bytes": 54176 + }, + { + "_path": "lib/python3.12/lib-dynload/pyexpat.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "469d29cad01d83becaaa0ffa62761d0d556d48e90cc7fa4bef96b93955e5cc30", + "sha256_in_prefix": "469d29cad01d83becaaa0ffa62761d0d556d48e90cc7fa4bef96b93955e5cc30", + "size_in_bytes": 98352 + }, + { + "_path": "lib/python3.12/lib-dynload/readline.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "812a02c22c213dc0329024b590fd7ce566567ba2930a97517298a63cffeac070", + "sha256_in_prefix": "812a02c22c213dc0329024b590fd7ce566567ba2930a97517298a63cffeac070", + "size_in_bytes": 78416 + }, + { + "_path": "lib/python3.12/lib-dynload/resource.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "e78994af80fa4dfd0658eee901033b999d0e516f649c555c76289e4918ca294f", + "sha256_in_prefix": "e78994af80fa4dfd0658eee901033b999d0e516f649c555c76289e4918ca294f", + "size_in_bytes": 53552 + }, + { + "_path": "lib/python3.12/lib-dynload/select.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "425ab37263f89f95139d73bf070fdf5d18770547922c6abd34174c2ce5af0798", + "sha256_in_prefix": "425ab37263f89f95139d73bf070fdf5d18770547922c6abd34174c2ce5af0798", + "size_in_bytes": 75520 + }, + { + "_path": "lib/python3.12/lib-dynload/syslog.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "a0a16a649d1f75eda06f975191cab163ad6eaee6f89af5662ff6a3317d42e5e9", + "sha256_in_prefix": "a0a16a649d1f75eda06f975191cab163ad6eaee6f89af5662ff6a3317d42e5e9", + "size_in_bytes": 53632 + }, + { + "_path": "lib/python3.12/lib-dynload/termios.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "c819196a155ccbe9bff824150328b04c3d2ab14d774a59cd6b3f1e6acc053150", + "sha256_in_prefix": "c819196a155ccbe9bff824150328b04c3d2ab14d774a59cd6b3f1e6acc053150", + "size_in_bytes": 54864 + }, + { + "_path": "lib/python3.12/lib-dynload/unicodedata.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "859770590c70d5199aee141820cff416a9cbad1ea4120ad645dd1f0df4811aeb", + "sha256_in_prefix": "859770590c70d5199aee141820cff416a9cbad1ea4120ad645dd1f0df4811aeb", + "size_in_bytes": 1163440 + }, + { + "_path": "lib/python3.12/lib-dynload/xxlimited.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "6348e2d4a2c045ee0a0c6aa3ed20fcccd68f52c81f695b374a0c091abd62c43a", + "sha256_in_prefix": "6348e2d4a2c045ee0a0c6aa3ed20fcccd68f52c81f695b374a0c091abd62c43a", + "size_in_bytes": 53920 + }, + { + "_path": "lib/python3.12/lib-dynload/xxlimited_35.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "34b15b7626627d7f4efb03a92aaff56477a8c7f62b5b46dcf258f3c0a547acce", + "sha256_in_prefix": "34b15b7626627d7f4efb03a92aaff56477a8c7f62b5b46dcf258f3c0a547acce", + "size_in_bytes": 53520 + }, + { + "_path": "lib/python3.12/lib-dynload/xxsubtype.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "dc6c8758aaf74a398cd292ef3e6b899b4b491d4bb2f3e9d193fd127ba9cc9a33", + "sha256_in_prefix": "dc6c8758aaf74a398cd292ef3e6b899b4b491d4bb2f3e9d193fd127ba9cc9a33", + "size_in_bytes": 52656 + }, + { + "_path": "lib/python3.12/lib-dynload/zlib.cpython-312-darwin.so", + "path_type": "hardlink", + "sha256": "9b382d8cff3876f2f801922a39e3ab834f0f7e781ef965c68a61777fc85844b4", + "sha256_in_prefix": "9b382d8cff3876f2f801922a39e3ab834f0f7e781ef965c68a61777fc85844b4", + "size_in_bytes": 76224 + }, + { + "_path": "lib/python3.12/lib2to3/Grammar.txt", + "path_type": "hardlink", + "sha256": "508e62e787dd756eb0a4eb1b8d128320ca02cd246ab14cc8ce0a476dc88cc5b6", + "sha256_in_prefix": "508e62e787dd756eb0a4eb1b8d128320ca02cd246ab14cc8ce0a476dc88cc5b6", + "size_in_bytes": 8696 + }, + { + "_path": "lib/python3.12/lib2to3/PatternGrammar.txt", + "path_type": "hardlink", + "sha256": "ee5ba5db3b6722a0e2fbe2560ebc1c883e72328ef9c3b4da1c7c5d1cc649bce3", + "sha256_in_prefix": "ee5ba5db3b6722a0e2fbe2560ebc1c883e72328ef9c3b4da1c7c5d1cc649bce3", + "size_in_bytes": 793 + }, + { + "_path": "lib/python3.12/lib2to3/__init__.py", + "path_type": "hardlink", + "sha256": "5373a81ab198cda8e95652dff46ecfee197a0b8901e8432ab448d97b8bc37f87", + "sha256_in_prefix": "5373a81ab198cda8e95652dff46ecfee197a0b8901e8432ab448d97b8bc37f87", + "size_in_bytes": 156 + }, + { + "_path": "lib/python3.12/lib2to3/__main__.py", + "path_type": "hardlink", + "sha256": "c7b09f90e66dea194ad63dc02c6425dff977d16f1f21a157b7475905c219a707", + "sha256_in_prefix": "c7b09f90e66dea194ad63dc02c6425dff977d16f1f21a157b7475905c219a707", + "size_in_bytes": 67 + }, + { + "_path": "lib/python3.12/lib2to3/__pycache__/__init__.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "a2ed04ff125e97f971dee4722ebaabb098c73d771d4f1a6fe60f4c37bb401f3b", + "sha256_in_prefix": "a2ed04ff125e97f971dee4722ebaabb098c73d771d4f1a6fe60f4c37bb401f3b", + "size_in_bytes": 598 + }, + { + "_path": "lib/python3.12/lib2to3/__pycache__/__main__.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "4b62538b2d19361174a7583fbd81c801a35cdff83ead6e78a7b2766a6057c73c", + "sha256_in_prefix": "4b62538b2d19361174a7583fbd81c801a35cdff83ead6e78a7b2766a6057c73c", + "size_in_bytes": 529 + }, + { + "_path": "lib/python3.12/lib2to3/__pycache__/btm_matcher.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "a370bd4136df38d06408a30a1a573a7a61dda219a845d20b8887bf422e4daedb", + "sha256_in_prefix": "a370bd4136df38d06408a30a1a573a7a61dda219a845d20b8887bf422e4daedb", + "size_in_bytes": 7625 + }, + { + "_path": "lib/python3.12/lib2to3/__pycache__/btm_utils.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "25469415263861b9076d5b214ca2d358bbb576c8adcc902b3b4714a17645e344", + "sha256_in_prefix": "25469415263861b9076d5b214ca2d358bbb576c8adcc902b3b4714a17645e344", + "size_in_bytes": 11378 + }, + { + "_path": "lib/python3.12/lib2to3/__pycache__/fixer_base.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "6112cbd8ec1e098a44e381f68fa2a7f0bc86ee02f82aecbfde35a33ab6d998f9", + "sha256_in_prefix": "6112cbd8ec1e098a44e381f68fa2a7f0bc86ee02f82aecbfde35a33ab6d998f9", + "size_in_bytes": 8123 + }, + { + "_path": "lib/python3.12/lib2to3/__pycache__/fixer_util.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "095a005c14c90ae18a61b743b1baa488e62482ebe82f6f4524e6a976d2adced9", + "sha256_in_prefix": "095a005c14c90ae18a61b743b1baa488e62482ebe82f6f4524e6a976d2adced9", + "size_in_bytes": 22082 + }, + { + "_path": "lib/python3.12/lib2to3/__pycache__/main.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "2025259ca429f58f010b3f46f0b0c59d78177d405bcfdabfd663440f5962d86f", + "sha256_in_prefix": "2025259ca429f58f010b3f46f0b0c59d78177d405bcfdabfd663440f5962d86f", + "size_in_bytes": 14339 + }, + { + "_path": "lib/python3.12/lib2to3/__pycache__/patcomp.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "e9deeea1af8d2491be0d0c28fcbe36117ff926d433f04442e674d1d007750164", + "sha256_in_prefix": "e9deeea1af8d2491be0d0c28fcbe36117ff926d433f04442e674d1d007750164", + "size_in_bytes": 10198 + }, + { + "_path": "lib/python3.12/lib2to3/__pycache__/pygram.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "7243e3803d4a6069bc0fd94e1df25d00e210b736b47b96df2dd4abb69024d29c", + "sha256_in_prefix": "7243e3803d4a6069bc0fd94e1df25d00e210b736b47b96df2dd4abb69024d29c", + "size_in_bytes": 2151 + }, + { + "_path": "lib/python3.12/lib2to3/__pycache__/pytree.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "b98e944ba3e8ab5c2c15e62708310125c4823b77a51ebfb7df3dc15b631274dc", + "sha256_in_prefix": "b98e944ba3e8ab5c2c15e62708310125c4823b77a51ebfb7df3dc15b631274dc", + "size_in_bytes": 35046 + }, + { + "_path": "lib/python3.12/lib2to3/__pycache__/refactor.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "61cfa9d4e0c55fcbda923c849cace5d14921ea4cd290896eed2705c4cc3702fa", + "sha256_in_prefix": "61cfa9d4e0c55fcbda923c849cace5d14921ea4cd290896eed2705c4cc3702fa", + "size_in_bytes": 34746 + }, + { + "_path": "lib/python3.12/lib2to3/btm_matcher.py", + "path_type": "hardlink", + "sha256": "a1aa5d35558acf4b6016054963285cb145f97a764926bea07cbd674563f3248d", + "sha256_in_prefix": "a1aa5d35558acf4b6016054963285cb145f97a764926bea07cbd674563f3248d", + "size_in_bytes": 6623 + }, + { + "_path": "lib/python3.12/lib2to3/btm_utils.py", + "path_type": "hardlink", + "sha256": "c0653eb497a1a48195dd9c4ecbbf87e4eab31188be29ab1640e353209741588c", + "sha256_in_prefix": "c0653eb497a1a48195dd9c4ecbbf87e4eab31188be29ab1640e353209741588c", + "size_in_bytes": 9945 + }, + { + "_path": "lib/python3.12/lib2to3/fixer_base.py", + "path_type": "hardlink", + "sha256": "c795a53ca849c42212c8ec33a74284e0377df852eb4ea599aba62d5af1df282a", + "sha256_in_prefix": "c795a53ca849c42212c8ec33a74284e0377df852eb4ea599aba62d5af1df282a", + "size_in_bytes": 6690 + }, + { + "_path": "lib/python3.12/lib2to3/fixer_util.py", + "path_type": "hardlink", + "sha256": "306d0b2ea8169bdca711c6a31c0b1a3ce710d38ae2b6568ef519aa38451af608", + "sha256_in_prefix": "306d0b2ea8169bdca711c6a31c0b1a3ce710d38ae2b6568ef519aa38451af608", + "size_in_bytes": 15206 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/__init__.py", + "path_type": "hardlink", + "sha256": "836cdb388117cf81e78d9fa2a141cca1b14b0179733322e710067749a1b16fe9", + "sha256_in_prefix": "836cdb388117cf81e78d9fa2a141cca1b14b0179733322e710067749a1b16fe9", + "size_in_bytes": 47 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/__pycache__/__init__.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "d970f73e5ff404af04c42b71444677aa895ba7bc1a72544fa591098628ffbb08", + "sha256_in_prefix": "d970f73e5ff404af04c42b71444677aa895ba7bc1a72544fa591098628ffbb08", + "size_in_bytes": 396 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/__pycache__/fix_apply.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "b686f1f94cbd8af9b1811711aad33b960368949b13fa7b382dba86b9340e964e", + "sha256_in_prefix": "b686f1f94cbd8af9b1811711aad33b960368949b13fa7b382dba86b9340e964e", + "size_in_bytes": 3021 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/__pycache__/fix_asserts.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "89494908ab99ca71dd133afd3e027997e5c1db52c3a5764cecdf802ff7777d6e", + "sha256_in_prefix": "89494908ab99ca71dd133afd3e027997e5c1db52c3a5764cecdf802ff7777d6e", + "size_in_bytes": 1778 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/__pycache__/fix_basestring.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "393384160a55f0af98492f4b4692cbb1139c11a14bfc73e7b6daf085fba49e53", + "sha256_in_prefix": "393384160a55f0af98492f4b4692cbb1139c11a14bfc73e7b6daf085fba49e53", + "size_in_bytes": 1024 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/__pycache__/fix_buffer.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "bc19adeaee453cf310532fc89b5befa2aee662f5947c8224617b3a8891b77651", + "sha256_in_prefix": "bc19adeaee453cf310532fc89b5befa2aee662f5947c8224617b3a8891b77651", + "size_in_bytes": 1214 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/__pycache__/fix_dict.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "cf5609d4b5e984feedb321baa7d3f3fbbfb8fd9efd9a699f3f1809546306a5d1", + "sha256_in_prefix": "cf5609d4b5e984feedb321baa7d3f3fbbfb8fd9efd9a699f3f1809546306a5d1", + "size_in_bytes": 4828 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/__pycache__/fix_except.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "47295fc8354c077f95a9a356c3dcaf46b09b2742564f8dd39b43a14ee3f4bfe5", + "sha256_in_prefix": "47295fc8354c077f95a9a356c3dcaf46b09b2742564f8dd39b43a14ee3f4bfe5", + "size_in_bytes": 4282 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/__pycache__/fix_exec.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "8154213e3b147c53840d1181e8189b2994621b6bae0b4b3bea337d4d159fec4b", + "sha256_in_prefix": "8154213e3b147c53840d1181e8189b2994621b6bae0b4b3bea337d4d159fec4b", + "size_in_bytes": 1857 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/__pycache__/fix_execfile.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "ccfff884b5055e4c51a22df9b77dc5d04ad8b4d4f7921461e3cb27217ab68f1c", + "sha256_in_prefix": "ccfff884b5055e4c51a22df9b77dc5d04ad8b4d4f7921461e3cb27217ab68f1c", + "size_in_bytes": 2988 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/__pycache__/fix_exitfunc.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "977a5f5425f423babcf9c170f6deb52a89d1d127d8afaa860c7f5d529e2609b6", + "sha256_in_prefix": "977a5f5425f423babcf9c170f6deb52a89d1d127d8afaa860c7f5d529e2609b6", + "size_in_bytes": 3823 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/__pycache__/fix_filter.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "053fb3b53d3b3fa36e1b1488df64c7ddc35e1f787287f228717be56a0498aaa3", + "sha256_in_prefix": "053fb3b53d3b3fa36e1b1488df64c7ddc35e1f787287f228717be56a0498aaa3", + "size_in_bytes": 3861 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/__pycache__/fix_funcattrs.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "a75e6c1d87534047966946b651549167f23cb4fb7d882297abb197bc1bb97c5d", + "sha256_in_prefix": "a75e6c1d87534047966946b651549167f23cb4fb7d882297abb197bc1bb97c5d", + "size_in_bytes": 1418 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/__pycache__/fix_future.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "23d72574b1a5424ea9cb3c7bc8d6c4b71c2460981f60a3918cb84593df05d551", + "sha256_in_prefix": "23d72574b1a5424ea9cb3c7bc8d6c4b71c2460981f60a3918cb84593df05d551", + "size_in_bytes": 1163 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/__pycache__/fix_getcwdu.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "c1a3aa4bc04c5b8c2179747d4997ed8a0374e0f47e6016f9ba7e8bd45fc267c4", + "sha256_in_prefix": "c1a3aa4bc04c5b8c2179747d4997ed8a0374e0f47e6016f9ba7e8bd45fc267c4", + "size_in_bytes": 1191 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/__pycache__/fix_has_key.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "ca5b39248173866cc8440cbce5ae882d5bd1569a1fe3dc64f0d03191998a9a5e", + "sha256_in_prefix": "ca5b39248173866cc8440cbce5ae882d5bd1569a1fe3dc64f0d03191998a9a5e", + "size_in_bytes": 4466 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/__pycache__/fix_idioms.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "5846044d280f08f78d8a8e933e9ba2d09ac037435c76b102cac2744b93d7cec8", + "sha256_in_prefix": "5846044d280f08f78d8a8e933e9ba2d09ac037435c76b102cac2744b93d7cec8", + "size_in_bytes": 5705 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/__pycache__/fix_import.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "20f664b4c9b93541d0c6d47f925c797360e50ac38862c52dbb1be4f4da69c9dd", + "sha256_in_prefix": "20f664b4c9b93541d0c6d47f925c797360e50ac38862c52dbb1be4f4da69c9dd", + "size_in_bytes": 4510 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/__pycache__/fix_imports.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "448a3375aebdba7bb518d2abb88931be777f8d9dafc31f7cc5d3071bf482213f", + "sha256_in_prefix": "448a3375aebdba7bb518d2abb88931be777f8d9dafc31f7cc5d3071bf482213f", + "size_in_bytes": 6351 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/__pycache__/fix_imports2.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "dd1dec441dda5f9276529d07fb86916249c8e00ee491a9f92962cd6ef19c1eb4", + "sha256_in_prefix": "dd1dec441dda5f9276529d07fb86916249c8e00ee491a9f92962cd6ef19c1eb4", + "size_in_bytes": 864 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/__pycache__/fix_input.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "f9a102b9dd6ae5196812cb4ccd95266dbc85eeb4bbf86fb4b60d523b29594331", + "sha256_in_prefix": "f9a102b9dd6ae5196812cb4ccd95266dbc85eeb4bbf86fb4b60d523b29594331", + "size_in_bytes": 1515 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/__pycache__/fix_intern.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "b28cbe3d2a7d2bc9a44d4eb8ad15442fe96e6de6d875b441c2ecd429c90ed136", + "sha256_in_prefix": "b28cbe3d2a7d2bc9a44d4eb8ad15442fe96e6de6d875b441c2ecd429c90ed136", + "size_in_bytes": 1658 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/__pycache__/fix_isinstance.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "a0db4e2b5c54680eccfa43c79f6aab2d21733542c69a300ef3e8b0fe604829cd", + "sha256_in_prefix": "a0db4e2b5c54680eccfa43c79f6aab2d21733542c69a300ef3e8b0fe604829cd", + "size_in_bytes": 2600 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/__pycache__/fix_itertools.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "d6d60fa611fdd3b29f119a2aa9313bc954e3503d24e130f78ecbae8010a678c0", + "sha256_in_prefix": "d6d60fa611fdd3b29f119a2aa9313bc954e3503d24e130f78ecbae8010a678c0", + "size_in_bytes": 2226 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/__pycache__/fix_itertools_imports.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "487ea00bb9c8374664616c58789e60f3d9cf0bf3a37289f1627bf69c049282c3", + "sha256_in_prefix": "487ea00bb9c8374664616c58789e60f3d9cf0bf3a37289f1627bf69c049282c3", + "size_in_bytes": 2967 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/__pycache__/fix_long.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "ad08d69faeb606df9f56e6925945a156962e42c1efe8aae7bd2ffbfaf4735e1e", + "sha256_in_prefix": "ad08d69faeb606df9f56e6925945a156962e42c1efe8aae7bd2ffbfaf4735e1e", + "size_in_bytes": 1090 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/__pycache__/fix_map.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "46359268bb310851ecb16fc654534e6787b7ecee950e1cb0e8898f4554b5972f", + "sha256_in_prefix": "46359268bb310851ecb16fc654534e6787b7ecee950e1cb0e8898f4554b5972f", + "size_in_bytes": 4761 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/__pycache__/fix_metaclass.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "4b57217ec7c2dbd152c4e8aab1b1c2193caec1a80ab4eb919f3b9472b3fbcf6b", + "sha256_in_prefix": "4b57217ec7c2dbd152c4e8aab1b1c2193caec1a80ab4eb919f3b9472b3fbcf6b", + "size_in_bytes": 10714 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/__pycache__/fix_methodattrs.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "d3b43e43de88f31d479b807d87f409395e07d4c8e6fd5aa3356b3259476d28c1", + "sha256_in_prefix": "d3b43e43de88f31d479b807d87f409395e07d4c8e6fd5aa3356b3259476d28c1", + "size_in_bytes": 1398 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/__pycache__/fix_ne.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "94b5bbea6b0abbf51fb241bc2a2b165a94fcc4752c5c6f7aede80cdff4e63a9b", + "sha256_in_prefix": "94b5bbea6b0abbf51fb241bc2a2b165a94fcc4752c5c6f7aede80cdff4e63a9b", + "size_in_bytes": 1289 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/__pycache__/fix_next.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "ec50b2fdb587bcdd833e58bfbed53365d12aaf1711f62efbc6de05ca9109be1d", + "sha256_in_prefix": "ec50b2fdb587bcdd833e58bfbed53365d12aaf1711f62efbc6de05ca9109be1d", + "size_in_bytes": 4614 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/__pycache__/fix_nonzero.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "6eec087d3c315547eb5b923410f59866e1684ebf67d5192b05c720a3a50ad189", + "sha256_in_prefix": "6eec087d3c315547eb5b923410f59866e1684ebf67d5192b05c720a3a50ad189", + "size_in_bytes": 1328 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/__pycache__/fix_numliterals.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "e5879d840c337f511fb2c08e23fd3468e5aef4044684ebfd8b3698b06e001d27", + "sha256_in_prefix": "e5879d840c337f511fb2c08e23fd3468e5aef4044684ebfd8b3698b06e001d27", + "size_in_bytes": 1683 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/__pycache__/fix_operator.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "e47e06903b2d816007bcf13bcd35e9ba0152f6f28ef9a29b8a5931c80f54076d", + "sha256_in_prefix": "e47e06903b2d816007bcf13bcd35e9ba0152f6f28ef9a29b8a5931c80f54076d", + "size_in_bytes": 5869 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/__pycache__/fix_paren.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "7bccac6d51901f8d5ea81ed01eb187d856ef4752e43846aa8094d1503c85acce", + "sha256_in_prefix": "7bccac6d51901f8d5ea81ed01eb187d856ef4752e43846aa8094d1503c85acce", + "size_in_bytes": 1875 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/__pycache__/fix_print.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "a51ce784ef9afe8c3bd4ba456efa7038da5340f817f34f91f59628d1edcfbc6c", + "sha256_in_prefix": "a51ce784ef9afe8c3bd4ba456efa7038da5340f817f34f91f59628d1edcfbc6c", + "size_in_bytes": 3747 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/__pycache__/fix_raise.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "41fdac8d5e35dfd92f41eca87e8f38e15d9fd52785c137458e8464e4fba8187c", + "sha256_in_prefix": "41fdac8d5e35dfd92f41eca87e8f38e15d9fd52785c137458e8464e4fba8187c", + "size_in_bytes": 3632 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/__pycache__/fix_raw_input.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "cf37882b4294fbf449ca14c4c6125e120f12594c7bca88837bd3d0097850e9ad", + "sha256_in_prefix": "cf37882b4294fbf449ca14c4c6125e120f12594c7bca88837bd3d0097850e9ad", + "size_in_bytes": 1196 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/__pycache__/fix_reduce.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "79e958fdef4f80de00e7155660b4822a9298177341e28318fbf63533c00d4c05", + "sha256_in_prefix": "79e958fdef4f80de00e7155660b4822a9298177341e28318fbf63533c00d4c05", + "size_in_bytes": 1471 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/__pycache__/fix_reload.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "ff8bfaf83765d5d5ee65372185f2e655a2e1ead45f74dfc6987cd31984eb84b2", + "sha256_in_prefix": "ff8bfaf83765d5d5ee65372185f2e655a2e1ead45f74dfc6987cd31984eb84b2", + "size_in_bytes": 1670 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/__pycache__/fix_renames.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "7917242ca61c39c612f56191f269a7fcdc5c746e9d0147c71b05a39aea94537a", + "sha256_in_prefix": "7917242ca61c39c612f56191f269a7fcdc5c746e9d0147c71b05a39aea94537a", + "size_in_bytes": 3118 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/__pycache__/fix_repr.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "30df45b438bf5b7fff997e1f4dc01826847246834c1a69a4f0affe4fef83c79d", + "sha256_in_prefix": "30df45b438bf5b7fff997e1f4dc01826847246834c1a69a4f0affe4fef83c79d", + "size_in_bytes": 1376 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/__pycache__/fix_set_literal.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "9a352752ec6a1f430737b3a9f5ddfa0bbb71893078c7221994fc95bff0fa049c", + "sha256_in_prefix": "9a352752ec6a1f430737b3a9f5ddfa0bbb71893078c7221994fc95bff0fa049c", + "size_in_bytes": 2880 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/__pycache__/fix_standarderror.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "b50d0e862ffc70d8218d448fa5f47400e1ee8d434a50e08f1231bb4b266d5008", + "sha256_in_prefix": "b50d0e862ffc70d8218d448fa5f47400e1ee8d434a50e08f1231bb4b266d5008", + "size_in_bytes": 1085 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/__pycache__/fix_sys_exc.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "8e6d0ed8bdfcf9bcdc404551c157da87d83346e802f6523b282af45670e79708", + "sha256_in_prefix": "8e6d0ed8bdfcf9bcdc404551c157da87d83346e802f6523b282af45670e79708", + "size_in_bytes": 2263 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/__pycache__/fix_throw.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "84ced0515609af9f3725c453f896386c60101d19ca7c59477c6914338dd833d5", + "sha256_in_prefix": "84ced0515609af9f3725c453f896386c60101d19ca7c59477c6914338dd833d5", + "size_in_bytes": 2696 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/__pycache__/fix_tuple_params.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "b637a964edaeb91c7c354f1d6e5bb71bd4815d22d8a90079a742c8d220d37513", + "sha256_in_prefix": "b637a964edaeb91c7c354f1d6e5bb71bd4815d22d8a90079a742c8d220d37513", + "size_in_bytes": 8110 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/__pycache__/fix_types.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "af064ba8e0e084ea6e18c95dcd56e310a2d5db248c3d9bec10b53efe7bfe9967", + "sha256_in_prefix": "af064ba8e0e084ea6e18c95dcd56e310a2d5db248c3d9bec10b53efe7bfe9967", + "size_in_bytes": 2525 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/__pycache__/fix_unicode.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "82afe90ef054a0d6054f9e7022d00603e4441d6309922d1a109d5cc584a234af", + "sha256_in_prefix": "82afe90ef054a0d6054f9e7022d00603e4441d6309922d1a109d5cc584a234af", + "size_in_bytes": 2413 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/__pycache__/fix_urllib.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "b847a08114b1d31ad834337e569b481c68465fffaf1f1bc10a865aad50816a3f", + "sha256_in_prefix": "b847a08114b1d31ad834337e569b481c68465fffaf1f1bc10a865aad50816a3f", + "size_in_bytes": 9455 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/__pycache__/fix_ws_comma.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "8897868956c1725c642e3627468eb1164447aab6b4c6d86dffd26e58ab0170c9", + "sha256_in_prefix": "8897868956c1725c642e3627468eb1164447aab6b4c6d86dffd26e58ab0170c9", + "size_in_bytes": 1810 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/__pycache__/fix_xrange.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "34feca7db52fbebd93a451dd90d70ba07009d8e4a3d7aba77ddc007a1323c5da", + "sha256_in_prefix": "34feca7db52fbebd93a451dd90d70ba07009d8e4a3d7aba77ddc007a1323c5da", + "size_in_bytes": 4069 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/__pycache__/fix_xreadlines.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "ae565169401ed03675802924ed562657aa3f69c2250ae2d9af606203733aa8b7", + "sha256_in_prefix": "ae565169401ed03675802924ed562657aa3f69c2250ae2d9af606203733aa8b7", + "size_in_bytes": 1530 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/__pycache__/fix_zip.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "41d9ff31c7a4257a2acfe87c47a689ac90707f3d4866314d841d0c6f8e210dc2", + "sha256_in_prefix": "41d9ff31c7a4257a2acfe87c47a689ac90707f3d4866314d841d0c6f8e210dc2", + "size_in_bytes": 2231 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/fix_apply.py", + "path_type": "hardlink", + "sha256": "b5171e32758a78450854f40867775d4aca58665bc920ebece04fcfcc153af02a", + "sha256_in_prefix": "b5171e32758a78450854f40867775d4aca58665bc920ebece04fcfcc153af02a", + "size_in_bytes": 2346 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/fix_asserts.py", + "path_type": "hardlink", + "sha256": "4c77972812cb5ec0a72afbce3e1d618c27ef7b239329c5c952c2bcbe77dba5dd", + "sha256_in_prefix": "4c77972812cb5ec0a72afbce3e1d618c27ef7b239329c5c952c2bcbe77dba5dd", + "size_in_bytes": 984 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/fix_basestring.py", + "path_type": "hardlink", + "sha256": "d041443d6499a735bb78fec9da1bf33b3d034b5192c98bc273b16a44692fc88f", + "sha256_in_prefix": "d041443d6499a735bb78fec9da1bf33b3d034b5192c98bc273b16a44692fc88f", + "size_in_bytes": 320 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/fix_buffer.py", + "path_type": "hardlink", + "sha256": "2da37b49c30d6a0b4db43146ebb4ac8e5ffcb9814816b4742e464cb856977883", + "sha256_in_prefix": "2da37b49c30d6a0b4db43146ebb4ac8e5ffcb9814816b4742e464cb856977883", + "size_in_bytes": 590 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/fix_dict.py", + "path_type": "hardlink", + "sha256": "38f460596ebfb64046aab3d9a65935bd4c76a470118fb7d10a088dc0ecdc53ea", + "sha256_in_prefix": "38f460596ebfb64046aab3d9a65935bd4c76a470118fb7d10a088dc0ecdc53ea", + "size_in_bytes": 3760 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/fix_except.py", + "path_type": "hardlink", + "sha256": "7ff6f560c3c3d7a5d9ceef5ba31c556341f7ce1bc1b52d96b063f6c2c4765651", + "sha256_in_prefix": "7ff6f560c3c3d7a5d9ceef5ba31c556341f7ce1bc1b52d96b063f6c2c4765651", + "size_in_bytes": 3344 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/fix_exec.py", + "path_type": "hardlink", + "sha256": "9e0893327205dea12004e88d18c580286e7977e081b5eda7baf5b7bc93bc6c52", + "sha256_in_prefix": "9e0893327205dea12004e88d18c580286e7977e081b5eda7baf5b7bc93bc6c52", + "size_in_bytes": 979 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/fix_execfile.py", + "path_type": "hardlink", + "sha256": "6ff65db1192099457cb3d9f2618a893c6ac430028550284f3a34d5c08042b0eb", + "sha256_in_prefix": "6ff65db1192099457cb3d9f2618a893c6ac430028550284f3a34d5c08042b0eb", + "size_in_bytes": 2048 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/fix_exitfunc.py", + "path_type": "hardlink", + "sha256": "ef4f18f651d32410c43644c27590903d41e38e763b0e108e6c685a3412a7d29c", + "sha256_in_prefix": "ef4f18f651d32410c43644c27590903d41e38e763b0e108e6c685a3412a7d29c", + "size_in_bytes": 2495 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/fix_filter.py", + "path_type": "hardlink", + "sha256": "2c7f0121193395750eab2b2abf5059d9a3b1a61f81763f52511265d7bca5cb21", + "sha256_in_prefix": "2c7f0121193395750eab2b2abf5059d9a3b1a61f81763f52511265d7bca5cb21", + "size_in_bytes": 2765 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/fix_funcattrs.py", + "path_type": "hardlink", + "sha256": "111df53fac6a121d61abe33883a68e731820ddc4864b0a4c1000cf2ac5f019cd", + "sha256_in_prefix": "111df53fac6a121d61abe33883a68e731820ddc4864b0a4c1000cf2ac5f019cd", + "size_in_bytes": 644 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/fix_future.py", + "path_type": "hardlink", + "sha256": "baba8cafb48dd9181a0e1f7b0f20b585ce2925e8f347e00b87407a256bb16663", + "sha256_in_prefix": "baba8cafb48dd9181a0e1f7b0f20b585ce2925e8f347e00b87407a256bb16663", + "size_in_bytes": 547 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/fix_getcwdu.py", + "path_type": "hardlink", + "sha256": "5bc5252f683a401e7d81c5911617c4af1a1bcdf99a51c4bf1cfccb00446ff220", + "sha256_in_prefix": "5bc5252f683a401e7d81c5911617c4af1a1bcdf99a51c4bf1cfccb00446ff220", + "size_in_bytes": 451 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/fix_has_key.py", + "path_type": "hardlink", + "sha256": "32943d3b921c1c3f0d3776d19e5120806990b817bc99a7e22799847abfda1f63", + "sha256_in_prefix": "32943d3b921c1c3f0d3776d19e5120806990b817bc99a7e22799847abfda1f63", + "size_in_bytes": 3196 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/fix_idioms.py", + "path_type": "hardlink", + "sha256": "600e34faf36e14307e59d55088e3979881d497b8fc9d77659e77709f9e8bafd7", + "sha256_in_prefix": "600e34faf36e14307e59d55088e3979881d497b8fc9d77659e77709f9e8bafd7", + "size_in_bytes": 4876 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/fix_import.py", + "path_type": "hardlink", + "sha256": "803baf96f9603c957eb974f252b0ad9829c889a293e0ce6829db1bce3da6dd4e", + "sha256_in_prefix": "803baf96f9603c957eb974f252b0ad9829c889a293e0ce6829db1bce3da6dd4e", + "size_in_bytes": 3256 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/fix_imports.py", + "path_type": "hardlink", + "sha256": "cdf7ee6d85e2b148230984cfc4ea3f193be458958ea42ef290854a9672a64370", + "sha256_in_prefix": "cdf7ee6d85e2b148230984cfc4ea3f193be458958ea42ef290854a9672a64370", + "size_in_bytes": 5684 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/fix_imports2.py", + "path_type": "hardlink", + "sha256": "b6f3c628839ffe7fd72569dd6ca2210e18edae3e180002747ea011b76b7ec0ef", + "sha256_in_prefix": "b6f3c628839ffe7fd72569dd6ca2210e18edae3e180002747ea011b76b7ec0ef", + "size_in_bytes": 289 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/fix_input.py", + "path_type": "hardlink", + "sha256": "10c5ef3b45a4ee7e88af8852181916a788aae2bea52b08f3473815c1c43598d1", + "sha256_in_prefix": "10c5ef3b45a4ee7e88af8852181916a788aae2bea52b08f3473815c1c43598d1", + "size_in_bytes": 708 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/fix_intern.py", + "path_type": "hardlink", + "sha256": "8d29a162536b99c91bd2f9259dda7f39fec751949d6354d2c1f2e5d070c87d66", + "sha256_in_prefix": "8d29a162536b99c91bd2f9259dda7f39fec751949d6354d2c1f2e5d070c87d66", + "size_in_bytes": 1144 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/fix_isinstance.py", + "path_type": "hardlink", + "sha256": "8408c92b99f50d8c4978b47a2b2155588e315f2ebbe58c160dcdcdcb89e19914", + "sha256_in_prefix": "8408c92b99f50d8c4978b47a2b2155588e315f2ebbe58c160dcdcdcb89e19914", + "size_in_bytes": 1608 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/fix_itertools.py", + "path_type": "hardlink", + "sha256": "578a51b9935020b03a510de15ece55fcd02c9474f37a54c158fb97ba5fd15af1", + "sha256_in_prefix": "578a51b9935020b03a510de15ece55fcd02c9474f37a54c158fb97ba5fd15af1", + "size_in_bytes": 1548 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/fix_itertools_imports.py", + "path_type": "hardlink", + "sha256": "2e419cfbd7f2a326ae7fa10873aa377112ebec32545238fdf988acb088c3cdb7", + "sha256_in_prefix": "2e419cfbd7f2a326ae7fa10873aa377112ebec32545238fdf988acb088c3cdb7", + "size_in_bytes": 2086 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/fix_long.py", + "path_type": "hardlink", + "sha256": "306b80e0a72c0d16dd934b7d51ab0c9a4224f83be5d6cbad8a7158a0a5d73551", + "sha256_in_prefix": "306b80e0a72c0d16dd934b7d51ab0c9a4224f83be5d6cbad8a7158a0a5d73551", + "size_in_bytes": 476 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/fix_map.py", + "path_type": "hardlink", + "sha256": "b82c0762c44adf2af7745c030afe291e2badfe360925046c8e58d85340717696", + "sha256_in_prefix": "b82c0762c44adf2af7745c030afe291e2badfe360925046c8e58d85340717696", + "size_in_bytes": 3640 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/fix_metaclass.py", + "path_type": "hardlink", + "sha256": "45a30c866aa2ff69e089da147ed09986aad4516b5e5dd943f8dfcb7d3946a3e1", + "sha256_in_prefix": "45a30c866aa2ff69e089da147ed09986aad4516b5e5dd943f8dfcb7d3946a3e1", + "size_in_bytes": 8197 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/fix_methodattrs.py", + "path_type": "hardlink", + "sha256": "8d60082f98ce52ee4955099bfd447cbadfa0e9b24ccb8d135cecc833168d44e8", + "sha256_in_prefix": "8d60082f98ce52ee4955099bfd447cbadfa0e9b24ccb8d135cecc833168d44e8", + "size_in_bytes": 606 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/fix_ne.py", + "path_type": "hardlink", + "sha256": "4f9cb1388ba86f29422d20979d3423fdf3541ba35a17ed44d6f4a517ff784ecd", + "sha256_in_prefix": "4f9cb1388ba86f29422d20979d3423fdf3541ba35a17ed44d6f4a517ff784ecd", + "size_in_bytes": 571 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/fix_next.py", + "path_type": "hardlink", + "sha256": "5c7d86d9f81b2498486d626c7feced1b92f23171cf9e42881abb78de1a93bccd", + "sha256_in_prefix": "5c7d86d9f81b2498486d626c7feced1b92f23171cf9e42881abb78de1a93bccd", + "size_in_bytes": 3174 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/fix_nonzero.py", + "path_type": "hardlink", + "sha256": "c2cd7e3ba44508643a20eec4ea4c19f2f1adfd36f6b974d7c143e449571ae736", + "sha256_in_prefix": "c2cd7e3ba44508643a20eec4ea4c19f2f1adfd36f6b974d7c143e449571ae736", + "size_in_bytes": 591 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/fix_numliterals.py", + "path_type": "hardlink", + "sha256": "1c4dd0f7881999abde6cf4d232836fa3e55fc41a7d5aa2b9866092f65707db7f", + "sha256_in_prefix": "1c4dd0f7881999abde6cf4d232836fa3e55fc41a7d5aa2b9866092f65707db7f", + "size_in_bytes": 768 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/fix_operator.py", + "path_type": "hardlink", + "sha256": "023872fe9f03a25387cf2c17fc950cf0f990353df66e603c3a1cd3199dbccd86", + "sha256_in_prefix": "023872fe9f03a25387cf2c17fc950cf0f990353df66e603c3a1cd3199dbccd86", + "size_in_bytes": 3426 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/fix_paren.py", + "path_type": "hardlink", + "sha256": "53734f1d7778ad28a4ec3ab4415923e2da8f230de4cd527589829f570e9f254d", + "sha256_in_prefix": "53734f1d7778ad28a4ec3ab4415923e2da8f230de4cd527589829f570e9f254d", + "size_in_bytes": 1226 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/fix_print.py", + "path_type": "hardlink", + "sha256": "cf2690f1b502249289f52cd544190db0b94d59df5eca139829cd2bf0742e9dba", + "sha256_in_prefix": "cf2690f1b502249289f52cd544190db0b94d59df5eca139829cd2bf0742e9dba", + "size_in_bytes": 2844 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/fix_raise.py", + "path_type": "hardlink", + "sha256": "c38ffec5862597ee8f9dac50385af943ee312bfc394366be08b2fc12563ca1a5", + "sha256_in_prefix": "c38ffec5862597ee8f9dac50385af943ee312bfc394366be08b2fc12563ca1a5", + "size_in_bytes": 2926 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/fix_raw_input.py", + "path_type": "hardlink", + "sha256": "ce04cbaa76d414949afc230360dd9a29ff579bd868cc7f8805230d126ac9ce9b", + "sha256_in_prefix": "ce04cbaa76d414949afc230360dd9a29ff579bd868cc7f8805230d126ac9ce9b", + "size_in_bytes": 454 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/fix_reduce.py", + "path_type": "hardlink", + "sha256": "9a03910a6c183586e1db01863fcde6417d06745fb3e63032333d71c5e82e7919", + "sha256_in_prefix": "9a03910a6c183586e1db01863fcde6417d06745fb3e63032333d71c5e82e7919", + "size_in_bytes": 837 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/fix_reload.py", + "path_type": "hardlink", + "sha256": "17570148167e43b2155b6e1c814a3cca9e3ef53750c504932a9c7d62a8b68a3f", + "sha256_in_prefix": "17570148167e43b2155b6e1c814a3cca9e3ef53750c504932a9c7d62a8b68a3f", + "size_in_bytes": 1081 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/fix_renames.py", + "path_type": "hardlink", + "sha256": "8b71472317bf3adabf819e665c725d03e3064baa45f6ffbfd78cca83eaa46e8d", + "sha256_in_prefix": "8b71472317bf3adabf819e665c725d03e3064baa45f6ffbfd78cca83eaa46e8d", + "size_in_bytes": 2221 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/fix_repr.py", + "path_type": "hardlink", + "sha256": "d16930b7ef8577747cfef602aba854c64ce85d4ae1e54a18a456eaa202643e3d", + "sha256_in_prefix": "d16930b7ef8577747cfef602aba854c64ce85d4ae1e54a18a456eaa202643e3d", + "size_in_bytes": 613 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/fix_set_literal.py", + "path_type": "hardlink", + "sha256": "33f2c0b6e16357e083c3a98877e7317abe1578a44c288e5979c9d96fb5aa6727", + "sha256_in_prefix": "33f2c0b6e16357e083c3a98877e7317abe1578a44c288e5979c9d96fb5aa6727", + "size_in_bytes": 1697 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/fix_standarderror.py", + "path_type": "hardlink", + "sha256": "ce7eb37bc7fb29aa138b1cec6656ae8b4886cbfa700e119a1bb8484284cb717a", + "sha256_in_prefix": "ce7eb37bc7fb29aa138b1cec6656ae8b4886cbfa700e119a1bb8484284cb717a", + "size_in_bytes": 449 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/fix_sys_exc.py", + "path_type": "hardlink", + "sha256": "0143830586d09d702ca3eeaa8f86698e5fd18af69fd28147e71a1a77600d356a", + "sha256_in_prefix": "0143830586d09d702ca3eeaa8f86698e5fd18af69fd28147e71a1a77600d356a", + "size_in_bytes": 1034 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/fix_throw.py", + "path_type": "hardlink", + "sha256": "fec731ed523d5cdfa21893833b52b2844eabfd1549792c1c9f8ceac2d0e8e901", + "sha256_in_prefix": "fec731ed523d5cdfa21893833b52b2844eabfd1549792c1c9f8ceac2d0e8e901", + "size_in_bytes": 1582 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/fix_tuple_params.py", + "path_type": "hardlink", + "sha256": "f3307d4750d0657d9c42b857d5f37bdb5824f9358939da7d16d13f61eb8abc72", + "sha256_in_prefix": "f3307d4750d0657d9c42b857d5f37bdb5824f9358939da7d16d13f61eb8abc72", + "size_in_bytes": 5565 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/fix_types.py", + "path_type": "hardlink", + "sha256": "a0a133cfc78e82e1f71ce628408e7d10a38552ba3e3228ebd113838c1ce44484", + "sha256_in_prefix": "a0a133cfc78e82e1f71ce628408e7d10a38552ba3e3228ebd113838c1ce44484", + "size_in_bytes": 1774 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/fix_unicode.py", + "path_type": "hardlink", + "sha256": "01b2a9b1084b6a0424f27eec488c761f75f053a409608ec36a9ee0ede0d38097", + "sha256_in_prefix": "01b2a9b1084b6a0424f27eec488c761f75f053a409608ec36a9ee0ede0d38097", + "size_in_bytes": 1256 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/fix_urllib.py", + "path_type": "hardlink", + "sha256": "3d1c04d976ff4d2841025a785aaab0cc4ee06c9c9b4e09d1e2456949fa273856", + "sha256_in_prefix": "3d1c04d976ff4d2841025a785aaab0cc4ee06c9c9b4e09d1e2456949fa273856", + "size_in_bytes": 8367 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/fix_ws_comma.py", + "path_type": "hardlink", + "sha256": "5e7a16daec0b2619110516804bf90cac459a4d0315198fd4eff69c36c54378dd", + "sha256_in_prefix": "5e7a16daec0b2619110516804bf90cac459a4d0315198fd4eff69c36c54378dd", + "size_in_bytes": 1090 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/fix_xrange.py", + "path_type": "hardlink", + "sha256": "60d8ce92db6f399606d2e40a3c631ba566127e8cd637ebbf35b822672139cab2", + "sha256_in_prefix": "60d8ce92db6f399606d2e40a3c631ba566127e8cd637ebbf35b822672139cab2", + "size_in_bytes": 2694 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/fix_xreadlines.py", + "path_type": "hardlink", + "sha256": "e8c2f19f7047bfc7539fd78839929004d8fe0efba1fbcbd9d712d285e43834ba", + "sha256_in_prefix": "e8c2f19f7047bfc7539fd78839929004d8fe0efba1fbcbd9d712d285e43834ba", + "size_in_bytes": 689 + }, + { + "_path": "lib/python3.12/lib2to3/fixes/fix_zip.py", + "path_type": "hardlink", + "sha256": "55ce115556c7513dd967364dc6a40c39210c874e8168cf090ddd6dc606df34cb", + "sha256_in_prefix": "55ce115556c7513dd967364dc6a40c39210c874e8168cf090ddd6dc606df34cb", + "size_in_bytes": 1289 + }, + { + "_path": "lib/python3.12/lib2to3/main.py", + "path_type": "hardlink", + "sha256": "8f5dfa77b8c8b375daba8bb88aaa195395674311e2513b29575a70821e3aa0b8", + "sha256_in_prefix": "8f5dfa77b8c8b375daba8bb88aaa195395674311e2513b29575a70821e3aa0b8", + "size_in_bytes": 11854 + }, + { + "_path": "lib/python3.12/lib2to3/patcomp.py", + "path_type": "hardlink", + "sha256": "a033a3eb91a39f96747d4300aa3394965e529c71896cd6503dd27e6b685eede5", + "sha256_in_prefix": "a033a3eb91a39f96747d4300aa3394965e529c71896cd6503dd27e6b685eede5", + "size_in_bytes": 7054 + }, + { + "_path": "lib/python3.12/lib2to3/pgen2/__init__.py", + "path_type": "hardlink", + "sha256": "858eb0f50533bd3bd16fe32815f77fabfed92ede885070b6cb15827ec66ea500", + "sha256_in_prefix": "858eb0f50533bd3bd16fe32815f77fabfed92ede885070b6cb15827ec66ea500", + "size_in_bytes": 143 + }, + { + "_path": "lib/python3.12/lib2to3/pgen2/__pycache__/__init__.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "2a04f04c0b7967699c9cf9d59dc416c39b7b70ffd449e54799632c55766ae12d", + "sha256_in_prefix": "2a04f04c0b7967699c9cf9d59dc416c39b7b70ffd449e54799632c55766ae12d", + "size_in_bytes": 431 + }, + { + "_path": "lib/python3.12/lib2to3/pgen2/__pycache__/conv.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "bbe43a55a18e09f2f4aee97e9581538ba0a000cdce42c16343f3e9d0a3d97550", + "sha256_in_prefix": "bbe43a55a18e09f2f4aee97e9581538ba0a000cdce42c16343f3e9d0a3d97550", + "size_in_bytes": 11973 + }, + { + "_path": "lib/python3.12/lib2to3/pgen2/__pycache__/driver.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "d53f3a3fdf661fe6002fa64a1e5088efe1e49fb5af3c06758dbff6ae7debd569", + "sha256_in_prefix": "d53f3a3fdf661fe6002fa64a1e5088efe1e49fb5af3c06758dbff6ae7debd569", + "size_in_bytes": 8368 + }, + { + "_path": "lib/python3.12/lib2to3/pgen2/__pycache__/grammar.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "7478de3140d799fc775d961eea3d66c638626398ee040ab41d58a175c3b07910", + "sha256_in_prefix": "7478de3140d799fc775d961eea3d66c638626398ee040ab41d58a175c3b07910", + "size_in_bytes": 7288 + }, + { + "_path": "lib/python3.12/lib2to3/pgen2/__pycache__/literals.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "aed8f68debf0165fb8691806977b95660b469d918b23fdba2afaa5c6e437b334", + "sha256_in_prefix": "aed8f68debf0165fb8691806977b95660b469d918b23fdba2afaa5c6e437b334", + "size_in_bytes": 2839 + }, + { + "_path": "lib/python3.12/lib2to3/pgen2/__pycache__/parse.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "4bf5dc17a1c50ba54a859ae6c356941395d606500d7e0b65d62dd23ff90acde5", + "sha256_in_prefix": "4bf5dc17a1c50ba54a859ae6c356941395d606500d7e0b65d62dd23ff90acde5", + "size_in_bytes": 8983 + }, + { + "_path": "lib/python3.12/lib2to3/pgen2/__pycache__/pgen.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "57a741efc037d25f96b46b36fb4daa9b268424bf98245f6b726d5b2189f14a10", + "sha256_in_prefix": "57a741efc037d25f96b46b36fb4daa9b268424bf98245f6b726d5b2189f14a10", + "size_in_bytes": 19043 + }, + { + "_path": "lib/python3.12/lib2to3/pgen2/__pycache__/token.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "b6e94f04953edc6327f90b4175dd5c2290f2a43d20d905dfc105da187ccb6e68", + "sha256_in_prefix": "b6e94f04953edc6327f90b4175dd5c2290f2a43d20d905dfc105da187ccb6e68", + "size_in_bytes": 2501 + }, + { + "_path": "lib/python3.12/lib2to3/pgen2/__pycache__/tokenize.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "7ee5ca8e53280f15ec5716c3f269729576ae7ba4bac92a94f05ae406c685a68e", + "sha256_in_prefix": "7ee5ca8e53280f15ec5716c3f269729576ae7ba4bac92a94f05ae406c685a68e", + "size_in_bytes": 21182 + }, + { + "_path": "lib/python3.12/lib2to3/pgen2/conv.py", + "path_type": "hardlink", + "sha256": "e2946a686c12e02248fafb1a57e7514e0c22bdb2b4a66e644215c86fedc37bff", + "sha256_in_prefix": "e2946a686c12e02248fafb1a57e7514e0c22bdb2b4a66e644215c86fedc37bff", + "size_in_bytes": 9642 + }, + { + "_path": "lib/python3.12/lib2to3/pgen2/driver.py", + "path_type": "hardlink", + "sha256": "57af5e220cd6c6b75e8dead2cea395ead2297dd98e398ad705ca2bce0e9e6594", + "sha256_in_prefix": "57af5e220cd6c6b75e8dead2cea395ead2297dd98e398ad705ca2bce0e9e6594", + "size_in_bytes": 5969 + }, + { + "_path": "lib/python3.12/lib2to3/pgen2/grammar.py", + "path_type": "hardlink", + "sha256": "4898d446d6ae73f7259a3f91839eca1a3380670a9f378b80780707f714fad17c", + "sha256_in_prefix": "4898d446d6ae73f7259a3f91839eca1a3380670a9f378b80780707f714fad17c", + "size_in_bytes": 5552 + }, + { + "_path": "lib/python3.12/lib2to3/pgen2/literals.py", + "path_type": "hardlink", + "sha256": "84bc9d5387a2e20fab844e530358571afa39fa3fc0e8024270b5f7d8ac5a595a", + "sha256_in_prefix": "84bc9d5387a2e20fab844e530358571afa39fa3fc0e8024270b5f7d8ac5a595a", + "size_in_bytes": 1635 + }, + { + "_path": "lib/python3.12/lib2to3/pgen2/parse.py", + "path_type": "hardlink", + "sha256": "e245e005e524ab445a570df31f70c6fd7b901ee3b0b68bd3bcf4b41b37fa7bb6", + "sha256_in_prefix": "e245e005e524ab445a570df31f70c6fd7b901ee3b0b68bd3bcf4b41b37fa7bb6", + "size_in_bytes": 8155 + }, + { + "_path": "lib/python3.12/lib2to3/pgen2/pgen.py", + "path_type": "hardlink", + "sha256": "8fe2ac7e0303f0110d75832d746e6661fcd5373fa498d929163f557fd1027434", + "sha256_in_prefix": "8fe2ac7e0303f0110d75832d746e6661fcd5373fa498d929163f557fd1027434", + "size_in_bytes": 13830 + }, + { + "_path": "lib/python3.12/lib2to3/pgen2/token.py", + "path_type": "hardlink", + "sha256": "7ee05616410d46d8caed0cb0755bf780c62cccf17e3c93c8ccb8dcaaa1e7094c", + "sha256_in_prefix": "7ee05616410d46d8caed0cb0755bf780c62cccf17e3c93c8ccb8dcaaa1e7094c", + "size_in_bytes": 1302 + }, + { + "_path": "lib/python3.12/lib2to3/pgen2/tokenize.py", + "path_type": "hardlink", + "sha256": "aaa0b98f6a65e08e9f8e34358198e329d29554a0d4b5f5059924a252eeb0f5c4", + "sha256_in_prefix": "aaa0b98f6a65e08e9f8e34358198e329d29554a0d4b5f5059924a252eeb0f5c4", + "size_in_bytes": 21119 + }, + { + "_path": "lib/python3.12/lib2to3/pygram.py", + "path_type": "hardlink", + "sha256": "b49d77876a9d1822ff6be04daf464341a8e4c0c3414240abf519254de2a97a48", + "sha256_in_prefix": "b49d77876a9d1822ff6be04daf464341a8e4c0c3414240abf519254de2a97a48", + "size_in_bytes": 1305 + }, + { + "_path": "lib/python3.12/lib2to3/pytree.py", + "path_type": "hardlink", + "sha256": "e53689352fb4fc83d85a09369650389ee01db802ad872a8abfc0bf6603ec38b9", + "sha256_in_prefix": "e53689352fb4fc83d85a09369650389ee01db802ad872a8abfc0bf6603ec38b9", + "size_in_bytes": 27974 + }, + { + "_path": "lib/python3.12/lib2to3/refactor.py", + "path_type": "hardlink", + "sha256": "6e9a4262fb65cd4d277f009df73ffa5748f5fe3b963d3c5395c160d5f88b089b", + "sha256_in_prefix": "6e9a4262fb65cd4d277f009df73ffa5748f5fe3b963d3c5395c160d5f88b089b", + "size_in_bytes": 27507 + }, + { + "_path": "lib/python3.12/linecache.py", + "path_type": "hardlink", + "sha256": "e814839fc75010db274ae034f45b0fff7e529ccb702319048545fef84c2045b7", + "sha256_in_prefix": "e814839fc75010db274ae034f45b0fff7e529ccb702319048545fef84c2045b7", + "size_in_bytes": 5690 + }, + { + "_path": "lib/python3.12/locale.py", + "path_type": "hardlink", + "sha256": "5caa43b5ca0d60fd8a6c0bf7e9b8c8a23e86c58e49f1f8b4398f0d2fdf237b6e", + "sha256_in_prefix": "5caa43b5ca0d60fd8a6c0bf7e9b8c8a23e86c58e49f1f8b4398f0d2fdf237b6e", + "size_in_bytes": 78558 + }, + { + "_path": "lib/python3.12/logging/__init__.py", + "path_type": "hardlink", + "sha256": "c246c90b76621840a71d59360039b713544d351fde5c9ac4994dbf42d304fe55", + "sha256_in_prefix": "c246c90b76621840a71d59360039b713544d351fde5c9ac4994dbf42d304fe55", + "size_in_bytes": 83583 + }, + { + "_path": "lib/python3.12/logging/__pycache__/__init__.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "f52741f3ebe816b0c09d841a1a14db765dab7e702d831317bfffa5e53b75e7e3", + "sha256_in_prefix": "f52741f3ebe816b0c09d841a1a14db765dab7e702d831317bfffa5e53b75e7e3", + "size_in_bytes": 95773 + }, + { + "_path": "lib/python3.12/logging/__pycache__/config.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "0e33ac77cc9c6380384e148a0ce3ca9a3d30221e00ef95caecf41696df40d087", + "sha256_in_prefix": "0e33ac77cc9c6380384e148a0ce3ca9a3d30221e00ef95caecf41696df40d087", + "size_in_bytes": 43311 + }, + { + "_path": "lib/python3.12/logging/__pycache__/handlers.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "ed6d8edaa44f3f8e48fbf6a99b702df3812c1c087386ee442b93f607a44e7a0b", + "sha256_in_prefix": "ed6d8edaa44f3f8e48fbf6a99b702df3812c1c087386ee442b93f607a44e7a0b", + "size_in_bytes": 67248 + }, + { + "_path": "lib/python3.12/logging/config.py", + "path_type": "hardlink", + "sha256": "4f39b6fab0d83992524c1e8fa5e96251cc7a22f490e4e60b15c732740bf741ae", + "sha256_in_prefix": "4f39b6fab0d83992524c1e8fa5e96251cc7a22f490e4e60b15c732740bf741ae", + "size_in_bytes": 41526 + }, + { + "_path": "lib/python3.12/logging/handlers.py", + "path_type": "hardlink", + "sha256": "d6790ea3ee1fb3fe87459c57fe241383d0f324932f66bdeaeef23a099e87eba8", + "sha256_in_prefix": "d6790ea3ee1fb3fe87459c57fe241383d0f324932f66bdeaeef23a099e87eba8", + "size_in_bytes": 62297 + }, + { + "_path": "lib/python3.12/lzma.py", + "path_type": "hardlink", + "sha256": "58fb9d2fdc8a8af7b25e218f17ea3b51bdfa53bdf40f440ab33c605974ca5c2e", + "sha256_in_prefix": "58fb9d2fdc8a8af7b25e218f17ea3b51bdfa53bdf40f440ab33c605974ca5c2e", + "size_in_bytes": 13277 + }, + { + "_path": "lib/python3.12/mailbox.py", + "path_type": "hardlink", + "sha256": "9a56f129b4f06cf24e77c5a085414b72b51f43206ba8b850da8647e9de2c0274", + "sha256_in_prefix": "9a56f129b4f06cf24e77c5a085414b72b51f43206ba8b850da8647e9de2c0274", + "size_in_bytes": 78766 + }, + { + "_path": "lib/python3.12/mailcap.py", + "path_type": "hardlink", + "sha256": "d3242c92bfedb13c7cf5e7aa116e9a38c07e9c6de58f53d03f72a469e9448ca6", + "sha256_in_prefix": "d3242c92bfedb13c7cf5e7aa116e9a38c07e9c6de58f53d03f72a469e9448ca6", + "size_in_bytes": 9333 + }, + { + "_path": "lib/python3.12/mimetypes.py", + "path_type": "hardlink", + "sha256": "f70302916d265621c71f3b2a7a37a8d26f7cd486662551bf860e19613aa0d99d", + "sha256_in_prefix": "f70302916d265621c71f3b2a7a37a8d26f7cd486662551bf860e19613aa0d99d", + "size_in_bytes": 22717 + }, + { + "_path": "lib/python3.12/modulefinder.py", + "path_type": "hardlink", + "sha256": "e07ab000c3698a7530af2c52955ac8bb7647140d22dca1c30f83443faa191e0f", + "sha256_in_prefix": "e07ab000c3698a7530af2c52955ac8bb7647140d22dca1c30f83443faa191e0f", + "size_in_bytes": 23699 + }, + { + "_path": "lib/python3.12/multiprocessing/__init__.py", + "path_type": "hardlink", + "sha256": "a5a42976033c7d63ee2740acceef949a3582dcb0e0442845f9717e1be771c68b", + "sha256_in_prefix": "a5a42976033c7d63ee2740acceef949a3582dcb0e0442845f9717e1be771c68b", + "size_in_bytes": 916 + }, + { + "_path": "lib/python3.12/multiprocessing/__pycache__/__init__.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "875dfc4df060d83805dd7b49029b443f401761527bd7c4df43c31f34d220f10f", + "sha256_in_prefix": "875dfc4df060d83805dd7b49029b443f401761527bd7c4df43c31f34d220f10f", + "size_in_bytes": 1208 + }, + { + "_path": "lib/python3.12/multiprocessing/__pycache__/connection.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "9e2296747272ac54a7e2aad40c6b4b80627845c2594906a6bea8c8eb04f41b04", + "sha256_in_prefix": "9e2296747272ac54a7e2aad40c6b4b80627845c2594906a6bea8c8eb04f41b04", + "size_in_bytes": 48396 + }, + { + "_path": "lib/python3.12/multiprocessing/__pycache__/context.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "d763b70ba8892637cc4eb8b95a83da152f57c89c0d9ec3413e58c2d512fdbac4", + "sha256_in_prefix": "d763b70ba8892637cc4eb8b95a83da152f57c89c0d9ec3413e58c2d512fdbac4", + "size_in_bytes": 17281 + }, + { + "_path": "lib/python3.12/multiprocessing/__pycache__/forkserver.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "0d007731f58479fcec81884edb7dbc12636818370850180fadc5b92c5ad647d1", + "sha256_in_prefix": "0d007731f58479fcec81884edb7dbc12636818370850180fadc5b92c5ad647d1", + "size_in_bytes": 15411 + }, + { + "_path": "lib/python3.12/multiprocessing/__pycache__/heap.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "eea70bf259f7a5f88ab45a81ec0d424d652a8d51c1375be93160bd93dfc0d1d5", + "sha256_in_prefix": "eea70bf259f7a5f88ab45a81ec0d424d652a8d51c1375be93160bd93dfc0d1d5", + "size_in_bytes": 14119 + }, + { + "_path": "lib/python3.12/multiprocessing/__pycache__/managers.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "2ee9a3bc40348e344894614b8d679b277d41499995df8d788ba14f617913a143", + "sha256_in_prefix": "2ee9a3bc40348e344894614b8d679b277d41499995df8d788ba14f617913a143", + "size_in_bytes": 68269 + }, + { + "_path": "lib/python3.12/multiprocessing/__pycache__/pool.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "439a501091b6ab7c3e955c7dba8ba73eeec4739e3f3270e9b3c40046808b3c42", + "sha256_in_prefix": "439a501091b6ab7c3e955c7dba8ba73eeec4739e3f3270e9b3c40046808b3c42", + "size_in_bytes": 44291 + }, + { + "_path": "lib/python3.12/multiprocessing/__pycache__/popen_fork.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "5a9e03b1425ef0e2a7d2dfb27cba4013b8b1456da1ba9bd304986a178831a208", + "sha256_in_prefix": "5a9e03b1425ef0e2a7d2dfb27cba4013b8b1456da1ba9bd304986a178831a208", + "size_in_bytes": 4358 + }, + { + "_path": "lib/python3.12/multiprocessing/__pycache__/popen_forkserver.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "303a0fcc46dfdd8a979b708481b5d1d7030629c037478286526c8a4f97eeed15", + "sha256_in_prefix": "303a0fcc46dfdd8a979b708481b5d1d7030629c037478286526c8a4f97eeed15", + "size_in_bytes": 4218 + }, + { + "_path": "lib/python3.12/multiprocessing/__pycache__/popen_spawn_posix.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "3519718db1e49a910dc38f348e088f9291a904e921b99112522ad3ca26c96ab3", + "sha256_in_prefix": "3519718db1e49a910dc38f348e088f9291a904e921b99112522ad3ca26c96ab3", + "size_in_bytes": 4199 + }, + { + "_path": "lib/python3.12/multiprocessing/__pycache__/popen_spawn_win32.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "870ef925629dc29c9a408f04e458f73e732769eee68840e2db15aa130c9e9e57", + "sha256_in_prefix": "870ef925629dc29c9a408f04e458f73e732769eee68840e2db15aa130c9e9e57", + "size_in_bytes": 6420 + }, + { + "_path": "lib/python3.12/multiprocessing/__pycache__/process.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "48ba6dd23eb95056a942ff89d07e0cd39e9a8fd0bf467914def7c2af1d8effaa", + "sha256_in_prefix": "48ba6dd23eb95056a942ff89d07e0cd39e9a8fd0bf467914def7c2af1d8effaa", + "size_in_bytes": 17996 + }, + { + "_path": "lib/python3.12/multiprocessing/__pycache__/queues.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "00a49e0b81bc52eb4e3dc72629372a1c49751344857665c75bc051606ab9c149", + "sha256_in_prefix": "00a49e0b81bc52eb4e3dc72629372a1c49751344857665c75bc051606ab9c149", + "size_in_bytes": 18772 + }, + { + "_path": "lib/python3.12/multiprocessing/__pycache__/reduction.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "f1431b57d43f99083b44dc97f2a599862749d610e7082ff019266a86eac8f788", + "sha256_in_prefix": "f1431b57d43f99083b44dc97f2a599862749d610e7082ff019266a86eac8f788", + "size_in_bytes": 14153 + }, + { + "_path": "lib/python3.12/multiprocessing/__pycache__/resource_sharer.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "55eac2e0ea81ee66f6cbf0d52abc74f0111ab383f08815a7625887ee410da917", + "sha256_in_prefix": "55eac2e0ea81ee66f6cbf0d52abc74f0111ab383f08815a7625887ee410da917", + "size_in_bytes": 9159 + }, + { + "_path": "lib/python3.12/multiprocessing/__pycache__/resource_tracker.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "45930f9fa48627aa2a61eb15ddab0fb4aea3d786d490f603978d3afdf4b3f600", + "sha256_in_prefix": "45930f9fa48627aa2a61eb15ddab0fb4aea3d786d490f603978d3afdf4b3f600", + "size_in_bytes": 11408 + }, + { + "_path": "lib/python3.12/multiprocessing/__pycache__/shared_memory.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "ee6fa4605035941d35eaf5a3d0085cb86327640a240f311be1e2657323e1e20d", + "sha256_in_prefix": "ee6fa4605035941d35eaf5a3d0085cb86327640a240f311be1e2657323e1e20d", + "size_in_bytes": 23814 + }, + { + "_path": "lib/python3.12/multiprocessing/__pycache__/sharedctypes.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "e6fdcc72e1591ca021cb23cc8eee8aedf1ed1c974cc577dac8558d47822f5027", + "sha256_in_prefix": "e6fdcc72e1591ca021cb23cc8eee8aedf1ed1c974cc577dac8558d47822f5027", + "size_in_bytes": 10953 + }, + { + "_path": "lib/python3.12/multiprocessing/__pycache__/spawn.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "4b0994726dc2d0ed421fab73a521c7c1b92acc158f64dace052d466f068d2e8f", + "sha256_in_prefix": "4b0994726dc2d0ed421fab73a521c7c1b92acc158f64dace052d466f068d2e8f", + "size_in_bytes": 11926 + }, + { + "_path": "lib/python3.12/multiprocessing/__pycache__/synchronize.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "751c49969cebd7da3645c92e6d15c5b4d7d64fc2745ba6a155bd16b5d6fdf4a9", + "sha256_in_prefix": "751c49969cebd7da3645c92e6d15c5b4d7d64fc2745ba6a155bd16b5d6fdf4a9", + "size_in_bytes": 21091 + }, + { + "_path": "lib/python3.12/multiprocessing/__pycache__/util.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "9834c79fcf00103ac456001eb6c0b30aea5110f6625437f142c256f5e1978b55", + "sha256_in_prefix": "9834c79fcf00103ac456001eb6c0b30aea5110f6625437f142c256f5e1978b55", + "size_in_bytes": 18934 + }, + { + "_path": "lib/python3.12/multiprocessing/connection.py", + "path_type": "hardlink", + "sha256": "0aefc3bfec2f73f93a7cdffbbbee0bfcba31c8e37be45afbfe19a5f963654d55", + "sha256_in_prefix": "0aefc3bfec2f73f93a7cdffbbbee0bfcba31c8e37be45afbfe19a5f963654d55", + "size_in_bytes": 41369 + }, + { + "_path": "lib/python3.12/multiprocessing/context.py", + "path_type": "hardlink", + "sha256": "63f15d3169f4453eb80af4ce673a193a0670941206673ab5192ea16a17e8419f", + "sha256_in_prefix": "63f15d3169f4453eb80af4ce673a193a0670941206673ab5192ea16a17e8419f", + "size_in_bytes": 11673 + }, + { + "_path": "lib/python3.12/multiprocessing/dummy/__init__.py", + "path_type": "hardlink", + "sha256": "9127a40ea0ff342cb414383b5e7c594a05be2dd835fe246bd3bb0dc036a32a90", + "sha256_in_prefix": "9127a40ea0ff342cb414383b5e7c594a05be2dd835fe246bd3bb0dc036a32a90", + "size_in_bytes": 3061 + }, + { + "_path": "lib/python3.12/multiprocessing/dummy/__pycache__/__init__.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "d950fafab5a447427c9daaaa5330572dc37d94305bcbc97e7cee50157a4d4cda", + "sha256_in_prefix": "d950fafab5a447427c9daaaa5330572dc37d94305bcbc97e7cee50157a4d4cda", + "size_in_bytes": 5858 + }, + { + "_path": "lib/python3.12/multiprocessing/dummy/__pycache__/connection.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "5376f73863b8c3961c3174322c6fe92f15a90c65d4dadf07ef356838d8be201a", + "sha256_in_prefix": "5376f73863b8c3961c3174322c6fe92f15a90c65d4dadf07ef356838d8be201a", + "size_in_bytes": 3749 + }, + { + "_path": "lib/python3.12/multiprocessing/dummy/connection.py", + "path_type": "hardlink", + "sha256": "d63dd1979fde9c133efe430ee870e6ba6de43c0a0513866ce3ce475791fe57ab", + "sha256_in_prefix": "d63dd1979fde9c133efe430ee870e6ba6de43c0a0513866ce3ce475791fe57ab", + "size_in_bytes": 1598 + }, + { + "_path": "lib/python3.12/multiprocessing/forkserver.py", + "path_type": "hardlink", + "sha256": "e99f0aa2e4dc41af9d259f220c5eb2632e2ace89b6851e712223bf2682016f29", + "sha256_in_prefix": "e99f0aa2e4dc41af9d259f220c5eb2632e2ace89b6851e712223bf2682016f29", + "size_in_bytes": 12134 + }, + { + "_path": "lib/python3.12/multiprocessing/heap.py", + "path_type": "hardlink", + "sha256": "f6bb79bb99b9ae484935f0d68822e9603a1622dd0b6c4966c79db232a93ba614", + "sha256_in_prefix": "f6bb79bb99b9ae484935f0d68822e9603a1622dd0b6c4966c79db232a93ba614", + "size_in_bytes": 11626 + }, + { + "_path": "lib/python3.12/multiprocessing/managers.py", + "path_type": "hardlink", + "sha256": "7c5431f44b7f966ada442a8524e2df857e6319447001094e78fc4fb041a58f4e", + "sha256_in_prefix": "7c5431f44b7f966ada442a8524e2df857e6319447001094e78fc4fb041a58f4e", + "size_in_bytes": 47616 + }, + { + "_path": "lib/python3.12/multiprocessing/pool.py", + "path_type": "hardlink", + "sha256": "418cd41ea5c341e66c6979a38070f6f552cbbdf0539073022b6d15c67e53f480", + "sha256_in_prefix": "418cd41ea5c341e66c6979a38070f6f552cbbdf0539073022b6d15c67e53f480", + "size_in_bytes": 32760 + }, + { + "_path": "lib/python3.12/multiprocessing/popen_fork.py", + "path_type": "hardlink", + "sha256": "0a09db57e7fab7061c01a61778feea6e2b6bb02ccbc150332f2960b05258ef95", + "sha256_in_prefix": "0a09db57e7fab7061c01a61778feea6e2b6bb02ccbc150332f2960b05258ef95", + "size_in_bytes": 2377 + }, + { + "_path": "lib/python3.12/multiprocessing/popen_forkserver.py", + "path_type": "hardlink", + "sha256": "0588ad0e5a36718b4377dc2a2a97864a10986c25a33dc3bfed12595711b0cdab", + "sha256_in_prefix": "0588ad0e5a36718b4377dc2a2a97864a10986c25a33dc3bfed12595711b0cdab", + "size_in_bytes": 2230 + }, + { + "_path": "lib/python3.12/multiprocessing/popen_spawn_posix.py", + "path_type": "hardlink", + "sha256": "97b5d25aa479516894489877e6a7921252ee35f51e118c2f1f91f32919e7caa8", + "sha256_in_prefix": "97b5d25aa479516894489877e6a7921252ee35f51e118c2f1f91f32919e7caa8", + "size_in_bytes": 2029 + }, + { + "_path": "lib/python3.12/multiprocessing/popen_spawn_win32.py", + "path_type": "hardlink", + "sha256": "6ef8efd9cd4e99c64a6778f7ad0957e924de9eb4aa167337ed121a2621b1ffaa", + "sha256_in_prefix": "6ef8efd9cd4e99c64a6778f7ad0957e924de9eb4aa167337ed121a2621b1ffaa", + "size_in_bytes": 4515 + }, + { + "_path": "lib/python3.12/multiprocessing/process.py", + "path_type": "hardlink", + "sha256": "67f0c2a7a3a83c92dd024705bac18619a2e123c9df77c414beb81035ea4a0e18", + "sha256_in_prefix": "67f0c2a7a3a83c92dd024705bac18619a2e123c9df77c414beb81035ea4a0e18", + "size_in_bytes": 12139 + }, + { + "_path": "lib/python3.12/multiprocessing/queues.py", + "path_type": "hardlink", + "sha256": "f4721a323ab2981a172dd2b853d2cfeded696e9716fba340cf6e168f5ed95f83", + "sha256_in_prefix": "f4721a323ab2981a172dd2b853d2cfeded696e9716fba340cf6e168f5ed95f83", + "size_in_bytes": 12693 + }, + { + "_path": "lib/python3.12/multiprocessing/reduction.py", + "path_type": "hardlink", + "sha256": "4999f8b9ae7b3e8a7f5de302612b4131498dc2e238a2c47f894905c1c63294fe", + "sha256_in_prefix": "4999f8b9ae7b3e8a7f5de302612b4131498dc2e238a2c47f894905c1c63294fe", + "size_in_bytes": 9512 + }, + { + "_path": "lib/python3.12/multiprocessing/resource_sharer.py", + "path_type": "hardlink", + "sha256": "bba3c7f2b76a9cf4e8ceb642801c405411da95adf91947d81b0043586038290e", + "sha256_in_prefix": "bba3c7f2b76a9cf4e8ceb642801c405411da95adf91947d81b0043586038290e", + "size_in_bytes": 5145 + }, + { + "_path": "lib/python3.12/multiprocessing/resource_tracker.py", + "path_type": "hardlink", + "sha256": "b0099f5e2285fe2462b77c47bbf29220b57c778741a34f386c10c1e9940884c8", + "sha256_in_prefix": "b0099f5e2285fe2462b77c47bbf29220b57c778741a34f386c10c1e9940884c8", + "size_in_bytes": 10332 + }, + { + "_path": "lib/python3.12/multiprocessing/shared_memory.py", + "path_type": "hardlink", + "sha256": "51301e70710220e1c494ff5383ac94442a38a4a6622f2eb94e40128c45de1aeb", + "sha256_in_prefix": "51301e70710220e1c494ff5383ac94442a38a4a6622f2eb94e40128c45de1aeb", + "size_in_bytes": 18458 + }, + { + "_path": "lib/python3.12/multiprocessing/sharedctypes.py", + "path_type": "hardlink", + "sha256": "77ef522912474652490b7df523112858e51721e63dcf109b8567a35ce9b31b0d", + "sha256_in_prefix": "77ef522912474652490b7df523112858e51721e63dcf109b8567a35ce9b31b0d", + "size_in_bytes": 6306 + }, + { + "_path": "lib/python3.12/multiprocessing/spawn.py", + "path_type": "hardlink", + "sha256": "ebf9fa40eb622384c37690d8c78e7208744df031155ab4ceedab0fc791a1669b", + "sha256_in_prefix": "ebf9fa40eb622384c37690d8c78e7208744df031155ab4ceedab0fc791a1669b", + "size_in_bytes": 9644 + }, + { + "_path": "lib/python3.12/multiprocessing/synchronize.py", + "path_type": "hardlink", + "sha256": "9afc08f6d99deb0cefcbe2f0302dadf3942114aa5564afa0b41bc69f54d1ecaf", + "sha256_in_prefix": "9afc08f6d99deb0cefcbe2f0302dadf3942114aa5564afa0b41bc69f54d1ecaf", + "size_in_bytes": 12285 + }, + { + "_path": "lib/python3.12/multiprocessing/util.py", + "path_type": "hardlink", + "sha256": "6752c4515ec69f82e9df64e017da490c3754e51d818c270ea1ad2d64e09268be", + "sha256_in_prefix": "6752c4515ec69f82e9df64e017da490c3754e51d818c270ea1ad2d64e09268be", + "size_in_bytes": 14261 + }, + { + "_path": "lib/python3.12/netrc.py", + "path_type": "hardlink", + "sha256": "229da6d0cbe6a10295be6c64ac3806420ea018124c09e4887410548fc2fc8b5d", + "sha256_in_prefix": "229da6d0cbe6a10295be6c64ac3806420ea018124c09e4887410548fc2fc8b5d", + "size_in_bytes": 6922 + }, + { + "_path": "lib/python3.12/nntplib.py", + "path_type": "hardlink", + "sha256": "6a76a94b951b273aa87335d7c9c4d7273e4c59485c784b057f681443b32d9004", + "sha256_in_prefix": "6a76a94b951b273aa87335d7c9c4d7273e4c59485c784b057f681443b32d9004", + "size_in_bytes": 41087 + }, + { + "_path": "lib/python3.12/ntpath.py", + "path_type": "hardlink", + "sha256": "0ba5b71169c209deaf39bb3c6f043f65586c931424236ed10cfe9b932b1e6197", + "sha256_in_prefix": "0ba5b71169c209deaf39bb3c6f043f65586c931424236ed10cfe9b932b1e6197", + "size_in_bytes": 31483 + }, + { + "_path": "lib/python3.12/nturl2path.py", + "path_type": "hardlink", + "sha256": "980982ba66cc403d17874369d2770e09845b3d49f1d4514e1c52e01518114332", + "sha256_in_prefix": "980982ba66cc403d17874369d2770e09845b3d49f1d4514e1c52e01518114332", + "size_in_bytes": 2887 + }, + { + "_path": "lib/python3.12/numbers.py", + "path_type": "hardlink", + "sha256": "ac381960a3dc1db0498b0bd43d8ef278d6599713121a186b153ff09d9552e0db", + "sha256_in_prefix": "ac381960a3dc1db0498b0bd43d8ef278d6599713121a186b153ff09d9552e0db", + "size_in_bytes": 11467 + }, + { + "_path": "lib/python3.12/opcode.py", + "path_type": "hardlink", + "sha256": "192f6008508f28d3273bff42eaea9b01c8394dab1607cd36aea778bdd166c3a6", + "sha256_in_prefix": "192f6008508f28d3273bff42eaea9b01c8394dab1607cd36aea778bdd166c3a6", + "size_in_bytes": 13174 + }, + { + "_path": "lib/python3.12/operator.py", + "path_type": "hardlink", + "sha256": "b2af20f67667203c1730e686cc5d0427becc94db4c97f1d3efe3ed2158473f6a", + "sha256_in_prefix": "b2af20f67667203c1730e686cc5d0427becc94db4c97f1d3efe3ed2158473f6a", + "size_in_bytes": 10965 + }, + { + "_path": "lib/python3.12/optparse.py", + "path_type": "hardlink", + "sha256": "07d224301cba312fa0697bff9cd5a4bb4f778a90629632091b3f4ae874d89af5", + "sha256_in_prefix": "07d224301cba312fa0697bff9cd5a4bb4f778a90629632091b3f4ae874d89af5", + "size_in_bytes": 60369 + }, + { + "_path": "lib/python3.12/os.py", + "path_type": "hardlink", + "sha256": "e36b0a6d4feefa0ec1f15b84abd87f61da6f5db434586467869ff0e5f5e1dc24", + "sha256_in_prefix": "e36b0a6d4feefa0ec1f15b84abd87f61da6f5db434586467869ff0e5f5e1dc24", + "size_in_bytes": 39760 + }, + { + "_path": "lib/python3.12/pathlib.py", + "path_type": "hardlink", + "sha256": "dc14d8207519fb8bcdd9c7bae1d54da3ad1b339aa83d4979c16057cd552a3487", + "sha256_in_prefix": "dc14d8207519fb8bcdd9c7bae1d54da3ad1b339aa83d4979c16057cd552a3487", + "size_in_bytes": 51105 + }, + { + "_path": "lib/python3.12/pdb.py", + "path_type": "hardlink", + "sha256": "2e235aa352654b9341dfd3ae088ad27dddf960fb1c9e9158d693d86a3ab4928a", + "sha256_in_prefix": "2e235aa352654b9341dfd3ae088ad27dddf960fb1c9e9158d693d86a3ab4928a", + "size_in_bytes": 70062 + }, + { + "_path": "lib/python3.12/pickle.py", + "path_type": "hardlink", + "sha256": "865b5788a1e35433f89d047187a514057e15ddc2a301b06b5f85da62b4259c04", + "sha256_in_prefix": "865b5788a1e35433f89d047187a514057e15ddc2a301b06b5f85da62b4259c04", + "size_in_bytes": 64901 + }, + { + "_path": "lib/python3.12/pickletools.py", + "path_type": "hardlink", + "sha256": "85a06ddd0cbb8c08557b65ba22ed49f7458314bc78d74c298877da7afd06c4bb", + "sha256_in_prefix": "85a06ddd0cbb8c08557b65ba22ed49f7458314bc78d74c298877da7afd06c4bb", + "size_in_bytes": 93862 + }, + { + "_path": "lib/python3.12/pipes.py", + "path_type": "hardlink", + "sha256": "153f2d249d954b5536c6a049202617ff43ba2f9b109c426e06676c577ddedc61", + "sha256_in_prefix": "153f2d249d954b5536c6a049202617ff43ba2f9b109c426e06676c577ddedc61", + "size_in_bytes": 8978 + }, + { + "_path": "lib/python3.12/pkgutil.py", + "path_type": "hardlink", + "sha256": "44300bc77f6f52ef2ad74d26e5053309c04f49eaa91c099356eb61426cde504f", + "sha256_in_prefix": "44300bc77f6f52ef2ad74d26e5053309c04f49eaa91c099356eb61426cde504f", + "size_in_bytes": 18281 + }, + { + "_path": "lib/python3.12/platform.py", + "path_type": "hardlink", + "sha256": "dbfb80dd05e351a45456b40d272c869bb9e8f6c4d7ef22fda738755318f147ca", + "sha256_in_prefix": "dbfb80dd05e351a45456b40d272c869bb9e8f6c4d7ef22fda738755318f147ca", + "size_in_bytes": 43516 + }, + { + "_path": "lib/python3.12/plistlib.py", + "path_type": "hardlink", + "sha256": "502ea7953e190f0bb03c6acec41c6ab54eb51bbdbd9d8e1c41e53a2d2191aebf", + "sha256_in_prefix": "502ea7953e190f0bb03c6acec41c6ab54eb51bbdbd9d8e1c41e53a2d2191aebf", + "size_in_bytes": 28342 + }, + { + "_path": "lib/python3.12/poplib.py", + "path_type": "hardlink", + "sha256": "08609dc8298e62bf9232de174f5ae4307f27ebef490bf7996625f88d837f08ad", + "sha256_in_prefix": "08609dc8298e62bf9232de174f5ae4307f27ebef490bf7996625f88d837f08ad", + "size_in_bytes": 14163 + }, + { + "_path": "lib/python3.12/posixpath.py", + "path_type": "hardlink", + "sha256": "8396232224e1b9df7896a32980046825b64c00bb010ddd2a4ccc23fe4fbfe262", + "sha256_in_prefix": "8396232224e1b9df7896a32980046825b64c00bb010ddd2a4ccc23fe4fbfe262", + "size_in_bytes": 17564 + }, + { + "_path": "lib/python3.12/pprint.py", + "path_type": "hardlink", + "sha256": "1585c8d74d7f485590db2af46680ae0a73737ca9fb66022b2bcbbc4c4925e203", + "sha256_in_prefix": "1585c8d74d7f485590db2af46680ae0a73737ca9fb66022b2bcbbc4c4925e203", + "size_in_bytes": 24158 + }, + { + "_path": "lib/python3.12/profile.py", + "path_type": "hardlink", + "sha256": "dee2125b2a0913fcfd0330b75d7fb752f2dbbe1bf43e479fb0cba117b9ae6e17", + "sha256_in_prefix": "dee2125b2a0913fcfd0330b75d7fb752f2dbbe1bf43e479fb0cba117b9ae6e17", + "size_in_bytes": 23093 + }, + { + "_path": "lib/python3.12/pstats.py", + "path_type": "hardlink", + "sha256": "3e89c57f1e9d2501abf2e49701cf7d7f1e9525b1b88aeacdfb1c4cc530f4168e", + "sha256_in_prefix": "3e89c57f1e9d2501abf2e49701cf7d7f1e9525b1b88aeacdfb1c4cc530f4168e", + "size_in_bytes": 29289 + }, + { + "_path": "lib/python3.12/pty.py", + "path_type": "hardlink", + "sha256": "ddbb1749387539c2929957c7ec1235fd201d7ec15d285fe5246e88b35c722a4a", + "sha256_in_prefix": "ddbb1749387539c2929957c7ec1235fd201d7ec15d285fe5246e88b35c722a4a", + "size_in_bytes": 6137 + }, + { + "_path": "lib/python3.12/py_compile.py", + "path_type": "hardlink", + "sha256": "3464f04938b57a7aafbc5c394ccd4c46823ee607f7fe36b48b91ecbc30ff4e48", + "sha256_in_prefix": "3464f04938b57a7aafbc5c394ccd4c46823ee607f7fe36b48b91ecbc30ff4e48", + "size_in_bytes": 7837 + }, + { + "_path": "lib/python3.12/pyclbr.py", + "path_type": "hardlink", + "sha256": "e8ca09333701ba41244e20b8c2c37b7ed0499b88c4b2ca82cac51ef89ca9e647", + "sha256_in_prefix": "e8ca09333701ba41244e20b8c2c37b7ed0499b88c4b2ca82cac51ef89ca9e647", + "size_in_bytes": 11396 + }, + { + "_path": "lib/python3.12/pydoc.py", + "path_type": "hardlink", + "sha256": "ed4be37cfad5bd55fc11374f1343df4ec2ee9862cce4f825976a6cb851b5cd55", + "sha256_in_prefix": "ed4be37cfad5bd55fc11374f1343df4ec2ee9862cce4f825976a6cb851b5cd55", + "size_in_bytes": 109280 + }, + { + "_path": "lib/python3.12/pydoc_data/__init__.py", + "path_type": "hardlink", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size_in_bytes": 0 + }, + { + "_path": "lib/python3.12/pydoc_data/__pycache__/__init__.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "3c02bc6d766b9475db585874b52a3a2211b8033a4797d78bde7d9949f43d18ba", + "sha256_in_prefix": "3c02bc6d766b9475db585874b52a3a2211b8033a4797d78bde7d9949f43d18ba", + "size_in_bytes": 393 + }, + { + "_path": "lib/python3.12/pydoc_data/__pycache__/topics.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "9b2c02d1763d361b1915ca3d41a560c65dc4e4dd326662a729df020c9c3315f6", + "sha256_in_prefix": "9b2c02d1763d361b1915ca3d41a560c65dc4e4dd326662a729df020c9c3315f6", + "size_in_bytes": 501342 + }, + { + "_path": "lib/python3.12/pydoc_data/_pydoc.css", + "path_type": "hardlink", + "sha256": "038d4bf51b4d373284640f3658d70eaa856def24d8d02b8e29b289beaabf1cc9", + "sha256_in_prefix": "038d4bf51b4d373284640f3658d70eaa856def24d8d02b8e29b289beaabf1cc9", + "size_in_bytes": 1325 + }, + { + "_path": "lib/python3.12/pydoc_data/topics.py", + "path_type": "hardlink", + "sha256": "e77a8728b1bf2c1e46582c676307ef5a59ec0c400a60b44be717a2083a1b4c3e", + "sha256_in_prefix": "e77a8728b1bf2c1e46582c676307ef5a59ec0c400a60b44be717a2083a1b4c3e", + "size_in_bytes": 803712 + }, + { + "_path": "lib/python3.12/queue.py", + "path_type": "hardlink", + "sha256": "f6c37fc37cd7440979f7d22d40ee818fa3b714c573610c08fa52911d541193f0", + "sha256_in_prefix": "f6c37fc37cd7440979f7d22d40ee818fa3b714c573610c08fa52911d541193f0", + "size_in_bytes": 11496 + }, + { + "_path": "lib/python3.12/quopri.py", + "path_type": "hardlink", + "sha256": "a1cd7f3b22033d32151209886cc855d4b71cc4c83530769f920097582339013a", + "sha256_in_prefix": "a1cd7f3b22033d32151209886cc855d4b71cc4c83530769f920097582339013a", + "size_in_bytes": 7184 + }, + { + "_path": "lib/python3.12/random.py", + "path_type": "hardlink", + "sha256": "0693d4ded36916f5b07d6c395cc331dbf1011bb70e90daaa29eaa32490a09425", + "sha256_in_prefix": "0693d4ded36916f5b07d6c395cc331dbf1011bb70e90daaa29eaa32490a09425", + "size_in_bytes": 34683 + }, + { + "_path": "lib/python3.12/re/__init__.py", + "path_type": "hardlink", + "sha256": "8ff3c37c63b917fcf8dc8d50993a502292a3dc159e41de4f4018c72a53d1c07b", + "sha256_in_prefix": "8ff3c37c63b917fcf8dc8d50993a502292a3dc159e41de4f4018c72a53d1c07b", + "size_in_bytes": 16315 + }, + { + "_path": "lib/python3.12/re/__pycache__/__init__.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "7aba98f6df028ed142da9cf25003eadc0b74f349789c5d94737910327930047c", + "sha256_in_prefix": "7aba98f6df028ed142da9cf25003eadc0b74f349789c5d94737910327930047c", + "size_in_bytes": 18189 + }, + { + "_path": "lib/python3.12/re/__pycache__/_casefix.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "167865fd5cc5095b43cab10ee8da45e90f329263efae083a3577b9aac831004e", + "sha256_in_prefix": "167865fd5cc5095b43cab10ee8da45e90f329263efae083a3577b9aac831004e", + "size_in_bytes": 2070 + }, + { + "_path": "lib/python3.12/re/__pycache__/_compiler.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "c4a1f26400e20101a374efc0cafdce74ad28d008f020aa862555073d3df3c963", + "sha256_in_prefix": "c4a1f26400e20101a374efc0cafdce74ad28d008f020aa862555073d3df3c963", + "size_in_bytes": 26753 + }, + { + "_path": "lib/python3.12/re/__pycache__/_constants.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "6cb221cdb3c595ac5038616e79fb3b70f1c44a9f7e3801f3b7e8644f72be895d", + "sha256_in_prefix": "6cb221cdb3c595ac5038616e79fb3b70f1c44a9f7e3801f3b7e8644f72be895d", + "size_in_bytes": 5550 + }, + { + "_path": "lib/python3.12/re/__pycache__/_parser.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "1b8f42858b03fd6ada7416f7d17464702071c787971503cb885f068d21fcdb4a", + "sha256_in_prefix": "1b8f42858b03fd6ada7416f7d17464702071c787971503cb885f068d21fcdb4a", + "size_in_bytes": 42254 + }, + { + "_path": "lib/python3.12/re/_casefix.py", + "path_type": "hardlink", + "sha256": "41572ac50cf96b04496e676d8a6708898bb8e752e06dad34ed4c50c5d8f1fe40", + "sha256_in_prefix": "41572ac50cf96b04496e676d8a6708898bb8e752e06dad34ed4c50c5d8f1fe40", + "size_in_bytes": 5446 + }, + { + "_path": "lib/python3.12/re/_compiler.py", + "path_type": "hardlink", + "sha256": "c05067f8bfa4c13cbbf1eedc4d5cafc9b621bcb6ebc5771ba0518a18095af15a", + "sha256_in_prefix": "c05067f8bfa4c13cbbf1eedc4d5cafc9b621bcb6ebc5771ba0518a18095af15a", + "size_in_bytes": 26089 + }, + { + "_path": "lib/python3.12/re/_constants.py", + "path_type": "hardlink", + "sha256": "fa4fdb200f238f9e7817b63892b0d69833d8165134801e775e10cc113348a375", + "sha256_in_prefix": "fa4fdb200f238f9e7817b63892b0d69833d8165134801e775e10cc113348a375", + "size_in_bytes": 5930 + }, + { + "_path": "lib/python3.12/re/_parser.py", + "path_type": "hardlink", + "sha256": "a51a85b37cf3f44ba7ff25754da5f31306e4ccfa6eb3c017f9d37bdf4e770840", + "sha256_in_prefix": "a51a85b37cf3f44ba7ff25754da5f31306e4ccfa6eb3c017f9d37bdf4e770840", + "size_in_bytes": 41201 + }, + { + "_path": "lib/python3.12/reprlib.py", + "path_type": "hardlink", + "sha256": "8da31054076803065758311f54b18b8a616824941977d907dc3ee729228e9015", + "sha256_in_prefix": "8da31054076803065758311f54b18b8a616824941977d907dc3ee729228e9015", + "size_in_bytes": 6569 + }, + { + "_path": "lib/python3.12/rlcompleter.py", + "path_type": "hardlink", + "sha256": "fee9ad9c55529be48329b78e982fbba0201bd218326eaf80a87996c9f8c805bb", + "sha256_in_prefix": "fee9ad9c55529be48329b78e982fbba0201bd218326eaf80a87996c9f8c805bb", + "size_in_bytes": 7827 + }, + { + "_path": "lib/python3.12/runpy.py", + "path_type": "hardlink", + "sha256": "b1f47f717848022b83b511c74e0f862f58d1e11afa768910e87a49fccf0be2ff", + "sha256_in_prefix": "b1f47f717848022b83b511c74e0f862f58d1e11afa768910e87a49fccf0be2ff", + "size_in_bytes": 12898 + }, + { + "_path": "lib/python3.12/sched.py", + "path_type": "hardlink", + "sha256": "edfb309483d7cb05e06ad86d1fdeb819629f71402dc6710a1bec36c7afcaac50", + "sha256_in_prefix": "edfb309483d7cb05e06ad86d1fdeb819629f71402dc6710a1bec36c7afcaac50", + "size_in_bytes": 6351 + }, + { + "_path": "lib/python3.12/secrets.py", + "path_type": "hardlink", + "sha256": "277000574358a6ecda4bb40e73332ae81a3bc1c8e1fa36f50e5c6a7d4d3f0f17", + "sha256_in_prefix": "277000574358a6ecda4bb40e73332ae81a3bc1c8e1fa36f50e5c6a7d4d3f0f17", + "size_in_bytes": 1984 + }, + { + "_path": "lib/python3.12/selectors.py", + "path_type": "hardlink", + "sha256": "1eeb102373e18c96311203f30c516e785bd8642275aa0bd66e43a284c9692385", + "sha256_in_prefix": "1eeb102373e18c96311203f30c516e785bd8642275aa0bd66e43a284c9692385", + "size_in_bytes": 19671 + }, + { + "_path": "lib/python3.12/shelve.py", + "path_type": "hardlink", + "sha256": "b978c6f0ffa901b041d6518afed03f2938a62168066013ee7d23baac31c356c0", + "sha256_in_prefix": "b978c6f0ffa901b041d6518afed03f2938a62168066013ee7d23baac31c356c0", + "size_in_bytes": 8560 + }, + { + "_path": "lib/python3.12/shlex.py", + "path_type": "hardlink", + "sha256": "f927227de5ba5b1b2bdd75e3d9c8cb72b602b3bba3cc8edbf8fb554de0dc1fd7", + "sha256_in_prefix": "f927227de5ba5b1b2bdd75e3d9c8cb72b602b3bba3cc8edbf8fb554de0dc1fd7", + "size_in_bytes": 13353 + }, + { + "_path": "lib/python3.12/shutil.py", + "path_type": "hardlink", + "sha256": "cd1d0c76d0c907b8dafdb1203dc0dd947cf703f516e26ebde9fca55822b5b9ad", + "sha256_in_prefix": "cd1d0c76d0c907b8dafdb1203dc0dd947cf703f516e26ebde9fca55822b5b9ad", + "size_in_bytes": 58088 + }, + { + "_path": "lib/python3.12/signal.py", + "path_type": "hardlink", + "sha256": "0363c964c90ac0b3e515de5749205e6e6454051a1211058375d84d91eab6071a", + "sha256_in_prefix": "0363c964c90ac0b3e515de5749205e6e6454051a1211058375d84d91eab6071a", + "size_in_bytes": 2495 + }, + { + "_path": "lib/python3.12/site-packages/README.txt", + "path_type": "hardlink", + "sha256": "cba8fece8f62c36306ba27a128f124a257710e41fc619301ee97be93586917cb", + "sha256_in_prefix": "cba8fece8f62c36306ba27a128f124a257710e41fc619301ee97be93586917cb", + "size_in_bytes": 119 + }, + { + "_path": "lib/python3.12/site.py", + "path_type": "hardlink", + "sha256": "72296c68b28b4af912b6cf361d529562210679468e0e3ed04bec8e40a273bb62", + "sha256_in_prefix": "72296c68b28b4af912b6cf361d529562210679468e0e3ed04bec8e40a273bb62", + "size_in_bytes": 22823 + }, + { + "_path": "lib/python3.12/smtplib.py", + "path_type": "hardlink", + "sha256": "f19369e751e199f5dfc05882e2f77b6a692719cebd8a18c84552544a0b93e963", + "sha256_in_prefix": "f19369e751e199f5dfc05882e2f77b6a692719cebd8a18c84552544a0b93e963", + "size_in_bytes": 43532 + }, + { + "_path": "lib/python3.12/sndhdr.py", + "path_type": "hardlink", + "sha256": "d1cb49f6545ef831a69322275ef26f6ca6964953e70d81a8a80fcca8d600ffc0", + "sha256_in_prefix": "d1cb49f6545ef831a69322275ef26f6ca6964953e70d81a8a80fcca8d600ffc0", + "size_in_bytes": 7448 + }, + { + "_path": "lib/python3.12/socket.py", + "path_type": "hardlink", + "sha256": "b59366f7c35583a274c8031351c146d9c64c4e680adf45d99a3335536a20a6cc", + "sha256_in_prefix": "b59366f7c35583a274c8031351c146d9c64c4e680adf45d99a3335536a20a6cc", + "size_in_bytes": 37411 + }, + { + "_path": "lib/python3.12/socketserver.py", + "path_type": "hardlink", + "sha256": "177f7e4c71a255eecb94ef404df1682843a416b7c5083ae2b07a38016d7e16d7", + "sha256_in_prefix": "177f7e4c71a255eecb94ef404df1682843a416b7c5083ae2b07a38016d7e16d7", + "size_in_bytes": 27851 + }, + { + "_path": "lib/python3.12/sqlite3/__init__.py", + "path_type": "hardlink", + "sha256": "f7cc982617b68e147540ef352d38310fe4d25c2c9c2542b67d0590c871df09a8", + "sha256_in_prefix": "f7cc982617b68e147540ef352d38310fe4d25c2c9c2542b67d0590c871df09a8", + "size_in_bytes": 2501 + }, + { + "_path": "lib/python3.12/sqlite3/__main__.py", + "path_type": "hardlink", + "sha256": "495a939623e825a487cde07b62a68aeefdbb1704b53a8b5388af070dc3fac690", + "sha256_in_prefix": "495a939623e825a487cde07b62a68aeefdbb1704b53a8b5388af070dc3fac690", + "size_in_bytes": 3855 + }, + { + "_path": "lib/python3.12/sqlite3/__pycache__/__init__.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "29a547f6cec8b38a8f33d5011c2e10f0aaeb318d215c31fe6f2db645f8af15f3", + "sha256_in_prefix": "29a547f6cec8b38a8f33d5011c2e10f0aaeb318d215c31fe6f2db645f8af15f3", + "size_in_bytes": 2081 + }, + { + "_path": "lib/python3.12/sqlite3/__pycache__/__main__.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "c29f80905fce5d5842418d1321e5a7c978e125be280f9714397f62f3e30db2ae", + "sha256_in_prefix": "c29f80905fce5d5842418d1321e5a7c978e125be280f9714397f62f3e30db2ae", + "size_in_bytes": 5839 + }, + { + "_path": "lib/python3.12/sqlite3/__pycache__/dbapi2.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "1b73d7f916576074fffeb9d009b5589d109683bf624404afa9ff8816869b4fda", + "sha256_in_prefix": "1b73d7f916576074fffeb9d009b5589d109683bf624404afa9ff8816869b4fda", + "size_in_bytes": 5299 + }, + { + "_path": "lib/python3.12/sqlite3/__pycache__/dump.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "d44b9cf1b9a4bbacfa80fa18e3fb932d09f40f23e1348800a5aaaf1df419d9d7", + "sha256_in_prefix": "d44b9cf1b9a4bbacfa80fa18e3fb932d09f40f23e1348800a5aaaf1df419d9d7", + "size_in_bytes": 3909 + }, + { + "_path": "lib/python3.12/sqlite3/dbapi2.py", + "path_type": "hardlink", + "sha256": "7c5c8d98df1f2c50c4062a3be2c0f0499190c179fa4fc281507a1ef763a98f28", + "sha256_in_prefix": "7c5c8d98df1f2c50c4062a3be2c0f0499190c179fa4fc281507a1ef763a98f28", + "size_in_bytes": 3631 + }, + { + "_path": "lib/python3.12/sqlite3/dump.py", + "path_type": "hardlink", + "sha256": "7b23e13d844d448f6b34fa8b051cec57c9a2c37a94eae96c57b03233b64457d8", + "sha256_in_prefix": "7b23e13d844d448f6b34fa8b051cec57c9a2c37a94eae96c57b03233b64457d8", + "size_in_bytes": 3471 + }, + { + "_path": "lib/python3.12/sre_compile.py", + "path_type": "hardlink", + "sha256": "f7fd87f8ac9dad7d1387e2401761ec05806c5108201a6d1ede6ab2f481f6df54", + "sha256_in_prefix": "f7fd87f8ac9dad7d1387e2401761ec05806c5108201a6d1ede6ab2f481f6df54", + "size_in_bytes": 231 + }, + { + "_path": "lib/python3.12/sre_constants.py", + "path_type": "hardlink", + "sha256": "87013dc0b349c2c044100f70a8daa9d713e60a527e26f6ab8ee1fc978a6d3234", + "sha256_in_prefix": "87013dc0b349c2c044100f70a8daa9d713e60a527e26f6ab8ee1fc978a6d3234", + "size_in_bytes": 232 + }, + { + "_path": "lib/python3.12/sre_parse.py", + "path_type": "hardlink", + "sha256": "c4929134532306081918f185c99305c6f55213bc16b32f8c259bc60f7f81e810", + "sha256_in_prefix": "c4929134532306081918f185c99305c6f55213bc16b32f8c259bc60f7f81e810", + "size_in_bytes": 229 + }, + { + "_path": "lib/python3.12/ssl.py", + "path_type": "hardlink", + "sha256": "ca7dd38c7d39af5112b9669abffcef3f1bb374fb8fa0a2cd071aea09fce203da", + "sha256_in_prefix": "ca7dd38c7d39af5112b9669abffcef3f1bb374fb8fa0a2cd071aea09fce203da", + "size_in_bytes": 50822 + }, + { + "_path": "lib/python3.12/stat.py", + "path_type": "hardlink", + "sha256": "052af0327eae6941b69b05c088b3e748f79995635f80ac4cc7125eb333eb4c77", + "sha256_in_prefix": "052af0327eae6941b69b05c088b3e748f79995635f80ac4cc7125eb333eb4c77", + "size_in_bytes": 5485 + }, + { + "_path": "lib/python3.12/statistics.py", + "path_type": "hardlink", + "sha256": "b9ef01a757de37e9fbf13d32beeb9530c8271582cabec4998226dcb7e0613cd0", + "sha256_in_prefix": "b9ef01a757de37e9fbf13d32beeb9530c8271582cabec4998226dcb7e0613cd0", + "size_in_bytes": 50227 + }, + { + "_path": "lib/python3.12/string.py", + "path_type": "hardlink", + "sha256": "24aeae1f0526250f442022022bf98df9a823b1cb330543ee79e70e44907462e9", + "sha256_in_prefix": "24aeae1f0526250f442022022bf98df9a823b1cb330543ee79e70e44907462e9", + "size_in_bytes": 11786 + }, + { + "_path": "lib/python3.12/stringprep.py", + "path_type": "hardlink", + "sha256": "60b6c83581093029312efb6670b11c540090b3f78bcf72264467b494f02f21a5", + "sha256_in_prefix": "60b6c83581093029312efb6670b11c540090b3f78bcf72264467b494f02f21a5", + "size_in_bytes": 12917 + }, + { + "_path": "lib/python3.12/struct.py", + "path_type": "hardlink", + "sha256": "9c231f9497caf513a22dee8f790b07f969b0e45854a0bdd6dd84b492e08c2856", + "sha256_in_prefix": "9c231f9497caf513a22dee8f790b07f969b0e45854a0bdd6dd84b492e08c2856", + "size_in_bytes": 257 + }, + { + "_path": "lib/python3.12/subprocess.py", + "path_type": "hardlink", + "sha256": "615c6025002fbf150850f43efe49e72c2754dd4bdf35159b29e99bb82ea31907", + "sha256_in_prefix": "615c6025002fbf150850f43efe49e72c2754dd4bdf35159b29e99bb82ea31907", + "size_in_bytes": 88659 + }, + { + "_path": "lib/python3.12/sunau.py", + "path_type": "hardlink", + "sha256": "7e4f850f6460bcd302439d6d2a9fc1bfc31f88f87ad86c508489f5612b346b7a", + "sha256_in_prefix": "7e4f850f6460bcd302439d6d2a9fc1bfc31f88f87ad86c508489f5612b346b7a", + "size_in_bytes": 18478 + }, + { + "_path": "lib/python3.12/symtable.py", + "path_type": "hardlink", + "sha256": "53801d0f6d9b7702d9537e6a13dfac06b89340f70d9f046aa512f37b3e0ca7a6", + "sha256_in_prefix": "53801d0f6d9b7702d9537e6a13dfac06b89340f70d9f046aa512f37b3e0ca7a6", + "size_in_bytes": 10753 + }, + { + "_path": "lib/python3.12/sysconfig.py", + "path_type": "hardlink", + "sha256": "42d47318d7b26a578adc466a3c5b25266a6ceb154fb67b825b163ed2d02341fb", + "sha256_in_prefix": "42d47318d7b26a578adc466a3c5b25266a6ceb154fb67b825b163ed2d02341fb", + "size_in_bytes": 31075 + }, + { + "_path": "lib/python3.12/tabnanny.py", + "path_type": "hardlink", + "sha256": "edd89dcff09ac08bf48a135cd839bc295d8f74438872973b31c07a75bba7944a", + "sha256_in_prefix": "edd89dcff09ac08bf48a135cd839bc295d8f74438872973b31c07a75bba7944a", + "size_in_bytes": 11531 + }, + { + "_path": "lib/python3.12/tarfile.py", + "path_type": "hardlink", + "sha256": "5dd00cc68e88d9581551b1a457398c5b63d87ae1152fa03ef298743485d12cc8", + "sha256_in_prefix": "5dd00cc68e88d9581551b1a457398c5b63d87ae1152fa03ef298743485d12cc8", + "size_in_bytes": 106883 + }, + { + "_path": "lib/python3.12/telnetlib.py", + "path_type": "hardlink", + "sha256": "1984cebfb50180759ca075b0ea340d3624500dc22fab524a4dbf57c18bb548ca", + "sha256_in_prefix": "1984cebfb50180759ca075b0ea340d3624500dc22fab524a4dbf57c18bb548ca", + "size_in_bytes": 23301 + }, + { + "_path": "lib/python3.12/tempfile.py", + "path_type": "hardlink", + "sha256": "fb44155f430fac1923d3d7b6af1a0210edcfb580291d664e66f338491d68b62b", + "sha256_in_prefix": "fb44155f430fac1923d3d7b6af1a0210edcfb580291d664e66f338491d68b62b", + "size_in_bytes": 32236 + }, + { + "_path": "lib/python3.12/test/__init__.py", + "path_type": "hardlink", + "sha256": "836cdb388117cf81e78d9fa2a141cca1b14b0179733322e710067749a1b16fe9", + "sha256_in_prefix": "836cdb388117cf81e78d9fa2a141cca1b14b0179733322e710067749a1b16fe9", + "size_in_bytes": 47 + }, + { + "_path": "lib/python3.12/test/__pycache__/__init__.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "192c5a56d72d0ae47b1fe2ebef41af2d66ba911eb675fa1f6e1dcbafc060bb80", + "sha256_in_prefix": "192c5a56d72d0ae47b1fe2ebef41af2d66ba911eb675fa1f6e1dcbafc060bb80", + "size_in_bytes": 387 + }, + { + "_path": "lib/python3.12/test/__pycache__/test_script_helper.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "b37c50bd376541297f0f025c58f0d358760a5313c31054b8ec4839ae7244afc9", + "sha256_in_prefix": "b37c50bd376541297f0f025c58f0d358760a5313c31054b8ec4839ae7244afc9", + "size_in_bytes": 10502 + }, + { + "_path": "lib/python3.12/test/__pycache__/test_support.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "e4f6383b6d224777a6793a90b022478c5599d266c27154e4ddbcc08c72072037", + "sha256_in_prefix": "e4f6383b6d224777a6793a90b022478c5599d266c27154e4ddbcc08c72072037", + "size_in_bytes": 45450 + }, + { + "_path": "lib/python3.12/test/support/__init__.py", + "path_type": "hardlink", + "sha256": "39ce6a99ef58e089cd7ba2396b5c928001690b9a353c92f78f96b3d2e76afe16", + "sha256_in_prefix": "39ce6a99ef58e089cd7ba2396b5c928001690b9a353c92f78f96b3d2e76afe16", + "size_in_bytes": 79472 + }, + { + "_path": "lib/python3.12/test/support/__pycache__/__init__.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "c0e721c24397183d6c7d3d2bf4ea54d7cf75a2f8e571ca094fa1cd2101bc65a8", + "sha256_in_prefix": "c0e721c24397183d6c7d3d2bf4ea54d7cf75a2f8e571ca094fa1cd2101bc65a8", + "size_in_bytes": 97326 + }, + { + "_path": "lib/python3.12/test/support/__pycache__/ast_helper.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "1b66816339a5276d63ff3cf911e6603fe5e8885cbb681c6b13689386888f0024", + "sha256_in_prefix": "1b66816339a5276d63ff3cf911e6603fe5e8885cbb681c6b13689386888f0024", + "size_in_bytes": 2466 + }, + { + "_path": "lib/python3.12/test/support/__pycache__/asynchat.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "eb1ceb9e7e9ac142d81aae74e17bd5d200b3f314ba2eca23bf7e36d2e3c4e5f1", + "sha256_in_prefix": "eb1ceb9e7e9ac142d81aae74e17bd5d200b3f314ba2eca23bf7e36d2e3c4e5f1", + "size_in_bytes": 10987 + }, + { + "_path": "lib/python3.12/test/support/__pycache__/asyncore.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "1202c33543f7aa733dceaeaed457d1c22da016cc69058c14fdb969bcb3ff7051", + "sha256_in_prefix": "1202c33543f7aa733dceaeaed457d1c22da016cc69058c14fdb969bcb3ff7051", + "size_in_bytes": 25241 + }, + { + "_path": "lib/python3.12/test/support/__pycache__/bytecode_helper.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "96057896c4d5f610d8dd0120f00e70ed66052c2a085ba7f0f650dcfa51580431", + "sha256_in_prefix": "96057896c4d5f610d8dd0120f00e70ed66052c2a085ba7f0f650dcfa51580431", + "size_in_bytes": 7971 + }, + { + "_path": "lib/python3.12/test/support/__pycache__/hashlib_helper.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "42918d8d9c694c67bf581c363842eb60f6505f09cd3bd016ea8fd4125b77e46d", + "sha256_in_prefix": "42918d8d9c694c67bf581c363842eb60f6505f09cd3bd016ea8fd4125b77e46d", + "size_in_bytes": 2803 + }, + { + "_path": "lib/python3.12/test/support/__pycache__/hypothesis_helper.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "5d1762db25d1369d75b12e478fe3eb41456c094030a00384779000b8a4039124", + "sha256_in_prefix": "5d1762db25d1369d75b12e478fe3eb41456c094030a00384779000b8a4039124", + "size_in_bytes": 1554 + }, + { + "_path": "lib/python3.12/test/support/__pycache__/import_helper.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "3633c2206093d0a5b8bf9eb2df8571db8ff9c9fa53d5444800ddada54032477d", + "sha256_in_prefix": "3633c2206093d0a5b8bf9eb2df8571db8ff9c9fa53d5444800ddada54032477d", + "size_in_bytes": 14640 + }, + { + "_path": "lib/python3.12/test/support/__pycache__/interpreters.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "019a1a837cb6d11f57fd2380e1aedc6be8d6e6b50b535dae5b8329e8a1714827", + "sha256_in_prefix": "019a1a837cb6d11f57fd2380e1aedc6be8d6e6b50b535dae5b8329e8a1714827", + "size_in_bytes": 9853 + }, + { + "_path": "lib/python3.12/test/support/__pycache__/logging_helper.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "d750df069362c4928b8a7b6a1557fc7d1930f2a8fa7c10ef154d55de6f726757", + "sha256_in_prefix": "d750df069362c4928b8a7b6a1557fc7d1930f2a8fa7c10ef154d55de6f726757", + "size_in_bytes": 1836 + }, + { + "_path": "lib/python3.12/test/support/__pycache__/os_helper.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "42073116109e464a62d5d361587c3762123bd05573d2b668db1b1e4e1ed1564a", + "sha256_in_prefix": "42073116109e464a62d5d361587c3762123bd05573d2b668db1b1e4e1ed1564a", + "size_in_bytes": 30036 + }, + { + "_path": "lib/python3.12/test/support/__pycache__/pty_helper.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "0e023a95e3477ccce7cde23372361f49322c22d2fe2e981e870aa338e16f1418", + "sha256_in_prefix": "0e023a95e3477ccce7cde23372361f49322c22d2fe2e981e870aa338e16f1418", + "size_in_bytes": 4050 + }, + { + "_path": "lib/python3.12/test/support/__pycache__/script_helper.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "083ed38cc93a596274821b3b15dea3aa995617c122496e4a71349b298b4b3669", + "sha256_in_prefix": "083ed38cc93a596274821b3b15dea3aa995617c122496e4a71349b298b4b3669", + "size_in_bytes": 13305 + }, + { + "_path": "lib/python3.12/test/support/__pycache__/smtpd.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "5709352461ee4b5c4e1d7ab646e27a36a68efd2f1eb85b68db1037bdbbac4e7f", + "sha256_in_prefix": "5709352461ee4b5c4e1d7ab646e27a36a68efd2f1eb85b68db1037bdbbac4e7f", + "size_in_bytes": 39416 + }, + { + "_path": "lib/python3.12/test/support/__pycache__/socket_helper.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "53281424aea59e717560569bf8d12c282423044b8f625d1d9e63d73d80a1c5a8", + "sha256_in_prefix": "53281424aea59e717560569bf8d12c282423044b8f625d1d9e63d73d80a1c5a8", + "size_in_bytes": 16487 + }, + { + "_path": "lib/python3.12/test/support/__pycache__/testcase.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "63f9f09eaf68d1dcd38c1e79ec13114b3772b762c3b9555a0678214ee3f2ddb3", + "sha256_in_prefix": "63f9f09eaf68d1dcd38c1e79ec13114b3772b762c3b9555a0678214ee3f2ddb3", + "size_in_bytes": 2045 + }, + { + "_path": "lib/python3.12/test/support/__pycache__/threading_helper.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "e041411dda0e8864c252f0e06903b4b7685d86106972546fda1e1f2f08caa6d2", + "sha256_in_prefix": "e041411dda0e8864c252f0e06903b4b7685d86106972546fda1e1f2f08caa6d2", + "size_in_bytes": 12013 + }, + { + "_path": "lib/python3.12/test/support/__pycache__/warnings_helper.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "97deee091383b721b02325c1a0c9708bb3d5955ba550bcfcdc2a1c4731888142", + "sha256_in_prefix": "97deee091383b721b02325c1a0c9708bb3d5955ba550bcfcdc2a1c4731888142", + "size_in_bytes": 10165 + }, + { + "_path": "lib/python3.12/test/support/_hypothesis_stubs/__init__.py", + "path_type": "hardlink", + "sha256": "6addb9fbd5d9007e5d50c40c4af5710d73bd62a5c1192b6d067a35cf580be219", + "sha256_in_prefix": "6addb9fbd5d9007e5d50c40c4af5710d73bd62a5c1192b6d067a35cf580be219", + "size_in_bytes": 2444 + }, + { + "_path": "lib/python3.12/test/support/_hypothesis_stubs/__pycache__/__init__.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "393a7f09e3cf0d4cebc63193bf898a1b63cbe61c070f7b9daac1e5b750626d28", + "sha256_in_prefix": "393a7f09e3cf0d4cebc63193bf898a1b63cbe61c070f7b9daac1e5b750626d28", + "size_in_bytes": 4185 + }, + { + "_path": "lib/python3.12/test/support/_hypothesis_stubs/__pycache__/_helpers.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "203d5008bc46346af3af6413bef6f5e218b2dee24f74d49bb3c62e6d8dd13d12", + "sha256_in_prefix": "203d5008bc46346af3af6413bef6f5e218b2dee24f74d49bb3c62e6d8dd13d12", + "size_in_bytes": 2835 + }, + { + "_path": "lib/python3.12/test/support/_hypothesis_stubs/__pycache__/strategies.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "3d9808a05f7fc2990f3787e3c8d0b98f591b975560c2cdd7f3e9dfd675cc74b6", + "sha256_in_prefix": "3d9808a05f7fc2990f3787e3c8d0b98f591b975560c2cdd7f3e9dfd675cc74b6", + "size_in_bytes": 3353 + }, + { + "_path": "lib/python3.12/test/support/_hypothesis_stubs/_helpers.py", + "path_type": "hardlink", + "sha256": "7d1d2fc87b9cbaf744af1ed8e31a96947b13da28bf2e7a0358996af9c195e380", + "sha256_in_prefix": "7d1d2fc87b9cbaf744af1ed8e31a96947b13da28bf2e7a0358996af9c195e380", + "size_in_bytes": 1298 + }, + { + "_path": "lib/python3.12/test/support/_hypothesis_stubs/strategies.py", + "path_type": "hardlink", + "sha256": "1fd24490e10dec6271a006fc01014adcccf9d486b7c201dde975092927246b68", + "sha256_in_prefix": "1fd24490e10dec6271a006fc01014adcccf9d486b7c201dde975092927246b68", + "size_in_bytes": 1857 + }, + { + "_path": "lib/python3.12/test/support/ast_helper.py", + "path_type": "hardlink", + "sha256": "5c72e61f5972cec7e2f830aa0bcdd6c8f3d56c7736a8e78af679d994aa7af84e", + "sha256_in_prefix": "5c72e61f5972cec7e2f830aa0bcdd6c8f3d56c7736a8e78af679d994aa7af84e", + "size_in_bytes": 1828 + }, + { + "_path": "lib/python3.12/test/support/asynchat.py", + "path_type": "hardlink", + "sha256": "67f2619c60c171d03b091931851b658f7a92446e131ac261a3352eb0ccc1b17e", + "sha256_in_prefix": "67f2619c60c171d03b091931851b658f7a92446e131ac261a3352eb0ccc1b17e", + "size_in_bytes": 11602 + }, + { + "_path": "lib/python3.12/test/support/asyncore.py", + "path_type": "hardlink", + "sha256": "4cc554dcb58d602bd9d557b2aa497fe9a325d9e021d97a95c0358e907291a47a", + "sha256_in_prefix": "4cc554dcb58d602bd9d557b2aa497fe9a325d9e021d97a95c0358e907291a47a", + "size_in_bytes": 20381 + }, + { + "_path": "lib/python3.12/test/support/bytecode_helper.py", + "path_type": "hardlink", + "sha256": "fb67d0e9f8e7869235e94949b06313e412be59c29ad1f089f323019f0f3a0e49", + "sha256_in_prefix": "fb67d0e9f8e7869235e94949b06313e412be59c29ad1f089f323019f0f3a0e49", + "size_in_bytes": 4999 + }, + { + "_path": "lib/python3.12/test/support/hashlib_helper.py", + "path_type": "hardlink", + "sha256": "19924c427e33c86284ef2a41f76ab6937ab36f12e3d1ef4e617cdbf616a8fc12", + "sha256_in_prefix": "19924c427e33c86284ef2a41f76ab6937ab36f12e3d1ef4e617cdbf616a8fc12", + "size_in_bytes": 1907 + }, + { + "_path": "lib/python3.12/test/support/hypothesis_helper.py", + "path_type": "hardlink", + "sha256": "0cbf55d49bdb78c5a93446d44dfe0bf247a408ae159813989285f7e8c87fd469", + "sha256_in_prefix": "0cbf55d49bdb78c5a93446d44dfe0bf247a408ae159813989285f7e8c87fd469", + "size_in_bytes": 1383 + }, + { + "_path": "lib/python3.12/test/support/import_helper.py", + "path_type": "hardlink", + "sha256": "32bcd1fc9d407042df157c843fbe5684ea3d7704f587f55049017e28a65bda4c", + "sha256_in_prefix": "32bcd1fc9d407042df157c843fbe5684ea3d7704f587f55049017e28a65bda4c", + "size_in_bytes": 10521 + }, + { + "_path": "lib/python3.12/test/support/interpreters.py", + "path_type": "hardlink", + "sha256": "b74464655baa283d2de961e223e0853b498ca51f0889cb790267c8554ac79c92", + "sha256_in_prefix": "b74464655baa283d2de961e223e0853b498ca51f0889cb790267c8554ac79c92", + "size_in_bytes": 5808 + }, + { + "_path": "lib/python3.12/test/support/logging_helper.py", + "path_type": "hardlink", + "sha256": "be1927e654180fcf6d84257be161fe6fa59796774e862c89b6b78adb656738f3", + "sha256_in_prefix": "be1927e654180fcf6d84257be161fe6fa59796774e862c89b6b78adb656738f3", + "size_in_bytes": 916 + }, + { + "_path": "lib/python3.12/test/support/os_helper.py", + "path_type": "hardlink", + "sha256": "927aa94e0831b09c237b129749e06bb355deb007be0e1fd63dc0cdf4ef5c265d", + "sha256_in_prefix": "927aa94e0831b09c237b129749e06bb355deb007be0e1fd63dc0cdf4ef5c265d", + "size_in_bytes": 24286 + }, + { + "_path": "lib/python3.12/test/support/pty_helper.py", + "path_type": "hardlink", + "sha256": "d724296e344278ce3ffb39962c5761dd04b19e987f8068a09fff02cab7418cc2", + "sha256_in_prefix": "d724296e344278ce3ffb39962c5761dd04b19e987f8068a09fff02cab7418cc2", + "size_in_bytes": 3052 + }, + { + "_path": "lib/python3.12/test/support/script_helper.py", + "path_type": "hardlink", + "sha256": "65a4dc19ffb84e91400a7e3c6e51a58ced9f998270703fb8f9fc96daaa0c5740", + "sha256_in_prefix": "65a4dc19ffb84e91400a7e3c6e51a58ced9f998270703fb8f9fc96daaa0c5740", + "size_in_bytes": 11719 + }, + { + "_path": "lib/python3.12/test/support/smtpd.py", + "path_type": "hardlink", + "sha256": "00599762dd76cb7f6e0763238079c436f96f6a50331abaf2511cad8f0169ae40", + "sha256_in_prefix": "00599762dd76cb7f6e0763238079c436f96f6a50331abaf2511cad8f0169ae40", + "size_in_bytes": 30733 + }, + { + "_path": "lib/python3.12/test/support/socket_helper.py", + "path_type": "hardlink", + "sha256": "482196211cee77253034cb6b85b50bffb302fde20f083a5e888f34af603ea4ec", + "sha256_in_prefix": "482196211cee77253034cb6b85b50bffb302fde20f083a5e888f34af603ea4ec", + "size_in_bytes": 13794 + }, + { + "_path": "lib/python3.12/test/support/testcase.py", + "path_type": "hardlink", + "sha256": "3181376673273db26aa634b690c176d9b5cc176351f5f0d0d5f5a480d6fa0ece", + "sha256_in_prefix": "3181376673273db26aa634b690c176d9b5cc176351f5f0d0d5f5a480d6fa0ece", + "size_in_bytes": 1047 + }, + { + "_path": "lib/python3.12/test/support/threading_helper.py", + "path_type": "hardlink", + "sha256": "7f191895d8e33cb8b36645d0ef197096c459c6f63450366114753a85eaa8c113", + "sha256_in_prefix": "7f191895d8e33cb8b36645d0ef197096c459c6f63450366114753a85eaa8c113", + "size_in_bytes": 8049 + }, + { + "_path": "lib/python3.12/test/support/warnings_helper.py", + "path_type": "hardlink", + "sha256": "515c10201568a2fcb868d1c34ffe9d7f04e3f617a2cb61d587167359a83b09ec", + "sha256_in_prefix": "515c10201568a2fcb868d1c34ffe9d7f04e3f617a2cb61d587167359a83b09ec", + "size_in_bytes": 6853 + }, + { + "_path": "lib/python3.12/test/test_script_helper.py", + "path_type": "hardlink", + "sha256": "f484f6c67bdf6c47322799d6d9437dd4d00ff194c98f6caf97bb69e7bd65e867", + "sha256_in_prefix": "f484f6c67bdf6c47322799d6d9437dd4d00ff194c98f6caf97bb69e7bd65e867", + "size_in_bytes": 5960 + }, + { + "_path": "lib/python3.12/test/test_support.py", + "path_type": "hardlink", + "sha256": "abb8f0e9bce292ff4ce907541aa4fcae663064e9340b0fe9a41a3e9c07729fdc", + "sha256_in_prefix": "abb8f0e9bce292ff4ce907541aa4fcae663064e9340b0fe9a41a3e9c07729fdc", + "size_in_bytes": 27701 + }, + { + "_path": "lib/python3.12/textwrap.py", + "path_type": "hardlink", + "sha256": "62867e40cdea6669b361f72af4d7daf0359f207c92cbeddfc7c7506397c1f31c", + "sha256_in_prefix": "62867e40cdea6669b361f72af4d7daf0359f207c92cbeddfc7c7506397c1f31c", + "size_in_bytes": 19718 + }, + { + "_path": "lib/python3.12/this.py", + "path_type": "hardlink", + "sha256": "481d0cb3de511eae0b5713dad18542b07eafd9c013bb7690f7497bad49923a71", + "sha256_in_prefix": "481d0cb3de511eae0b5713dad18542b07eafd9c013bb7690f7497bad49923a71", + "size_in_bytes": 1003 + }, + { + "_path": "lib/python3.12/threading.py", + "path_type": "hardlink", + "sha256": "8273b4cf5b6f274b4993f5cae08634dd272c6952af9867ff9aa13ed446f1549b", + "sha256_in_prefix": "8273b4cf5b6f274b4993f5cae08634dd272c6952af9867ff9aa13ed446f1549b", + "size_in_bytes": 60123 + }, + { + "_path": "lib/python3.12/timeit.py", + "path_type": "hardlink", + "sha256": "d47d9deb6be0136d817e04d0e4824aa66c66efa01fe61cf62860fff08ecfe83a", + "sha256_in_prefix": "d47d9deb6be0136d817e04d0e4824aa66c66efa01fe61cf62860fff08ecfe83a", + "size_in_bytes": 13464 + }, + { + "_path": "lib/python3.12/tkinter/__init__.py", + "path_type": "hardlink", + "sha256": "0ee94734ebb7c8a97fcbfd367381c634bd9ac6caced7b64decf706c9f08d9932", + "sha256_in_prefix": "0ee94734ebb7c8a97fcbfd367381c634bd9ac6caced7b64decf706c9f08d9932", + "size_in_bytes": 172514 + }, + { + "_path": "lib/python3.12/tkinter/__main__.py", + "path_type": "hardlink", + "sha256": "9738a6cb9cdd8139721dd82118bd527897db5325d807222883f70fb1c5a1c27e", + "sha256_in_prefix": "9738a6cb9cdd8139721dd82118bd527897db5325d807222883f70fb1c5a1c27e", + "size_in_bytes": 148 + }, + { + "_path": "lib/python3.12/tkinter/__pycache__/__init__.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "8a818505a98005d2edbb4158f4ca6d0b30de0eee52816f4ef820cc825949f8a5", + "sha256_in_prefix": "8a818505a98005d2edbb4158f4ca6d0b30de0eee52816f4ef820cc825949f8a5", + "size_in_bytes": 245463 + }, + { + "_path": "lib/python3.12/tkinter/__pycache__/__main__.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "9ebd66b6de11f5efbff9ad4635843262f231e80a98d20dbd9cae95e15c53c80d", + "sha256_in_prefix": "9ebd66b6de11f5efbff9ad4635843262f231e80a98d20dbd9cae95e15c53c80d", + "size_in_bytes": 676 + }, + { + "_path": "lib/python3.12/tkinter/__pycache__/colorchooser.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "c4270ea531db365cb38aa9c944b1253271656e54397d4806a75a22c30b0e0a71", + "sha256_in_prefix": "c4270ea531db365cb38aa9c944b1253271656e54397d4806a75a22c30b0e0a71", + "size_in_bytes": 3010 + }, + { + "_path": "lib/python3.12/tkinter/__pycache__/commondialog.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "384019f384834ff9f042a630d62c41235217134c65f01bc8119406ee207f98f2", + "sha256_in_prefix": "384019f384834ff9f042a630d62c41235217134c65f01bc8119406ee207f98f2", + "size_in_bytes": 2148 + }, + { + "_path": "lib/python3.12/tkinter/__pycache__/constants.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "6c65e11b0ca60ef78a194cd5445782644d24a96749be3dd3022baa982f9ba04c", + "sha256_in_prefix": "6c65e11b0ca60ef78a194cd5445782644d24a96749be3dd3022baa982f9ba04c", + "size_in_bytes": 2186 + }, + { + "_path": "lib/python3.12/tkinter/__pycache__/dialog.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "0b3c901d438005e7668084494f15bc9c8a9246899d00210f2cb68a872e4b3523", + "sha256_in_prefix": "0b3c901d438005e7668084494f15bc9c8a9246899d00210f2cb68a872e4b3523", + "size_in_bytes": 2364 + }, + { + "_path": "lib/python3.12/tkinter/__pycache__/dnd.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "f612f5a4887df731cbb3decfdf9fdc5173dff300bebfb0ed6fdded73b75289cc", + "sha256_in_prefix": "f612f5a4887df731cbb3decfdf9fdc5173dff300bebfb0ed6fdded73b75289cc", + "size_in_bytes": 16579 + }, + { + "_path": "lib/python3.12/tkinter/__pycache__/filedialog.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "cfef1d398c35f794742bb6d5dc8c918632b12aa2227169ca72d936303d933fec", + "sha256_in_prefix": "cfef1d398c35f794742bb6d5dc8c918632b12aa2227169ca72d936303d933fec", + "size_in_bytes": 22884 + }, + { + "_path": "lib/python3.12/tkinter/__pycache__/font.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "88530b333742eafaf187bc8d33c11b8790919642019997d566a803e83eca4a3e", + "sha256_in_prefix": "88530b333742eafaf187bc8d33c11b8790919642019997d566a803e83eca4a3e", + "size_in_bytes": 11146 + }, + { + "_path": "lib/python3.12/tkinter/__pycache__/messagebox.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "99947b9f728f2cb1b0595b8c09a0e524beb2e47388d173947d59d45f7108c22f", + "sha256_in_prefix": "99947b9f728f2cb1b0595b8c09a0e524beb2e47388d173947d59d45f7108c22f", + "size_in_bytes": 4354 + }, + { + "_path": "lib/python3.12/tkinter/__pycache__/scrolledtext.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "98f15bf0665ac7503a531d65a975a59e71efcd9b7e9a2d891514baaaa87d1401", + "sha256_in_prefix": "98f15bf0665ac7503a531d65a975a59e71efcd9b7e9a2d891514baaaa87d1401", + "size_in_bytes": 3583 + }, + { + "_path": "lib/python3.12/tkinter/__pycache__/simpledialog.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "d088a4f68452c9dadb41aea32d5f5372436cd8ccdf43fa265f8c32cc1a8f5e53", + "sha256_in_prefix": "d088a4f68452c9dadb41aea32d5f5372436cd8ccdf43fa265f8c32cc1a8f5e53", + "size_in_bytes": 17797 + }, + { + "_path": "lib/python3.12/tkinter/__pycache__/tix.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "dd630a5e9467af46caa435e6ea7a3e2d82e569be7163e57ae469bf5865e2d807", + "sha256_in_prefix": "dd630a5e9467af46caa435e6ea7a3e2d82e569be7163e57ae469bf5865e2d807", + "size_in_bytes": 112073 + }, + { + "_path": "lib/python3.12/tkinter/__pycache__/ttk.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "81cfd33ef7ed6f1f9052c04b6924e420e500fd64887dc26f66ba7e8c34065da2", + "sha256_in_prefix": "81cfd33ef7ed6f1f9052c04b6924e420e500fd64887dc26f66ba7e8c34065da2", + "size_in_bytes": 73833 + }, + { + "_path": "lib/python3.12/tkinter/colorchooser.py", + "path_type": "hardlink", + "sha256": "1224241dcfb4ec6aff3cafc66adeb2b2a3759397a28693173915458c50040143", + "sha256_in_prefix": "1224241dcfb4ec6aff3cafc66adeb2b2a3759397a28693173915458c50040143", + "size_in_bytes": 2660 + }, + { + "_path": "lib/python3.12/tkinter/commondialog.py", + "path_type": "hardlink", + "sha256": "e683ab0ee9404baec656a88d637910bcb2badb4b4e5d5def2b80cc4534551e6f", + "sha256_in_prefix": "e683ab0ee9404baec656a88d637910bcb2badb4b4e5d5def2b80cc4534551e6f", + "size_in_bytes": 1289 + }, + { + "_path": "lib/python3.12/tkinter/constants.py", + "path_type": "hardlink", + "sha256": "c01314dc51d1c8effeba2528720a65da133596d4143200c68595c02067bf1da2", + "sha256_in_prefix": "c01314dc51d1c8effeba2528720a65da133596d4143200c68595c02067bf1da2", + "size_in_bytes": 1493 + }, + { + "_path": "lib/python3.12/tkinter/dialog.py", + "path_type": "hardlink", + "sha256": "4f8201d3ada7b6d0f450b417e55747adaee5f894412c4875169b0736a5ff0faa", + "sha256_in_prefix": "4f8201d3ada7b6d0f450b417e55747adaee5f894412c4875169b0736a5ff0faa", + "size_in_bytes": 1535 + }, + { + "_path": "lib/python3.12/tkinter/dnd.py", + "path_type": "hardlink", + "sha256": "542b804b243b502b5525a8b1f04a02a120b1db4e3599f5c7865e60693ed3672a", + "sha256_in_prefix": "542b804b243b502b5525a8b1f04a02a120b1db4e3599f5c7865e60693ed3672a", + "size_in_bytes": 11644 + }, + { + "_path": "lib/python3.12/tkinter/filedialog.py", + "path_type": "hardlink", + "sha256": "d75c1eb4131db658b8622acffd8262ecbd7337425c799ea3be8d605ea6be7b94", + "sha256_in_prefix": "d75c1eb4131db658b8622acffd8262ecbd7337425c799ea3be8d605ea6be7b94", + "size_in_bytes": 14939 + }, + { + "_path": "lib/python3.12/tkinter/font.py", + "path_type": "hardlink", + "sha256": "a73482badacc4a69ff7fae9445793a4d858212fdef103360a478bbfd6ed2f496", + "sha256_in_prefix": "a73482badacc4a69ff7fae9445793a4d858212fdef103360a478bbfd6ed2f496", + "size_in_bytes": 7000 + }, + { + "_path": "lib/python3.12/tkinter/messagebox.py", + "path_type": "hardlink", + "sha256": "cdbf655c66778a19f0e25754a5f198a850c8bd958ce651e8fe4b2b52ad7f9c63", + "sha256_in_prefix": "cdbf655c66778a19f0e25754a5f198a850c8bd958ce651e8fe4b2b52ad7f9c63", + "size_in_bytes": 3861 + }, + { + "_path": "lib/python3.12/tkinter/scrolledtext.py", + "path_type": "hardlink", + "sha256": "c7cc050ec9cc3cc6a47215b5bc79b2d3e5c6ed895a4300ab0e20f6c249385e3f", + "sha256_in_prefix": "c7cc050ec9cc3cc6a47215b5bc79b2d3e5c6ed895a4300ab0e20f6c249385e3f", + "size_in_bytes": 1816 + }, + { + "_path": "lib/python3.12/tkinter/simpledialog.py", + "path_type": "hardlink", + "sha256": "63349ae75f9d74a49376f3375e38e5059c9424b918bfd2c67cf45ec70dcf3eac", + "sha256_in_prefix": "63349ae75f9d74a49376f3375e38e5059c9424b918bfd2c67cf45ec70dcf3eac", + "size_in_bytes": 11753 + }, + { + "_path": "lib/python3.12/tkinter/tix.py", + "path_type": "hardlink", + "sha256": "5d7a11093a1f6510de786b0e9d67902ab33a57f637cd8f5e2603cf6c5c609a18", + "sha256_in_prefix": "5d7a11093a1f6510de786b0e9d67902ab33a57f637cd8f5e2603cf6c5c609a18", + "size_in_bytes": 77032 + }, + { + "_path": "lib/python3.12/tkinter/ttk.py", + "path_type": "hardlink", + "sha256": "9e10f6f4434357958dc813ae4d9128d36d51f7bf9193ebc3f1ea049176a8b5ad", + "sha256_in_prefix": "9e10f6f4434357958dc813ae4d9128d36d51f7bf9193ebc3f1ea049176a8b5ad", + "size_in_bytes": 56242 + }, + { + "_path": "lib/python3.12/token.py", + "path_type": "hardlink", + "sha256": "fc76ed1a1cbdb2c961d27cd67acee766abcfcdab06661701db4d9524efb5bd41", + "sha256_in_prefix": "fc76ed1a1cbdb2c961d27cd67acee766abcfcdab06661701db4d9524efb5bd41", + "size_in_bytes": 2479 + }, + { + "_path": "lib/python3.12/tokenize.py", + "path_type": "hardlink", + "sha256": "601b53c9ae77e96fe2a9e10deb273aac64270635cc02e0d46d0976b91f890848", + "sha256_in_prefix": "601b53c9ae77e96fe2a9e10deb273aac64270635cc02e0d46d0976b91f890848", + "size_in_bytes": 19596 + }, + { + "_path": "lib/python3.12/tomllib/__init__.py", + "path_type": "hardlink", + "sha256": "71f67036895f4c5acab942618af0cbd3d814451ba61e967f358d0f341a5b8f51", + "sha256_in_prefix": "71f67036895f4c5acab942618af0cbd3d814451ba61e967f358d0f341a5b8f51", + "size_in_bytes": 308 + }, + { + "_path": "lib/python3.12/tomllib/__pycache__/__init__.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "9539bc88fd9e18cf3eab191fb4067c55016c18d88fa167587fd34243f975d78d", + "sha256_in_prefix": "9539bc88fd9e18cf3eab191fb4067c55016c18d88fa167587fd34243f975d78d", + "size_in_bytes": 557 + }, + { + "_path": "lib/python3.12/tomllib/__pycache__/_parser.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "ef2887c9795ec14c21b444a333c6a23fd79b1203c7acf8717674a7e1e3ab2452", + "sha256_in_prefix": "ef2887c9795ec14c21b444a333c6a23fd79b1203c7acf8717674a7e1e3ab2452", + "size_in_bytes": 27127 + }, + { + "_path": "lib/python3.12/tomllib/__pycache__/_re.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "51c87a033260fd1f7c8677e29d189a04757b9208c9840ce322b59485291cb03a", + "sha256_in_prefix": "51c87a033260fd1f7c8677e29d189a04757b9208c9840ce322b59485291cb03a", + "size_in_bytes": 4110 + }, + { + "_path": "lib/python3.12/tomllib/__pycache__/_types.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "46c5bb21ebab38534e0f2ab9ece7103c2a2e9d8057daeaba03b60e69c035b670", + "sha256_in_prefix": "46c5bb21ebab38534e0f2ab9ece7103c2a2e9d8057daeaba03b60e69c035b670", + "size_in_bytes": 568 + }, + { + "_path": "lib/python3.12/tomllib/_parser.py", + "path_type": "hardlink", + "sha256": "4579b04a7566452304781ccce37d3ebc1c36e810b058bdb1f33c0e51ddab0397", + "sha256_in_prefix": "4579b04a7566452304781ccce37d3ebc1c36e810b058bdb1f33c0e51ddab0397", + "size_in_bytes": 22631 + }, + { + "_path": "lib/python3.12/tomllib/_re.py", + "path_type": "hardlink", + "sha256": "75b8e0e428594f6dca6bdcfd0c73977ddb52a4fc147dd80c5e78fc34ea25cbec", + "sha256_in_prefix": "75b8e0e428594f6dca6bdcfd0c73977ddb52a4fc147dd80c5e78fc34ea25cbec", + "size_in_bytes": 2943 + }, + { + "_path": "lib/python3.12/tomllib/_types.py", + "path_type": "hardlink", + "sha256": "f864c6d9552a929c7032ace654ee05ef26ca75d21b027b801d77e65907138b74", + "sha256_in_prefix": "f864c6d9552a929c7032ace654ee05ef26ca75d21b027b801d77e65907138b74", + "size_in_bytes": 254 + }, + { + "_path": "lib/python3.12/trace.py", + "path_type": "hardlink", + "sha256": "dd08f8dc9adfd264e52adaf319be22246e59f2b3a9c2b6fd8cfd62bc915be639", + "sha256_in_prefix": "dd08f8dc9adfd264e52adaf319be22246e59f2b3a9c2b6fd8cfd62bc915be639", + "size_in_bytes": 29182 + }, + { + "_path": "lib/python3.12/traceback.py", + "path_type": "hardlink", + "sha256": "a96b7d5bfe46a8be9b90613b1555dbd795d51f46aec6b769af06cec465bee39e", + "sha256_in_prefix": "a96b7d5bfe46a8be9b90613b1555dbd795d51f46aec6b769af06cec465bee39e", + "size_in_bytes": 46325 + }, + { + "_path": "lib/python3.12/tracemalloc.py", + "path_type": "hardlink", + "sha256": "c2cc84a05b824df79840c98729a0e94ef8909b11c528a1b2c5a00aa436b97b25", + "sha256_in_prefix": "c2cc84a05b824df79840c98729a0e94ef8909b11c528a1b2c5a00aa436b97b25", + "size_in_bytes": 18047 + }, + { + "_path": "lib/python3.12/tty.py", + "path_type": "hardlink", + "sha256": "1ab5e5e047130b310355e907a3306178299b9f2044fb526ac63bd116e9a16d2b", + "sha256_in_prefix": "1ab5e5e047130b310355e907a3306178299b9f2044fb526ac63bd116e9a16d2b", + "size_in_bytes": 2035 + }, + { + "_path": "lib/python3.12/turtle.py", + "path_type": "hardlink", + "sha256": "1140915f9d17dc0b9ca8ced708d21d75fb38ae395b063a351d85874c7b9fc154", + "sha256_in_prefix": "1140915f9d17dc0b9ca8ced708d21d75fb38ae395b063a351d85874c7b9fc154", + "size_in_bytes": 146361 + }, + { + "_path": "lib/python3.12/turtledemo/__init__.py", + "path_type": "hardlink", + "sha256": "5f465277c96c107a5af544b0a962561f97cb0bfd75906d9bf9741450ed02b0e1", + "sha256_in_prefix": "5f465277c96c107a5af544b0a962561f97cb0bfd75906d9bf9741450ed02b0e1", + "size_in_bytes": 314 + }, + { + "_path": "lib/python3.12/turtledemo/__main__.py", + "path_type": "hardlink", + "sha256": "6620f0af34be5e144cf5097f120b3c9e457be5389b8b35c7aae2e88495486aee", + "sha256_in_prefix": "6620f0af34be5e144cf5097f120b3c9e457be5389b8b35c7aae2e88495486aee", + "size_in_bytes": 15285 + }, + { + "_path": "lib/python3.12/turtledemo/__pycache__/__init__.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "0a90154ff24755c97f77213e9af143115292c3c0d82339a2dfbbb9990f77e318", + "sha256_in_prefix": "0a90154ff24755c97f77213e9af143115292c3c0d82339a2dfbbb9990f77e318", + "size_in_bytes": 720 + }, + { + "_path": "lib/python3.12/turtledemo/__pycache__/__main__.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "bff7a45be2a332c49952ad9f03abfcca2ec9a93da03dd85336a2effe6be75e8c", + "sha256_in_prefix": "bff7a45be2a332c49952ad9f03abfcca2ec9a93da03dd85336a2effe6be75e8c", + "size_in_bytes": 21626 + }, + { + "_path": "lib/python3.12/turtledemo/__pycache__/bytedesign.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "14b2aaaebd3abdfcfdd0b45416c76ee41e63c9501623d72e290968850b425045", + "sha256_in_prefix": "14b2aaaebd3abdfcfdd0b45416c76ee41e63c9501623d72e290968850b425045", + "size_in_bytes": 8481 + }, + { + "_path": "lib/python3.12/turtledemo/__pycache__/chaos.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "de0c0e48bbc41dcf37bb4c409fa26748033c4e6258384f7fff9ac0d716ff0d77", + "sha256_in_prefix": "de0c0e48bbc41dcf37bb4c409fa26748033c4e6258384f7fff9ac0d716ff0d77", + "size_in_bytes": 2740 + }, + { + "_path": "lib/python3.12/turtledemo/__pycache__/clock.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "b7bc1d2a27190eddb9aa7861425676dfe89d2d4fdaf0d8bfb9611dca9ed82101", + "sha256_in_prefix": "b7bc1d2a27190eddb9aa7861425676dfe89d2d4fdaf0d8bfb9611dca9ed82101", + "size_in_bytes": 6170 + }, + { + "_path": "lib/python3.12/turtledemo/__pycache__/colormixer.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "be98213c3af06166258c94eea4a3d6fb229c9e2558082818ce40ddfc30c16c92", + "sha256_in_prefix": "be98213c3af06166258c94eea4a3d6fb229c9e2558082818ce40ddfc30c16c92", + "size_in_bytes": 3572 + }, + { + "_path": "lib/python3.12/turtledemo/__pycache__/forest.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "9b8b2897fe5e0dc4d5512db1dc77bd971745bda9c151fe278771295f93477f12", + "sha256_in_prefix": "9b8b2897fe5e0dc4d5512db1dc77bd971745bda9c151fe278771295f93477f12", + "size_in_bytes": 5352 + }, + { + "_path": "lib/python3.12/turtledemo/__pycache__/fractalcurves.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "16f7e573158f54433bd4fa95d04cbbf2612f3247c7f6e4f29adec6ee1c2e41b0", + "sha256_in_prefix": "16f7e573158f54433bd4fa95d04cbbf2612f3247c7f6e4f29adec6ee1c2e41b0", + "size_in_bytes": 6048 + }, + { + "_path": "lib/python3.12/turtledemo/__pycache__/lindenmayer.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "fd5c00aadef194132573a6bab0fcb4c820c4b70c272882e9aa9a55ab3cc6244d", + "sha256_in_prefix": "fd5c00aadef194132573a6bab0fcb4c820c4b70c272882e9aa9a55ab3cc6244d", + "size_in_bytes": 4034 + }, + { + "_path": "lib/python3.12/turtledemo/__pycache__/minimal_hanoi.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "14843184c0e182babf5115e83b147f2316fe19f5ab4a23efc2e3ac7fadbc1956", + "sha256_in_prefix": "14843184c0e182babf5115e83b147f2316fe19f5ab4a23efc2e3ac7fadbc1956", + "size_in_bytes": 4234 + }, + { + "_path": "lib/python3.12/turtledemo/__pycache__/nim.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "39ab321bad1f5ea68e0358daa87d3c9f03eab08fea041526c3c242c9382fc002", + "sha256_in_prefix": "39ab321bad1f5ea68e0358daa87d3c9f03eab08fea041526c3c242c9382fc002", + "size_in_bytes": 13788 + }, + { + "_path": "lib/python3.12/turtledemo/__pycache__/paint.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "9e492e6a19ae894cacc0351b6e6d612ae4b38ab727aaea7a59c0f620991d9f9d", + "sha256_in_prefix": "9e492e6a19ae894cacc0351b6e6d612ae4b38ab727aaea7a59c0f620991d9f9d", + "size_in_bytes": 2325 + }, + { + "_path": "lib/python3.12/turtledemo/__pycache__/peace.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "356b0b2091a2b5c0ad2c52105c436273a8d4a22454ab78b5fefa4563a4ce974a", + "sha256_in_prefix": "356b0b2091a2b5c0ad2c52105c436273a8d4a22454ab78b5fefa4563a4ce974a", + "size_in_bytes": 2068 + }, + { + "_path": "lib/python3.12/turtledemo/__pycache__/penrose.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "b76e1da3168ad929d66a10b63754aae94f3d230b062f4434ccea77ae83061037", + "sha256_in_prefix": "b76e1da3168ad929d66a10b63754aae94f3d230b062f4434ccea77ae83061037", + "size_in_bytes": 7457 + }, + { + "_path": "lib/python3.12/turtledemo/__pycache__/planet_and_moon.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "7f98bb8dcf162df7a0dc0a79f601bda8c354bc4be1a30d8591d28ca46d142c50", + "sha256_in_prefix": "7f98bb8dcf162df7a0dc0a79f601bda8c354bc4be1a30d8591d28ca46d142c50", + "size_in_bytes": 6564 + }, + { + "_path": "lib/python3.12/turtledemo/__pycache__/rosette.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "da05d4dfd5f5b649d871ffa489ade3a81aa2433f3dab74a63e29eff5657b8376", + "sha256_in_prefix": "da05d4dfd5f5b649d871ffa489ade3a81aa2433f3dab74a63e29eff5657b8376", + "size_in_bytes": 3090 + }, + { + "_path": "lib/python3.12/turtledemo/__pycache__/round_dance.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "c0ad5179076c4fe109a566e5356f8e5b8974ff827613a824243d5a8d6af3e82b", + "sha256_in_prefix": "c0ad5179076c4fe109a566e5356f8e5b8974ff827613a824243d5a8d6af3e82b", + "size_in_bytes": 3082 + }, + { + "_path": "lib/python3.12/turtledemo/__pycache__/sorting_animate.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "d1b19d606e7b5d31b02b0c715027939b702687b53662184620bce1f1a67a29f8", + "sha256_in_prefix": "d1b19d606e7b5d31b02b0c715027939b702687b53662184620bce1f1a67a29f8", + "size_in_bytes": 10530 + }, + { + "_path": "lib/python3.12/turtledemo/__pycache__/tree.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "c1f8b59f5e44909f3be0156a160234c223b6f21c61c8b70cc7d37d9df4499256", + "sha256_in_prefix": "c1f8b59f5e44909f3be0156a160234c223b6f21c61c8b70cc7d37d9df4499256", + "size_in_bytes": 2801 + }, + { + "_path": "lib/python3.12/turtledemo/__pycache__/two_canvases.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "a5b355a84e0986cf1a41f142ae8af2b84d579062280fbe6e0a2f9ff008f7634a", + "sha256_in_prefix": "a5b355a84e0986cf1a41f142ae8af2b84d579062280fbe6e0a2f9ff008f7634a", + "size_in_bytes": 2560 + }, + { + "_path": "lib/python3.12/turtledemo/__pycache__/yinyang.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "ed335a62a565472ab39cdbf6a6affac919ec91d3f49b4f26e486bae9734afb6d", + "sha256_in_prefix": "ed335a62a565472ab39cdbf6a6affac919ec91d3f49b4f26e486bae9734afb6d", + "size_in_bytes": 1913 + }, + { + "_path": "lib/python3.12/turtledemo/bytedesign.py", + "path_type": "hardlink", + "sha256": "6deeee99e0ddb4ed29a648f95d4d33e9f3292c21dbecec301337c22a605a280f", + "sha256_in_prefix": "6deeee99e0ddb4ed29a648f95d4d33e9f3292c21dbecec301337c22a605a280f", + "size_in_bytes": 4248 + }, + { + "_path": "lib/python3.12/turtledemo/chaos.py", + "path_type": "hardlink", + "sha256": "bc8a3a9b77e90446fb7060ff68ee008ffd6b23b366052207ec225cc163b4dae5", + "sha256_in_prefix": "bc8a3a9b77e90446fb7060ff68ee008ffd6b23b366052207ec225cc163b4dae5", + "size_in_bytes": 951 + }, + { + "_path": "lib/python3.12/turtledemo/clock.py", + "path_type": "hardlink", + "sha256": "8728b6e1f7e81e8c9fbc5797588d1766e6be15d353e0f29c38f3e75d28084fcd", + "sha256_in_prefix": "8728b6e1f7e81e8c9fbc5797588d1766e6be15d353e0f29c38f3e75d28084fcd", + "size_in_bytes": 3180 + }, + { + "_path": "lib/python3.12/turtledemo/colormixer.py", + "path_type": "hardlink", + "sha256": "bbb065830edb37fd53b1c004118853176fd8da32ee532cb0d363960880920374", + "sha256_in_prefix": "bbb065830edb37fd53b1c004118853176fd8da32ee532cb0d363960880920374", + "size_in_bytes": 1339 + }, + { + "_path": "lib/python3.12/turtledemo/forest.py", + "path_type": "hardlink", + "sha256": "68cd81b7da35ca49d9066cc2cba24768cddbf90797dbd619a559cf899cde926b", + "sha256_in_prefix": "68cd81b7da35ca49d9066cc2cba24768cddbf90797dbd619a559cf899cde926b", + "size_in_bytes": 2966 + }, + { + "_path": "lib/python3.12/turtledemo/fractalcurves.py", + "path_type": "hardlink", + "sha256": "29fadf34c5eabda4649848d052fa2ed3ae829e55bc3ac5933f2aedf3fb04b320", + "sha256_in_prefix": "29fadf34c5eabda4649848d052fa2ed3ae829e55bc3ac5933f2aedf3fb04b320", + "size_in_bytes": 3473 + }, + { + "_path": "lib/python3.12/turtledemo/lindenmayer.py", + "path_type": "hardlink", + "sha256": "4b597f52c1cb35ae8ed540d1db2dab52276c7874febd7a659ee50f26be26f61e", + "sha256_in_prefix": "4b597f52c1cb35ae8ed540d1db2dab52276c7874febd7a659ee50f26be26f61e", + "size_in_bytes": 2434 + }, + { + "_path": "lib/python3.12/turtledemo/minimal_hanoi.py", + "path_type": "hardlink", + "sha256": "0e458a6257fb5a4ecd2785962850fa87924b23d4ead8aebb70aab38904ff8ef5", + "sha256_in_prefix": "0e458a6257fb5a4ecd2785962850fa87924b23d4ead8aebb70aab38904ff8ef5", + "size_in_bytes": 2051 + }, + { + "_path": "lib/python3.12/turtledemo/nim.py", + "path_type": "hardlink", + "sha256": "939d1ee904a7b00579bb44719b0286e7524bf560c7ffff6d482064b41b09fdb3", + "sha256_in_prefix": "939d1ee904a7b00579bb44719b0286e7524bf560c7ffff6d482064b41b09fdb3", + "size_in_bytes": 6513 + }, + { + "_path": "lib/python3.12/turtledemo/paint.py", + "path_type": "hardlink", + "sha256": "81aa22d0da1d934cb47edfef1883f9fe8ef864c56d484f79f9ec4b46457d047e", + "sha256_in_prefix": "81aa22d0da1d934cb47edfef1883f9fe8ef864c56d484f79f9ec4b46457d047e", + "size_in_bytes": 1291 + }, + { + "_path": "lib/python3.12/turtledemo/peace.py", + "path_type": "hardlink", + "sha256": "b260b857164684b3065ad760fec0245ab6505c220814fb179a3d080f2bba0814", + "sha256_in_prefix": "b260b857164684b3065ad760fec0245ab6505c220814fb179a3d080f2bba0814", + "size_in_bytes": 1066 + }, + { + "_path": "lib/python3.12/turtledemo/penrose.py", + "path_type": "hardlink", + "sha256": "14aeb10db966bfd4ec923a19eb96892eb2aa2723c0962c0824fe2ca9f30e300a", + "sha256_in_prefix": "14aeb10db966bfd4ec923a19eb96892eb2aa2723c0962c0824fe2ca9f30e300a", + "size_in_bytes": 3380 + }, + { + "_path": "lib/python3.12/turtledemo/planet_and_moon.py", + "path_type": "hardlink", + "sha256": "cd2c5344b67dbe781cf4c7f0f1eb1b97e6d8a5bf50329bdaa4e42e7d390ea609", + "sha256_in_prefix": "cd2c5344b67dbe781cf4c7f0f1eb1b97e6d8a5bf50329bdaa4e42e7d390ea609", + "size_in_bytes": 2825 + }, + { + "_path": "lib/python3.12/turtledemo/rosette.py", + "path_type": "hardlink", + "sha256": "61dfd5bb932cc5a0c3bb9caa8ed74889a19a8d3ee3cb6707ea8f63595ec350b0", + "sha256_in_prefix": "61dfd5bb932cc5a0c3bb9caa8ed74889a19a8d3ee3cb6707ea8f63595ec350b0", + "size_in_bytes": 1361 + }, + { + "_path": "lib/python3.12/turtledemo/round_dance.py", + "path_type": "hardlink", + "sha256": "4ecaac02e68f11ec1a406a6ce8a4b17e4f8af74f76157e0776360d0dd041f276", + "sha256_in_prefix": "4ecaac02e68f11ec1a406a6ce8a4b17e4f8af74f76157e0776360d0dd041f276", + "size_in_bytes": 1804 + }, + { + "_path": "lib/python3.12/turtledemo/sorting_animate.py", + "path_type": "hardlink", + "sha256": "a82a7608d3620cd8a956d3335bddbc2e30320486645de5d2ec26f481b0a74254", + "sha256_in_prefix": "a82a7608d3620cd8a956d3335bddbc2e30320486645de5d2ec26f481b0a74254", + "size_in_bytes": 5052 + }, + { + "_path": "lib/python3.12/turtledemo/tree.py", + "path_type": "hardlink", + "sha256": "3318448046c83c176f95a97c33b5cd82e0076bee038d72810bef3dac1085e590", + "sha256_in_prefix": "3318448046c83c176f95a97c33b5cd82e0076bee038d72810bef3dac1085e590", + "size_in_bytes": 1401 + }, + { + "_path": "lib/python3.12/turtledemo/turtle.cfg", + "path_type": "hardlink", + "sha256": "de66698dc4f083792df6aaed1e5d94e879852d72f1f24ac09c8fb4cd144c6c88", + "sha256_in_prefix": "de66698dc4f083792df6aaed1e5d94e879852d72f1f24ac09c8fb4cd144c6c88", + "size_in_bytes": 160 + }, + { + "_path": "lib/python3.12/turtledemo/two_canvases.py", + "path_type": "hardlink", + "sha256": "3300593114fb9286af9360cc9d871a40e5dcbea4aedc24b832607d1dd71c7b96", + "sha256_in_prefix": "3300593114fb9286af9360cc9d871a40e5dcbea4aedc24b832607d1dd71c7b96", + "size_in_bytes": 1119 + }, + { + "_path": "lib/python3.12/turtledemo/yinyang.py", + "path_type": "hardlink", + "sha256": "0737a80b939aafcf3d8a1bf60b63e781979c749337d02b6c216680893f9fffc5", + "sha256_in_prefix": "0737a80b939aafcf3d8a1bf60b63e781979c749337d02b6c216680893f9fffc5", + "size_in_bytes": 821 + }, + { + "_path": "lib/python3.12/types.py", + "path_type": "hardlink", + "sha256": "345474ef027a1273f353da9bdc1f7c18f65335e72e681bcc0376774cc51f2405", + "sha256_in_prefix": "345474ef027a1273f353da9bdc1f7c18f65335e72e681bcc0376774cc51f2405", + "size_in_bytes": 10993 + }, + { + "_path": "lib/python3.12/typing.py", + "path_type": "hardlink", + "sha256": "a92b15962dc0e9a49cd0563b0b0b5861bd58278cdde6295e63ce02ae7fabd97d", + "sha256_in_prefix": "a92b15962dc0e9a49cd0563b0b0b5861bd58278cdde6295e63ce02ae7fabd97d", + "size_in_bytes": 116414 + }, + { + "_path": "lib/python3.12/unittest/__init__.py", + "path_type": "hardlink", + "sha256": "32ed48385c0377bc2900a76e9a6acc3705aeef402c72de8554b3c637420506f0", + "sha256_in_prefix": "32ed48385c0377bc2900a76e9a6acc3705aeef402c72de8554b3c637420506f0", + "size_in_bytes": 3487 + }, + { + "_path": "lib/python3.12/unittest/__main__.py", + "path_type": "hardlink", + "sha256": "ff6b9a100d32001715b40d61bc4d613623b139edb1fdc3566427b83c331caae3", + "sha256_in_prefix": "ff6b9a100d32001715b40d61bc4d613623b139edb1fdc3566427b83c331caae3", + "size_in_bytes": 472 + }, + { + "_path": "lib/python3.12/unittest/__pycache__/__init__.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "f1eae42f4fa78034d788b0a2f472d68b8c187a2de5bca7aa16bcad2a360081ed", + "sha256_in_prefix": "f1eae42f4fa78034d788b0a2f472d68b8c187a2de5bca7aa16bcad2a360081ed", + "size_in_bytes": 3686 + }, + { + "_path": "lib/python3.12/unittest/__pycache__/__main__.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "c94e7e7d31f689bb4c8eb875ff9fc9cb1c6a73af94f3f510a60398a45999c53e", + "sha256_in_prefix": "c94e7e7d31f689bb4c8eb875ff9fc9cb1c6a73af94f3f510a60398a45999c53e", + "size_in_bytes": 870 + }, + { + "_path": "lib/python3.12/unittest/__pycache__/_log.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "10abd1c4acf8da5f3c99adf7f0fcb1072737a22dae90ee59226246a12edd374b", + "sha256_in_prefix": "10abd1c4acf8da5f3c99adf7f0fcb1072737a22dae90ee59226246a12edd374b", + "size_in_bytes": 4930 + }, + { + "_path": "lib/python3.12/unittest/__pycache__/async_case.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "1c06b1fe7bf1be21505afef5dffc640e54de2281e21da54e8a5342c885e4bbf3", + "sha256_in_prefix": "1c06b1fe7bf1be21505afef5dffc640e54de2281e21da54e8a5342c885e4bbf3", + "size_in_bytes": 6615 + }, + { + "_path": "lib/python3.12/unittest/__pycache__/case.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "d6e3f540c4a4f26259ddb2a7f06823610d077f3ec4663e935db12c19c81c90c3", + "sha256_in_prefix": "d6e3f540c4a4f26259ddb2a7f06823610d077f3ec4663e935db12c19c81c90c3", + "size_in_bytes": 70080 + }, + { + "_path": "lib/python3.12/unittest/__pycache__/loader.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "2248ec21c5d7b0032a284dd7f9e9e76d3ba527f98c1fb59cc3c1ef2750ecc0bd", + "sha256_in_prefix": "2248ec21c5d7b0032a284dd7f9e9e76d3ba527f98c1fb59cc3c1ef2750ecc0bd", + "size_in_bytes": 24193 + }, + { + "_path": "lib/python3.12/unittest/__pycache__/main.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "4a7b723ec76330da892c510a25763800c1b91422fe211b8f34704f06097eebf7", + "sha256_in_prefix": "4a7b723ec76330da892c510a25763800c1b91422fe211b8f34704f06097eebf7", + "size_in_bytes": 13819 + }, + { + "_path": "lib/python3.12/unittest/__pycache__/mock.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "3f1600b17dce2a31ff39cc686f7f0df65f5cec92c0157b522bcf5e03de87919c", + "sha256_in_prefix": "3f1600b17dce2a31ff39cc686f7f0df65f5cec92c0157b522bcf5e03de87919c", + "size_in_bytes": 117537 + }, + { + "_path": "lib/python3.12/unittest/__pycache__/result.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "2e6d00c04a82a84bc669e6f830782f6415f04a29c8edf5131f7893bcfaa0ccec", + "sha256_in_prefix": "2e6d00c04a82a84bc669e6f830782f6415f04a29c8edf5131f7893bcfaa0ccec", + "size_in_bytes": 12997 + }, + { + "_path": "lib/python3.12/unittest/__pycache__/runner.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "76a5a77a1d206b126d969a75ffe3fe13ad6299c0ac561a5e383fe09ce381feb6", + "sha256_in_prefix": "76a5a77a1d206b126d969a75ffe3fe13ad6299c0ac561a5e383fe09ce381feb6", + "size_in_bytes": 16741 + }, + { + "_path": "lib/python3.12/unittest/__pycache__/signals.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "0ab8ccfd23c12061b82333d519118fd46d704a0f04f06c3a96ce0d4817ad88e4", + "sha256_in_prefix": "0ab8ccfd23c12061b82333d519118fd46d704a0f04f06c3a96ce0d4817ad88e4", + "size_in_bytes": 3867 + }, + { + "_path": "lib/python3.12/unittest/__pycache__/suite.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "9e1f8b2b286b398a3e17b58b9b2d55e522fde0cec8a4fd6ab9dad05e660834c1", + "sha256_in_prefix": "9e1f8b2b286b398a3e17b58b9b2d55e522fde0cec8a4fd6ab9dad05e660834c1", + "size_in_bytes": 15716 + }, + { + "_path": "lib/python3.12/unittest/__pycache__/util.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "511a039d513ceafb5e58a4c39617944f9031cc5101c64a2e1bf63b9a1ad784ba", + "sha256_in_prefix": "511a039d513ceafb5e58a4c39617944f9031cc5101c64a2e1bf63b9a1ad784ba", + "size_in_bytes": 7537 + }, + { + "_path": "lib/python3.12/unittest/_log.py", + "path_type": "hardlink", + "sha256": "905672317ab26c656c600defce25d477728068f597f00a7f94e22e8128c323b9", + "sha256_in_prefix": "905672317ab26c656c600defce25d477728068f597f00a7f94e22e8128c323b9", + "size_in_bytes": 2746 + }, + { + "_path": "lib/python3.12/unittest/async_case.py", + "path_type": "hardlink", + "sha256": "b389b976f622c28223105998bf0be011f2b8c48eb33d2f1133e41e562867ee31", + "sha256_in_prefix": "b389b976f622c28223105998bf0be011f2b8c48eb33d2f1133e41e562867ee31", + "size_in_bytes": 5465 + }, + { + "_path": "lib/python3.12/unittest/case.py", + "path_type": "hardlink", + "sha256": "45bac6d80a4fc3a0dea8340a80681e30b263f017b4a5002cb8f489a632e0f987", + "sha256_in_prefix": "45bac6d80a4fc3a0dea8340a80681e30b263f017b4a5002cb8f489a632e0f987", + "size_in_bytes": 57531 + }, + { + "_path": "lib/python3.12/unittest/loader.py", + "path_type": "hardlink", + "sha256": "b7d18839241a4339d4913e73867c639e2a7dd20345f53c9fb30be5c639b20513", + "sha256_in_prefix": "b7d18839241a4339d4913e73867c639e2a7dd20345f53c9fb30be5c639b20513", + "size_in_bytes": 21010 + }, + { + "_path": "lib/python3.12/unittest/main.py", + "path_type": "hardlink", + "sha256": "db58280574389c0d6cba9559cc51e1787f5b418c4e85d354aa55ca43335c487a", + "sha256_in_prefix": "db58280574389c0d6cba9559cc51e1787f5b418c4e85d354aa55ca43335c487a", + "size_in_bytes": 11991 + }, + { + "_path": "lib/python3.12/unittest/mock.py", + "path_type": "hardlink", + "sha256": "c596af2675784e6a81203b89fbbcdad6a6476d643c7bc67d37c76ed9328ebc66", + "sha256_in_prefix": "c596af2675784e6a81203b89fbbcdad6a6476d643c7bc67d37c76ed9328ebc66", + "size_in_bytes": 104588 + }, + { + "_path": "lib/python3.12/unittest/result.py", + "path_type": "hardlink", + "sha256": "5db286bdd3821d64150377e554d7edbdd58db7bb8b950772f977e9ec1d535617", + "sha256_in_prefix": "5db286bdd3821d64150377e554d7edbdd58db7bb8b950772f977e9ec1d535617", + "size_in_bytes": 9130 + }, + { + "_path": "lib/python3.12/unittest/runner.py", + "path_type": "hardlink", + "sha256": "76d9beb9c21d0d367a1b040a921ad43f90b7971fcc8cacfccd6f9760bedf1ce2", + "sha256_in_prefix": "76d9beb9c21d0d367a1b040a921ad43f90b7971fcc8cacfccd6f9760bedf1ce2", + "size_in_bytes": 10368 + }, + { + "_path": "lib/python3.12/unittest/signals.py", + "path_type": "hardlink", + "sha256": "f8286e818ca56e10e03745bc056cdfd31147678f9a1dc8cb6b0fe96ef9a4362a", + "sha256_in_prefix": "f8286e818ca56e10e03745bc056cdfd31147678f9a1dc8cb6b0fe96ef9a4362a", + "size_in_bytes": 2403 + }, + { + "_path": "lib/python3.12/unittest/suite.py", + "path_type": "hardlink", + "sha256": "ed2da92bc9f97c53403ee2d3d12cc53b16a96e85d596ebc887b5a93458f3f6bc", + "sha256_in_prefix": "ed2da92bc9f97c53403ee2d3d12cc53b16a96e85d596ebc887b5a93458f3f6bc", + "size_in_bytes": 13512 + }, + { + "_path": "lib/python3.12/unittest/util.py", + "path_type": "hardlink", + "sha256": "fdcc640c3505d16deab9c32eae7c3f5f67c3b5e81c563dc6698fa7fcf403854d", + "sha256_in_prefix": "fdcc640c3505d16deab9c32eae7c3f5f67c3b5e81c563dc6698fa7fcf403854d", + "size_in_bytes": 5215 + }, + { + "_path": "lib/python3.12/urllib/__init__.py", + "path_type": "hardlink", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size_in_bytes": 0 + }, + { + "_path": "lib/python3.12/urllib/__pycache__/__init__.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "bf5e23d976f618ea5f366df0bddf87662cda9d0080862dffe9f287a2b4b88835", + "sha256_in_prefix": "bf5e23d976f618ea5f366df0bddf87662cda9d0080862dffe9f287a2b4b88835", + "size_in_bytes": 389 + }, + { + "_path": "lib/python3.12/urllib/__pycache__/error.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "ccf38ed885481184538c8b1900631d0646e634e24cd97255fbf8174b4ce7873f", + "sha256_in_prefix": "ccf38ed885481184538c8b1900631d0646e634e24cd97255fbf8174b4ce7873f", + "size_in_bytes": 3902 + }, + { + "_path": "lib/python3.12/urllib/__pycache__/parse.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "430fa4906f5d6e6e6d81d45ada21bd422af35f5b3cb11ccaedafea3d246a1e23", + "sha256_in_prefix": "430fa4906f5d6e6e6d81d45ada21bd422af35f5b3cb11ccaedafea3d246a1e23", + "size_in_bytes": 50108 + }, + { + "_path": "lib/python3.12/urllib/__pycache__/request.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "f98b7d9f463e11ee958774e6473572f4c8c5497c44971af4219d7fd08368e287", + "sha256_in_prefix": "f98b7d9f463e11ee958774e6473572f4c8c5497c44971af4219d7fd08368e287", + "size_in_bytes": 115595 + }, + { + "_path": "lib/python3.12/urllib/__pycache__/response.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "dbd31c4705a75e0598b144d00cdf971f3caa54b0b192651d67a7644bf1b55c69", + "sha256_in_prefix": "dbd31c4705a75e0598b144d00cdf971f3caa54b0b192651d67a7644bf1b55c69", + "size_in_bytes": 4668 + }, + { + "_path": "lib/python3.12/urllib/__pycache__/robotparser.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "84eee4eede237bfca71d98e1324af04955d69d83577efad810e2b21b8a04fb83", + "sha256_in_prefix": "84eee4eede237bfca71d98e1324af04955d69d83577efad810e2b21b8a04fb83", + "size_in_bytes": 12550 + }, + { + "_path": "lib/python3.12/urllib/error.py", + "path_type": "hardlink", + "sha256": "d12b3cc66af3f42a8ebe63e1c91d24f92c6237b6a93a3702938dffabd812d77b", + "sha256_in_prefix": "d12b3cc66af3f42a8ebe63e1c91d24f92c6237b6a93a3702938dffabd812d77b", + "size_in_bytes": 2415 + }, + { + "_path": "lib/python3.12/urllib/parse.py", + "path_type": "hardlink", + "sha256": "2582309acd08b572a7b80b22c2d976cdc42be417503a12afce2d129498456ae8", + "sha256_in_prefix": "2582309acd08b572a7b80b22c2d976cdc42be417503a12afce2d129498456ae8", + "size_in_bytes": 44829 + }, + { + "_path": "lib/python3.12/urllib/request.py", + "path_type": "hardlink", + "sha256": "bd66422e67f305ec9ada71090293ec8bf9a94f9a0a74ace0613e9400c712e726", + "sha256_in_prefix": "bd66422e67f305ec9ada71090293ec8bf9a94f9a0a74ace0613e9400c712e726", + "size_in_bytes": 103157 + }, + { + "_path": "lib/python3.12/urllib/response.py", + "path_type": "hardlink", + "sha256": "7e6c3b6d7a95f0d74f5968f51a87adae8a51bf42390cdfec98c7a99203e7bb76", + "sha256_in_prefix": "7e6c3b6d7a95f0d74f5968f51a87adae8a51bf42390cdfec98c7a99203e7bb76", + "size_in_bytes": 2361 + }, + { + "_path": "lib/python3.12/urllib/robotparser.py", + "path_type": "hardlink", + "sha256": "389b811835f9a3ba72b192c3487b0266fa31f6e571b7a83ceb2a34792dc0d9fc", + "sha256_in_prefix": "389b811835f9a3ba72b192c3487b0266fa31f6e571b7a83ceb2a34792dc0d9fc", + "size_in_bytes": 9424 + }, + { + "_path": "lib/python3.12/uu.py", + "path_type": "hardlink", + "sha256": "dd1f5be33fb25a1b0832891ea07db4a4a2ae41b466e37e24e204604fdc6d18cf", + "sha256_in_prefix": "dd1f5be33fb25a1b0832891ea07db4a4a2ae41b466e37e24e204604fdc6d18cf", + "size_in_bytes": 7365 + }, + { + "_path": "lib/python3.12/uuid.py", + "path_type": "hardlink", + "sha256": "fe357bff7241e9fd6f86ee81567fd20aeec2e17460428ea9b7924bebf57301fc", + "sha256_in_prefix": "fe357bff7241e9fd6f86ee81567fd20aeec2e17460428ea9b7924bebf57301fc", + "size_in_bytes": 29656 + }, + { + "_path": "lib/python3.12/venv/__init__.py", + "path_type": "hardlink", + "sha256": "ce2e0f80e0b3fa49715e4263d95193dc2371a58c75bdc0f82b7d461bd7dc803b", + "sha256_in_prefix": "ce2e0f80e0b3fa49715e4263d95193dc2371a58c75bdc0f82b7d461bd7dc803b", + "size_in_bytes": 24618 + }, + { + "_path": "lib/python3.12/venv/__main__.py", + "path_type": "hardlink", + "sha256": "722537c68c0622f8293d39bb6ab1288f3637d8dc45d6f9aae96e49af8145ca36", + "sha256_in_prefix": "722537c68c0622f8293d39bb6ab1288f3637d8dc45d6f9aae96e49af8145ca36", + "size_in_bytes": 145 + }, + { + "_path": "lib/python3.12/venv/__pycache__/__init__.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "0a599d7bff07f525b8992a4e2200a0b3d793505a204988b57e4ec19aca374d68", + "sha256_in_prefix": "0a599d7bff07f525b8992a4e2200a0b3d793505a204988b57e4ec19aca374d68", + "size_in_bytes": 29167 + }, + { + "_path": "lib/python3.12/venv/__pycache__/__main__.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "7fc007b421193ea0fa0bed97012d240dcaa07529483201149423c187a56fd572", + "sha256_in_prefix": "7fc007b421193ea0fa0bed97012d240dcaa07529483201149423c187a56fd572", + "size_in_bytes": 734 + }, + { + "_path": "lib/python3.12/venv/scripts/common/Activate.ps1", + "path_type": "hardlink", + "sha256": "3795a060dea7d621320d6d841deb37591fadf7f5592c5cb2286f9867af0e91df", + "sha256_in_prefix": "3795a060dea7d621320d6d841deb37591fadf7f5592c5cb2286f9867af0e91df", + "size_in_bytes": 9033 + }, + { + "_path": "lib/python3.12/venv/scripts/common/activate", + "path_type": "hardlink", + "sha256": "76b3d2a782a6b9871ba5b0fe6096a7e315b06c9095be1618ebf5087e9ba1f73b", + "sha256_in_prefix": "76b3d2a782a6b9871ba5b0fe6096a7e315b06c9095be1618ebf5087e9ba1f73b", + "size_in_bytes": 2042 + }, + { + "_path": "lib/python3.12/venv/scripts/posix/activate.csh", + "path_type": "hardlink", + "sha256": "cdd8a01bb9c221836bfa4470d52c9fb5acbce2de6454df71efdae3adc342441e", + "sha256_in_prefix": "cdd8a01bb9c221836bfa4470d52c9fb5acbce2de6454df71efdae3adc342441e", + "size_in_bytes": 936 + }, + { + "_path": "lib/python3.12/venv/scripts/posix/activate.fish", + "path_type": "hardlink", + "sha256": "a100a3f99289828886d7a4bfab657751aea2b4313ffcb5b95bc643d63469448d", + "sha256_in_prefix": "a100a3f99289828886d7a4bfab657751aea2b4313ffcb5b95bc643d63469448d", + "size_in_bytes": 2215 + }, + { + "_path": "lib/python3.12/warnings.py", + "path_type": "hardlink", + "sha256": "8eb1bb88d0beb82ebecfe7ee5cf54ed9b77b4a7acee1989e392a65de42017c49", + "sha256_in_prefix": "8eb1bb88d0beb82ebecfe7ee5cf54ed9b77b4a7acee1989e392a65de42017c49", + "size_in_bytes": 21760 + }, + { + "_path": "lib/python3.12/wave.py", + "path_type": "hardlink", + "sha256": "0330428ea9e45fee49acc4ae5bdca4c235f4236c51dab09f30442ccafa25c1f8", + "sha256_in_prefix": "0330428ea9e45fee49acc4ae5bdca4c235f4236c51dab09f30442ccafa25c1f8", + "size_in_bytes": 22769 + }, + { + "_path": "lib/python3.12/weakref.py", + "path_type": "hardlink", + "sha256": "56f8d313fb74019e53eb9287400702fbce788b7fe30e097b0b6e06296f3f080c", + "sha256_in_prefix": "56f8d313fb74019e53eb9287400702fbce788b7fe30e097b0b6e06296f3f080c", + "size_in_bytes": 21513 + }, + { + "_path": "lib/python3.12/webbrowser.py", + "path_type": "hardlink", + "sha256": "f83a36818ef51b0e2efbc3937187dc5f24062908a0e18c8ceb228139dad98348", + "sha256_in_prefix": "f83a36818ef51b0e2efbc3937187dc5f24062908a0e18c8ceb228139dad98348", + "size_in_bytes": 23628 + }, + { + "_path": "lib/python3.12/wsgiref/__init__.py", + "path_type": "hardlink", + "sha256": "c30e144025a63d267778d92f2f066fa592b476e789d888f79b96c059bf0bef60", + "sha256_in_prefix": "c30e144025a63d267778d92f2f066fa592b476e789d888f79b96c059bf0bef60", + "size_in_bytes": 657 + }, + { + "_path": "lib/python3.12/wsgiref/__pycache__/__init__.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "b4339637466bfd2fce5f9ca555afe2999705490eeeddd37d39189f42c3b8d3c6", + "sha256_in_prefix": "b4339637466bfd2fce5f9ca555afe2999705490eeeddd37d39189f42c3b8d3c6", + "size_in_bytes": 1060 + }, + { + "_path": "lib/python3.12/wsgiref/__pycache__/handlers.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "7074c4c31fc9595b9134c1e0ce476405ac28cdcc95a8cfdda00b5af960153b32", + "sha256_in_prefix": "7074c4c31fc9595b9134c1e0ce476405ac28cdcc95a8cfdda00b5af960153b32", + "size_in_bytes": 23854 + }, + { + "_path": "lib/python3.12/wsgiref/__pycache__/headers.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "7fc5975f46179dea66c7379024906b667b22b634b3c78812de75f0e24c38222b", + "sha256_in_prefix": "7fc5975f46179dea66c7379024906b667b22b634b3c78812de75f0e24c38222b", + "size_in_bytes": 9872 + }, + { + "_path": "lib/python3.12/wsgiref/__pycache__/simple_server.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "0a13dc801cee6a5f745c356f5f8cbe07f56f526af244440a8d4839bd06589600", + "sha256_in_prefix": "0a13dc801cee6a5f745c356f5f8cbe07f56f526af244440a8d4839bd06589600", + "size_in_bytes": 8429 + }, + { + "_path": "lib/python3.12/wsgiref/__pycache__/types.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "a2e75ca01315a6db2e57dc84cedf800ca29517aa46d99da45cd9bf5d681c2adc", + "sha256_in_prefix": "a2e75ca01315a6db2e57dc84cedf800ca29517aa46d99da45cd9bf5d681c2adc", + "size_in_bytes": 3913 + }, + { + "_path": "lib/python3.12/wsgiref/__pycache__/util.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "3442a680ad0d6bdaf4acee116593b1b4a8318fc331dd492d1b9c1ddff9479206", + "sha256_in_prefix": "3442a680ad0d6bdaf4acee116593b1b4a8318fc331dd492d1b9c1ddff9479206", + "size_in_bytes": 7056 + }, + { + "_path": "lib/python3.12/wsgiref/__pycache__/validate.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "d75ebac38ec42b9a66382b2b5f761c66e621296928330b17a354bb8a9fde8f9c", + "sha256_in_prefix": "d75ebac38ec42b9a66382b2b5f761c66e621296928330b17a354bb8a9fde8f9c", + "size_in_bytes": 20439 + }, + { + "_path": "lib/python3.12/wsgiref/handlers.py", + "path_type": "hardlink", + "sha256": "b4ed08869ab79d7c17065993875cdc6eb1b2a0b3645b74325bc0aab44e97cfc5", + "sha256_in_prefix": "b4ed08869ab79d7c17065993875cdc6eb1b2a0b3645b74325bc0aab44e97cfc5", + "size_in_bytes": 21664 + }, + { + "_path": "lib/python3.12/wsgiref/headers.py", + "path_type": "hardlink", + "sha256": "0fbf95a47d8e4c0d831fd52312ec43076cbf503c190269876f170a5cf5585fb9", + "sha256_in_prefix": "0fbf95a47d8e4c0d831fd52312ec43076cbf503c190269876f170a5cf5585fb9", + "size_in_bytes": 6766 + }, + { + "_path": "lib/python3.12/wsgiref/simple_server.py", + "path_type": "hardlink", + "sha256": "d435cad48b5f63c0356e1ac70755e6e35eb94b02f9844b813e5762199110bc2b", + "sha256_in_prefix": "d435cad48b5f63c0356e1ac70755e6e35eb94b02f9844b813e5762199110bc2b", + "size_in_bytes": 5171 + }, + { + "_path": "lib/python3.12/wsgiref/types.py", + "path_type": "hardlink", + "sha256": "ba66d30ce511a88eba9b809616c51e12bf89c67972102e7d976b18557f7a6387", + "sha256_in_prefix": "ba66d30ce511a88eba9b809616c51e12bf89c67972102e7d976b18557f7a6387", + "size_in_bytes": 1717 + }, + { + "_path": "lib/python3.12/wsgiref/util.py", + "path_type": "hardlink", + "sha256": "93783cda348368538525f52a5e9a5a43a3de93caec26b6a030ecfb3aedf98b98", + "sha256_in_prefix": "93783cda348368538525f52a5e9a5a43a3de93caec26b6a030ecfb3aedf98b98", + "size_in_bytes": 5472 + }, + { + "_path": "lib/python3.12/wsgiref/validate.py", + "path_type": "hardlink", + "sha256": "4132f87dcf11a332f6ec5b051e68e59ff493dd6fdcc4f716ea72373734977a0a", + "sha256_in_prefix": "4132f87dcf11a332f6ec5b051e68e59ff493dd6fdcc4f716ea72373734977a0a", + "size_in_bytes": 15036 + }, + { + "_path": "lib/python3.12/xdrlib.py", + "path_type": "hardlink", + "sha256": "983c5e8e3090bdbeb94bf4faf841c1f8c916bcbca423863f6870a142d16a4fb8", + "sha256_in_prefix": "983c5e8e3090bdbeb94bf4faf841c1f8c916bcbca423863f6870a142d16a4fb8", + "size_in_bytes": 5942 + }, + { + "_path": "lib/python3.12/xml/__init__.py", + "path_type": "hardlink", + "sha256": "34296f728e7fe68cccb97a9f6edbf3bf3a686f44044c744fe85f207a92ed4811", + "sha256_in_prefix": "34296f728e7fe68cccb97a9f6edbf3bf3a686f44044c744fe85f207a92ed4811", + "size_in_bytes": 557 + }, + { + "_path": "lib/python3.12/xml/__pycache__/__init__.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "cade69a6c61bfb28a5fcd4e0cc47053059767a98bce60c0fc3b27f8ac62095f4", + "sha256_in_prefix": "cade69a6c61bfb28a5fcd4e0cc47053059767a98bce60c0fc3b27f8ac62095f4", + "size_in_bytes": 961 + }, + { + "_path": "lib/python3.12/xml/dom/NodeFilter.py", + "path_type": "hardlink", + "sha256": "9bfacbbb64e239a75591a7260b3ed86748eeb4366e6c40f3542753e79bace9a7", + "sha256_in_prefix": "9bfacbbb64e239a75591a7260b3ed86748eeb4366e6c40f3542753e79bace9a7", + "size_in_bytes": 936 + }, + { + "_path": "lib/python3.12/xml/dom/__init__.py", + "path_type": "hardlink", + "sha256": "b415a6f3d3663c3ac332ee4a0f4213eadad9281508dc97410e258a03633b063a", + "sha256_in_prefix": "b415a6f3d3663c3ac332ee4a0f4213eadad9281508dc97410e258a03633b063a", + "size_in_bytes": 4019 + }, + { + "_path": "lib/python3.12/xml/dom/__pycache__/NodeFilter.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "89bb16a8eae76232495138098b018115b189968f6b296089d30b55dd3b29ef69", + "sha256_in_prefix": "89bb16a8eae76232495138098b018115b189968f6b296089d30b55dd3b29ef69", + "size_in_bytes": 1316 + }, + { + "_path": "lib/python3.12/xml/dom/__pycache__/__init__.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "f5ee0ee6cd6f98b409eddf51ea20c4995062cd60b2b8daf5febc208dc7bf51a9", + "sha256_in_prefix": "f5ee0ee6cd6f98b409eddf51ea20c4995062cd60b2b8daf5febc208dc7bf51a9", + "size_in_bytes": 6446 + }, + { + "_path": "lib/python3.12/xml/dom/__pycache__/domreg.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "1479ac3dc3896da6328f192c1bf227180d629565818fa7e7083c2aa428e80bcd", + "sha256_in_prefix": "1479ac3dc3896da6328f192c1bf227180d629565818fa7e7083c2aa428e80bcd", + "size_in_bytes": 4084 + }, + { + "_path": "lib/python3.12/xml/dom/__pycache__/expatbuilder.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "59a047d809b393c4299e58cbbfe4b6af03baafef0e7fd7f6dd05f80168b356da", + "sha256_in_prefix": "59a047d809b393c4299e58cbbfe4b6af03baafef0e7fd7f6dd05f80168b356da", + "size_in_bytes": 45669 + }, + { + "_path": "lib/python3.12/xml/dom/__pycache__/minicompat.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "46b2776da3d4c1c85b23cc56ac4bcb88a8aa8967115bb486f800725cba3cb79d", + "sha256_in_prefix": "46b2776da3d4c1c85b23cc56ac4bcb88a8aa8967115bb486f800725cba3cb79d", + "size_in_bytes": 3632 + }, + { + "_path": "lib/python3.12/xml/dom/__pycache__/minidom.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "bf8615db712847e93d7751ccd3a752ca2ef6b243413c433d247f3c3c9a7a9435", + "sha256_in_prefix": "bf8615db712847e93d7751ccd3a752ca2ef6b243413c433d247f3c3c9a7a9435", + "size_in_bytes": 92711 + }, + { + "_path": "lib/python3.12/xml/dom/__pycache__/pulldom.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "20b17ab58a427e1df253ea4238c42a58ce4d162eb71c9c77706bdcb17063211e", + "sha256_in_prefix": "20b17ab58a427e1df253ea4238c42a58ce4d162eb71c9c77706bdcb17063211e", + "size_in_bytes": 17713 + }, + { + "_path": "lib/python3.12/xml/dom/__pycache__/xmlbuilder.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "1460fe3f0df267867e3b7b8d3658850d87fe2cd7ac72be187efac9981297acb3", + "sha256_in_prefix": "1460fe3f0df267867e3b7b8d3658850d87fe2cd7ac72be187efac9981297acb3", + "size_in_bytes": 17259 + }, + { + "_path": "lib/python3.12/xml/dom/domreg.py", + "path_type": "hardlink", + "sha256": "826b02a803930834b96b1086cbee7db1d21c684f65dd3073706dc7bb5ba1a3e8", + "sha256_in_prefix": "826b02a803930834b96b1086cbee7db1d21c684f65dd3073706dc7bb5ba1a3e8", + "size_in_bytes": 3451 + }, + { + "_path": "lib/python3.12/xml/dom/expatbuilder.py", + "path_type": "hardlink", + "sha256": "80598dbc5970feaa36ea2b7549e3e76dd018fb80cf79e4a5e27e9e71af60c82c", + "sha256_in_prefix": "80598dbc5970feaa36ea2b7549e3e76dd018fb80cf79e4a5e27e9e71af60c82c", + "size_in_bytes": 35693 + }, + { + "_path": "lib/python3.12/xml/dom/minicompat.py", + "path_type": "hardlink", + "sha256": "42974c4c67803dfe80b016ff8aeea0d1e5c751703ab3aec5be765f4e534367be", + "sha256_in_prefix": "42974c4c67803dfe80b016ff8aeea0d1e5c751703ab3aec5be765f4e534367be", + "size_in_bytes": 3367 + }, + { + "_path": "lib/python3.12/xml/dom/minidom.py", + "path_type": "hardlink", + "sha256": "af4ee09b06efc54e7fe58032d8338c4bc8578094946d03a200740deab25d97cb", + "sha256_in_prefix": "af4ee09b06efc54e7fe58032d8338c4bc8578094946d03a200740deab25d97cb", + "size_in_bytes": 68140 + }, + { + "_path": "lib/python3.12/xml/dom/pulldom.py", + "path_type": "hardlink", + "sha256": "614b88673d496a360e6b10efe8d733c7c0826fb214470ff12f24a1e597699870", + "sha256_in_prefix": "614b88673d496a360e6b10efe8d733c7c0826fb214470ff12f24a1e597699870", + "size_in_bytes": 11637 + }, + { + "_path": "lib/python3.12/xml/dom/xmlbuilder.py", + "path_type": "hardlink", + "sha256": "d4f33a8f018755626b64557953a91c6bba21ff613da46f7558a2874aa5d08ebf", + "sha256_in_prefix": "d4f33a8f018755626b64557953a91c6bba21ff613da46f7558a2874aa5d08ebf", + "size_in_bytes": 12387 + }, + { + "_path": "lib/python3.12/xml/etree/ElementInclude.py", + "path_type": "hardlink", + "sha256": "97b513db52e9d8382d446e283583e3adf20aae86fb93d4764565ac08250399c0", + "sha256_in_prefix": "97b513db52e9d8382d446e283583e3adf20aae86fb93d4764565ac08250399c0", + "size_in_bytes": 6882 + }, + { + "_path": "lib/python3.12/xml/etree/ElementPath.py", + "path_type": "hardlink", + "sha256": "ae8a80a8b51567b4f0965481682705e70c73dd6bfa145283f630d6833f1b4975", + "sha256_in_prefix": "ae8a80a8b51567b4f0965481682705e70c73dd6bfa145283f630d6833f1b4975", + "size_in_bytes": 13997 + }, + { + "_path": "lib/python3.12/xml/etree/ElementTree.py", + "path_type": "hardlink", + "sha256": "aa0c383b6416165e0315bf5d5635e34133e65156a7c85d07edf2b411829413e3", + "sha256_in_prefix": "aa0c383b6416165e0315bf5d5635e34133e65156a7c85d07edf2b411829413e3", + "size_in_bytes": 73526 + }, + { + "_path": "lib/python3.12/xml/etree/__init__.py", + "path_type": "hardlink", + "sha256": "91950edfb196c105d93886f8af7ea3c0a79e06a6b63be3e5a4ea09804e8672a6", + "sha256_in_prefix": "91950edfb196c105d93886f8af7ea3c0a79e06a6b63be3e5a4ea09804e8672a6", + "size_in_bytes": 1605 + }, + { + "_path": "lib/python3.12/xml/etree/__pycache__/ElementInclude.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "4c1adbe58b4229072b2e81b9d1336ed895ead524a26d5b7a14c58c178b6b0e0e", + "sha256_in_prefix": "4c1adbe58b4229072b2e81b9d1336ed895ead524a26d5b7a14c58c178b6b0e0e", + "size_in_bytes": 4251 + }, + { + "_path": "lib/python3.12/xml/etree/__pycache__/ElementPath.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "7267334477d80c976ae463f0dbc0ef8df38fca5a9ed373ce7525b1786911e564", + "sha256_in_prefix": "7267334477d80c976ae463f0dbc0ef8df38fca5a9ed373ce7525b1786911e564", + "size_in_bytes": 15183 + }, + { + "_path": "lib/python3.12/xml/etree/__pycache__/ElementTree.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "539cc575de98356e18fc72a2afc048da8afa7625bda114a750b2fbb87862dab0", + "sha256_in_prefix": "539cc575de98356e18fc72a2afc048da8afa7625bda114a750b2fbb87862dab0", + "size_in_bytes": 81569 + }, + { + "_path": "lib/python3.12/xml/etree/__pycache__/__init__.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "8aae37fb35370aff3bd6dca199e5469e2a82aade3e659b7ad478f0f54aae161c", + "sha256_in_prefix": "8aae37fb35370aff3bd6dca199e5469e2a82aade3e659b7ad478f0f54aae161c", + "size_in_bytes": 392 + }, + { + "_path": "lib/python3.12/xml/etree/__pycache__/cElementTree.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "857d7c423396ae23b59ef7273155a45f2e33c28ca089b5d3727b2f4448c3db5f", + "sha256_in_prefix": "857d7c423396ae23b59ef7273155a45f2e33c28ca089b5d3727b2f4448c3db5f", + "size_in_bytes": 441 + }, + { + "_path": "lib/python3.12/xml/etree/cElementTree.py", + "path_type": "hardlink", + "sha256": "d0f57acab07fe4f9c116c3392d85946bac8e78608f409cea70005f16ea019b57", + "sha256_in_prefix": "d0f57acab07fe4f9c116c3392d85946bac8e78608f409cea70005f16ea019b57", + "size_in_bytes": 82 + }, + { + "_path": "lib/python3.12/xml/parsers/__init__.py", + "path_type": "hardlink", + "sha256": "b88497adc30d5d5eda7789c25a2206ee9270c932d584d7ac42680325651da45c", + "sha256_in_prefix": "b88497adc30d5d5eda7789c25a2206ee9270c932d584d7ac42680325651da45c", + "size_in_bytes": 167 + }, + { + "_path": "lib/python3.12/xml/parsers/__pycache__/__init__.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "894e5ade3ee88f1bb88aae36adff43c5d3e052777f377cdda674c4c273e5d630", + "sha256_in_prefix": "894e5ade3ee88f1bb88aae36adff43c5d3e052777f377cdda674c4c273e5d630", + "size_in_bytes": 571 + }, + { + "_path": "lib/python3.12/xml/parsers/__pycache__/expat.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "fe7bfe47488b4b106f886843e3eba4b99a56a8c2d702ea7d46d2b7ecc77a7860", + "sha256_in_prefix": "fe7bfe47488b4b106f886843e3eba4b99a56a8c2d702ea7d46d2b7ecc77a7860", + "size_in_bytes": 670 + }, + { + "_path": "lib/python3.12/xml/parsers/expat.py", + "path_type": "hardlink", + "sha256": "64e1947747c2874117a7458bba1f07c86620cc0ed9a4a4116d262878e4a2aa09", + "sha256_in_prefix": "64e1947747c2874117a7458bba1f07c86620cc0ed9a4a4116d262878e4a2aa09", + "size_in_bytes": 248 + }, + { + "_path": "lib/python3.12/xml/sax/__init__.py", + "path_type": "hardlink", + "sha256": "2f949d27b9eda6284482b43f4c202830fb35ea94f4101d70452119d3210bdbe0", + "sha256_in_prefix": "2f949d27b9eda6284482b43f4c202830fb35ea94f4101d70452119d3210bdbe0", + "size_in_bytes": 3238 + }, + { + "_path": "lib/python3.12/xml/sax/__pycache__/__init__.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "be3c0fc7eb10437ea69cab21bf7153c5aae21f8d0907bb5b01605d86bccade9f", + "sha256_in_prefix": "be3c0fc7eb10437ea69cab21bf7153c5aae21f8d0907bb5b01605d86bccade9f", + "size_in_bytes": 4044 + }, + { + "_path": "lib/python3.12/xml/sax/__pycache__/_exceptions.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "fd1322ca3fa5d749fa8cddde1391411111eace81069d1c70320b1f1f40d2f452", + "sha256_in_prefix": "fd1322ca3fa5d749fa8cddde1391411111eace81069d1c70320b1f1f40d2f452", + "size_in_bytes": 6471 + }, + { + "_path": "lib/python3.12/xml/sax/__pycache__/expatreader.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "2537a2592f1c943b4c52d7556887ddebaa58f692f23a011a52edab4dff7a154f", + "sha256_in_prefix": "2537a2592f1c943b4c52d7556887ddebaa58f692f23a011a52edab4dff7a154f", + "size_in_bytes": 20855 + }, + { + "_path": "lib/python3.12/xml/sax/__pycache__/handler.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "33288a712fa6fd95b1def655300267109eed8397c7ee606178ee70275b4ddd7c", + "sha256_in_prefix": "33288a712fa6fd95b1def655300267109eed8397c7ee606178ee70275b4ddd7c", + "size_in_bytes": 15143 + }, + { + "_path": "lib/python3.12/xml/sax/__pycache__/saxutils.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "03a8d83b719902a3ebfe8305566fbcca77cd1ef4a14edbe4663f5f8e9d2e075f", + "sha256_in_prefix": "03a8d83b719902a3ebfe8305566fbcca77cd1ef4a14edbe4663f5f8e9d2e075f", + "size_in_bytes": 19863 + }, + { + "_path": "lib/python3.12/xml/sax/__pycache__/xmlreader.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "5a1af017908773ebab3e29a465e63a5c501e73f2f391c12bf4b89188c905b884", + "sha256_in_prefix": "5a1af017908773ebab3e29a465e63a5c501e73f2f391c12bf4b89188c905b884", + "size_in_bytes": 19809 + }, + { + "_path": "lib/python3.12/xml/sax/_exceptions.py", + "path_type": "hardlink", + "sha256": "26564d5742496196d17a4a0ee135d28f652ec81742cf2fa4bff83e64323578ac", + "sha256_in_prefix": "26564d5742496196d17a4a0ee135d28f652ec81742cf2fa4bff83e64323578ac", + "size_in_bytes": 4699 + }, + { + "_path": "lib/python3.12/xml/sax/expatreader.py", + "path_type": "hardlink", + "sha256": "d45486127c4f81f381f68777965fb94e4adb0a886350039875f2c389c6e88c25", + "sha256_in_prefix": "d45486127c4f81f381f68777965fb94e4adb0a886350039875f2c389c6e88c25", + "size_in_bytes": 15550 + }, + { + "_path": "lib/python3.12/xml/sax/handler.py", + "path_type": "hardlink", + "sha256": "64c7aae49f1dd382a7b9012610307bfa1d43a14a5dc09a5c8da30903f6805c3d", + "sha256_in_prefix": "64c7aae49f1dd382a7b9012610307bfa1d43a14a5dc09a5c8da30903f6805c3d", + "size_in_bytes": 15617 + }, + { + "_path": "lib/python3.12/xml/sax/saxutils.py", + "path_type": "hardlink", + "sha256": "3fe2cdb6386e0c4d42d37c657bbecb78b69c57aedb1610dbd8bf4043944130ab", + "sha256_in_prefix": "3fe2cdb6386e0c4d42d37c657bbecb78b69c57aedb1610dbd8bf4043944130ab", + "size_in_bytes": 12255 + }, + { + "_path": "lib/python3.12/xml/sax/xmlreader.py", + "path_type": "hardlink", + "sha256": "0962c8d64ac8b03148d4ae62a531f544c4fd1be2116c6f4a53b480cff463dbba", + "sha256_in_prefix": "0962c8d64ac8b03148d4ae62a531f544c4fd1be2116c6f4a53b480cff463dbba", + "size_in_bytes": 12624 + }, + { + "_path": "lib/python3.12/xmlrpc/__init__.py", + "path_type": "hardlink", + "sha256": "87ad5c8954dd56fbbca04517bf87477ff4dce575170c7dd1281d7ef1f4214ac8", + "sha256_in_prefix": "87ad5c8954dd56fbbca04517bf87477ff4dce575170c7dd1281d7ef1f4214ac8", + "size_in_bytes": 38 + }, + { + "_path": "lib/python3.12/xmlrpc/__pycache__/__init__.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "417b8e833ff919402591e20c7cf99033d3cbe9df84b18ffb68c649971ae16ec7", + "sha256_in_prefix": "417b8e833ff919402591e20c7cf99033d3cbe9df84b18ffb68c649971ae16ec7", + "size_in_bytes": 389 + }, + { + "_path": "lib/python3.12/xmlrpc/__pycache__/client.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "3f8361ec22013c156a64c88fb6fb544797b4b817b0436295307ff3b5b12fc814", + "sha256_in_prefix": "3f8361ec22013c156a64c88fb6fb544797b4b817b0436295307ff3b5b12fc814", + "size_in_bytes": 51838 + }, + { + "_path": "lib/python3.12/xmlrpc/__pycache__/server.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "1282ba8024536abead2c0dde268f6ab59784bd1515acd7c63491eae615a4e3ba", + "sha256_in_prefix": "1282ba8024536abead2c0dde268f6ab59784bd1515acd7c63491eae615a4e3ba", + "size_in_bytes": 43058 + }, + { + "_path": "lib/python3.12/xmlrpc/client.py", + "path_type": "hardlink", + "sha256": "c77e7072ab9aaab6c6f16f89f2e7d528183b816df5d9f80e490f773ab45fe238", + "sha256_in_prefix": "c77e7072ab9aaab6c6f16f89f2e7d528183b816df5d9f80e490f773ab45fe238", + "size_in_bytes": 49331 + }, + { + "_path": "lib/python3.12/xmlrpc/server.py", + "path_type": "hardlink", + "sha256": "6781c25a6224b8bafe13050d26456c8a8b480c96e7974bcf60d4deb0c4ad454c", + "sha256_in_prefix": "6781c25a6224b8bafe13050d26456c8a8b480c96e7974bcf60d4deb0c4ad454c", + "size_in_bytes": 36822 + }, + { + "_path": "lib/python3.12/zipapp.py", + "path_type": "hardlink", + "sha256": "56e098b62cef6c39944bb898326dd920b70be461fe644139e2b699977d2997a1", + "sha256_in_prefix": "56e098b62cef6c39944bb898326dd920b70be461fe644139e2b699977d2997a1", + "size_in_bytes": 7543 + }, + { + "_path": "lib/python3.12/zipfile/__init__.py", + "path_type": "hardlink", + "sha256": "d670588a44cb0af08f6727cc381efdf05126c2e264549700ebbac7f9b54dd936", + "sha256_in_prefix": "d670588a44cb0af08f6727cc381efdf05126c2e264549700ebbac7f9b54dd936", + "size_in_bytes": 87082 + }, + { + "_path": "lib/python3.12/zipfile/__main__.py", + "path_type": "hardlink", + "sha256": "e418cdbb27adf0063e3cec28179ac6b7bdb6ac743bb49d157f450551fcf38be2", + "sha256_in_prefix": "e418cdbb27adf0063e3cec28179ac6b7bdb6ac743bb49d157f450551fcf38be2", + "size_in_bytes": 58 + }, + { + "_path": "lib/python3.12/zipfile/__pycache__/__init__.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "586422c62b8bf01dbf3f09e652d04da4f7a74ff6bac0551047e307015979406a", + "sha256_in_prefix": "586422c62b8bf01dbf3f09e652d04da4f7a74ff6bac0551047e307015979406a", + "size_in_bytes": 99172 + }, + { + "_path": "lib/python3.12/zipfile/__pycache__/__main__.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "d29d4f271daab5eb07473cab2ddb9dce2810cfcfe6e06ba272fddd18166ed6e1", + "sha256_in_prefix": "d29d4f271daab5eb07473cab2ddb9dce2810cfcfe6e06ba272fddd18166ed6e1", + "size_in_bytes": 486 + }, + { + "_path": "lib/python3.12/zipfile/_path/__init__.py", + "path_type": "hardlink", + "sha256": "3db24a524a31bbb4ce64f23a931dc47403058bbb90e54c4869a17b1245474165", + "sha256_in_prefix": "3db24a524a31bbb4ce64f23a931dc47403058bbb90e54c4869a17b1245474165", + "size_in_bytes": 10409 + }, + { + "_path": "lib/python3.12/zipfile/_path/__pycache__/__init__.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "147a012dbf0be140062415c988503e50985d55f865090959befcc96835321cb7", + "sha256_in_prefix": "147a012dbf0be140062415c988503e50985d55f865090959befcc96835321cb7", + "size_in_bytes": 18701 + }, + { + "_path": "lib/python3.12/zipfile/_path/__pycache__/glob.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "1396647d0c27c61a98054c5f30c5d6dbc449e3faebcf99b3d3279b52f80d95cf", + "sha256_in_prefix": "1396647d0c27c61a98054c5f30c5d6dbc449e3faebcf99b3d3279b52f80d95cf", + "size_in_bytes": 1786 + }, + { + "_path": "lib/python3.12/zipfile/_path/glob.py", + "path_type": "hardlink", + "sha256": "7020d375669c257879b5b1278e7649ef51cbfe16e9aef967e5aca51cca11f893", + "sha256_in_prefix": "7020d375669c257879b5b1278e7649ef51cbfe16e9aef967e5aca51cca11f893", + "size_in_bytes": 893 + }, + { + "_path": "lib/python3.12/zipimport.py", + "path_type": "hardlink", + "sha256": "4ac94d92219c2e1c0d67ad3fff3753ec3a3756af62a36a2f696f02cd12d518f0", + "sha256_in_prefix": "4ac94d92219c2e1c0d67ad3fff3753ec3a3756af62a36a2f696f02cd12d518f0", + "size_in_bytes": 28132 + }, + { + "_path": "lib/python3.12/zoneinfo/__init__.py", + "path_type": "hardlink", + "sha256": "ac7fb403e4371d07482ef2fda81dbcf6879484e9fc41d4be42c156d7e54c68a8", + "sha256_in_prefix": "ac7fb403e4371d07482ef2fda81dbcf6879484e9fc41d4be42c156d7e54c68a8", + "size_in_bytes": 703 + }, + { + "_path": "lib/python3.12/zoneinfo/__pycache__/__init__.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "2387c37055a233c5b2986765eda38a7dfbcd5a4d7fac8e71267d49a8aa51baed", + "sha256_in_prefix": "2387c37055a233c5b2986765eda38a7dfbcd5a4d7fac8e71267d49a8aa51baed", + "size_in_bytes": 1356 + }, + { + "_path": "lib/python3.12/zoneinfo/__pycache__/_common.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "f4ccf4bcc0a81505a7cd0e31e3c0e6d67974e09b67c982efcfeb81da78be0c2e", + "sha256_in_prefix": "f4ccf4bcc0a81505a7cd0e31e3c0e6d67974e09b67c982efcfeb81da78be0c2e", + "size_in_bytes": 5575 + }, + { + "_path": "lib/python3.12/zoneinfo/__pycache__/_tzpath.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "4f48505821c83c35b76c4ddaf58dff8b88a57b73509b41ecd7270ebd345b4ad5", + "sha256_in_prefix": "4f48505821c83c35b76c4ddaf58dff8b88a57b73509b41ecd7270ebd345b4ad5", + "size_in_bytes": 7360 + }, + { + "_path": "lib/python3.12/zoneinfo/__pycache__/_zoneinfo.cpython-312.pyc", + "path_type": "hardlink", + "sha256": "0c6d874dbd544ae03684540c4638830b4c681e7221c70337db2736e433b56fc7", + "sha256_in_prefix": "0c6d874dbd544ae03684540c4638830b4c681e7221c70337db2736e433b56fc7", + "size_in_bytes": 27004 + }, + { + "_path": "lib/python3.12/zoneinfo/_common.py", + "path_type": "hardlink", + "sha256": "67deaf0ba41aa4865e007297677207485a89b75629eea0ee5c472be8a3e83bf6", + "sha256_in_prefix": "67deaf0ba41aa4865e007297677207485a89b75629eea0ee5c472be8a3e83bf6", + "size_in_bytes": 5294 + }, + { + "_path": "lib/python3.12/zoneinfo/_tzpath.py", + "path_type": "hardlink", + "sha256": "5dc473af6f6ae35e5531cc9705a1e4923aa07e7d35f6b4c275b90c6a3c2591c4", + "sha256_in_prefix": "5dc473af6f6ae35e5531cc9705a1e4923aa07e7d35f6b4c275b90c6a3c2591c4", + "size_in_bytes": 5388 + }, + { + "_path": "lib/python3.12/zoneinfo/_zoneinfo.py", + "path_type": "hardlink", + "sha256": "ebb9b679519a23252eb90541003a2fdbb3f2d7bc36713fd70672baa575dcdcb6", + "sha256_in_prefix": "ebb9b679519a23252eb90541003a2fdbb3f2d7bc36713fd70672baa575dcdcb6", + "size_in_bytes": 24674 + }, + { + "_path": "share/man/man1/python3.1", + "path_type": "softlink", + "sha256": "a873f4b72c962d4081f47ab3f4a992d9de7ab19a367795c95fedd5603cb293a7", + "size_in_bytes": 20092 + }, + { + "_path": "share/man/man1/python3.12.1", + "path_type": "hardlink", + "sha256": "a873f4b72c962d4081f47ab3f4a992d9de7ab19a367795c95fedd5603cb293a7", + "sha256_in_prefix": "a873f4b72c962d4081f47ab3f4a992d9de7ab19a367795c95fedd5603cb293a7", + "size_in_bytes": 20092 + } + ], + "paths_version": 1 + }, + "requested_spec": "None", + "sha256": "ccd6c55a286d51d907c878ed2bfa7d1becce0fee71374a9386c5eb90d803ac72", + "size": 13085901, + "subdir": "osx-arm64", + "timestamp": 1708117361000, + "url": "https://conda.anaconda.org/conda-forge/osx-arm64/python-3.12.2-hdf0ec26_0_cpython.conda", + "version": "3.12.2" +} \ No newline at end of file diff --git a/crates/pet-conda/tests/unix/conda_envs/user_home/miniconda3/envs/env_python_3/conda-meta/python-dateutil-2.8.2-pyhd8ed1ab_0.json b/crates/pet-conda/tests/unix/conda_envs/user_home/miniconda3/envs/env_python_3/conda-meta/python-dateutil-2.8.2-pyhd8ed1ab_0.json new file mode 100644 index 00000000..a22f5d23 --- /dev/null +++ b/crates/pet-conda/tests/unix/conda_envs/user_home/miniconda3/envs/env_python_3/conda-meta/python-dateutil-2.8.2-pyhd8ed1ab_0.json @@ -0,0 +1,350 @@ +{ + "build": "pyhd8ed1ab_0", + "build_number": 0, + "channel": "https://conda.anaconda.org/conda-forge/noarch", + "constrains": [], + "depends": [ + "python >=3.6", + "six >=1.5" + ], + "extracted_package_dir": "/Users/donjayamanne/miniconda3/pkgs/python-dateutil-2.8.2-pyhd8ed1ab_0", + "files": [ + "lib/python3.12/site-packages/dateutil/__init__.py", + "lib/python3.12/site-packages/dateutil/_common.py", + "lib/python3.12/site-packages/dateutil/_version.py", + "lib/python3.12/site-packages/dateutil/easter.py", + "lib/python3.12/site-packages/dateutil/parser/__init__.py", + "lib/python3.12/site-packages/dateutil/parser/_parser.py", + "lib/python3.12/site-packages/dateutil/parser/isoparser.py", + "lib/python3.12/site-packages/dateutil/relativedelta.py", + "lib/python3.12/site-packages/dateutil/rrule.py", + "lib/python3.12/site-packages/dateutil/tz/__init__.py", + "lib/python3.12/site-packages/dateutil/tz/_common.py", + "lib/python3.12/site-packages/dateutil/tz/_factories.py", + "lib/python3.12/site-packages/dateutil/tz/tz.py", + "lib/python3.12/site-packages/dateutil/tz/win.py", + "lib/python3.12/site-packages/dateutil/tzwin.py", + "lib/python3.12/site-packages/dateutil/utils.py", + "lib/python3.12/site-packages/dateutil/zoneinfo/__init__.py", + "lib/python3.12/site-packages/dateutil/zoneinfo/dateutil-zoneinfo.tar.gz", + "lib/python3.12/site-packages/dateutil/zoneinfo/rebuild.py", + "lib/python3.12/site-packages/python_dateutil-2.8.2.dist-info/INSTALLER", + "lib/python3.12/site-packages/python_dateutil-2.8.2.dist-info/LICENSE", + "lib/python3.12/site-packages/python_dateutil-2.8.2.dist-info/METADATA", + "lib/python3.12/site-packages/python_dateutil-2.8.2.dist-info/RECORD", + "lib/python3.12/site-packages/python_dateutil-2.8.2.dist-info/REQUESTED", + "lib/python3.12/site-packages/python_dateutil-2.8.2.dist-info/WHEEL", + "lib/python3.12/site-packages/python_dateutil-2.8.2.dist-info/direct_url.json", + "lib/python3.12/site-packages/python_dateutil-2.8.2.dist-info/top_level.txt", + "lib/python3.12/site-packages/python_dateutil-2.8.2.dist-info/zip-safe", + "lib/python3.12/site-packages/dateutil/__pycache__/__init__.cpython-312.pyc", + "lib/python3.12/site-packages/dateutil/__pycache__/_common.cpython-312.pyc", + "lib/python3.12/site-packages/dateutil/__pycache__/_version.cpython-312.pyc", + "lib/python3.12/site-packages/dateutil/__pycache__/easter.cpython-312.pyc", + "lib/python3.12/site-packages/dateutil/parser/__pycache__/__init__.cpython-312.pyc", + "lib/python3.12/site-packages/dateutil/parser/__pycache__/_parser.cpython-312.pyc", + "lib/python3.12/site-packages/dateutil/parser/__pycache__/isoparser.cpython-312.pyc", + "lib/python3.12/site-packages/dateutil/__pycache__/relativedelta.cpython-312.pyc", + "lib/python3.12/site-packages/dateutil/__pycache__/rrule.cpython-312.pyc", + "lib/python3.12/site-packages/dateutil/tz/__pycache__/__init__.cpython-312.pyc", + "lib/python3.12/site-packages/dateutil/tz/__pycache__/_common.cpython-312.pyc", + "lib/python3.12/site-packages/dateutil/tz/__pycache__/_factories.cpython-312.pyc", + "lib/python3.12/site-packages/dateutil/tz/__pycache__/tz.cpython-312.pyc", + "lib/python3.12/site-packages/dateutil/tz/__pycache__/win.cpython-312.pyc", + "lib/python3.12/site-packages/dateutil/__pycache__/tzwin.cpython-312.pyc", + "lib/python3.12/site-packages/dateutil/__pycache__/utils.cpython-312.pyc", + "lib/python3.12/site-packages/dateutil/zoneinfo/__pycache__/__init__.cpython-312.pyc", + "lib/python3.12/site-packages/dateutil/zoneinfo/__pycache__/rebuild.cpython-312.pyc" + ], + "fn": "python-dateutil-2.8.2-pyhd8ed1ab_0.tar.bz2", + "license": "Apache-2.0", + "link": { + "source": "/Users/donjayamanne/miniconda3/pkgs/python-dateutil-2.8.2-pyhd8ed1ab_0", + "type": 1 + }, + "md5": "dd999d1cc9f79e67dbb855c8924c7984", + "name": "python-dateutil", + "noarch": "python", + "package_tarball_full_path": "/Users/donjayamanne/miniconda3/pkgs/python-dateutil-2.8.2-pyhd8ed1ab_0.tar.bz2", + "package_type": "noarch_python", + "paths_data": { + "paths": [ + { + "_path": "site-packages/dateutil/__init__.py", + "path_type": "hardlink", + "sha256": "957125012ab0606c2a96b49649e5f5f49c05e417bdb4d79c0daf5e6e4fb48269", + "sha256_in_prefix": "957125012ab0606c2a96b49649e5f5f49c05e417bdb4d79c0daf5e6e4fb48269", + "size_in_bytes": 222 + }, + { + "_path": "site-packages/dateutil/_common.py", + "path_type": "hardlink", + "sha256": "efbc34cb2b64af19586d29fefa50d53d431a6d45d147d237941bffbd0454a946", + "sha256_in_prefix": "efbc34cb2b64af19586d29fefa50d53d431a6d45d147d237941bffbd0454a946", + "size_in_bytes": 932 + }, + { + "_path": "site-packages/dateutil/_version.py", + "path_type": "hardlink", + "sha256": "6b0c87bf63d8bc347ce1dc63ac7cb39a6f2789e17032372eb9284f87e40d90ce", + "sha256_in_prefix": "6b0c87bf63d8bc347ce1dc63ac7cb39a6f2789e17032372eb9284f87e40d90ce", + "size_in_bytes": 142 + }, + { + "_path": "site-packages/dateutil/easter.py", + "path_type": "hardlink", + "sha256": "772062fa52af8a61f5bbf93aa7b6742492bbd9086a56d541b2a072be910f2af7", + "sha256_in_prefix": "772062fa52af8a61f5bbf93aa7b6742492bbd9086a56d541b2a072be910f2af7", + "size_in_bytes": 2678 + }, + { + "_path": "site-packages/dateutil/parser/__init__.py", + "path_type": "hardlink", + "sha256": "c1693a185bb14e98e8820086b6091c789a2d8b8a558e5e3f7c7417a4d39a4988", + "sha256_in_prefix": "c1693a185bb14e98e8820086b6091c789a2d8b8a558e5e3f7c7417a4d39a4988", + "size_in_bytes": 1766 + }, + { + "_path": "site-packages/dateutil/parser/_parser.py", + "path_type": "hardlink", + "sha256": "ee494377289c92c401fd7825fb7500981c33098a2bd40219aa4948713e9d1fff", + "sha256_in_prefix": "ee494377289c92c401fd7825fb7500981c33098a2bd40219aa4948713e9d1fff", + "size_in_bytes": 58796 + }, + { + "_path": "site-packages/dateutil/parser/isoparser.py", + "path_type": "hardlink", + "sha256": "12d2d8ef0db61d6c7e5c9a535b1243dd736ce8b047442a6cefbb4274b9d869df", + "sha256_in_prefix": "12d2d8ef0db61d6c7e5c9a535b1243dd736ce8b047442a6cefbb4274b9d869df", + "size_in_bytes": 13247 + }, + { + "_path": "site-packages/dateutil/relativedelta.py", + "path_type": "hardlink", + "sha256": "1a3571aa90155a71baeeb75b7fba64a08949bd0aa68eef4d49f18272a6e573b5", + "sha256_in_prefix": "1a3571aa90155a71baeeb75b7fba64a08949bd0aa68eef4d49f18272a6e573b5", + "size_in_bytes": 24904 + }, + { + "_path": "site-packages/dateutil/rrule.py", + "path_type": "hardlink", + "sha256": "6fa1955783296436c1849e6a8ad40a472c7cfbf38ac9e01b939ee8af603c0185", + "sha256_in_prefix": "6fa1955783296436c1849e6a8ad40a472c7cfbf38ac9e01b939ee8af603c0185", + "size_in_bytes": 66556 + }, + { + "_path": "site-packages/dateutil/tz/__init__.py", + "path_type": "hardlink", + "sha256": "17e333d77bfa8d8b1e92541ff537bd27a9f370b0e6ab8ee03916bad4adf9fc50", + "sha256_in_prefix": "17e333d77bfa8d8b1e92541ff537bd27a9f370b0e6ab8ee03916bad4adf9fc50", + "size_in_bytes": 444 + }, + { + "_path": "site-packages/dateutil/tz/_common.py", + "path_type": "hardlink", + "sha256": "720cc34c036c397bc473ce9c605efb12c962b9269bf0fbb0a6c979f9b5f7fd2e", + "sha256_in_prefix": "720cc34c036c397bc473ce9c605efb12c962b9269bf0fbb0a6c979f9b5f7fd2e", + "size_in_bytes": 12977 + }, + { + "_path": "site-packages/dateutil/tz/_factories.py", + "path_type": "hardlink", + "sha256": "ba76fa5d0357acf32f7a4b13094f8083c8e6559b384a88e83d47001e95a7aef5", + "sha256_in_prefix": "ba76fa5d0357acf32f7a4b13094f8083c8e6559b384a88e83d47001e95a7aef5", + "size_in_bytes": 2569 + }, + { + "_path": "site-packages/dateutil/tz/tz.py", + "path_type": "hardlink", + "sha256": "268b558c3705d7a873a28b90d24656fb998262eed78faecd23e55082759aa4a1", + "sha256_in_prefix": "268b558c3705d7a873a28b90d24656fb998262eed78faecd23e55082759aa4a1", + "size_in_bytes": 62857 + }, + { + "_path": "site-packages/dateutil/tz/win.py", + "path_type": "hardlink", + "sha256": "c49b335a04b0135c4fc7f1c98f86647a9cae902fe1372d35e9631c5e16d1681f", + "sha256_in_prefix": "c49b335a04b0135c4fc7f1c98f86647a9cae902fe1372d35e9631c5e16d1681f", + "size_in_bytes": 12935 + }, + { + "_path": "site-packages/dateutil/tzwin.py", + "path_type": "hardlink", + "sha256": "ec0af8bdd4029e733498a4773148db20ab19ac155f1e0770b0965cfe619845ec", + "sha256_in_prefix": "ec0af8bdd4029e733498a4773148db20ab19ac155f1e0770b0965cfe619845ec", + "size_in_bytes": 59 + }, + { + "_path": "site-packages/dateutil/utils.py", + "path_type": "hardlink", + "sha256": "74a09c844c3c78e6e2d25a064f1f75ba70719bfed41a5537bff16314c76ac183", + "sha256_in_prefix": "74a09c844c3c78e6e2d25a064f1f75ba70719bfed41a5537bff16314c76ac183", + "size_in_bytes": 1965 + }, + { + "_path": "site-packages/dateutil/zoneinfo/__init__.py", + "path_type": "hardlink", + "sha256": "298834a6d842323729e4c5d21220499f79cc8d978d65abfbae5270e7eb73d52e", + "sha256_in_prefix": "298834a6d842323729e4c5d21220499f79cc8d978d65abfbae5270e7eb73d52e", + "size_in_bytes": 5889 + }, + { + "_path": "site-packages/dateutil/zoneinfo/dateutil-zoneinfo.tar.gz", + "path_type": "hardlink", + "sha256": "02471d071dd7904670312a52fd398e11fac41472ef8313cd0d5230195c5355a2", + "sha256_in_prefix": "02471d071dd7904670312a52fd398e11fac41472ef8313cd0d5230195c5355a2", + "size_in_bytes": 174394 + }, + { + "_path": "site-packages/dateutil/zoneinfo/rebuild.py", + "path_type": "hardlink", + "sha256": "322a98cc2207bcd6cc1fe2dd4582effb84f410803b8432ade462d1d084532dd2", + "sha256_in_prefix": "322a98cc2207bcd6cc1fe2dd4582effb84f410803b8432ade462d1d084532dd2", + "size_in_bytes": 2392 + }, + { + "_path": "site-packages/python_dateutil-2.8.2.dist-info/INSTALLER", + "path_type": "hardlink", + "sha256": "d0edee15f91b406f3f99726e44eb990be6e34fd0345b52b910c568e0eef6a2a8", + "sha256_in_prefix": "d0edee15f91b406f3f99726e44eb990be6e34fd0345b52b910c568e0eef6a2a8", + "size_in_bytes": 5 + }, + { + "_path": "site-packages/python_dateutil-2.8.2.dist-info/LICENSE", + "path_type": "hardlink", + "sha256": "ba00f51a0d92823b5a1cde27d8b5b9d2321e67ed8da9bc163eff96d5e17e577e", + "sha256_in_prefix": "ba00f51a0d92823b5a1cde27d8b5b9d2321e67ed8da9bc163eff96d5e17e577e", + "size_in_bytes": 2889 + }, + { + "_path": "site-packages/python_dateutil-2.8.2.dist-info/METADATA", + "path_type": "hardlink", + "sha256": "9e7635278895a09fd78e8d37e28c4b5b5b517f2c4fac754d4943ef0ad69a2fbb", + "sha256_in_prefix": "9e7635278895a09fd78e8d37e28c4b5b5b517f2c4fac754d4943ef0ad69a2fbb", + "size_in_bytes": 8196 + }, + { + "_path": "site-packages/python_dateutil-2.8.2.dist-info/RECORD", + "path_type": "hardlink", + "sha256": "d8907130a0fc65b745b0cac0ef33fb628369bb42d92542f05fbf51836bcea806", + "sha256_in_prefix": "d8907130a0fc65b745b0cac0ef33fb628369bb42d92542f05fbf51836bcea806", + "size_in_bytes": 3265 + }, + { + "_path": "site-packages/python_dateutil-2.8.2.dist-info/REQUESTED", + "path_type": "hardlink", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size_in_bytes": 0 + }, + { + "_path": "site-packages/python_dateutil-2.8.2.dist-info/WHEEL", + "path_type": "hardlink", + "sha256": "67e9f2629c2b712ab17ddbb1e4c6e7fc3439db988fec9d831b72601af398c934", + "sha256_in_prefix": "67e9f2629c2b712ab17ddbb1e4c6e7fc3439db988fec9d831b72601af398c934", + "size_in_bytes": 110 + }, + { + "_path": "site-packages/python_dateutil-2.8.2.dist-info/direct_url.json", + "path_type": "hardlink", + "sha256": "6eef3c41ab527120bd71b1e07ef0e7af538f02bb0b87e3503a52d9d29ab49839", + "sha256_in_prefix": "6eef3c41ab527120bd71b1e07ef0e7af538f02bb0b87e3503a52d9d29ab49839", + "size_in_bytes": 111 + }, + { + "_path": "site-packages/python_dateutil-2.8.2.dist-info/top_level.txt", + "path_type": "hardlink", + "sha256": "e2d8dd5a485166f17b2c0fc161efcbf60076c3fa766becf9cba02b8da464a2df", + "sha256_in_prefix": "e2d8dd5a485166f17b2c0fc161efcbf60076c3fa766becf9cba02b8da464a2df", + "size_in_bytes": 9 + }, + { + "_path": "site-packages/python_dateutil-2.8.2.dist-info/zip-safe", + "path_type": "hardlink", + "sha256": "01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b", + "sha256_in_prefix": "01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b", + "size_in_bytes": 1 + }, + { + "_path": "lib/python3.12/site-packages/dateutil/__pycache__/__init__.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/dateutil/__pycache__/_common.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/dateutil/__pycache__/_version.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/dateutil/__pycache__/easter.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/dateutil/parser/__pycache__/__init__.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/dateutil/parser/__pycache__/_parser.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/dateutil/parser/__pycache__/isoparser.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/dateutil/__pycache__/relativedelta.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/dateutil/__pycache__/rrule.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/dateutil/tz/__pycache__/__init__.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/dateutil/tz/__pycache__/_common.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/dateutil/tz/__pycache__/_factories.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/dateutil/tz/__pycache__/tz.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/dateutil/tz/__pycache__/win.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/dateutil/__pycache__/tzwin.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/dateutil/__pycache__/utils.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/dateutil/zoneinfo/__pycache__/__init__.cpython-312.pyc", + "path_type": "pyc_file" + }, + { + "_path": "lib/python3.12/site-packages/dateutil/zoneinfo/__pycache__/rebuild.cpython-312.pyc", + "path_type": "pyc_file" + } + ], + "paths_version": 1 + }, + "requested_spec": "None", + "sha256": "54d7785c7678166aa45adeaccfc1d2b8c3c799ca2dc05d4a82bb39b1968bd7da", + "size": 245987, + "subdir": "noarch", + "timestamp": 1626286448000, + "url": "https://conda.anaconda.org/conda-forge/noarch/python-dateutil-2.8.2-pyhd8ed1ab_0.tar.bz2", + "version": "2.8.2" +} \ No newline at end of file diff --git a/crates/pet-conda/tests/unix/conda_envs/user_home/miniconda3/envs/env_python_3/conda-meta/python_abi-3.12-4_cp312.json b/crates/pet-conda/tests/unix/conda_envs/user_home/miniconda3/envs/env_python_3/conda-meta/python_abi-3.12-4_cp312.json new file mode 100644 index 00000000..ae7da345 --- /dev/null +++ b/crates/pet-conda/tests/unix/conda_envs/user_home/miniconda3/envs/env_python_3/conda-meta/python_abi-3.12-4_cp312.json @@ -0,0 +1,31 @@ +{ + "build": "4_cp312", + "build_number": 4, + "channel": "https://conda.anaconda.org/conda-forge/osx-arm64", + "constrains": [ + "python 3.12.* *_cpython" + ], + "depends": [], + "extracted_package_dir": "/Users/donjayamanne/miniconda3/pkgs/python_abi-3.12-4_cp312", + "files": [], + "fn": "python_abi-3.12-4_cp312.conda", + "license": "BSD-3-Clause", + "link": { + "source": "/Users/donjayamanne/miniconda3/pkgs/python_abi-3.12-4_cp312", + "type": 1 + }, + "md5": "bbb3a02c78b2d8219d7213f76d644a2a", + "name": "python_abi", + "package_tarball_full_path": "/Users/donjayamanne/miniconda3/pkgs/python_abi-3.12-4_cp312.conda", + "paths_data": { + "paths": [], + "paths_version": 1 + }, + "requested_spec": "None", + "sha256": "db25428e4f24f8693ffa39f3ff6dfbb8fd53bc298764b775b57edab1c697560f", + "size": 6508, + "subdir": "osx-arm64", + "timestamp": 1695147497000, + "url": "https://conda.anaconda.org/conda-forge/osx-arm64/python_abi-3.12-4_cp312.conda", + "version": "3.12" +} \ No newline at end of file diff --git a/crates/pet-conda/tests/unix/conda_envs/user_home/miniconda3/envs/myenv/bin/python b/crates/pet-conda/tests/unix/conda_envs/user_home/miniconda3/envs/myenv/bin/python new file mode 100644 index 00000000..e69de29b diff --git a/crates/pet-conda/tests/unix/conda_envs/user_home/miniconda3/envs/myenv/bin/python3 b/crates/pet-conda/tests/unix/conda_envs/user_home/miniconda3/envs/myenv/bin/python3 new file mode 100644 index 00000000..e69de29b diff --git a/crates/pet-conda/tests/unix/conda_envs/user_home/miniconda3/envs/myenv/bin/python3.1 b/crates/pet-conda/tests/unix/conda_envs/user_home/miniconda3/envs/myenv/bin/python3.1 new file mode 100644 index 00000000..e69de29b diff --git a/crates/pet-conda/tests/unix/conda_envs/user_home/miniconda3/envs/myenv/bin/python3.10 b/crates/pet-conda/tests/unix/conda_envs/user_home/miniconda3/envs/myenv/bin/python3.10 new file mode 100644 index 00000000..e69de29b diff --git a/crates/pet-conda/tests/unix/conda_envs/user_home/miniconda3/envs/myenv/conda-meta/history b/crates/pet-conda/tests/unix/conda_envs/user_home/miniconda3/envs/myenv/conda-meta/history new file mode 100644 index 00000000..ed4a0c95 --- /dev/null +++ b/crates/pet-conda/tests/unix/conda_envs/user_home/miniconda3/envs/myenv/conda-meta/history @@ -0,0 +1,19 @@ +==> 2024-05-08 12:20:05 <== +# cmd: /Users/donjayamanne/.pyenv/versions/miniconda3-latest/bin/conda create -n myenv python=3.10 +# conda version: 24.3.0 ++defaults/noarch::tzdata-2024a-h04d1e81_0 ++defaults/osx-arm64::bzip2-1.0.8-h80987f9_6 ++defaults/osx-arm64::ca-certificates-2024.3.11-hca03da5_0 ++defaults/osx-arm64::libffi-3.4.4-hca03da5_1 ++defaults/osx-arm64::ncurses-6.4-h313beb8_0 ++defaults/osx-arm64::openssl-3.0.13-h1a28f6b_1 ++defaults/osx-arm64::pip-24.0-py310hca03da5_0 ++defaults/osx-arm64::python-3.10.14-hb885b13_1 ++defaults/osx-arm64::readline-8.2-h1a28f6b_0 ++defaults/osx-arm64::setuptools-69.5.1-py310hca03da5_0 ++defaults/osx-arm64::sqlite-3.45.3-h80987f9_0 ++defaults/osx-arm64::tk-8.6.14-h6ba3021_0 ++defaults/osx-arm64::wheel-0.43.0-py310hca03da5_0 ++defaults/osx-arm64::xz-5.4.6-h80987f9_1 ++defaults/osx-arm64::zlib-1.2.13-h18a0788_1 +# update specs: ['python=3.10'] diff --git a/crates/pet-conda/tests/unix/conda_envs/user_home/miniconda3/envs/myenv/conda-meta/pip-24.0-py310hca03da5_0.json b/crates/pet-conda/tests/unix/conda_envs/user_home/miniconda3/envs/myenv/conda-meta/pip-24.0-py310hca03da5_0.json new file mode 100644 index 00000000..fd01836e --- /dev/null +++ b/crates/pet-conda/tests/unix/conda_envs/user_home/miniconda3/envs/myenv/conda-meta/pip-24.0-py310hca03da5_0.json @@ -0,0 +1,8143 @@ +{ + "build": "py310hca03da5_0", + "build_number": 0, + "channel": "https://repo.anaconda.com/pkgs/main/osx-arm64", + "constrains": [], + "depends": [ + "python >=3.10,<3.11.0a0", + "setuptools", + "wheel" + ], + "extracted_package_dir": "/Users/donjayamanne/.pyenv/versions/miniconda3-latest/pkgs/pip-24.0-py310hca03da5_0", + "files": [ + "bin/pip", + "bin/pip3", + "lib/python3.10/site-packages/pip-24.0-py3.10.egg-info/PKG-INFO", + "lib/python3.10/site-packages/pip-24.0-py3.10.egg-info/SOURCES.txt", + "lib/python3.10/site-packages/pip-24.0-py3.10.egg-info/dependency_links.txt", + "lib/python3.10/site-packages/pip-24.0-py3.10.egg-info/entry_points.txt", + "lib/python3.10/site-packages/pip-24.0-py3.10.egg-info/top_level.txt", + "lib/python3.10/site-packages/pip/__init__.py", + "lib/python3.10/site-packages/pip/__main__.py", + "lib/python3.10/site-packages/pip/__pip-runner__.py", + "lib/python3.10/site-packages/pip/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/__pycache__/__main__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/__pycache__/__pip-runner__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/__init__.py", + "lib/python3.10/site-packages/pip/_internal/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/__pycache__/build_env.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/__pycache__/cache.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/__pycache__/configuration.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/__pycache__/exceptions.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/__pycache__/main.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/__pycache__/pyproject.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/__pycache__/self_outdated_check.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/__pycache__/wheel_builder.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/build_env.py", + "lib/python3.10/site-packages/pip/_internal/cache.py", + "lib/python3.10/site-packages/pip/_internal/cli/__init__.py", + "lib/python3.10/site-packages/pip/_internal/cli/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/cli/__pycache__/autocompletion.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/cli/__pycache__/base_command.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/cli/__pycache__/cmdoptions.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/cli/__pycache__/command_context.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/cli/__pycache__/main.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/cli/__pycache__/main_parser.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/cli/__pycache__/parser.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/cli/__pycache__/progress_bars.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/cli/__pycache__/req_command.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/cli/__pycache__/spinners.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/cli/__pycache__/status_codes.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/cli/autocompletion.py", + "lib/python3.10/site-packages/pip/_internal/cli/base_command.py", + "lib/python3.10/site-packages/pip/_internal/cli/cmdoptions.py", + "lib/python3.10/site-packages/pip/_internal/cli/command_context.py", + "lib/python3.10/site-packages/pip/_internal/cli/main.py", + "lib/python3.10/site-packages/pip/_internal/cli/main_parser.py", + "lib/python3.10/site-packages/pip/_internal/cli/parser.py", + "lib/python3.10/site-packages/pip/_internal/cli/progress_bars.py", + "lib/python3.10/site-packages/pip/_internal/cli/req_command.py", + "lib/python3.10/site-packages/pip/_internal/cli/spinners.py", + "lib/python3.10/site-packages/pip/_internal/cli/status_codes.py", + "lib/python3.10/site-packages/pip/_internal/commands/__init__.py", + "lib/python3.10/site-packages/pip/_internal/commands/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/commands/__pycache__/cache.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/commands/__pycache__/check.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/commands/__pycache__/completion.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/commands/__pycache__/configuration.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/commands/__pycache__/debug.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/commands/__pycache__/download.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/commands/__pycache__/freeze.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/commands/__pycache__/hash.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/commands/__pycache__/help.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/commands/__pycache__/index.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/commands/__pycache__/inspect.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/commands/__pycache__/install.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/commands/__pycache__/list.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/commands/__pycache__/search.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/commands/__pycache__/show.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/commands/__pycache__/uninstall.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/commands/__pycache__/wheel.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/commands/cache.py", + "lib/python3.10/site-packages/pip/_internal/commands/check.py", + "lib/python3.10/site-packages/pip/_internal/commands/completion.py", + "lib/python3.10/site-packages/pip/_internal/commands/configuration.py", + "lib/python3.10/site-packages/pip/_internal/commands/debug.py", + "lib/python3.10/site-packages/pip/_internal/commands/download.py", + "lib/python3.10/site-packages/pip/_internal/commands/freeze.py", + "lib/python3.10/site-packages/pip/_internal/commands/hash.py", + "lib/python3.10/site-packages/pip/_internal/commands/help.py", + "lib/python3.10/site-packages/pip/_internal/commands/index.py", + "lib/python3.10/site-packages/pip/_internal/commands/inspect.py", + "lib/python3.10/site-packages/pip/_internal/commands/install.py", + "lib/python3.10/site-packages/pip/_internal/commands/list.py", + "lib/python3.10/site-packages/pip/_internal/commands/search.py", + "lib/python3.10/site-packages/pip/_internal/commands/show.py", + "lib/python3.10/site-packages/pip/_internal/commands/uninstall.py", + "lib/python3.10/site-packages/pip/_internal/commands/wheel.py", + "lib/python3.10/site-packages/pip/_internal/configuration.py", + "lib/python3.10/site-packages/pip/_internal/distributions/__init__.py", + "lib/python3.10/site-packages/pip/_internal/distributions/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/distributions/__pycache__/base.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/distributions/__pycache__/installed.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/distributions/__pycache__/sdist.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/distributions/__pycache__/wheel.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/distributions/base.py", + "lib/python3.10/site-packages/pip/_internal/distributions/installed.py", + "lib/python3.10/site-packages/pip/_internal/distributions/sdist.py", + "lib/python3.10/site-packages/pip/_internal/distributions/wheel.py", + "lib/python3.10/site-packages/pip/_internal/exceptions.py", + "lib/python3.10/site-packages/pip/_internal/index/__init__.py", + "lib/python3.10/site-packages/pip/_internal/index/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/index/__pycache__/collector.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/index/__pycache__/package_finder.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/index/__pycache__/sources.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/index/collector.py", + "lib/python3.10/site-packages/pip/_internal/index/package_finder.py", + "lib/python3.10/site-packages/pip/_internal/index/sources.py", + "lib/python3.10/site-packages/pip/_internal/locations/__init__.py", + "lib/python3.10/site-packages/pip/_internal/locations/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/locations/__pycache__/_distutils.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/locations/__pycache__/_sysconfig.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/locations/__pycache__/base.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/locations/_distutils.py", + "lib/python3.10/site-packages/pip/_internal/locations/_sysconfig.py", + "lib/python3.10/site-packages/pip/_internal/locations/base.py", + "lib/python3.10/site-packages/pip/_internal/main.py", + "lib/python3.10/site-packages/pip/_internal/metadata/__init__.py", + "lib/python3.10/site-packages/pip/_internal/metadata/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/metadata/__pycache__/_json.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/metadata/__pycache__/base.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/metadata/__pycache__/pkg_resources.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/metadata/_json.py", + "lib/python3.10/site-packages/pip/_internal/metadata/base.py", + "lib/python3.10/site-packages/pip/_internal/metadata/importlib/__init__.py", + "lib/python3.10/site-packages/pip/_internal/metadata/importlib/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/metadata/importlib/__pycache__/_compat.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/metadata/importlib/__pycache__/_dists.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/metadata/importlib/__pycache__/_envs.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/metadata/importlib/_compat.py", + "lib/python3.10/site-packages/pip/_internal/metadata/importlib/_dists.py", + "lib/python3.10/site-packages/pip/_internal/metadata/importlib/_envs.py", + "lib/python3.10/site-packages/pip/_internal/metadata/pkg_resources.py", + "lib/python3.10/site-packages/pip/_internal/models/__init__.py", + "lib/python3.10/site-packages/pip/_internal/models/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/models/__pycache__/candidate.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/models/__pycache__/direct_url.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/models/__pycache__/format_control.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/models/__pycache__/index.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/models/__pycache__/installation_report.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/models/__pycache__/link.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/models/__pycache__/scheme.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/models/__pycache__/search_scope.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/models/__pycache__/selection_prefs.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/models/__pycache__/target_python.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/models/__pycache__/wheel.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/models/candidate.py", + "lib/python3.10/site-packages/pip/_internal/models/direct_url.py", + "lib/python3.10/site-packages/pip/_internal/models/format_control.py", + "lib/python3.10/site-packages/pip/_internal/models/index.py", + "lib/python3.10/site-packages/pip/_internal/models/installation_report.py", + "lib/python3.10/site-packages/pip/_internal/models/link.py", + "lib/python3.10/site-packages/pip/_internal/models/scheme.py", + "lib/python3.10/site-packages/pip/_internal/models/search_scope.py", + "lib/python3.10/site-packages/pip/_internal/models/selection_prefs.py", + "lib/python3.10/site-packages/pip/_internal/models/target_python.py", + "lib/python3.10/site-packages/pip/_internal/models/wheel.py", + "lib/python3.10/site-packages/pip/_internal/network/__init__.py", + "lib/python3.10/site-packages/pip/_internal/network/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/network/__pycache__/auth.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/network/__pycache__/cache.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/network/__pycache__/download.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/network/__pycache__/lazy_wheel.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/network/__pycache__/session.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/network/__pycache__/utils.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/network/__pycache__/xmlrpc.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/network/auth.py", + "lib/python3.10/site-packages/pip/_internal/network/cache.py", + "lib/python3.10/site-packages/pip/_internal/network/download.py", + "lib/python3.10/site-packages/pip/_internal/network/lazy_wheel.py", + "lib/python3.10/site-packages/pip/_internal/network/session.py", + "lib/python3.10/site-packages/pip/_internal/network/utils.py", + "lib/python3.10/site-packages/pip/_internal/network/xmlrpc.py", + "lib/python3.10/site-packages/pip/_internal/operations/__init__.py", + "lib/python3.10/site-packages/pip/_internal/operations/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/operations/__pycache__/check.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/operations/__pycache__/freeze.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/operations/__pycache__/prepare.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/operations/build/__init__.py", + "lib/python3.10/site-packages/pip/_internal/operations/build/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/operations/build/__pycache__/build_tracker.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/operations/build/__pycache__/metadata.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/operations/build/__pycache__/metadata_editable.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/operations/build/__pycache__/metadata_legacy.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/operations/build/__pycache__/wheel.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/operations/build/__pycache__/wheel_editable.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/operations/build/__pycache__/wheel_legacy.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/operations/build/build_tracker.py", + "lib/python3.10/site-packages/pip/_internal/operations/build/metadata.py", + "lib/python3.10/site-packages/pip/_internal/operations/build/metadata_editable.py", + "lib/python3.10/site-packages/pip/_internal/operations/build/metadata_legacy.py", + "lib/python3.10/site-packages/pip/_internal/operations/build/wheel.py", + "lib/python3.10/site-packages/pip/_internal/operations/build/wheel_editable.py", + "lib/python3.10/site-packages/pip/_internal/operations/build/wheel_legacy.py", + "lib/python3.10/site-packages/pip/_internal/operations/check.py", + "lib/python3.10/site-packages/pip/_internal/operations/freeze.py", + "lib/python3.10/site-packages/pip/_internal/operations/install/__init__.py", + "lib/python3.10/site-packages/pip/_internal/operations/install/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/operations/install/__pycache__/editable_legacy.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/operations/install/__pycache__/wheel.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/operations/install/editable_legacy.py", + "lib/python3.10/site-packages/pip/_internal/operations/install/wheel.py", + "lib/python3.10/site-packages/pip/_internal/operations/prepare.py", + "lib/python3.10/site-packages/pip/_internal/pyproject.py", + "lib/python3.10/site-packages/pip/_internal/req/__init__.py", + "lib/python3.10/site-packages/pip/_internal/req/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/req/__pycache__/constructors.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/req/__pycache__/req_file.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/req/__pycache__/req_install.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/req/__pycache__/req_set.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/req/__pycache__/req_uninstall.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/req/constructors.py", + "lib/python3.10/site-packages/pip/_internal/req/req_file.py", + "lib/python3.10/site-packages/pip/_internal/req/req_install.py", + "lib/python3.10/site-packages/pip/_internal/req/req_set.py", + "lib/python3.10/site-packages/pip/_internal/req/req_uninstall.py", + "lib/python3.10/site-packages/pip/_internal/resolution/__init__.py", + "lib/python3.10/site-packages/pip/_internal/resolution/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/resolution/__pycache__/base.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/resolution/base.py", + "lib/python3.10/site-packages/pip/_internal/resolution/legacy/__init__.py", + "lib/python3.10/site-packages/pip/_internal/resolution/legacy/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/resolution/legacy/__pycache__/resolver.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/resolution/legacy/resolver.py", + "lib/python3.10/site-packages/pip/_internal/resolution/resolvelib/__init__.py", + "lib/python3.10/site-packages/pip/_internal/resolution/resolvelib/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/resolution/resolvelib/__pycache__/base.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/resolution/resolvelib/__pycache__/candidates.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/resolution/resolvelib/__pycache__/factory.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/resolution/resolvelib/__pycache__/found_candidates.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/resolution/resolvelib/__pycache__/provider.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/resolution/resolvelib/__pycache__/reporter.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/resolution/resolvelib/__pycache__/requirements.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/resolution/resolvelib/__pycache__/resolver.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/resolution/resolvelib/base.py", + "lib/python3.10/site-packages/pip/_internal/resolution/resolvelib/candidates.py", + "lib/python3.10/site-packages/pip/_internal/resolution/resolvelib/factory.py", + "lib/python3.10/site-packages/pip/_internal/resolution/resolvelib/found_candidates.py", + "lib/python3.10/site-packages/pip/_internal/resolution/resolvelib/provider.py", + "lib/python3.10/site-packages/pip/_internal/resolution/resolvelib/reporter.py", + "lib/python3.10/site-packages/pip/_internal/resolution/resolvelib/requirements.py", + "lib/python3.10/site-packages/pip/_internal/resolution/resolvelib/resolver.py", + "lib/python3.10/site-packages/pip/_internal/self_outdated_check.py", + "lib/python3.10/site-packages/pip/_internal/utils/__init__.py", + "lib/python3.10/site-packages/pip/_internal/utils/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/utils/__pycache__/_jaraco_text.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/utils/__pycache__/_log.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/utils/__pycache__/appdirs.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/utils/__pycache__/compat.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/utils/__pycache__/compatibility_tags.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/utils/__pycache__/datetime.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/utils/__pycache__/deprecation.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/utils/__pycache__/direct_url_helpers.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/utils/__pycache__/egg_link.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/utils/__pycache__/encoding.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/utils/__pycache__/entrypoints.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/utils/__pycache__/filesystem.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/utils/__pycache__/filetypes.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/utils/__pycache__/glibc.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/utils/__pycache__/hashes.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/utils/__pycache__/logging.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/utils/__pycache__/misc.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/utils/__pycache__/models.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/utils/__pycache__/packaging.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/utils/__pycache__/setuptools_build.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/utils/__pycache__/subprocess.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/utils/__pycache__/temp_dir.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/utils/__pycache__/unpacking.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/utils/__pycache__/urls.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/utils/__pycache__/virtualenv.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/utils/__pycache__/wheel.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/utils/_jaraco_text.py", + "lib/python3.10/site-packages/pip/_internal/utils/_log.py", + "lib/python3.10/site-packages/pip/_internal/utils/appdirs.py", + "lib/python3.10/site-packages/pip/_internal/utils/compat.py", + "lib/python3.10/site-packages/pip/_internal/utils/compatibility_tags.py", + "lib/python3.10/site-packages/pip/_internal/utils/datetime.py", + "lib/python3.10/site-packages/pip/_internal/utils/deprecation.py", + "lib/python3.10/site-packages/pip/_internal/utils/direct_url_helpers.py", + "lib/python3.10/site-packages/pip/_internal/utils/egg_link.py", + "lib/python3.10/site-packages/pip/_internal/utils/encoding.py", + "lib/python3.10/site-packages/pip/_internal/utils/entrypoints.py", + "lib/python3.10/site-packages/pip/_internal/utils/filesystem.py", + "lib/python3.10/site-packages/pip/_internal/utils/filetypes.py", + "lib/python3.10/site-packages/pip/_internal/utils/glibc.py", + "lib/python3.10/site-packages/pip/_internal/utils/hashes.py", + "lib/python3.10/site-packages/pip/_internal/utils/logging.py", + "lib/python3.10/site-packages/pip/_internal/utils/misc.py", + "lib/python3.10/site-packages/pip/_internal/utils/models.py", + "lib/python3.10/site-packages/pip/_internal/utils/packaging.py", + "lib/python3.10/site-packages/pip/_internal/utils/setuptools_build.py", + "lib/python3.10/site-packages/pip/_internal/utils/subprocess.py", + "lib/python3.10/site-packages/pip/_internal/utils/temp_dir.py", + "lib/python3.10/site-packages/pip/_internal/utils/unpacking.py", + "lib/python3.10/site-packages/pip/_internal/utils/urls.py", + "lib/python3.10/site-packages/pip/_internal/utils/virtualenv.py", + "lib/python3.10/site-packages/pip/_internal/utils/wheel.py", + "lib/python3.10/site-packages/pip/_internal/vcs/__init__.py", + "lib/python3.10/site-packages/pip/_internal/vcs/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/vcs/__pycache__/bazaar.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/vcs/__pycache__/git.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/vcs/__pycache__/mercurial.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/vcs/__pycache__/subversion.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/vcs/__pycache__/versioncontrol.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_internal/vcs/bazaar.py", + "lib/python3.10/site-packages/pip/_internal/vcs/git.py", + "lib/python3.10/site-packages/pip/_internal/vcs/mercurial.py", + "lib/python3.10/site-packages/pip/_internal/vcs/subversion.py", + "lib/python3.10/site-packages/pip/_internal/vcs/versioncontrol.py", + "lib/python3.10/site-packages/pip/_internal/wheel_builder.py", + "lib/python3.10/site-packages/pip/_vendor/__init__.py", + "lib/python3.10/site-packages/pip/_vendor/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/__pycache__/six.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/__pycache__/typing_extensions.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/cachecontrol/__init__.py", + "lib/python3.10/site-packages/pip/_vendor/cachecontrol/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/cachecontrol/__pycache__/_cmd.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/cachecontrol/__pycache__/adapter.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/cachecontrol/__pycache__/cache.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/cachecontrol/__pycache__/controller.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/cachecontrol/__pycache__/filewrapper.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/cachecontrol/__pycache__/heuristics.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/cachecontrol/__pycache__/serialize.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/cachecontrol/__pycache__/wrapper.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/cachecontrol/_cmd.py", + "lib/python3.10/site-packages/pip/_vendor/cachecontrol/adapter.py", + "lib/python3.10/site-packages/pip/_vendor/cachecontrol/cache.py", + "lib/python3.10/site-packages/pip/_vendor/cachecontrol/caches/__init__.py", + "lib/python3.10/site-packages/pip/_vendor/cachecontrol/caches/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/cachecontrol/caches/__pycache__/file_cache.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/cachecontrol/caches/__pycache__/redis_cache.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/cachecontrol/caches/file_cache.py", + "lib/python3.10/site-packages/pip/_vendor/cachecontrol/caches/redis_cache.py", + "lib/python3.10/site-packages/pip/_vendor/cachecontrol/controller.py", + "lib/python3.10/site-packages/pip/_vendor/cachecontrol/filewrapper.py", + "lib/python3.10/site-packages/pip/_vendor/cachecontrol/heuristics.py", + "lib/python3.10/site-packages/pip/_vendor/cachecontrol/py.typed", + "lib/python3.10/site-packages/pip/_vendor/cachecontrol/serialize.py", + "lib/python3.10/site-packages/pip/_vendor/cachecontrol/wrapper.py", + "lib/python3.10/site-packages/pip/_vendor/certifi/__init__.py", + "lib/python3.10/site-packages/pip/_vendor/certifi/__main__.py", + "lib/python3.10/site-packages/pip/_vendor/certifi/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/certifi/__pycache__/__main__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/certifi/__pycache__/core.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/certifi/cacert.pem", + "lib/python3.10/site-packages/pip/_vendor/certifi/core.py", + "lib/python3.10/site-packages/pip/_vendor/certifi/py.typed", + "lib/python3.10/site-packages/pip/_vendor/chardet/__init__.py", + "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/big5freq.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/big5prober.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/chardistribution.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/charsetgroupprober.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/charsetprober.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/codingstatemachine.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/codingstatemachinedict.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/cp949prober.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/enums.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/escprober.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/escsm.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/eucjpprober.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/euckrfreq.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/euckrprober.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/euctwfreq.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/euctwprober.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/gb2312freq.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/gb2312prober.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/hebrewprober.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/jisfreq.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/johabfreq.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/johabprober.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/jpcntx.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/langbulgarianmodel.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/langgreekmodel.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/langhebrewmodel.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/langhungarianmodel.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/langrussianmodel.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/langthaimodel.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/langturkishmodel.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/latin1prober.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/macromanprober.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/mbcharsetprober.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/mbcsgroupprober.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/mbcssm.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/resultdict.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/sbcharsetprober.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/sbcsgroupprober.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/sjisprober.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/universaldetector.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/utf1632prober.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/utf8prober.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/version.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/chardet/big5freq.py", + "lib/python3.10/site-packages/pip/_vendor/chardet/big5prober.py", + "lib/python3.10/site-packages/pip/_vendor/chardet/chardistribution.py", + "lib/python3.10/site-packages/pip/_vendor/chardet/charsetgroupprober.py", + "lib/python3.10/site-packages/pip/_vendor/chardet/charsetprober.py", + "lib/python3.10/site-packages/pip/_vendor/chardet/cli/__init__.py", + "lib/python3.10/site-packages/pip/_vendor/chardet/cli/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/chardet/cli/__pycache__/chardetect.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/chardet/cli/chardetect.py", + "lib/python3.10/site-packages/pip/_vendor/chardet/codingstatemachine.py", + "lib/python3.10/site-packages/pip/_vendor/chardet/codingstatemachinedict.py", + "lib/python3.10/site-packages/pip/_vendor/chardet/cp949prober.py", + "lib/python3.10/site-packages/pip/_vendor/chardet/enums.py", + "lib/python3.10/site-packages/pip/_vendor/chardet/escprober.py", + "lib/python3.10/site-packages/pip/_vendor/chardet/escsm.py", + "lib/python3.10/site-packages/pip/_vendor/chardet/eucjpprober.py", + "lib/python3.10/site-packages/pip/_vendor/chardet/euckrfreq.py", + "lib/python3.10/site-packages/pip/_vendor/chardet/euckrprober.py", + "lib/python3.10/site-packages/pip/_vendor/chardet/euctwfreq.py", + "lib/python3.10/site-packages/pip/_vendor/chardet/euctwprober.py", + "lib/python3.10/site-packages/pip/_vendor/chardet/gb2312freq.py", + "lib/python3.10/site-packages/pip/_vendor/chardet/gb2312prober.py", + "lib/python3.10/site-packages/pip/_vendor/chardet/hebrewprober.py", + "lib/python3.10/site-packages/pip/_vendor/chardet/jisfreq.py", + "lib/python3.10/site-packages/pip/_vendor/chardet/johabfreq.py", + "lib/python3.10/site-packages/pip/_vendor/chardet/johabprober.py", + "lib/python3.10/site-packages/pip/_vendor/chardet/jpcntx.py", + "lib/python3.10/site-packages/pip/_vendor/chardet/langbulgarianmodel.py", + "lib/python3.10/site-packages/pip/_vendor/chardet/langgreekmodel.py", + "lib/python3.10/site-packages/pip/_vendor/chardet/langhebrewmodel.py", + "lib/python3.10/site-packages/pip/_vendor/chardet/langhungarianmodel.py", + "lib/python3.10/site-packages/pip/_vendor/chardet/langrussianmodel.py", + "lib/python3.10/site-packages/pip/_vendor/chardet/langthaimodel.py", + "lib/python3.10/site-packages/pip/_vendor/chardet/langturkishmodel.py", + "lib/python3.10/site-packages/pip/_vendor/chardet/latin1prober.py", + "lib/python3.10/site-packages/pip/_vendor/chardet/macromanprober.py", + "lib/python3.10/site-packages/pip/_vendor/chardet/mbcharsetprober.py", + "lib/python3.10/site-packages/pip/_vendor/chardet/mbcsgroupprober.py", + "lib/python3.10/site-packages/pip/_vendor/chardet/mbcssm.py", + "lib/python3.10/site-packages/pip/_vendor/chardet/metadata/__init__.py", + "lib/python3.10/site-packages/pip/_vendor/chardet/metadata/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/chardet/metadata/__pycache__/languages.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/chardet/metadata/languages.py", + "lib/python3.10/site-packages/pip/_vendor/chardet/py.typed", + "lib/python3.10/site-packages/pip/_vendor/chardet/resultdict.py", + "lib/python3.10/site-packages/pip/_vendor/chardet/sbcharsetprober.py", + "lib/python3.10/site-packages/pip/_vendor/chardet/sbcsgroupprober.py", + "lib/python3.10/site-packages/pip/_vendor/chardet/sjisprober.py", + "lib/python3.10/site-packages/pip/_vendor/chardet/universaldetector.py", + "lib/python3.10/site-packages/pip/_vendor/chardet/utf1632prober.py", + "lib/python3.10/site-packages/pip/_vendor/chardet/utf8prober.py", + "lib/python3.10/site-packages/pip/_vendor/chardet/version.py", + "lib/python3.10/site-packages/pip/_vendor/colorama/__init__.py", + "lib/python3.10/site-packages/pip/_vendor/colorama/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/colorama/__pycache__/ansi.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/colorama/__pycache__/ansitowin32.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/colorama/__pycache__/initialise.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/colorama/__pycache__/win32.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/colorama/__pycache__/winterm.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/colorama/ansi.py", + "lib/python3.10/site-packages/pip/_vendor/colorama/ansitowin32.py", + "lib/python3.10/site-packages/pip/_vendor/colorama/initialise.py", + "lib/python3.10/site-packages/pip/_vendor/colorama/tests/__init__.py", + "lib/python3.10/site-packages/pip/_vendor/colorama/tests/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/colorama/tests/__pycache__/ansi_test.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/colorama/tests/__pycache__/ansitowin32_test.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/colorama/tests/__pycache__/initialise_test.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/colorama/tests/__pycache__/isatty_test.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/colorama/tests/__pycache__/utils.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/colorama/tests/__pycache__/winterm_test.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/colorama/tests/ansi_test.py", + "lib/python3.10/site-packages/pip/_vendor/colorama/tests/ansitowin32_test.py", + "lib/python3.10/site-packages/pip/_vendor/colorama/tests/initialise_test.py", + "lib/python3.10/site-packages/pip/_vendor/colorama/tests/isatty_test.py", + "lib/python3.10/site-packages/pip/_vendor/colorama/tests/utils.py", + "lib/python3.10/site-packages/pip/_vendor/colorama/tests/winterm_test.py", + "lib/python3.10/site-packages/pip/_vendor/colorama/win32.py", + "lib/python3.10/site-packages/pip/_vendor/colorama/winterm.py", + "lib/python3.10/site-packages/pip/_vendor/distlib/__init__.py", + "lib/python3.10/site-packages/pip/_vendor/distlib/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/distlib/__pycache__/compat.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/distlib/__pycache__/database.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/distlib/__pycache__/index.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/distlib/__pycache__/locators.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/distlib/__pycache__/manifest.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/distlib/__pycache__/markers.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/distlib/__pycache__/metadata.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/distlib/__pycache__/resources.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/distlib/__pycache__/scripts.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/distlib/__pycache__/util.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/distlib/__pycache__/version.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/distlib/__pycache__/wheel.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/distlib/compat.py", + "lib/python3.10/site-packages/pip/_vendor/distlib/database.py", + "lib/python3.10/site-packages/pip/_vendor/distlib/index.py", + "lib/python3.10/site-packages/pip/_vendor/distlib/locators.py", + "lib/python3.10/site-packages/pip/_vendor/distlib/manifest.py", + "lib/python3.10/site-packages/pip/_vendor/distlib/markers.py", + "lib/python3.10/site-packages/pip/_vendor/distlib/metadata.py", + "lib/python3.10/site-packages/pip/_vendor/distlib/resources.py", + "lib/python3.10/site-packages/pip/_vendor/distlib/scripts.py", + "lib/python3.10/site-packages/pip/_vendor/distlib/util.py", + "lib/python3.10/site-packages/pip/_vendor/distlib/version.py", + "lib/python3.10/site-packages/pip/_vendor/distlib/wheel.py", + "lib/python3.10/site-packages/pip/_vendor/distro/__init__.py", + "lib/python3.10/site-packages/pip/_vendor/distro/__main__.py", + "lib/python3.10/site-packages/pip/_vendor/distro/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/distro/__pycache__/__main__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/distro/__pycache__/distro.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/distro/distro.py", + "lib/python3.10/site-packages/pip/_vendor/distro/py.typed", + "lib/python3.10/site-packages/pip/_vendor/idna/__init__.py", + "lib/python3.10/site-packages/pip/_vendor/idna/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/idna/__pycache__/codec.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/idna/__pycache__/compat.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/idna/__pycache__/core.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/idna/__pycache__/idnadata.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/idna/__pycache__/intranges.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/idna/__pycache__/package_data.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/idna/__pycache__/uts46data.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/idna/codec.py", + "lib/python3.10/site-packages/pip/_vendor/idna/compat.py", + "lib/python3.10/site-packages/pip/_vendor/idna/core.py", + "lib/python3.10/site-packages/pip/_vendor/idna/idnadata.py", + "lib/python3.10/site-packages/pip/_vendor/idna/intranges.py", + "lib/python3.10/site-packages/pip/_vendor/idna/package_data.py", + "lib/python3.10/site-packages/pip/_vendor/idna/py.typed", + "lib/python3.10/site-packages/pip/_vendor/idna/uts46data.py", + "lib/python3.10/site-packages/pip/_vendor/msgpack/__init__.py", + "lib/python3.10/site-packages/pip/_vendor/msgpack/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/msgpack/__pycache__/exceptions.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/msgpack/__pycache__/ext.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/msgpack/__pycache__/fallback.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/msgpack/exceptions.py", + "lib/python3.10/site-packages/pip/_vendor/msgpack/ext.py", + "lib/python3.10/site-packages/pip/_vendor/msgpack/fallback.py", + "lib/python3.10/site-packages/pip/_vendor/packaging/__about__.py", + "lib/python3.10/site-packages/pip/_vendor/packaging/__init__.py", + "lib/python3.10/site-packages/pip/_vendor/packaging/__pycache__/__about__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/packaging/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/packaging/__pycache__/_manylinux.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/packaging/__pycache__/_musllinux.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/packaging/__pycache__/_structures.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/packaging/__pycache__/markers.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/packaging/__pycache__/requirements.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/packaging/__pycache__/specifiers.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/packaging/__pycache__/tags.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/packaging/__pycache__/utils.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/packaging/__pycache__/version.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/packaging/_manylinux.py", + "lib/python3.10/site-packages/pip/_vendor/packaging/_musllinux.py", + "lib/python3.10/site-packages/pip/_vendor/packaging/_structures.py", + "lib/python3.10/site-packages/pip/_vendor/packaging/markers.py", + "lib/python3.10/site-packages/pip/_vendor/packaging/py.typed", + "lib/python3.10/site-packages/pip/_vendor/packaging/requirements.py", + "lib/python3.10/site-packages/pip/_vendor/packaging/specifiers.py", + "lib/python3.10/site-packages/pip/_vendor/packaging/tags.py", + "lib/python3.10/site-packages/pip/_vendor/packaging/utils.py", + "lib/python3.10/site-packages/pip/_vendor/packaging/version.py", + "lib/python3.10/site-packages/pip/_vendor/pkg_resources/__init__.py", + "lib/python3.10/site-packages/pip/_vendor/pkg_resources/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/platformdirs/__init__.py", + "lib/python3.10/site-packages/pip/_vendor/platformdirs/__main__.py", + "lib/python3.10/site-packages/pip/_vendor/platformdirs/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/platformdirs/__pycache__/__main__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/platformdirs/__pycache__/android.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/platformdirs/__pycache__/api.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/platformdirs/__pycache__/macos.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/platformdirs/__pycache__/unix.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/platformdirs/__pycache__/version.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/platformdirs/__pycache__/windows.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/platformdirs/android.py", + "lib/python3.10/site-packages/pip/_vendor/platformdirs/api.py", + "lib/python3.10/site-packages/pip/_vendor/platformdirs/macos.py", + "lib/python3.10/site-packages/pip/_vendor/platformdirs/py.typed", + "lib/python3.10/site-packages/pip/_vendor/platformdirs/unix.py", + "lib/python3.10/site-packages/pip/_vendor/platformdirs/version.py", + "lib/python3.10/site-packages/pip/_vendor/platformdirs/windows.py", + "lib/python3.10/site-packages/pip/_vendor/pygments/__init__.py", + "lib/python3.10/site-packages/pip/_vendor/pygments/__main__.py", + "lib/python3.10/site-packages/pip/_vendor/pygments/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/pygments/__pycache__/__main__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/pygments/__pycache__/cmdline.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/pygments/__pycache__/console.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/pygments/__pycache__/filter.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/pygments/__pycache__/formatter.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/pygments/__pycache__/lexer.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/pygments/__pycache__/modeline.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/pygments/__pycache__/plugin.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/pygments/__pycache__/regexopt.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/pygments/__pycache__/scanner.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/pygments/__pycache__/sphinxext.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/pygments/__pycache__/style.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/pygments/__pycache__/token.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/pygments/__pycache__/unistring.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/pygments/__pycache__/util.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/pygments/cmdline.py", + "lib/python3.10/site-packages/pip/_vendor/pygments/console.py", + "lib/python3.10/site-packages/pip/_vendor/pygments/filter.py", + "lib/python3.10/site-packages/pip/_vendor/pygments/filters/__init__.py", + "lib/python3.10/site-packages/pip/_vendor/pygments/filters/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/pygments/formatter.py", + "lib/python3.10/site-packages/pip/_vendor/pygments/formatters/__init__.py", + "lib/python3.10/site-packages/pip/_vendor/pygments/formatters/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/pygments/formatters/__pycache__/_mapping.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/pygments/formatters/__pycache__/bbcode.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/pygments/formatters/__pycache__/groff.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/pygments/formatters/__pycache__/html.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/pygments/formatters/__pycache__/img.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/pygments/formatters/__pycache__/irc.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/pygments/formatters/__pycache__/latex.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/pygments/formatters/__pycache__/other.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/pygments/formatters/__pycache__/pangomarkup.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/pygments/formatters/__pycache__/rtf.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/pygments/formatters/__pycache__/svg.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/pygments/formatters/__pycache__/terminal.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/pygments/formatters/__pycache__/terminal256.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/pygments/formatters/_mapping.py", + "lib/python3.10/site-packages/pip/_vendor/pygments/formatters/bbcode.py", + "lib/python3.10/site-packages/pip/_vendor/pygments/formatters/groff.py", + "lib/python3.10/site-packages/pip/_vendor/pygments/formatters/html.py", + "lib/python3.10/site-packages/pip/_vendor/pygments/formatters/img.py", + "lib/python3.10/site-packages/pip/_vendor/pygments/formatters/irc.py", + "lib/python3.10/site-packages/pip/_vendor/pygments/formatters/latex.py", + "lib/python3.10/site-packages/pip/_vendor/pygments/formatters/other.py", + "lib/python3.10/site-packages/pip/_vendor/pygments/formatters/pangomarkup.py", + "lib/python3.10/site-packages/pip/_vendor/pygments/formatters/rtf.py", + "lib/python3.10/site-packages/pip/_vendor/pygments/formatters/svg.py", + "lib/python3.10/site-packages/pip/_vendor/pygments/formatters/terminal.py", + "lib/python3.10/site-packages/pip/_vendor/pygments/formatters/terminal256.py", + "lib/python3.10/site-packages/pip/_vendor/pygments/lexer.py", + "lib/python3.10/site-packages/pip/_vendor/pygments/lexers/__init__.py", + "lib/python3.10/site-packages/pip/_vendor/pygments/lexers/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/pygments/lexers/__pycache__/_mapping.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/pygments/lexers/__pycache__/python.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/pygments/lexers/_mapping.py", + "lib/python3.10/site-packages/pip/_vendor/pygments/lexers/python.py", + "lib/python3.10/site-packages/pip/_vendor/pygments/modeline.py", + "lib/python3.10/site-packages/pip/_vendor/pygments/plugin.py", + "lib/python3.10/site-packages/pip/_vendor/pygments/regexopt.py", + "lib/python3.10/site-packages/pip/_vendor/pygments/scanner.py", + "lib/python3.10/site-packages/pip/_vendor/pygments/sphinxext.py", + "lib/python3.10/site-packages/pip/_vendor/pygments/style.py", + "lib/python3.10/site-packages/pip/_vendor/pygments/styles/__init__.py", + "lib/python3.10/site-packages/pip/_vendor/pygments/styles/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/pygments/token.py", + "lib/python3.10/site-packages/pip/_vendor/pygments/unistring.py", + "lib/python3.10/site-packages/pip/_vendor/pygments/util.py", + "lib/python3.10/site-packages/pip/_vendor/pyparsing/__init__.py", + "lib/python3.10/site-packages/pip/_vendor/pyparsing/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/pyparsing/__pycache__/actions.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/pyparsing/__pycache__/common.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/pyparsing/__pycache__/core.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/pyparsing/__pycache__/exceptions.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/pyparsing/__pycache__/helpers.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/pyparsing/__pycache__/results.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/pyparsing/__pycache__/testing.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/pyparsing/__pycache__/unicode.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/pyparsing/__pycache__/util.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/pyparsing/actions.py", + "lib/python3.10/site-packages/pip/_vendor/pyparsing/common.py", + "lib/python3.10/site-packages/pip/_vendor/pyparsing/core.py", + "lib/python3.10/site-packages/pip/_vendor/pyparsing/diagram/__init__.py", + "lib/python3.10/site-packages/pip/_vendor/pyparsing/diagram/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/pyparsing/exceptions.py", + "lib/python3.10/site-packages/pip/_vendor/pyparsing/helpers.py", + "lib/python3.10/site-packages/pip/_vendor/pyparsing/py.typed", + "lib/python3.10/site-packages/pip/_vendor/pyparsing/results.py", + "lib/python3.10/site-packages/pip/_vendor/pyparsing/testing.py", + "lib/python3.10/site-packages/pip/_vendor/pyparsing/unicode.py", + "lib/python3.10/site-packages/pip/_vendor/pyparsing/util.py", + "lib/python3.10/site-packages/pip/_vendor/pyproject_hooks/__init__.py", + "lib/python3.10/site-packages/pip/_vendor/pyproject_hooks/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/pyproject_hooks/__pycache__/_compat.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/pyproject_hooks/__pycache__/_impl.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/pyproject_hooks/_compat.py", + "lib/python3.10/site-packages/pip/_vendor/pyproject_hooks/_impl.py", + "lib/python3.10/site-packages/pip/_vendor/pyproject_hooks/_in_process/__init__.py", + "lib/python3.10/site-packages/pip/_vendor/pyproject_hooks/_in_process/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/pyproject_hooks/_in_process/__pycache__/_in_process.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/pyproject_hooks/_in_process/_in_process.py", + "lib/python3.10/site-packages/pip/_vendor/requests/__init__.py", + "lib/python3.10/site-packages/pip/_vendor/requests/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/requests/__pycache__/__version__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/requests/__pycache__/_internal_utils.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/requests/__pycache__/adapters.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/requests/__pycache__/api.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/requests/__pycache__/auth.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/requests/__pycache__/certs.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/requests/__pycache__/compat.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/requests/__pycache__/cookies.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/requests/__pycache__/exceptions.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/requests/__pycache__/help.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/requests/__pycache__/hooks.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/requests/__pycache__/models.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/requests/__pycache__/packages.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/requests/__pycache__/sessions.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/requests/__pycache__/status_codes.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/requests/__pycache__/structures.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/requests/__pycache__/utils.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/requests/__version__.py", + "lib/python3.10/site-packages/pip/_vendor/requests/_internal_utils.py", + "lib/python3.10/site-packages/pip/_vendor/requests/adapters.py", + "lib/python3.10/site-packages/pip/_vendor/requests/api.py", + "lib/python3.10/site-packages/pip/_vendor/requests/auth.py", + "lib/python3.10/site-packages/pip/_vendor/requests/certs.py", + "lib/python3.10/site-packages/pip/_vendor/requests/compat.py", + "lib/python3.10/site-packages/pip/_vendor/requests/cookies.py", + "lib/python3.10/site-packages/pip/_vendor/requests/exceptions.py", + "lib/python3.10/site-packages/pip/_vendor/requests/help.py", + "lib/python3.10/site-packages/pip/_vendor/requests/hooks.py", + "lib/python3.10/site-packages/pip/_vendor/requests/models.py", + "lib/python3.10/site-packages/pip/_vendor/requests/packages.py", + "lib/python3.10/site-packages/pip/_vendor/requests/sessions.py", + "lib/python3.10/site-packages/pip/_vendor/requests/status_codes.py", + "lib/python3.10/site-packages/pip/_vendor/requests/structures.py", + "lib/python3.10/site-packages/pip/_vendor/requests/utils.py", + "lib/python3.10/site-packages/pip/_vendor/resolvelib/__init__.py", + "lib/python3.10/site-packages/pip/_vendor/resolvelib/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/resolvelib/__pycache__/providers.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/resolvelib/__pycache__/reporters.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/resolvelib/__pycache__/resolvers.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/resolvelib/__pycache__/structs.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/resolvelib/compat/__init__.py", + "lib/python3.10/site-packages/pip/_vendor/resolvelib/compat/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/resolvelib/compat/__pycache__/collections_abc.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/resolvelib/compat/collections_abc.py", + "lib/python3.10/site-packages/pip/_vendor/resolvelib/providers.py", + "lib/python3.10/site-packages/pip/_vendor/resolvelib/py.typed", + "lib/python3.10/site-packages/pip/_vendor/resolvelib/reporters.py", + "lib/python3.10/site-packages/pip/_vendor/resolvelib/resolvers.py", + "lib/python3.10/site-packages/pip/_vendor/resolvelib/structs.py", + "lib/python3.10/site-packages/pip/_vendor/rich/__init__.py", + "lib/python3.10/site-packages/pip/_vendor/rich/__main__.py", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/__main__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_cell_widths.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_emoji_codes.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_emoji_replace.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_export_format.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_extension.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_fileno.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_inspect.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_log_render.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_loop.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_null_file.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_palettes.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_pick.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_ratio.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_spinners.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_stack.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_timer.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_win32_console.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_windows.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_windows_renderer.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_wrap.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/abc.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/align.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/ansi.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/bar.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/box.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/cells.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/color.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/color_triplet.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/columns.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/console.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/constrain.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/containers.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/control.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/default_styles.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/diagnose.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/emoji.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/errors.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/file_proxy.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/filesize.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/highlighter.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/json.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/jupyter.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/layout.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/live.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/live_render.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/logging.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/markup.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/measure.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/padding.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/pager.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/palette.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/panel.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/pretty.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/progress.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/progress_bar.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/prompt.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/protocol.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/region.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/repr.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/rule.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/scope.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/screen.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/segment.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/spinner.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/status.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/style.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/styled.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/syntax.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/table.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/terminal_theme.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/text.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/theme.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/themes.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/traceback.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/tree.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/rich/_cell_widths.py", + "lib/python3.10/site-packages/pip/_vendor/rich/_emoji_codes.py", + "lib/python3.10/site-packages/pip/_vendor/rich/_emoji_replace.py", + "lib/python3.10/site-packages/pip/_vendor/rich/_export_format.py", + "lib/python3.10/site-packages/pip/_vendor/rich/_extension.py", + "lib/python3.10/site-packages/pip/_vendor/rich/_fileno.py", + "lib/python3.10/site-packages/pip/_vendor/rich/_inspect.py", + "lib/python3.10/site-packages/pip/_vendor/rich/_log_render.py", + "lib/python3.10/site-packages/pip/_vendor/rich/_loop.py", + "lib/python3.10/site-packages/pip/_vendor/rich/_null_file.py", + "lib/python3.10/site-packages/pip/_vendor/rich/_palettes.py", + "lib/python3.10/site-packages/pip/_vendor/rich/_pick.py", + "lib/python3.10/site-packages/pip/_vendor/rich/_ratio.py", + "lib/python3.10/site-packages/pip/_vendor/rich/_spinners.py", + "lib/python3.10/site-packages/pip/_vendor/rich/_stack.py", + "lib/python3.10/site-packages/pip/_vendor/rich/_timer.py", + "lib/python3.10/site-packages/pip/_vendor/rich/_win32_console.py", + "lib/python3.10/site-packages/pip/_vendor/rich/_windows.py", + "lib/python3.10/site-packages/pip/_vendor/rich/_windows_renderer.py", + "lib/python3.10/site-packages/pip/_vendor/rich/_wrap.py", + "lib/python3.10/site-packages/pip/_vendor/rich/abc.py", + "lib/python3.10/site-packages/pip/_vendor/rich/align.py", + "lib/python3.10/site-packages/pip/_vendor/rich/ansi.py", + "lib/python3.10/site-packages/pip/_vendor/rich/bar.py", + "lib/python3.10/site-packages/pip/_vendor/rich/box.py", + "lib/python3.10/site-packages/pip/_vendor/rich/cells.py", + "lib/python3.10/site-packages/pip/_vendor/rich/color.py", + "lib/python3.10/site-packages/pip/_vendor/rich/color_triplet.py", + "lib/python3.10/site-packages/pip/_vendor/rich/columns.py", + "lib/python3.10/site-packages/pip/_vendor/rich/console.py", + "lib/python3.10/site-packages/pip/_vendor/rich/constrain.py", + "lib/python3.10/site-packages/pip/_vendor/rich/containers.py", + "lib/python3.10/site-packages/pip/_vendor/rich/control.py", + "lib/python3.10/site-packages/pip/_vendor/rich/default_styles.py", + "lib/python3.10/site-packages/pip/_vendor/rich/diagnose.py", + "lib/python3.10/site-packages/pip/_vendor/rich/emoji.py", + "lib/python3.10/site-packages/pip/_vendor/rich/errors.py", + "lib/python3.10/site-packages/pip/_vendor/rich/file_proxy.py", + "lib/python3.10/site-packages/pip/_vendor/rich/filesize.py", + "lib/python3.10/site-packages/pip/_vendor/rich/highlighter.py", + "lib/python3.10/site-packages/pip/_vendor/rich/json.py", + "lib/python3.10/site-packages/pip/_vendor/rich/jupyter.py", + "lib/python3.10/site-packages/pip/_vendor/rich/layout.py", + "lib/python3.10/site-packages/pip/_vendor/rich/live.py", + "lib/python3.10/site-packages/pip/_vendor/rich/live_render.py", + "lib/python3.10/site-packages/pip/_vendor/rich/logging.py", + "lib/python3.10/site-packages/pip/_vendor/rich/markup.py", + "lib/python3.10/site-packages/pip/_vendor/rich/measure.py", + "lib/python3.10/site-packages/pip/_vendor/rich/padding.py", + "lib/python3.10/site-packages/pip/_vendor/rich/pager.py", + "lib/python3.10/site-packages/pip/_vendor/rich/palette.py", + "lib/python3.10/site-packages/pip/_vendor/rich/panel.py", + "lib/python3.10/site-packages/pip/_vendor/rich/pretty.py", + "lib/python3.10/site-packages/pip/_vendor/rich/progress.py", + "lib/python3.10/site-packages/pip/_vendor/rich/progress_bar.py", + "lib/python3.10/site-packages/pip/_vendor/rich/prompt.py", + "lib/python3.10/site-packages/pip/_vendor/rich/protocol.py", + "lib/python3.10/site-packages/pip/_vendor/rich/py.typed", + "lib/python3.10/site-packages/pip/_vendor/rich/region.py", + "lib/python3.10/site-packages/pip/_vendor/rich/repr.py", + "lib/python3.10/site-packages/pip/_vendor/rich/rule.py", + "lib/python3.10/site-packages/pip/_vendor/rich/scope.py", + "lib/python3.10/site-packages/pip/_vendor/rich/screen.py", + "lib/python3.10/site-packages/pip/_vendor/rich/segment.py", + "lib/python3.10/site-packages/pip/_vendor/rich/spinner.py", + "lib/python3.10/site-packages/pip/_vendor/rich/status.py", + "lib/python3.10/site-packages/pip/_vendor/rich/style.py", + "lib/python3.10/site-packages/pip/_vendor/rich/styled.py", + "lib/python3.10/site-packages/pip/_vendor/rich/syntax.py", + "lib/python3.10/site-packages/pip/_vendor/rich/table.py", + "lib/python3.10/site-packages/pip/_vendor/rich/terminal_theme.py", + "lib/python3.10/site-packages/pip/_vendor/rich/text.py", + "lib/python3.10/site-packages/pip/_vendor/rich/theme.py", + "lib/python3.10/site-packages/pip/_vendor/rich/themes.py", + "lib/python3.10/site-packages/pip/_vendor/rich/traceback.py", + "lib/python3.10/site-packages/pip/_vendor/rich/tree.py", + "lib/python3.10/site-packages/pip/_vendor/six.py", + "lib/python3.10/site-packages/pip/_vendor/tenacity/__init__.py", + "lib/python3.10/site-packages/pip/_vendor/tenacity/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/tenacity/__pycache__/_asyncio.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/tenacity/__pycache__/_utils.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/tenacity/__pycache__/after.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/tenacity/__pycache__/before.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/tenacity/__pycache__/before_sleep.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/tenacity/__pycache__/nap.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/tenacity/__pycache__/retry.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/tenacity/__pycache__/stop.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/tenacity/__pycache__/tornadoweb.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/tenacity/__pycache__/wait.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/tenacity/_asyncio.py", + "lib/python3.10/site-packages/pip/_vendor/tenacity/_utils.py", + "lib/python3.10/site-packages/pip/_vendor/tenacity/after.py", + "lib/python3.10/site-packages/pip/_vendor/tenacity/before.py", + "lib/python3.10/site-packages/pip/_vendor/tenacity/before_sleep.py", + "lib/python3.10/site-packages/pip/_vendor/tenacity/nap.py", + "lib/python3.10/site-packages/pip/_vendor/tenacity/py.typed", + "lib/python3.10/site-packages/pip/_vendor/tenacity/retry.py", + "lib/python3.10/site-packages/pip/_vendor/tenacity/stop.py", + "lib/python3.10/site-packages/pip/_vendor/tenacity/tornadoweb.py", + "lib/python3.10/site-packages/pip/_vendor/tenacity/wait.py", + "lib/python3.10/site-packages/pip/_vendor/tomli/__init__.py", + "lib/python3.10/site-packages/pip/_vendor/tomli/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/tomli/__pycache__/_parser.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/tomli/__pycache__/_re.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/tomli/__pycache__/_types.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/tomli/_parser.py", + "lib/python3.10/site-packages/pip/_vendor/tomli/_re.py", + "lib/python3.10/site-packages/pip/_vendor/tomli/_types.py", + "lib/python3.10/site-packages/pip/_vendor/tomli/py.typed", + "lib/python3.10/site-packages/pip/_vendor/truststore/__init__.py", + "lib/python3.10/site-packages/pip/_vendor/truststore/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/truststore/__pycache__/_api.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/truststore/__pycache__/_macos.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/truststore/__pycache__/_openssl.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/truststore/__pycache__/_ssl_constants.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/truststore/__pycache__/_windows.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/truststore/_api.py", + "lib/python3.10/site-packages/pip/_vendor/truststore/_macos.py", + "lib/python3.10/site-packages/pip/_vendor/truststore/_openssl.py", + "lib/python3.10/site-packages/pip/_vendor/truststore/_ssl_constants.py", + "lib/python3.10/site-packages/pip/_vendor/truststore/_windows.py", + "lib/python3.10/site-packages/pip/_vendor/truststore/py.typed", + "lib/python3.10/site-packages/pip/_vendor/typing_extensions.py", + "lib/python3.10/site-packages/pip/_vendor/urllib3/__init__.py", + "lib/python3.10/site-packages/pip/_vendor/urllib3/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/urllib3/__pycache__/_collections.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/urllib3/__pycache__/_version.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/urllib3/__pycache__/connection.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/urllib3/__pycache__/connectionpool.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/urllib3/__pycache__/exceptions.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/urllib3/__pycache__/fields.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/urllib3/__pycache__/filepost.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/urllib3/__pycache__/poolmanager.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/urllib3/__pycache__/request.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/urllib3/__pycache__/response.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/urllib3/_collections.py", + "lib/python3.10/site-packages/pip/_vendor/urllib3/_version.py", + "lib/python3.10/site-packages/pip/_vendor/urllib3/connection.py", + "lib/python3.10/site-packages/pip/_vendor/urllib3/connectionpool.py", + "lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/__init__.py", + "lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/__pycache__/_appengine_environ.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/__pycache__/appengine.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/__pycache__/ntlmpool.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/__pycache__/pyopenssl.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/__pycache__/securetransport.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/__pycache__/socks.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/_appengine_environ.py", + "lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/_securetransport/__init__.py", + "lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/_securetransport/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/_securetransport/__pycache__/bindings.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/_securetransport/__pycache__/low_level.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/_securetransport/bindings.py", + "lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/_securetransport/low_level.py", + "lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/appengine.py", + "lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/ntlmpool.py", + "lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/pyopenssl.py", + "lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/securetransport.py", + "lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/socks.py", + "lib/python3.10/site-packages/pip/_vendor/urllib3/exceptions.py", + "lib/python3.10/site-packages/pip/_vendor/urllib3/fields.py", + "lib/python3.10/site-packages/pip/_vendor/urllib3/filepost.py", + "lib/python3.10/site-packages/pip/_vendor/urllib3/packages/__init__.py", + "lib/python3.10/site-packages/pip/_vendor/urllib3/packages/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/urllib3/packages/__pycache__/six.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/urllib3/packages/backports/__init__.py", + "lib/python3.10/site-packages/pip/_vendor/urllib3/packages/backports/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/urllib3/packages/backports/__pycache__/makefile.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/urllib3/packages/backports/__pycache__/weakref_finalize.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/urllib3/packages/backports/makefile.py", + "lib/python3.10/site-packages/pip/_vendor/urllib3/packages/backports/weakref_finalize.py", + "lib/python3.10/site-packages/pip/_vendor/urllib3/packages/six.py", + "lib/python3.10/site-packages/pip/_vendor/urllib3/poolmanager.py", + "lib/python3.10/site-packages/pip/_vendor/urllib3/request.py", + "lib/python3.10/site-packages/pip/_vendor/urllib3/response.py", + "lib/python3.10/site-packages/pip/_vendor/urllib3/util/__init__.py", + "lib/python3.10/site-packages/pip/_vendor/urllib3/util/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/urllib3/util/__pycache__/connection.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/urllib3/util/__pycache__/proxy.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/urllib3/util/__pycache__/queue.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/urllib3/util/__pycache__/request.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/urllib3/util/__pycache__/response.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/urllib3/util/__pycache__/retry.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/urllib3/util/__pycache__/ssl_.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/urllib3/util/__pycache__/ssl_match_hostname.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/urllib3/util/__pycache__/ssltransport.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/urllib3/util/__pycache__/timeout.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/urllib3/util/__pycache__/url.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/urllib3/util/__pycache__/wait.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/urllib3/util/connection.py", + "lib/python3.10/site-packages/pip/_vendor/urllib3/util/proxy.py", + "lib/python3.10/site-packages/pip/_vendor/urllib3/util/queue.py", + "lib/python3.10/site-packages/pip/_vendor/urllib3/util/request.py", + "lib/python3.10/site-packages/pip/_vendor/urllib3/util/response.py", + "lib/python3.10/site-packages/pip/_vendor/urllib3/util/retry.py", + "lib/python3.10/site-packages/pip/_vendor/urllib3/util/ssl_.py", + "lib/python3.10/site-packages/pip/_vendor/urllib3/util/ssl_match_hostname.py", + "lib/python3.10/site-packages/pip/_vendor/urllib3/util/ssltransport.py", + "lib/python3.10/site-packages/pip/_vendor/urllib3/util/timeout.py", + "lib/python3.10/site-packages/pip/_vendor/urllib3/util/url.py", + "lib/python3.10/site-packages/pip/_vendor/urllib3/util/wait.py", + "lib/python3.10/site-packages/pip/_vendor/vendor.txt", + "lib/python3.10/site-packages/pip/_vendor/webencodings/__init__.py", + "lib/python3.10/site-packages/pip/_vendor/webencodings/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/webencodings/__pycache__/labels.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/webencodings/__pycache__/mklabels.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/webencodings/__pycache__/tests.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/webencodings/__pycache__/x_user_defined.cpython-310.pyc", + "lib/python3.10/site-packages/pip/_vendor/webencodings/labels.py", + "lib/python3.10/site-packages/pip/_vendor/webencodings/mklabels.py", + "lib/python3.10/site-packages/pip/_vendor/webencodings/tests.py", + "lib/python3.10/site-packages/pip/_vendor/webencodings/x_user_defined.py", + "lib/python3.10/site-packages/pip/py.typed" + ], + "fn": "pip-24.0-py310hca03da5_0.conda", + "license": "MIT", + "link": { + "source": "/Users/donjayamanne/.pyenv/versions/miniconda3-latest/pkgs/pip-24.0-py310hca03da5_0", + "type": 1 + }, + "md5": "d34ad3a54a4c5a6b653bdb0cd186153f", + "name": "pip", + "package_tarball_full_path": "/Users/donjayamanne/.pyenv/versions/miniconda3-latest/pkgs/pip-24.0-py310hca03da5_0.conda", + "paths_data": { + "paths": [ + { + "_path": "bin/pip", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_cbgv4j_lrp/croot/pip_1715096990868/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_", + "sha256": "366a754e29388d827c6ddc3ad3ebe532c91403b136fe5ca552e9ba8b30c4242a", + "sha256_in_prefix": "0b9fb01801730dfd65fc78452054d96f50e69cba2f4e41eb87a722dc214a95b9", + "size_in_bytes": 475 + }, + { + "_path": "bin/pip3", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_cbgv4j_lrp/croot/pip_1715096990868/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_", + "sha256": "366a754e29388d827c6ddc3ad3ebe532c91403b136fe5ca552e9ba8b30c4242a", + "sha256_in_prefix": "0b9fb01801730dfd65fc78452054d96f50e69cba2f4e41eb87a722dc214a95b9", + "size_in_bytes": 475 + }, + { + "_path": "lib/python3.10/site-packages/pip-24.0-py3.10.egg-info/PKG-INFO", + "path_type": "hardlink", + "sha256": "90d11f277fd5868da679ee257c97656dde511c8aac7d025231407e6ce90839e2", + "sha256_in_prefix": "90d11f277fd5868da679ee257c97656dde511c8aac7d025231407e6ce90839e2", + "size_in_bytes": 3581 + }, + { + "_path": "lib/python3.10/site-packages/pip-24.0-py3.10.egg-info/SOURCES.txt", + "path_type": "hardlink", + "sha256": "8c2e778e48f6ac271da58e18be23377e88dea24ca3743a0112483cc2f0a7c6b3", + "sha256_in_prefix": "8c2e778e48f6ac271da58e18be23377e88dea24ca3743a0112483cc2f0a7c6b3", + "size_in_bytes": 24039 + }, + { + "_path": "lib/python3.10/site-packages/pip-24.0-py3.10.egg-info/dependency_links.txt", + "path_type": "hardlink", + "sha256": "01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b", + "sha256_in_prefix": "01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b", + "size_in_bytes": 1 + }, + { + "_path": "lib/python3.10/site-packages/pip-24.0-py3.10.egg-info/entry_points.txt", + "path_type": "hardlink", + "sha256": "ca764dd7fef4eff2f6dce6bcfcee4b3b112871c8f59c36b8c474f981a95f37ba", + "sha256_in_prefix": "ca764dd7fef4eff2f6dce6bcfcee4b3b112871c8f59c36b8c474f981a95f37ba", + "size_in_bytes": 125 + }, + { + "_path": "lib/python3.10/site-packages/pip-24.0-py3.10.egg-info/top_level.txt", + "path_type": "hardlink", + "sha256": "ceebae7b8927a3227e5303cf5e0f1f7b34bb542ad7250ac03fbcde36ec2f1508", + "sha256_in_prefix": "ceebae7b8927a3227e5303cf5e0f1f7b34bb542ad7250ac03fbcde36ec2f1508", + "size_in_bytes": 4 + }, + { + "_path": "lib/python3.10/site-packages/pip/__init__.py", + "path_type": "hardlink", + "sha256": "a009359c5a4b994552e4b9fb371bcda06527e55927e851908cf68d0dff10f299", + "sha256_in_prefix": "a009359c5a4b994552e4b9fb371bcda06527e55927e851908cf68d0dff10f299", + "size_in_bytes": 355 + }, + { + "_path": "lib/python3.10/site-packages/pip/__main__.py", + "path_type": "hardlink", + "sha256": "5b36e11d74db484ea0058d7d98d37d9b8b39a3fdfae4b3af4d84a0aa06dd0611", + "sha256_in_prefix": "5b36e11d74db484ea0058d7d98d37d9b8b39a3fdfae4b3af4d84a0aa06dd0611", + "size_in_bytes": 854 + }, + { + "_path": "lib/python3.10/site-packages/pip/__pip-runner__.py", + "path_type": "hardlink", + "sha256": "127adf2a628ccd601daa0fc989c2c238ff58f79531ef31e1e0e6efa8bb50723a", + "sha256_in_prefix": "127adf2a628ccd601daa0fc989c2c238ff58f79531ef31e1e0e6efa8bb50723a", + "size_in_bytes": 1444 + }, + { + "_path": "lib/python3.10/site-packages/pip/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "e0fd1e97fcfb4e26a60349e8450a3d66eb98d77607fc4a2472a7b231b96420cb", + "sha256_in_prefix": "e0fd1e97fcfb4e26a60349e8450a3d66eb98d77607fc4a2472a7b231b96420cb", + "size_in_bytes": 591 + }, + { + "_path": "lib/python3.10/site-packages/pip/__pycache__/__main__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "8fc9271253bfb9ee7b1a998d5ff7a96204657950790578224b88122f034471c5", + "sha256_in_prefix": "8fc9271253bfb9ee7b1a998d5ff7a96204657950790578224b88122f034471c5", + "size_in_bytes": 427 + }, + { + "_path": "lib/python3.10/site-packages/pip/__pycache__/__pip-runner__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "945480e1cba5b18c501ee71aff3d9144949473e970a9686632f9c425a07a57f8", + "sha256_in_prefix": "945480e1cba5b18c501ee71aff3d9144949473e970a9686632f9c425a07a57f8", + "size_in_bytes": 1591 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/__init__.py", + "path_type": "hardlink", + "sha256": "8aa679f9842c415d3cb6451cecbf34e917a8a7ab60b8b1567fbd32485e9b7b46", + "sha256_in_prefix": "8aa679f9842c415d3cb6451cecbf34e917a8a7ab60b8b1567fbd32485e9b7b46", + "size_in_bytes": 515 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "e96e59213533be0f2dcad34cdf17c850b870eda6cf4775da1c17598439f43dc4", + "sha256_in_prefix": "e96e59213533be0f2dcad34cdf17c850b870eda6cf4775da1c17598439f43dc4", + "size_in_bytes": 655 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/__pycache__/build_env.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "594628a3fe30b92516dfa2024b4779deedb8cd62ad168c9966a5953267f7689f", + "sha256_in_prefix": "594628a3fe30b92516dfa2024b4779deedb8cd62ad168c9966a5953267f7689f", + "size_in_bytes": 9672 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/__pycache__/cache.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "450e0058a879cd2fce0e5f80c294eec7f9e14eae45eabc09fa44d43bbec83416", + "sha256_in_prefix": "450e0058a879cd2fce0e5f80c294eec7f9e14eae45eabc09fa44d43bbec83416", + "size_in_bytes": 9006 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/__pycache__/configuration.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "2e4d711457821910b72f5152d063cf8dba2ae8807d166c5b7918382943f2ffaa", + "sha256_in_prefix": "2e4d711457821910b72f5152d063cf8dba2ae8807d166c5b7918382943f2ffaa", + "size_in_bytes": 11609 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/__pycache__/exceptions.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "81d79ad4a323fb68910175baaa0a04cc49d0587981cc4dbe1748486b6154cb24", + "sha256_in_prefix": "81d79ad4a323fb68910175baaa0a04cc49d0587981cc4dbe1748486b6154cb24", + "size_in_bytes": 25427 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/__pycache__/main.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "f23de3baf654be7727c55e9242a49ef6c6c97a8f4f2c848468df1c3ee6763d78", + "sha256_in_prefix": "f23de3baf654be7727c55e9242a49ef6c6c97a8f4f2c848468df1c3ee6763d78", + "size_in_bytes": 579 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/__pycache__/pyproject.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "a11518385c5a9e996bf655aeb7139447bc52d38d1a1c3f94d2fb6360212b7264", + "sha256_in_prefix": "a11518385c5a9e996bf655aeb7139447bc52d38d1a1c3f94d2fb6360212b7264", + "size_in_bytes": 3601 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/__pycache__/self_outdated_check.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "15590e5d51c40bacd2aee486ca248ae9dac3efde2d8205d751426a78fca8e4fb", + "sha256_in_prefix": "15590e5d51c40bacd2aee486ca248ae9dac3efde2d8205d751426a78fca8e4fb", + "size_in_bytes": 6905 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/__pycache__/wheel_builder.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "bf5201d2b952f16ed1f4239a56d542c45143fe85ade3678c79126abb462a17d9", + "sha256_in_prefix": "bf5201d2b952f16ed1f4239a56d542c45143fe85ade3678c79126abb462a17d9", + "size_in_bytes": 8606 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/build_env.py", + "path_type": "hardlink", + "sha256": "d444a9ab0d22ba94bf2bba6164ae73b21544e42cf2f41b462c55385ba127bdaf", + "sha256_in_prefix": "d444a9ab0d22ba94bf2bba6164ae73b21544e42cf2f41b462c55385ba127bdaf", + "size_in_bytes": 10243 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/cache.py", + "path_type": "hardlink", + "sha256": "ba2603fbd17406fd42f19c9613ce65a730e641fee17149202fdf46988f08e354", + "sha256_in_prefix": "ba2603fbd17406fd42f19c9613ce65a730e641fee17149202fdf46988f08e354", + "size_in_bytes": 10370 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/cli/__init__.py", + "path_type": "hardlink", + "sha256": "1641c1829c716fefe077aaf51639cd85f30ecc0518c97a17289e9a6e28df7055", + "sha256_in_prefix": "1641c1829c716fefe077aaf51639cd85f30ecc0518c97a17289e9a6e28df7055", + "size_in_bytes": 132 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/cli/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "7666923c7fca56cb4057bb4f4522503d8f1317defc43933f1f63f35bc9278957", + "sha256_in_prefix": "7666923c7fca56cb4057bb4f4522503d8f1317defc43933f1f63f35bc9278957", + "size_in_bytes": 234 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/cli/__pycache__/autocompletion.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "8e6831602939e44630d1e52f1c5685179af030a9b8326cf4fb8044177d73ff72", + "sha256_in_prefix": "8e6831602939e44630d1e52f1c5685179af030a9b8326cf4fb8044177d73ff72", + "size_in_bytes": 5368 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/cli/__pycache__/base_command.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "e4fd71594c88c9b96deddbbf833ed716245fef3e7f31be2faef738b8e2ee5a72", + "sha256_in_prefix": "e4fd71594c88c9b96deddbbf833ed716245fef3e7f31be2faef738b8e2ee5a72", + "size_in_bytes": 6451 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/cli/__pycache__/cmdoptions.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "312d376dbcdb029efa8ccea838e7b19fc23184bc799b8f596df5466aa1992184", + "sha256_in_prefix": "312d376dbcdb029efa8ccea838e7b19fc23184bc799b8f596df5466aa1992184", + "size_in_bytes": 23471 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/cli/__pycache__/command_context.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "58790d71fc296425fc849fe8b8a69fd3b49636a9a63f6d77b930589d384590dc", + "sha256_in_prefix": "58790d71fc296425fc849fe8b8a69fd3b49636a9a63f6d77b930589d384590dc", + "size_in_bytes": 1274 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/cli/__pycache__/main.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "dfcd85a07824030febc7f6b01dbf5cdbc6704d4a9ebd1567834cfa6083772e66", + "sha256_in_prefix": "dfcd85a07824030febc7f6b01dbf5cdbc6704d4a9ebd1567834cfa6083772e66", + "size_in_bytes": 1468 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/cli/__pycache__/main_parser.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "3c6dd424a462b0ed1f32a1d0844a9fc47b73ebe2b7ac1c6a3c22c77e0ccf7200", + "sha256_in_prefix": "3c6dd424a462b0ed1f32a1d0844a9fc47b73ebe2b7ac1c6a3c22c77e0ccf7200", + "size_in_bytes": 2957 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/cli/__pycache__/parser.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c2b87bc2f5065c9ff627b3862e9c978268e119fc8bfdd1655058b63e522f32a8", + "sha256_in_prefix": "c2b87bc2f5065c9ff627b3862e9c978268e119fc8bfdd1655058b63e522f32a8", + "size_in_bytes": 9883 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/cli/__pycache__/progress_bars.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "ed598bf92f582895286b3ffdd2e1c875ec41dcbd15da0e7b478042d6dcf5c566", + "sha256_in_prefix": "ed598bf92f582895286b3ffdd2e1c875ec41dcbd15da0e7b478042d6dcf5c566", + "size_in_bytes": 1858 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/cli/__pycache__/req_command.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "ec0edfdefad5c45b37f3c28258ff26cce191861e27ea75f0dfaed2c20697fd16", + "sha256_in_prefix": "ec0edfdefad5c45b37f3c28258ff26cce191861e27ea75f0dfaed2c20697fd16", + "size_in_bytes": 13129 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/cli/__pycache__/spinners.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "40e2fc1e64bdb305ea097d098d90ea8b1011928dc5a6b2d6d58a245e9d808e98", + "sha256_in_prefix": "40e2fc1e64bdb305ea097d098d90ea8b1011928dc5a6b2d6d58a245e9d808e98", + "size_in_bytes": 4924 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/cli/__pycache__/status_codes.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "d61474c0ff8af420c040d71def40ff657dfdf5e291c1e10c78c585f5e67b7b6f", + "sha256_in_prefix": "d61474c0ff8af420c040d71def40ff657dfdf5e291c1e10c78c585f5e67b7b6f", + "size_in_bytes": 313 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/cli/autocompletion.py", + "path_type": "hardlink", + "sha256": "fdbaffe4d812c52baf3e3305d0c2c7cd2e6ce81a529100101caacb2bcf556ae3", + "sha256_in_prefix": "fdbaffe4d812c52baf3e3305d0c2c7cd2e6ce81a529100101caacb2bcf556ae3", + "size_in_bytes": 6690 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/cli/base_command.py", + "path_type": "hardlink", + "sha256": "8ae55619ada84eaee00517a8d1eaf7674b57276a2a0480ba4230c77270e12976", + "sha256_in_prefix": "8ae55619ada84eaee00517a8d1eaf7674b57276a2a0480ba4230c77270e12976", + "size_in_bytes": 8733 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/cli/cmdoptions.py", + "path_type": "hardlink", + "sha256": "d44226f32322c503042cee10ce881d2285a4bc8950aa5016d189cf78e9a7bc40", + "sha256_in_prefix": "d44226f32322c503042cee10ce881d2285a4bc8950aa5016d189cf78e9a7bc40", + "size_in_bytes": 30064 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/cli/command_context.py", + "path_type": "hardlink", + "sha256": "4478083f0b4e6e1e4a84cadddd8653925f336d51bee8e92697b61b157e04860d", + "sha256_in_prefix": "4478083f0b4e6e1e4a84cadddd8653925f336d51bee8e92697b61b157e04860d", + "size_in_bytes": 774 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/cli/main.py", + "path_type": "hardlink", + "sha256": "533c6dfd80f5848bc1d405b99b1b7a215721b791bbd7602d32a768e7550c8664", + "sha256_in_prefix": "533c6dfd80f5848bc1d405b99b1b7a215721b791bbd7602d32a768e7550c8664", + "size_in_bytes": 2816 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/cli/main_parser.py", + "path_type": "hardlink", + "sha256": "95a0e9b2e04397a9327f2c29f5e30c03db3ce237c7d932499febe62f4186f74c", + "sha256_in_prefix": "95a0e9b2e04397a9327f2c29f5e30c03db3ce237c7d932499febe62f4186f74c", + "size_in_bytes": 4338 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/cli/parser.py", + "path_type": "hardlink", + "sha256": "296e82dfeefee04ad3341d137cb4cac0e74771dfaa79f09e1a7acea04dabd114", + "sha256_in_prefix": "296e82dfeefee04ad3341d137cb4cac0e74771dfaa79f09e1a7acea04dabd114", + "size_in_bytes": 10781 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/cli/progress_bars.py", + "path_type": "hardlink", + "sha256": "4a8e263e84a35e45e2487893cf3aae1f7555c950ff9e35e51c9484c583d7028c", + "sha256_in_prefix": "4a8e263e84a35e45e2487893cf3aae1f7555c950ff9e35e51c9484c583d7028c", + "size_in_bytes": 1968 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/cli/req_command.py", + "path_type": "hardlink", + "sha256": "73bfd71c00675e60f7fea94af7eaf7ecaa9d28101c82654abd0d96713acd2df7", + "sha256_in_prefix": "73bfd71c00675e60f7fea94af7eaf7ecaa9d28101c82654abd0d96713acd2df7", + "size_in_bytes": 18369 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/cli/spinners.py", + "path_type": "hardlink", + "sha256": "84827cdc67ab74580509da1b200db726081eb5e825fee0b84a9e7cea7cc56cf1", + "sha256_in_prefix": "84827cdc67ab74580509da1b200db726081eb5e825fee0b84a9e7cea7cc56cf1", + "size_in_bytes": 5118 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/cli/status_codes.py", + "path_type": "hardlink", + "sha256": "b0414751a5096eabfc880acbdc702d733b5666618e157d358537ac4b2b43121d", + "sha256_in_prefix": "b0414751a5096eabfc880acbdc702d733b5666618e157d358537ac4b2b43121d", + "size_in_bytes": 116 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/commands/__init__.py", + "path_type": "hardlink", + "sha256": "e6844ef4eddd336bc6ba1d1b170e0739595eb6bcabcf91c732698f5b026b1fd5", + "sha256_in_prefix": "e6844ef4eddd336bc6ba1d1b170e0739595eb6bcabcf91c732698f5b026b1fd5", + "size_in_bytes": 3882 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/commands/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "813d610ce97ca43f477492dcea148e7abfa4747ff91e4ec013e0396d9f4fae66", + "sha256_in_prefix": "813d610ce97ca43f477492dcea148e7abfa4747ff91e4ec013e0396d9f4fae66", + "size_in_bytes": 3213 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/commands/__pycache__/cache.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "b2f9f6c236010c5f71142c3b98d5574ebfe147fecc633fbef188bee339ecd263", + "sha256_in_prefix": "b2f9f6c236010c5f71142c3b98d5574ebfe147fecc633fbef188bee339ecd263", + "size_in_bytes": 6384 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/commands/__pycache__/check.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "9f90d2303ca253f0a1536cf7f8e2b6b4ac61571fd4187d4f31a86f52756bf754", + "sha256_in_prefix": "9f90d2303ca253f0a1536cf7f8e2b6b4ac61571fd4187d4f31a86f52756bf754", + "size_in_bytes": 1592 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/commands/__pycache__/completion.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "914b9f775952aff92ec497c69837cba794a44a605592c33923ce712f566776b4", + "sha256_in_prefix": "914b9f775952aff92ec497c69837cba794a44a605592c33923ce712f566776b4", + "size_in_bytes": 4280 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/commands/__pycache__/configuration.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "4be67c5d55392a9ecbf9df6337a391b8ca4d05afb94c619892ca5b00fd11c6e3", + "sha256_in_prefix": "4be67c5d55392a9ecbf9df6337a391b8ca4d05afb94c619892ca5b00fd11c6e3", + "size_in_bytes": 8897 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/commands/__pycache__/debug.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "9341a5bb30011a0524687db1da9a782b29a97a80f0285c5f57c4fa7fb26c5168", + "sha256_in_prefix": "9341a5bb30011a0524687db1da9a782b29a97a80f0285c5f57c4fa7fb26c5168", + "size_in_bytes": 6847 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/commands/__pycache__/download.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "1bf5b84d909e74414918e9feaecd53a6de65ca8f43ec1bb9cf7619b2b05bfd92", + "sha256_in_prefix": "1bf5b84d909e74414918e9feaecd53a6de65ca8f43ec1bb9cf7619b2b05bfd92", + "size_in_bytes": 4207 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/commands/__pycache__/freeze.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "d808c4b1108b80ca30692fb1e2c8e6d761d840eda5b21c42c9a9dc022a742d71", + "sha256_in_prefix": "d808c4b1108b80ca30692fb1e2c8e6d761d840eda5b21c42c9a9dc022a742d71", + "size_in_bytes": 2933 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/commands/__pycache__/hash.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "b66d9d51dfd0222fe6ebdc7d05196dde74f333916f3bc5a31f9d321ca4e9caef", + "sha256_in_prefix": "b66d9d51dfd0222fe6ebdc7d05196dde74f333916f3bc5a31f9d321ca4e9caef", + "size_in_bytes": 2110 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/commands/__pycache__/help.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "a2911791cf3600dbe76aaef25649207936f1ab16c09f78d8429e133e2d965046", + "sha256_in_prefix": "a2911791cf3600dbe76aaef25649207936f1ab16c09f78d8429e133e2d965046", + "size_in_bytes": 1271 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/commands/__pycache__/index.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "6fb3ca7885549a427aec319b9bb777a4055981f721b27ae96b52640dece145c0", + "sha256_in_prefix": "6fb3ca7885549a427aec319b9bb777a4055981f721b27ae96b52640dece145c0", + "size_in_bytes": 4548 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/commands/__pycache__/inspect.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "524c6842a83271edd4030dea4379a3ebfbb05a46390442fe5697da65edd81d81", + "sha256_in_prefix": "524c6842a83271edd4030dea4379a3ebfbb05a46390442fe5697da65edd81d81", + "size_in_bytes": 2931 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/commands/__pycache__/install.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "a63beba0af3766a94e59a72bbb5e0ab5ded892d2422ee397f9bdf88d12638a04", + "sha256_in_prefix": "a63beba0af3766a94e59a72bbb5e0ab5ded892d2422ee397f9bdf88d12638a04", + "size_in_bytes": 17681 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/commands/__pycache__/list.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "412d281088a9025e33fa7668c285107a6591fe8dce1ee053abcc72473916ebc2", + "sha256_in_prefix": "412d281088a9025e33fa7668c285107a6591fe8dce1ee053abcc72473916ebc2", + "size_in_bytes": 10329 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/commands/__pycache__/search.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "ce20e7db06341f267531c11dff9525ab3ac5077789c32501d5dac1867e0f643a", + "sha256_in_prefix": "ce20e7db06341f267531c11dff9525ab3ac5077789c32501d5dac1867e0f643a", + "size_in_bytes": 5324 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/commands/__pycache__/show.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "6b208ccd04397ff0d6a9f3480fb1f6840ac1e6eb520ba7f510ddfece4e246f25", + "sha256_in_prefix": "6b208ccd04397ff0d6a9f3480fb1f6840ac1e6eb520ba7f510ddfece4e246f25", + "size_in_bytes": 6485 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/commands/__pycache__/uninstall.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "d69503fff5de1e570fe9bfd2cd638066bfcd3fc2f62e21ac25f79122d0e63ad9", + "sha256_in_prefix": "d69503fff5de1e570fe9bfd2cd638066bfcd3fc2f62e21ac25f79122d0e63ad9", + "size_in_bytes": 3292 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/commands/__pycache__/wheel.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "311bae0a6d053c2036880fe89ddf248f92f13d29f50a666f7cd19b3f4bb6ff8b", + "sha256_in_prefix": "311bae0a6d053c2036880fe89ddf248f92f13d29f50a666f7cd19b3f4bb6ff8b", + "size_in_bytes": 4938 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/commands/cache.py", + "path_type": "hardlink", + "sha256": "c60efafd9144042eb3a10de05cb45f31925fb78cf66b44701f81841590ba9e75", + "sha256_in_prefix": "c60efafd9144042eb3a10de05cb45f31925fb78cf66b44701f81841590ba9e75", + "size_in_bytes": 7944 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/commands/check.py", + "path_type": "hardlink", + "sha256": "45bd77436f32a0b8748f5829c79494d239517ac35cb76d5e40246c9da3bdc4a0", + "sha256_in_prefix": "45bd77436f32a0b8748f5829c79494d239517ac35cb76d5e40246c9da3bdc4a0", + "size_in_bytes": 1782 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/commands/completion.py", + "path_type": "hardlink", + "sha256": "1d3e250f46e0b1f947ab62038187e211da7b2061ad13bb3a320237c67d15404c", + "sha256_in_prefix": "1d3e250f46e0b1f947ab62038187e211da7b2061ad13bb3a320237c67d15404c", + "size_in_bytes": 4287 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/commands/configuration.py", + "path_type": "hardlink", + "sha256": "9fdf1e9f0a7acb46f91ba7e24508da668e3716524a62f7bf75a32137ee0144d7", + "sha256_in_prefix": "9fdf1e9f0a7acb46f91ba7e24508da668e3716524a62f7bf75a32137ee0144d7", + "size_in_bytes": 9766 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/commands/debug.py", + "path_type": "hardlink", + "sha256": "eb7f7bdae50278c20639d30c55e2141ab3a34cea93556a65142f366be85c2b20", + "sha256_in_prefix": "eb7f7bdae50278c20639d30c55e2141ab3a34cea93556a65142f366be85c2b20", + "size_in_bytes": 6777 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/commands/download.py", + "path_type": "hardlink", + "sha256": "7b8870d3cf331a8dba5a625a30846f0a788b94b9a83a3aa8946c9f1e3b029024", + "sha256_in_prefix": "7b8870d3cf331a8dba5a625a30846f0a788b94b9a83a3aa8946c9f1e3b029024", + "size_in_bytes": 5335 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/commands/freeze.py", + "path_type": "hardlink", + "sha256": "daa8d0ac7f4a5a2e51a1abf40ae47bbdcee15a6e2e3a2ff497ab69dc448a0c73", + "sha256_in_prefix": "daa8d0ac7f4a5a2e51a1abf40ae47bbdcee15a6e2e3a2ff497ab69dc448a0c73", + "size_in_bytes": 3172 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/commands/hash.py", + "path_type": "hardlink", + "sha256": "11554ebaf1ada0f11d162f1236799daa5090ae10b157e909b1dc2d75c0a75c64", + "sha256_in_prefix": "11554ebaf1ada0f11d162f1236799daa5090ae10b157e909b1dc2d75c0a75c64", + "size_in_bytes": 1703 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/commands/help.py", + "path_type": "hardlink", + "sha256": "81c73a40391c80730eb809f9531699c004adb1106b9c64a7ff2c634b9ec92283", + "sha256_in_prefix": "81c73a40391c80730eb809f9531699c004adb1106b9c64a7ff2c634b9ec92283", + "size_in_bytes": 1132 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/commands/index.py", + "path_type": "hardlink", + "sha256": "08d5d07abfcf799292268a1445c08508110a19fc3236851660ffcc59ccc070e3", + "sha256_in_prefix": "08d5d07abfcf799292268a1445c08508110a19fc3236851660ffcc59ccc070e3", + "size_in_bytes": 4775 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/commands/inspect.py", + "path_type": "hardlink", + "sha256": "db048fb7dc9faf7afa83eb364b92fa3ef46d687355c9be13ba874c4ad277f5cc", + "sha256_in_prefix": "db048fb7dc9faf7afa83eb364b92fa3ef46d687355c9be13ba874c4ad277f5cc", + "size_in_bytes": 3188 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/commands/install.py", + "path_type": "hardlink", + "sha256": "5710ddf810f76b6ec0a5e13638adf8adf0574ba668db0b5e98af7e1c2c0fab13", + "sha256_in_prefix": "5710ddf810f76b6ec0a5e13638adf8adf0574ba668db0b5e98af7e1c2c0fab13", + "size_in_bytes": 28782 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/commands/list.py", + "path_type": "hardlink", + "sha256": "ef0454526772c8e92797e59961b3bf2ed150c47956a1dde98ce63dc981f8df9a", + "sha256_in_prefix": "ef0454526772c8e92797e59961b3bf2ed150c47956a1dde98ce63dc981f8df9a", + "size_in_bytes": 12450 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/commands/search.py", + "path_type": "hardlink", + "sha256": "b1b059880451734e7442ab8e29c0af3abd8add72eca1879b2ca646462fff8942", + "sha256_in_prefix": "b1b059880451734e7442ab8e29c0af3abd8add72eca1879b2ca646462fff8942", + "size_in_bytes": 5697 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/commands/show.py", + "path_type": "hardlink", + "sha256": "b798e26b8cdc609449672e14fd5a27ef3325d378499a67287e3ea80cd4e78fb6", + "sha256_in_prefix": "b798e26b8cdc609449672e14fd5a27ef3325d378499a67287e3ea80cd4e78fb6", + "size_in_bytes": 6419 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/commands/uninstall.py", + "path_type": "hardlink", + "sha256": "388a8ef6da9a758f243381f08457f543ad9f508a7bbfc283ad3468f3258ccfb6", + "sha256_in_prefix": "388a8ef6da9a758f243381f08457f543ad9f508a7bbfc283ad3468f3258ccfb6", + "size_in_bytes": 3886 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/commands/wheel.py", + "path_type": "hardlink", + "sha256": "0929d7f0f99fd683c29ddee3edb9f5fdfe7c1bd28736201b96f549e73ca437e0", + "sha256_in_prefix": "0929d7f0f99fd683c29ddee3edb9f5fdfe7c1bd28736201b96f549e73ca437e0", + "size_in_bytes": 6476 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/configuration.py", + "path_type": "hardlink", + "sha256": "5e4022052d21a73b0cf8b17442ee61bcf58efc1b3aefea1029160506e31b112b", + "sha256_in_prefix": "5e4022052d21a73b0cf8b17442ee61bcf58efc1b3aefea1029160506e31b112b", + "size_in_bytes": 14006 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/distributions/__init__.py", + "path_type": "hardlink", + "sha256": "1eaea4b7a8170608cd8ade614d358b03378234e2a807e374a46612a9e86b962f", + "sha256_in_prefix": "1eaea4b7a8170608cd8ade614d358b03378234e2a807e374a46612a9e86b962f", + "size_in_bytes": 858 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/distributions/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "607f0986956a297871cce6a6294892e27687408ad6a83cbd2f8dbecaf38d4dc0", + "sha256_in_prefix": "607f0986956a297871cce6a6294892e27687408ad6a83cbd2f8dbecaf38d4dc0", + "size_in_bytes": 761 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/distributions/__pycache__/base.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "45767910a2be775bb07beef7b13d3139fd61b8aaa673117bab4afaeaabd4a157", + "sha256_in_prefix": "45767910a2be775bb07beef7b13d3139fd61b8aaa673117bab4afaeaabd4a157", + "size_in_bytes": 2443 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/distributions/__pycache__/installed.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "0bf93a8b94deec8946e4eefdbff0cd3ac09868a0b7202827bf72850bf53dad17", + "sha256_in_prefix": "0bf93a8b94deec8946e4eefdbff0cd3ac09868a0b7202827bf72850bf53dad17", + "size_in_bytes": 1445 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/distributions/__pycache__/sdist.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "33263ebfe42dd4bf4c049010e596d4d506a4fbe43fb7f22d28d108c452065d56", + "sha256_in_prefix": "33263ebfe42dd4bf4c049010e596d4d506a4fbe43fb7f22d28d108c452065d56", + "size_in_bytes": 5248 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/distributions/__pycache__/wheel.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "1cfd215afa0017eef4589b5f56a706a1bd17fc7fc93d959e58f483b770b2ab10", + "sha256_in_prefix": "1cfd215afa0017eef4589b5f56a706a1bd17fc7fc93d959e58f483b770b2ab10", + "size_in_bytes": 1810 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/distributions/base.py", + "path_type": "hardlink", + "sha256": "a11484be7bf66630676ab81a9a7bf67dc25ad67ea050329a5b483a096484a56b", + "sha256_in_prefix": "a11484be7bf66630676ab81a9a7bf67dc25ad67ea050329a5b483a096484a56b", + "size_in_bytes": 1743 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/distributions/installed.py", + "path_type": "hardlink", + "sha256": "4229c715b58043ca04d296c3f0c1595a4c259df5354184dc700d6f9e1ae560e5", + "sha256_in_prefix": "4229c715b58043ca04d296c3f0c1595a4c259df5354184dc700d6f9e1ae560e5", + "size_in_bytes": 842 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/distributions/sdist.py", + "path_type": "hardlink", + "sha256": "e0add5d1534c9651db07308989b8f077fb729542a998876ed8043286996f090a", + "sha256_in_prefix": "e0add5d1534c9651db07308989b8f077fb729542a998876ed8043286996f090a", + "size_in_bytes": 6709 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/distributions/wheel.py", + "path_type": "hardlink", + "sha256": "fa66b7b0eb54423d00c570846fafc58668e5de78789370341c2dad6806f637ee", + "sha256_in_prefix": "fa66b7b0eb54423d00c570846fafc58668e5de78789370341c2dad6806f637ee", + "size_in_bytes": 1277 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/exceptions.py", + "path_type": "hardlink", + "sha256": "4e617588d1449de49669e9b0960e9ae5ba4fbaad9c3072bb775f92be3b101dbd", + "sha256_in_prefix": "4e617588d1449de49669e9b0960e9ae5ba4fbaad9c3072bb775f92be3b101dbd", + "size_in_bytes": 23634 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/index/__init__.py", + "path_type": "hardlink", + "sha256": "be9b7e25e4d979f87c6be142db665e0525c555bb817174868882e141925a3694", + "sha256_in_prefix": "be9b7e25e4d979f87c6be142db665e0525c555bb817174868882e141925a3694", + "size_in_bytes": 30 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/index/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "69a390c14c42d321c0914ec949ee92a37b01839659b49ed0d1c0e99bc74fa8b3", + "sha256_in_prefix": "69a390c14c42d321c0914ec949ee92a37b01839659b49ed0d1c0e99bc74fa8b3", + "size_in_bytes": 188 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/index/__pycache__/collector.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "031675c584ab7350ac7c0a35733640bc136e4e4d2385435c122a3a786e16aa1a", + "sha256_in_prefix": "031675c584ab7350ac7c0a35733640bc136e4e4d2385435c122a3a786e16aa1a", + "size_in_bytes": 15273 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/index/__pycache__/package_finder.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "5738cfc23be31a5de5bdc4fb8a6af2219b001e4279afdaccb9cdbe6091732cbd", + "sha256_in_prefix": "5738cfc23be31a5de5bdc4fb8a6af2219b001e4279afdaccb9cdbe6091732cbd", + "size_in_bytes": 29416 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/index/__pycache__/sources.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "31120cdc964f7ea0fb5d580e653e7df00fa5990460714094792074cfc971b99e", + "sha256_in_prefix": "31120cdc964f7ea0fb5d580e653e7df00fa5990460714094792074cfc971b99e", + "size_in_bytes": 8878 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/index/collector.py", + "path_type": "hardlink", + "sha256": "b07d2d2ff70ea0293aa4b2df0921958c5338acf109b65945f95a1bbc0bcb487e", + "sha256_in_prefix": "b07d2d2ff70ea0293aa4b2df0921958c5338acf109b65945f95a1bbc0bcb487e", + "size_in_bytes": 16590 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/index/package_finder.py", + "path_type": "hardlink", + "sha256": "4bf9c2f20cd520c63a8a459f2a848ecd1b687ac52a9df36100f97f07048ebac0", + "sha256_in_prefix": "4bf9c2f20cd520c63a8a459f2a848ecd1b687ac52a9df36100f97f07048ebac0", + "size_in_bytes": 37843 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/index/sources.py", + "path_type": "hardlink", + "sha256": "7497a0891f5ff3a92c95a00772ff7e4792ff5c17f94739bf164c8fb5e0ee3f12", + "sha256_in_prefix": "7497a0891f5ff3a92c95a00772ff7e4792ff5c17f94739bf164c8fb5e0ee3f12", + "size_in_bytes": 8688 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/locations/__init__.py", + "path_type": "hardlink", + "sha256": "0e1f0b2561bc2d19432b82488fdb1f445f7a4d113313ef8dfc0225c7b4eaa1ee", + "sha256_in_prefix": "0e1f0b2561bc2d19432b82488fdb1f445f7a4d113313ef8dfc0225c7b4eaa1ee", + "size_in_bytes": 15365 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/locations/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "543771607cf9710fc2840954e4f175764d55b1a5c11ccd3dbe3a8149267905eb", + "sha256_in_prefix": "543771607cf9710fc2840954e4f175764d55b1a5c11ccd3dbe3a8149267905eb", + "size_in_bytes": 10990 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/locations/__pycache__/_distutils.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "fa829cee9ea8c494818bc21dc0d0251590e30367ca7bcbdacfb3e2302bf43b41", + "sha256_in_prefix": "fa829cee9ea8c494818bc21dc0d0251590e30367ca7bcbdacfb3e2302bf43b41", + "size_in_bytes": 4555 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/locations/__pycache__/_sysconfig.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "e03191cb83e2edab66ef78200e6296d2d7c182046590ebb6dd2c15d610600f64", + "sha256_in_prefix": "e03191cb83e2edab66ef78200e6296d2d7c182046590ebb6dd2c15d610600f64", + "size_in_bytes": 5954 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/locations/__pycache__/base.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "cbcb41a5a229afd88823cf487064f10a7a4b2fd15faf070ae5e6da6e83ca3783", + "sha256_in_prefix": "cbcb41a5a229afd88823cf487064f10a7a4b2fd15faf070ae5e6da6e83ca3783", + "size_in_bytes": 2358 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/locations/_distutils.py", + "path_type": "hardlink", + "sha256": "1fd6472bfdf9add0d5d50b268b841e68150b8c54f831bbba42ea151a427a4072", + "sha256_in_prefix": "1fd6472bfdf9add0d5d50b268b841e68150b8c54f831bbba42ea151a427a4072", + "size_in_bytes": 6009 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/locations/_sysconfig.py", + "path_type": "hardlink", + "sha256": "8f2355b547cc21fd26b7263e5e9d66f7243c8b0102a334955459a390df5adb2c", + "sha256_in_prefix": "8f2355b547cc21fd26b7263e5e9d66f7243c8b0102a334955459a390df5adb2c", + "size_in_bytes": 7680 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/locations/base.py", + "path_type": "hardlink", + "sha256": "45088f8b5778155336071934e1d4215d9d8faa47a58c42f67d967d498a8843bf", + "sha256_in_prefix": "45088f8b5778155336071934e1d4215d9d8faa47a58c42f67d967d498a8843bf", + "size_in_bytes": 2556 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/main.py", + "path_type": "hardlink", + "sha256": "afe52751ef072e8e57149cfc8a74dc38e4e2bbfb313618076fa57094652594e2", + "sha256_in_prefix": "afe52751ef072e8e57149cfc8a74dc38e4e2bbfb313618076fa57094652594e2", + "size_in_bytes": 340 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/metadata/__init__.py", + "path_type": "hardlink", + "sha256": "f695375b7b3ee87b6316e62159c2d36159926b38a494fbfb936c7ca7b5f51a60", + "sha256_in_prefix": "f695375b7b3ee87b6316e62159c2d36159926b38a494fbfb936c7ca7b5f51a60", + "size_in_bytes": 4339 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/metadata/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "861964f842ddfa556d5de1ea9a3e609533707091361d3602e05fb9433d58107c", + "sha256_in_prefix": "861964f842ddfa556d5de1ea9a3e609533707091361d3602e05fb9433d58107c", + "size_in_bytes": 4765 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/metadata/__pycache__/_json.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "33054b9763411f70c08e133a84b4c6e5925a4ffefa2fcdb7636dd8c6500f947d", + "sha256_in_prefix": "33054b9763411f70c08e133a84b4c6e5925a4ffefa2fcdb7636dd8c6500f947d", + "size_in_bytes": 2148 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/metadata/__pycache__/base.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "f14cbca4dfda836981fd3260e4ae7222b89e173d50250a310f750c267530de0a", + "sha256_in_prefix": "f14cbca4dfda836981fd3260e4ae7222b89e173d50250a310f750c267530de0a", + "size_in_bytes": 27293 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/metadata/__pycache__/pkg_resources.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "43550af0a83b9ab255b0ede77cce1a683edc02b83fdf2de2eca92f09bfc9d423", + "sha256_in_prefix": "43550af0a83b9ab255b0ede77cce1a683edc02b83fdf2de2eca92f09bfc9d423", + "size_in_bytes": 10575 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/metadata/_json.py", + "path_type": "hardlink", + "sha256": "473e4ce5c89236f213c1a4d047a35f37c4e02a033959f4f0b380fa085927a2f1", + "sha256_in_prefix": "473e4ce5c89236f213c1a4d047a35f37c4e02a033959f4f0b380fa085927a2f1", + "size_in_bytes": 2627 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/metadata/base.py", + "path_type": "hardlink", + "sha256": "9775a092ee31960afcb38a7a7d2fb7a90e1028ea4f6d62d1c22e5df68984146e", + "sha256_in_prefix": "9775a092ee31960afcb38a7a7d2fb7a90e1028ea4f6d62d1c22e5df68984146e", + "size_in_bytes": 25907 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/metadata/importlib/__init__.py", + "path_type": "hardlink", + "sha256": "8d4522768c671dc7c84c71da0161b51b68b97dd058925bffb89723a36c7b5581", + "sha256_in_prefix": "8d4522768c671dc7c84c71da0161b51b68b97dd058925bffb89723a36c7b5581", + "size_in_bytes": 135 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/metadata/importlib/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "52dd6c236e1b15c4a1938cb7ae38a49bbf53f0322cb688200cd45b49a5a4b1c0", + "sha256_in_prefix": "52dd6c236e1b15c4a1938cb7ae38a49bbf53f0322cb688200cd45b49a5a4b1c0", + "size_in_bytes": 309 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/metadata/importlib/__pycache__/_compat.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "db84e4886b8d75889e53bca9bfd0698bc74e4d72e74f5e77f7567105dc6eaaf3", + "sha256_in_prefix": "db84e4886b8d75889e53bca9bfd0698bc74e4d72e74f5e77f7567105dc6eaaf3", + "size_in_bytes": 2711 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/metadata/importlib/__pycache__/_dists.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "742292acadd77d850af71d28ad8595ad5dc00fc447f0649faa065ad071263ea1", + "sha256_in_prefix": "742292acadd77d850af71d28ad8595ad5dc00fc447f0649faa065ad071263ea1", + "size_in_bytes": 9017 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/metadata/importlib/__pycache__/_envs.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "9cfddaee4e55bdf1e45415def89eb48e873fdc1763d5628572b107dfe23ce368", + "sha256_in_prefix": "9cfddaee4e55bdf1e45415def89eb48e873fdc1763d5628572b107dfe23ce368", + "size_in_bytes": 7709 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/metadata/importlib/_compat.py", + "path_type": "hardlink", + "sha256": "1807bfa6b21f084e2253296b9ebff67494659240554546ce89d128203ecb3e81", + "sha256_in_prefix": "1807bfa6b21f084e2253296b9ebff67494659240554546ce89d128203ecb3e81", + "size_in_bytes": 1882 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/metadata/importlib/_dists.py", + "path_type": "hardlink", + "sha256": "50f975c14ba316a8b08a5b51275b4c178d9644834ed6c4a934d958436997d269", + "sha256_in_prefix": "50f975c14ba316a8b08a5b51275b4c178d9644834ed6c4a934d958436997d269", + "size_in_bytes": 8297 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/metadata/importlib/_envs.py", + "path_type": "hardlink", + "sha256": "5d36852181113f6245d10519b8fc761138ae8176cf11c67cabc64a7a1b7a2e97", + "sha256_in_prefix": "5d36852181113f6245d10519b8fc761138ae8176cf11c67cabc64a7a1b7a2e97", + "size_in_bytes": 7456 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/metadata/pkg_resources.py", + "path_type": "hardlink", + "sha256": "a298f0e08052a87be27bab1727f71b4f8da67b28283c451f354449b96658eec9", + "sha256_in_prefix": "a298f0e08052a87be27bab1727f71b4f8da67b28283c451f354449b96658eec9", + "size_in_bytes": 10035 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/models/__init__.py", + "path_type": "hardlink", + "sha256": "dc31d477fab1a4fa337f3a2ea2a6bd83db6cd42cebe6a6877c5c5b9f1ae27a93", + "sha256_in_prefix": "dc31d477fab1a4fa337f3a2ea2a6bd83db6cd42cebe6a6877c5c5b9f1ae27a93", + "size_in_bytes": 63 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/models/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "b63a6402d5bb5d36abe55dba13dcd58db1069e4c21aa45885f05aa53f4822309", + "sha256_in_prefix": "b63a6402d5bb5d36abe55dba13dcd58db1069e4c21aa45885f05aa53f4822309", + "size_in_bytes": 222 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/models/__pycache__/candidate.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "8c994d8dbc021a43ddc837e99370390d8c83b1d1b31067b73b5f00508d01537b", + "sha256_in_prefix": "8c994d8dbc021a43ddc837e99370390d8c83b1d1b31067b73b5f00508d01537b", + "size_in_bytes": 1400 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/models/__pycache__/direct_url.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "f5588aab47ecf0ea704cb9d1320eb6599c2417fa5272cebc5fb2fb4feab42f1c", + "sha256_in_prefix": "f5588aab47ecf0ea704cb9d1320eb6599c2417fa5272cebc5fb2fb4feab42f1c", + "size_in_bytes": 7667 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/models/__pycache__/format_control.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "f2e1ca4f858597da147ca52817bc47756d4a328e38b00b96ec80f63231860ede", + "sha256_in_prefix": "f2e1ca4f858597da147ca52817bc47756d4a328e38b00b96ec80f63231860ede", + "size_in_bytes": 2693 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/models/__pycache__/index.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "835ba1d4298335c63321d77db00da004e6fcecd5fcdad837fa604cb531e8d5f7", + "sha256_in_prefix": "835ba1d4298335c63321d77db00da004e6fcecd5fcdad837fa604cb531e8d5f7", + "size_in_bytes": 1191 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/models/__pycache__/installation_report.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "688171b3b48406bd1ec254678321fad9e2344d6eb79678722a0244817f958591", + "sha256_in_prefix": "688171b3b48406bd1ec254678321fad9e2344d6eb79678722a0244817f958591", + "size_in_bytes": 1712 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/models/__pycache__/link.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "d2c7d1a09f8c51365300e10a03e84bf79da1d95af71f57775d63091d290d50e1", + "sha256_in_prefix": "d2c7d1a09f8c51365300e10a03e84bf79da1d95af71f57775d63091d290d50e1", + "size_in_bytes": 18046 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/models/__pycache__/scheme.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "f81d193dc53abdda00d423c9b2e74f54ad6fa6b0e6f4b5215e43ed7419fca2ba", + "sha256_in_prefix": "f81d193dc53abdda00d423c9b2e74f54ad6fa6b0e6f4b5215e43ed7419fca2ba", + "size_in_bytes": 990 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/models/__pycache__/search_scope.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "ec3186710a3870fdd89b70b39e509e2ad9ec7752cfbe9e4ee9f8c08556749a50", + "sha256_in_prefix": "ec3186710a3870fdd89b70b39e509e2ad9ec7752cfbe9e4ee9f8c08556749a50", + "size_in_bytes": 3509 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/models/__pycache__/selection_prefs.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "b224a792d03a0d3e4949c355ae83f2a8f63f51dba0d29c3e535ca1f79db4bf74", + "sha256_in_prefix": "b224a792d03a0d3e4949c355ae83f2a8f63f51dba0d29c3e535ca1f79db4bf74", + "size_in_bytes": 1652 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/models/__pycache__/target_python.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "285aaceef8becf406f632f4c52cba58697f3c116b491fec5033a0a498cf16a8a", + "sha256_in_prefix": "285aaceef8becf406f632f4c52cba58697f3c116b491fec5033a0a498cf16a8a", + "size_in_bytes": 3769 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/models/__pycache__/wheel.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "da2a4373cc919f36f630959b0c312336f4414c58d772bc4da11ab50de41de8cb", + "sha256_in_prefix": "da2a4373cc919f36f630959b0c312336f4414c58d772bc4da11ab50de41de8cb", + "size_in_bytes": 4422 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/models/candidate.py", + "path_type": "hardlink", + "sha256": "8443eef15746139a95012bfabcbcfe47e460879fbb2cc6da8b58e0b6130277c3", + "sha256_in_prefix": "8443eef15746139a95012bfabcbcfe47e460879fbb2cc6da8b58e0b6130277c3", + "size_in_bytes": 931 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/models/direct_url.py", + "path_type": "hardlink", + "sha256": "170a2e60129ca9c921ec1fa4d87dc75604618454ee905c2a892de47efb452d29", + "sha256_in_prefix": "170a2e60129ca9c921ec1fa4d87dc75604618454ee905c2a892de47efb452d29", + "size_in_bytes": 6889 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/models/format_control.py", + "path_type": "hardlink", + "sha256": "c2db10a922bd1da522371404b81f82eb67958a6c3a1b8fd5405c55f7efca0c11", + "sha256_in_prefix": "c2db10a922bd1da522371404b81f82eb67958a6c3a1b8fd5405c55f7efca0c11", + "size_in_bytes": 2486 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/models/index.py", + "path_type": "hardlink", + "sha256": "b589cbf28c468b8692356babd261bc0c03fbac2eb2ba16bf33024ef31c3472b2", + "sha256_in_prefix": "b589cbf28c468b8692356babd261bc0c03fbac2eb2ba16bf33024ef31c3472b2", + "size_in_bytes": 1030 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/models/installation_report.py", + "path_type": "hardlink", + "sha256": "cd1559a1acfedafb2b7b38ff1f784b3a131908af5ced36f35a00be8ce6a50f4d", + "sha256_in_prefix": "cd1559a1acfedafb2b7b38ff1f784b3a131908af5ced36f35a00be8ce6a50f4d", + "size_in_bytes": 2818 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/models/link.py", + "path_type": "hardlink", + "sha256": "5e2ace006bf58e032eeefbbcee4b8f6e88468fb547a7056b776ab729481540d8", + "sha256_in_prefix": "5e2ace006bf58e032eeefbbcee4b8f6e88468fb547a7056b776ab729481540d8", + "size_in_bytes": 20777 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/models/scheme.py", + "path_type": "hardlink", + "sha256": "dc4150a7f202bbfb211f5f9306a865d1002eb0a08f0c53a580715e3785e8c16b", + "sha256_in_prefix": "dc4150a7f202bbfb211f5f9306a865d1002eb0a08f0c53a580715e3785e8c16b", + "size_in_bytes": 738 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/models/search_scope.py", + "path_type": "hardlink", + "sha256": "012572c99c622482f0edb4c8555a49c7c276f773371e4e45df78a51a7d1ef347", + "sha256_in_prefix": "012572c99c622482f0edb4c8555a49c7c276f773371e4e45df78a51a7d1ef347", + "size_in_bytes": 4643 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/models/selection_prefs.py", + "path_type": "hardlink", + "sha256": "299762eba82c47efd151752bf6e7a3b2c937ae64c7ad054959e340dac57e5526", + "sha256_in_prefix": "299762eba82c47efd151752bf6e7a3b2c937ae64c7ad054959e340dac57e5526", + "size_in_bytes": 1907 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/models/target_python.py", + "path_type": "hardlink", + "sha256": "df8124a2baccb91bd1a7e6e3a87289f9b38eef59bdc5d8cdd9bf16585102d875", + "sha256_in_prefix": "df8124a2baccb91bd1a7e6e3a87289f9b38eef59bdc5d8cdd9bf16585102d875", + "size_in_bytes": 4272 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/models/wheel.py", + "path_type": "hardlink", + "sha256": "62a6b3a0867299afd0d5e8c56b50bb3472904515a5bd691d2bde9544a98305e2", + "sha256_in_prefix": "62a6b3a0867299afd0d5e8c56b50bb3472904515a5bd691d2bde9544a98305e2", + "size_in_bytes": 3600 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/network/__init__.py", + "path_type": "hardlink", + "sha256": "8dfe93b799d5ffbce401106b2a88c85c8b607a3be87a054954a51b8406b92287", + "sha256_in_prefix": "8dfe93b799d5ffbce401106b2a88c85c8b607a3be87a054954a51b8406b92287", + "size_in_bytes": 50 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/network/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "7193bd2d2a5b393102335fd35bb849ef8a121d15781877bdd089f76a5985baa2", + "sha256_in_prefix": "7193bd2d2a5b393102335fd35bb849ef8a121d15781877bdd089f76a5985baa2", + "size_in_bytes": 210 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/network/__pycache__/auth.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "38d5dcfdfd0166d6c5dcb3f9127c2c9d8460e68a830a3adda7c01119bd6bfe50", + "sha256_in_prefix": "38d5dcfdfd0166d6c5dcb3f9127c2c9d8460e68a830a3adda7c01119bd6bfe50", + "size_in_bytes": 14381 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/network/__pycache__/cache.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "a1902bc95cee60a60eaa5f91051315807c047270f1b7e2d775308f84197bb365", + "sha256_in_prefix": "a1902bc95cee60a60eaa5f91051315807c047270f1b7e2d775308f84197bb365", + "size_in_bytes": 4548 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/network/__pycache__/download.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "6c7940db8a0a68e655a0b3cad422ac5ee8da7a0ae6ba5b5469eb4fb890adb04a", + "sha256_in_prefix": "6c7940db8a0a68e655a0b3cad422ac5ee8da7a0ae6ba5b5469eb4fb890adb04a", + "size_in_bytes": 5486 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/network/__pycache__/lazy_wheel.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "117f6267c73f72411e6f5e7b906354c005e96b6786c8573da75ee77396da4f26", + "sha256_in_prefix": "117f6267c73f72411e6f5e7b906354c005e96b6786c8573da75ee77396da4f26", + "size_in_bytes": 8378 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/network/__pycache__/session.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "0a7da29c11d541ea861493b4fe2ecc28c8743facdc8ba37890b0153c455b3a95", + "sha256_in_prefix": "0a7da29c11d541ea861493b4fe2ecc28c8743facdc8ba37890b0153c455b3a95", + "size_in_bytes": 12479 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/network/__pycache__/utils.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "2d5734c8527604d6523a8068389af38a5135cae30aa3e515067d0e5d7cba479d", + "sha256_in_prefix": "2d5734c8527604d6523a8068389af38a5135cae30aa3e515067d0e5d7cba479d", + "size_in_bytes": 1413 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/network/__pycache__/xmlrpc.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "224acec9948602bb36268d90a56f08ac4196c835017ce92a3f7602294f189a2b", + "sha256_in_prefix": "224acec9948602bb36268d90a56f08ac4196c835017ce92a3f7602294f189a2b", + "size_in_bytes": 2066 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/network/auth.py", + "path_type": "hardlink", + "sha256": "4c2f8e716d8a5385ba475854e2a3e0417bd51f9e1a7400a9673eac5aaf91f4d0", + "sha256_in_prefix": "4c2f8e716d8a5385ba475854e2a3e0417bd51f9e1a7400a9673eac5aaf91f4d0", + "size_in_bytes": 20541 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/network/cache.py", + "path_type": "hardlink", + "sha256": "e3c03def5a82cca345be46f9eee18493bfb4c5aa8f4b41d68f6ef5d50353c645", + "sha256_in_prefix": "e3c03def5a82cca345be46f9eee18493bfb4c5aa8f4b41d68f6ef5d50353c645", + "size_in_bytes": 3935 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/network/download.py", + "path_type": "hardlink", + "sha256": "8b44e7e79083e43ed7604158dd3c6261a09fd0e69a4d0e9249c3600ac49e575e", + "sha256_in_prefix": "8b44e7e79083e43ed7604158dd3c6261a09fd0e69a4d0e9249c3600ac49e575e", + "size_in_bytes": 6086 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/network/lazy_wheel.py", + "path_type": "hardlink", + "sha256": "d8f5d576e6193c23d99244057b527519b7c725678253ef855e89c6c887f0f5e5", + "sha256_in_prefix": "d8f5d576e6193c23d99244057b527519b7c725678253ef855e89c6c887f0f5e5", + "size_in_bytes": 7638 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/network/session.py", + "path_type": "hardlink", + "sha256": "f6da840c3f0989568576994e117271368f5c8d17c167a4486b4c9043fa813623", + "sha256_in_prefix": "f6da840c3f0989568576994e117271368f5c8d17c167a4486b4c9043fa813623", + "size_in_bytes": 18698 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/network/utils.py", + "path_type": "hardlink", + "sha256": "e80e52ad42441141f16c6b5bb1cc14d8da42cb3fb7ced883946587a51461b09f", + "sha256_in_prefix": "e80e52ad42441141f16c6b5bb1cc14d8da42cb3fb7ced883946587a51461b09f", + "size_in_bytes": 4073 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/network/xmlrpc.py", + "path_type": "hardlink", + "sha256": "b00c7339a709f8dd4d5c63ef6a9f630b7cee6164a79efdc65ed811dbe13600f0", + "sha256_in_prefix": "b00c7339a709f8dd4d5c63ef6a9f630b7cee6164a79efdc65ed811dbe13600f0", + "size_in_bytes": 1838 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/operations/__init__.py", + "path_type": "hardlink", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size_in_bytes": 0 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/operations/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "3edfe6f0441b3faadd64890f7ae7a90450d919b86c9ce2efb7ee0babbd9f47cd", + "sha256_in_prefix": "3edfe6f0441b3faadd64890f7ae7a90450d919b86c9ce2efb7ee0babbd9f47cd", + "size_in_bytes": 158 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/operations/__pycache__/check.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "0bb4166bce96f9a65dd3b1500f8f286623b1a320cf4e7333ebc22081ee610847", + "sha256_in_prefix": "0bb4166bce96f9a65dd3b1500f8f286623b1a320cf4e7333ebc22081ee610847", + "size_in_bytes": 5162 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/operations/__pycache__/freeze.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "9febdfa46bd06b5ed9b424ecdecb889ac426f385078457db7a627863b591499a", + "sha256_in_prefix": "9febdfa46bd06b5ed9b424ecdecb889ac426f385078457db7a627863b591499a", + "size_in_bytes": 6179 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/operations/__pycache__/prepare.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "e57bf3dd5fae30e0b1ff8872a9e7c28acf4a09b7c9aa23953beec67ceb4f7b51", + "sha256_in_prefix": "e57bf3dd5fae30e0b1ff8872a9e7c28acf4a09b7c9aa23953beec67ceb4f7b51", + "size_in_bytes": 15616 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/operations/build/__init__.py", + "path_type": "hardlink", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size_in_bytes": 0 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/operations/build/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "deffa7a31f32811c6b017e3a5a6bc36dd664cea6b0a9cb939b1f161aa55f7886", + "sha256_in_prefix": "deffa7a31f32811c6b017e3a5a6bc36dd664cea6b0a9cb939b1f161aa55f7886", + "size_in_bytes": 164 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/operations/build/__pycache__/build_tracker.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c3500c082ce86867760da3a4f1c1e1562bcf695a83d8d2a9210fba3b43bec99f", + "sha256_in_prefix": "c3500c082ce86867760da3a4f1c1e1562bcf695a83d8d2a9210fba3b43bec99f", + "size_in_bytes": 5014 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/operations/build/__pycache__/metadata.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "bfdfe79a65289f97135d7c3800bafa089cf100b01078812c3f377f3a3a27d64c", + "sha256_in_prefix": "bfdfe79a65289f97135d7c3800bafa089cf100b01078812c3f377f3a3a27d64c", + "size_in_bytes": 1397 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/operations/build/__pycache__/metadata_editable.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "6ed16244ad15b705fc80682798314fa7267ed548ab9f9f0405fdb35a6dc7afbd", + "sha256_in_prefix": "6ed16244ad15b705fc80682798314fa7267ed548ab9f9f0405fdb35a6dc7afbd", + "size_in_bytes": 1431 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/operations/build/__pycache__/metadata_legacy.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "fc5160452eb3c3b11d3db4fe68a24b0c7cbad60c0734a9f173678c5a69c5290c", + "sha256_in_prefix": "fc5160452eb3c3b11d3db4fe68a24b0c7cbad60c0734a9f173678c5a69c5290c", + "size_in_bytes": 2336 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/operations/build/__pycache__/wheel.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "4338cbd96b0d7b010ae02cbc17f5de3acd1aa89e0bf13c9411cd606f2cabdf36", + "sha256_in_prefix": "4338cbd96b0d7b010ae02cbc17f5de3acd1aa89e0bf13c9411cd606f2cabdf36", + "size_in_bytes": 1187 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/operations/build/__pycache__/wheel_editable.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "541aa76ee61e6d688137f9ce550d77e2d56b40f739db8df300ccceb29f3adeb5", + "sha256_in_prefix": "541aa76ee61e6d688137f9ce550d77e2d56b40f739db8df300ccceb29f3adeb5", + "size_in_bytes": 1411 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/operations/build/__pycache__/wheel_legacy.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "fc02ba223b559b86d050cc77901bb1dd5e7860df9a07f335c1d68f0a1eab5e8f", + "sha256_in_prefix": "fc02ba223b559b86d050cc77901bb1dd5e7860df9a07f335c1d68f0a1eab5e8f", + "size_in_bytes": 2721 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/operations/build/build_tracker.py", + "path_type": "hardlink", + "sha256": "cfe1f90ce92765d05addd87656ae9504c639a8b6082a6963da9e821992b92dcf", + "sha256_in_prefix": "cfe1f90ce92765d05addd87656ae9504c639a8b6082a6963da9e821992b92dcf", + "size_in_bytes": 4832 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/operations/build/metadata.py", + "path_type": "hardlink", + "sha256": "f52d02503f14dd0a99797a7e672b7c1f1c14f74944e10ae760382ba990f30677", + "sha256_in_prefix": "f52d02503f14dd0a99797a7e672b7c1f1c14f74944e10ae760382ba990f30677", + "size_in_bytes": 1422 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/operations/build/metadata_editable.py", + "path_type": "hardlink", + "sha256": "54b2fb2ef9ed284f2ac5d854744261728b45cd4b0e488f0d352d38df150b29ec", + "sha256_in_prefix": "54b2fb2ef9ed284f2ac5d854744261728b45cd4b0e488f0d352d38df150b29ec", + "size_in_bytes": 1474 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/operations/build/metadata_legacy.py", + "path_type": "hardlink", + "sha256": "a3e794db502cd7be610c2edd96e3357c927f16aa244c84a1c96a6329a2291d9c", + "sha256_in_prefix": "a3e794db502cd7be610c2edd96e3357c927f16aa244c84a1c96a6329a2291d9c", + "size_in_bytes": 2198 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/operations/build/wheel.py", + "path_type": "hardlink", + "sha256": "b13d761412c0c430bac32ac3a2b87c92f719d631b9a889c2456cf33fe5242624", + "sha256_in_prefix": "b13d761412c0c430bac32ac3a2b87c92f719d631b9a889c2456cf33fe5242624", + "size_in_bytes": 1075 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/operations/build/wheel_editable.py", + "path_type": "hardlink", + "sha256": "c8eb681face9024a0a60452dafc161ceb62790d1d0690063590d8761a7b53108", + "sha256_in_prefix": "c8eb681face9024a0a60452dafc161ceb62790d1d0690063590d8761a7b53108", + "size_in_bytes": 1417 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/operations/build/wheel_legacy.py", + "path_type": "hardlink", + "sha256": "0bd8faaee920408d67fc97902e8646b8375f530cc25d287221d3d3a7a79d6cc4", + "sha256_in_prefix": "0bd8faaee920408d67fc97902e8646b8375f530cc25d287221d3d3a7a79d6cc4", + "size_in_bytes": 3064 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/operations/check.py", + "path_type": "hardlink", + "sha256": "7eca80f3c8866aa7ed0abdad94fdec494db4d824a4a0e0d1b56d0ef8953d3386", + "sha256_in_prefix": "7eca80f3c8866aa7ed0abdad94fdec494db4d824a4a0e0d1b56d0ef8953d3386", + "size_in_bytes": 6806 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/operations/freeze.py", + "path_type": "hardlink", + "sha256": "baaa1e4c07fa1ce615311d948004fc37ce54668184544a1075a9ff028e9239f9", + "sha256_in_prefix": "baaa1e4c07fa1ce615311d948004fc37ce54668184544a1075a9ff028e9239f9", + "size_in_bytes": 9816 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/operations/install/__init__.py", + "path_type": "hardlink", + "sha256": "997ee1c83d863413b69851a8903437d2bfc65efed8fcf2ddb71714bf5e387beb", + "sha256_in_prefix": "997ee1c83d863413b69851a8903437d2bfc65efed8fcf2ddb71714bf5e387beb", + "size_in_bytes": 51 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/operations/install/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "e52d15037251ac1b7b23e35816a2ab88e64476c54652b0c3341ac9f9f8a8197c", + "sha256_in_prefix": "e52d15037251ac1b7b23e35816a2ab88e64476c54652b0c3341ac9f9f8a8197c", + "size_in_bytes": 222 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/operations/install/__pycache__/editable_legacy.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c9fba6d325dae3d4ffc59a8c2e0d42e378ecf53447602d561a7c5030489d3912", + "sha256_in_prefix": "c9fba6d325dae3d4ffc59a8c2e0d42e378ecf53447602d561a7c5030489d3912", + "size_in_bytes": 1451 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/operations/install/__pycache__/wheel.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "6de7598fd3fb920cb145785b203d8449e558e421e9798089c8821f73329a56f4", + "sha256_in_prefix": "6de7598fd3fb920cb145785b203d8449e558e421e9798089c8821f73329a56f4", + "size_in_bytes": 21270 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/operations/install/editable_legacy.py", + "path_type": "hardlink", + "sha256": "61e47429a7565f0fd985e0b536d006d6a5481243a04461dcdb7c7e62d196ecd5", + "sha256_in_prefix": "61e47429a7565f0fd985e0b536d006d6a5481243a04461dcdb7c7e62d196ecd5", + "size_in_bytes": 1282 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/operations/install/wheel.py", + "path_type": "hardlink", + "sha256": "f6119bd5ce1b4673c86f6146ec2b5448f7cfc6aa6b987401b702009563cd4ed1", + "sha256_in_prefix": "f6119bd5ce1b4673c86f6146ec2b5448f7cfc6aa6b987401b702009563cd4ed1", + "size_in_bytes": 27311 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/operations/prepare.py", + "path_type": "hardlink", + "sha256": "e7b3aaf3b1dfba75f745baa9e3b15d689afd7076c02949bfde0bfb5a1040a9b1", + "sha256_in_prefix": "e7b3aaf3b1dfba75f745baa9e3b15d689afd7076c02949bfde0bfb5a1040a9b1", + "size_in_bytes": 28128 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/pyproject.py", + "path_type": "hardlink", + "sha256": "e17b33a75d7182bd76eb2cc6e816c9034a1a43d597ba16f48f251bfb2ffa94f4", + "sha256_in_prefix": "e17b33a75d7182bd76eb2cc6e816c9034a1a43d597ba16f48f251bfb2ffa94f4", + "size_in_bytes": 7152 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/req/__init__.py", + "path_type": "hardlink", + "sha256": "4c42c58193a87f796132668809558bf54ecf9615e8f4eb9fa246cc009e89d862", + "sha256_in_prefix": "4c42c58193a87f796132668809558bf54ecf9615e8f4eb9fa246cc009e89d862", + "size_in_bytes": 2738 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/req/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "b421ef150fd0b4c8f615c561263cb81a118d80dad55cef4d268a8029980b4690", + "sha256_in_prefix": "b421ef150fd0b4c8f615c561263cb81a118d80dad55cef4d268a8029980b4690", + "size_in_bytes": 2527 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/req/__pycache__/constructors.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "9ee65f3a993829d198ec85ede228bdeb065ef9d2e4a710f9472489007ccc42c9", + "sha256_in_prefix": "9ee65f3a993829d198ec85ede228bdeb065ef9d2e4a710f9472489007ccc42c9", + "size_in_bytes": 14111 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/req/__pycache__/req_file.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "6eb0738d5af2eed7ebb8403cdf95302c19b0bf65f8456ac7b869a712f2f6131c", + "sha256_in_prefix": "6eb0738d5af2eed7ebb8403cdf95302c19b0bf65f8456ac7b869a712f2f6131c", + "size_in_bytes": 13955 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/req/__pycache__/req_install.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "1e8b50ecbda0e2c2a0b26d60559b61961efd03edb99a26127ed8da469cfdd67d", + "sha256_in_prefix": "1e8b50ecbda0e2c2a0b26d60559b61961efd03edb99a26127ed8da469cfdd67d", + "size_in_bytes": 24478 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/req/__pycache__/req_set.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "625c7d0f1fe8d34856611ade9bf85c224f56c6e2f3ef60111a1c4fd415749f1d", + "sha256_in_prefix": "625c7d0f1fe8d34856611ade9bf85c224f56c6e2f3ef60111a1c4fd415749f1d", + "size_in_bytes": 5180 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/req/__pycache__/req_uninstall.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "32a450d8da2e064abb37b19a57b905c8d81fc9205596a0d46072f75d3fcfca67", + "sha256_in_prefix": "32a450d8da2e064abb37b19a57b905c8d81fc9205596a0d46072f75d3fcfca67", + "size_in_bytes": 19192 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/req/constructors.py", + "path_type": "hardlink", + "sha256": "f21958e7a8a612d84b3914709a5a322b3dd83b25f298868ab0d07a3fd7b0bcd2", + "sha256_in_prefix": "f21958e7a8a612d84b3914709a5a322b3dd83b25f298868ab0d07a3fd7b0bcd2", + "size_in_bytes": 19018 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/req/req_file.py", + "path_type": "hardlink", + "sha256": "33cb6d3992fe3f0023eec70f125856dd90f68620fd9a6ffa14900621bc00cc42", + "sha256_in_prefix": "33cb6d3992fe3f0023eec70f125856dd90f68620fd9a6ffa14900621bc00cc42", + "size_in_bytes": 17790 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/req/req_install.py", + "path_type": "hardlink", + "sha256": "c2d38fc64c9148cf1ca264e4b3ca0bd46a76a321aa6c7ec9c080d1722d9088f9", + "sha256_in_prefix": "c2d38fc64c9148cf1ca264e4b3ca0bd46a76a321aa6c7ec9c080d1722d9088f9", + "size_in_bytes": 35460 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/req/req_set.py", + "path_type": "hardlink", + "sha256": "88c603513a12824c45cab3ff3ab4ed3d2830e1dc234721910e91a8a13a9e0386", + "sha256_in_prefix": "88c603513a12824c45cab3ff3ab4ed3d2830e1dc234721910e91a8a13a9e0386", + "size_in_bytes": 4704 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/req/req_uninstall.py", + "path_type": "hardlink", + "sha256": "9e6bd341a4420b48aefb94f0d1d8e55c98528fa5a6a8746f4f7aa4904742df91", + "sha256_in_prefix": "9e6bd341a4420b48aefb94f0d1d8e55c98528fa5a6a8746f4f7aa4904742df91", + "size_in_bytes": 24551 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/resolution/__init__.py", + "path_type": "hardlink", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size_in_bytes": 0 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/resolution/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "fe5b36bd52bb995f36ec2c92a374b9219be59ca40365d05c5d8d771734010365", + "sha256_in_prefix": "fe5b36bd52bb995f36ec2c92a374b9219be59ca40365d05c5d8d771734010365", + "size_in_bytes": 158 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/resolution/__pycache__/base.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "4c4a736435a6386860a08f167dd3017f82af21984467d3ca43a5acd66e9ae1eb", + "sha256_in_prefix": "4c4a736435a6386860a08f167dd3017f82af21984467d3ca43a5acd66e9ae1eb", + "size_in_bytes": 1010 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/resolution/base.py", + "path_type": "hardlink", + "sha256": "aa59a1df6e520557ef1ba31ef6073936c879b1dc07070cc706ae9a117b4ab0b0", + "sha256_in_prefix": "aa59a1df6e520557ef1ba31ef6073936c879b1dc07070cc706ae9a117b4ab0b0", + "size_in_bytes": 583 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/resolution/legacy/__init__.py", + "path_type": "hardlink", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size_in_bytes": 0 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/resolution/legacy/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "4518bcf0ff7e35d97cd7fb5109cec1fbea799bcd62654aeebabbf108529ed754", + "sha256_in_prefix": "4518bcf0ff7e35d97cd7fb5109cec1fbea799bcd62654aeebabbf108529ed754", + "size_in_bytes": 165 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/resolution/legacy/__pycache__/resolver.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "df6fbb7a7e77a5eee5701d05774f14e5c10ff7c949aee5be1bbb3db5ac01a5b8", + "sha256_in_prefix": "df6fbb7a7e77a5eee5701d05774f14e5c10ff7c949aee5be1bbb3db5ac01a5b8", + "size_in_bytes": 14867 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/resolution/legacy/resolver.py", + "path_type": "hardlink", + "sha256": "5e4db88d0eb61af2ebe0c73b22337faa23bcf2aa740489b35663c8173f502ce1", + "sha256_in_prefix": "5e4db88d0eb61af2ebe0c73b22337faa23bcf2aa740489b35663c8173f502ce1", + "size_in_bytes": 24025 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/resolution/resolvelib/__init__.py", + "path_type": "hardlink", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size_in_bytes": 0 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/resolution/resolvelib/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "44f35f3ed68efa9a7db08477bf84fa65e0e6af23a6f36bd6a9ebdfadfd020cbd", + "sha256_in_prefix": "44f35f3ed68efa9a7db08477bf84fa65e0e6af23a6f36bd6a9ebdfadfd020cbd", + "size_in_bytes": 169 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/resolution/resolvelib/__pycache__/base.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "fcbf0dee0c57812c532d414e03b255d771ff558b08df6665dcaf8f5fec9f2db1", + "sha256_in_prefix": "fcbf0dee0c57812c532d414e03b255d771ff558b08df6665dcaf8f5fec9f2db1", + "size_in_bytes": 6222 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/resolution/resolvelib/__pycache__/candidates.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "f101be2db373f147cc04aaa3c83324a97ea8540081370cd7804b47c15a89f3f2", + "sha256_in_prefix": "f101be2db373f147cc04aaa3c83324a97ea8540081370cd7804b47c15a89f3f2", + "size_in_bytes": 20423 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/resolution/resolvelib/__pycache__/factory.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "14ec9c954dc7fd0f5e94720396e912d79e876194aa66882f57fea8e52f79ca61", + "sha256_in_prefix": "14ec9c954dc7fd0f5e94720396e912d79e876194aa66882f57fea8e52f79ca61", + "size_in_bytes": 21327 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/resolution/resolvelib/__pycache__/found_candidates.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "2cc5a71f2401e61d74e024c9ac63414d60eaca86ec536c9bda36afc4267bfcea", + "sha256_in_prefix": "2cc5a71f2401e61d74e024c9ac63414d60eaca86ec536c9bda36afc4267bfcea", + "size_in_bytes": 4829 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/resolution/resolvelib/__pycache__/provider.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "868b15665a5a3fd4b6745448b382ee58ca57bd927488c7639f4d18f09e42a78b", + "sha256_in_prefix": "868b15665a5a3fd4b6745448b382ee58ca57bd927488c7639f4d18f09e42a78b", + "size_in_bytes": 7897 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/resolution/resolvelib/__pycache__/reporter.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "a997b67a187aa59c7c6eeece5158b7cf64d25b7b3a0236e20a6fe40c9710b4a7", + "sha256_in_prefix": "a997b67a187aa59c7c6eeece5158b7cf64d25b7b3a0236e20a6fe40c9710b4a7", + "size_in_bytes": 3666 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/resolution/resolvelib/__pycache__/requirements.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "581e10b8d4e064bbc58eb15273306d0398e65458c3806c25fe3a7705e1606087", + "sha256_in_prefix": "581e10b8d4e064bbc58eb15273306d0398e65458c3806c25fe3a7705e1606087", + "size_in_bytes": 8181 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/resolution/resolvelib/__pycache__/resolver.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "98ece7d0be667bdd71071645768a9ffb27158dbf5005eec7dae8aafc39940bc2", + "sha256_in_prefix": "98ece7d0be667bdd71071645768a9ffb27158dbf5005eec7dae8aafc39940bc2", + "size_in_bytes": 8714 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/resolution/resolvelib/base.py", + "path_type": "hardlink", + "sha256": "8e0e423a61cb86604828e47ee2ca5d243de3c942d86b505db2a881bb66099c9e", + "sha256_in_prefix": "8e0e423a61cb86604828e47ee2ca5d243de3c942d86b505db2a881bb66099c9e", + "size_in_bytes": 5173 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/resolution/resolvelib/candidates.py", + "path_type": "hardlink", + "sha256": "d7d2a2f753e8f8c4b10649c621f38691a5a415d3b39cdd16fe72afee32f6f0bd", + "sha256_in_prefix": "d7d2a2f753e8f8c4b10649c621f38691a5a415d3b39cdd16fe72afee32f6f0bd", + "size_in_bytes": 21052 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/resolution/resolvelib/factory.py", + "path_type": "hardlink", + "sha256": "beaaa4fa18dc85d85287059575e5b6fc0fb965b94b844fe70bfbf7321cf84af7", + "sha256_in_prefix": "beaaa4fa18dc85d85287059575e5b6fc0fb965b94b844fe70bfbf7321cf84af7", + "size_in_bytes": 32292 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/resolution/resolvelib/found_candidates.py", + "path_type": "hardlink", + "sha256": "86f2f71e86bd55a628faa10e664062d88ab0db9d540f13f3fae30755a5a62e91", + "sha256_in_prefix": "86f2f71e86bd55a628faa10e664062d88ab0db9d540f13f3fae30755a5a62e91", + "size_in_bytes": 5705 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/resolution/resolvelib/provider.py", + "path_type": "hardlink", + "sha256": "e2ddb78af8ebbaa33a84a057d4aa46893b7e3381c68517199c62d5d1cd352bb5", + "sha256_in_prefix": "e2ddb78af8ebbaa33a84a057d4aa46893b7e3381c68517199c62d5d1cd352bb5", + "size_in_bytes": 9824 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/resolution/resolvelib/reporter.py", + "path_type": "hardlink", + "sha256": "6059bd850bf3e031426e365e153439ea14f3dc073e9830671e478d455bcc1cb6", + "sha256_in_prefix": "6059bd850bf3e031426e365e153439ea14f3dc073e9830671e478d455bcc1cb6", + "size_in_bytes": 3100 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/resolution/resolvelib/requirements.py", + "path_type": "hardlink", + "sha256": "fa424e34fd168c37dd4ef040b36bd45cf8009cec8d2011005d8e1bef6a20b4f1", + "sha256_in_prefix": "fa424e34fd168c37dd4ef040b36bd45cf8009cec8d2011005d8e1bef6a20b4f1", + "size_in_bytes": 5696 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/resolution/resolvelib/resolver.py", + "path_type": "hardlink", + "sha256": "9cb24eb15304562da0414549a1414a31901ebb67fb19132318cbcd496cb3d017", + "sha256_in_prefix": "9cb24eb15304562da0414549a1414a31901ebb67fb19132318cbcd496cb3d017", + "size_in_bytes": 12592 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/self_outdated_check.py", + "path_type": "hardlink", + "sha256": "b1ac502c1f14cc816d31272abb2b46d744ce4ec61514943f9a45b5358fb8eb01", + "sha256_in_prefix": "b1ac502c1f14cc816d31272abb2b46d744ce4ec61514943f9a45b5358fb8eb01", + "size_in_bytes": 8378 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/utils/__init__.py", + "path_type": "hardlink", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size_in_bytes": 0 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/utils/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "b57627cc2a69e3999c0a447ddfb08013ee710ac30a356ad729f4eb171bf2e56b", + "sha256_in_prefix": "b57627cc2a69e3999c0a447ddfb08013ee710ac30a356ad729f4eb171bf2e56b", + "size_in_bytes": 153 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/utils/__pycache__/_jaraco_text.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "cc4f5d69d30b17439435715006facc4c818c26236a0dd429e23c700b72c75a5a", + "sha256_in_prefix": "cc4f5d69d30b17439435715006facc4c818c26236a0dd429e23c700b72c75a5a", + "size_in_bytes": 3809 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/utils/__pycache__/_log.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "3b67e65330219af9abc60dfea70124ef8726b1767bab9e9148b9e5ebf86233b0", + "sha256_in_prefix": "3b67e65330219af9abc60dfea70124ef8726b1767bab9e9148b9e5ebf86233b0", + "size_in_bytes": 1481 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/utils/__pycache__/appdirs.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "456f516485adc0523e0f8ee1d907b9d840041496a30da69ee77865687563dd9d", + "sha256_in_prefix": "456f516485adc0523e0f8ee1d907b9d840041496a30da69ee77865687563dd9d", + "size_in_bytes": 1579 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/utils/__pycache__/compat.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "1c52266adf5da2dd6ab0b28e7a89ab00b217a5feeff98efd8c7a46b314dc62d8", + "sha256_in_prefix": "1c52266adf5da2dd6ab0b28e7a89ab00b217a5feeff98efd8c7a46b314dc62d8", + "size_in_bytes": 1469 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/utils/__pycache__/compatibility_tags.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "3cdf61336e29f7ee6f3d6771eb7d433bfb18c5ba72d8ef3f29d5a165511ce2d3", + "sha256_in_prefix": "3cdf61336e29f7ee6f3d6771eb7d433bfb18c5ba72d8ef3f29d5a165511ce2d3", + "size_in_bytes": 4038 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/utils/__pycache__/datetime.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "a053ce5c8e2532817f1de7c35c76d322d60545228226605d9335594828003dba", + "sha256_in_prefix": "a053ce5c8e2532817f1de7c35c76d322d60545228226605d9335594828003dba", + "size_in_bytes": 476 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/utils/__pycache__/deprecation.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "3ea1fce54f88473f550418d106af074ad53a304704bbc18af2588e3c023cad98", + "sha256_in_prefix": "3ea1fce54f88473f550418d106af074ad53a304704bbc18af2588e3c023cad98", + "size_in_bytes": 3274 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/utils/__pycache__/direct_url_helpers.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "3b732d101edfcc19dce0f358f2349cc60304dafa06c597e92f73b9e72e9fbb4e", + "sha256_in_prefix": "3b732d101edfcc19dce0f358f2349cc60304dafa06c597e92f73b9e72e9fbb4e", + "size_in_bytes": 2044 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/utils/__pycache__/egg_link.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "0f5b3b789c84e3f0fe8e9aaeea5f2291c818bcc9b9fbc63c00ef43dca16eb19e", + "sha256_in_prefix": "0f5b3b789c84e3f0fe8e9aaeea5f2291c818bcc9b9fbc63c00ef43dca16eb19e", + "size_in_bytes": 2374 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/utils/__pycache__/encoding.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "d38541d264281302c18b2c280cfddf3ad7adf203f220eb55a0554014d0d7e3cb", + "sha256_in_prefix": "d38541d264281302c18b2c280cfddf3ad7adf203f220eb55a0554014d0d7e3cb", + "size_in_bytes": 1266 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/utils/__pycache__/entrypoints.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "860c003be3846c3c0faa10d85cb5582176756801e34133ea31317bfeb52a1f01", + "sha256_in_prefix": "860c003be3846c3c0faa10d85cb5582176756801e34133ea31317bfeb52a1f01", + "size_in_bytes": 2659 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/utils/__pycache__/filesystem.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "07e0a645e8130ed9fb27e3346a631efbcc1ca65a9cfe26fa181068fb3e47cef7", + "sha256_in_prefix": "07e0a645e8130ed9fb27e3346a631efbcc1ca65a9cfe26fa181068fb3e47cef7", + "size_in_bytes": 4442 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/utils/__pycache__/filetypes.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "3138564866aca80e88e6e0734dff2e6705fe40a531e0b57b4c89016f8155d329", + "sha256_in_prefix": "3138564866aca80e88e6e0734dff2e6705fe40a531e0b57b4c89016f8155d329", + "size_in_bytes": 903 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/utils/__pycache__/glibc.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c995379962c25c1e32ad6ee113f4e69b587ac25f6c8577e644c9595655ae518b", + "sha256_in_prefix": "c995379962c25c1e32ad6ee113f4e69b587ac25f6c8577e644c9595655ae518b", + "size_in_bytes": 1674 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/utils/__pycache__/hashes.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "d671dfc63c0bf189bf10879f7631ad7debd7ae6f2295c0b7df4ca340798b73e4", + "sha256_in_prefix": "d671dfc63c0bf189bf10879f7631ad7debd7ae6f2295c0b7df4ca340798b73e4", + "size_in_bytes": 5442 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/utils/__pycache__/logging.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "70929c6da4ef0ec3fea7c6b3c3af4a96e07ea35cee23cda547a2d4cca684ecab", + "sha256_in_prefix": "70929c6da4ef0ec3fea7c6b3c3af4a96e07ea35cee23cda547a2d4cca684ecab", + "size_in_bytes": 9636 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/utils/__pycache__/misc.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "5adaa4ceee775f6e3f06fc925bafb44083537f5367d362f9e723eb9d7d93407d", + "sha256_in_prefix": "5adaa4ceee775f6e3f06fc925bafb44083537f5367d362f9e723eb9d7d93407d", + "size_in_bytes": 23239 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/utils/__pycache__/models.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c56c9215bef13584bd398cadbef86318d59d2922e9663e6ca06f5d3650cf9627", + "sha256_in_prefix": "c56c9215bef13584bd398cadbef86318d59d2922e9663e6ca06f5d3650cf9627", + "size_in_bytes": 1949 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/utils/__pycache__/packaging.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "6d806bc3fef50b36597d185e0af149cea5362dc95ebaf90c13be1570f00bcc95", + "sha256_in_prefix": "6d806bc3fef50b36597d185e0af149cea5362dc95ebaf90c13be1570f00bcc95", + "size_in_bytes": 2041 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/utils/__pycache__/setuptools_build.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "f2d699ed2ec93c91169ec7d4954586c3189d825fc92b7c44ec908af706074f47", + "sha256_in_prefix": "f2d699ed2ec93c91169ec7d4954586c3189d825fc92b7c44ec908af706074f47", + "size_in_bytes": 3777 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/utils/__pycache__/subprocess.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "280d0aca8edf4cfb26fbf850f15d8640db390b9035e241859f130bb6139a324c", + "sha256_in_prefix": "280d0aca8edf4cfb26fbf850f15d8640db390b9035e241859f130bb6139a324c", + "size_in_bytes": 5731 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/utils/__pycache__/temp_dir.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "fbc3e17de7ebf3c5a706d12373632d995b0ab318d000674cc73c549714059433", + "sha256_in_prefix": "fbc3e17de7ebf3c5a706d12373632d995b0ab318d000674cc73c549714059433", + "size_in_bytes": 8284 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/utils/__pycache__/unpacking.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "7aa656b6d410600a3333dcfd4fad2432d0a55ce1b16778e256f9c3d823a74ebe", + "sha256_in_prefix": "7aa656b6d410600a3333dcfd4fad2432d0a55ce1b16778e256f9c3d823a74ebe", + "size_in_bytes": 6613 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/utils/__pycache__/urls.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c198497eef932687a0967688d99209be282dddafc8ff894fe6ca0492312a14dc", + "sha256_in_prefix": "c198497eef932687a0967688d99209be282dddafc8ff894fe6ca0492312a14dc", + "size_in_bytes": 1546 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/utils/__pycache__/virtualenv.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "aa2303b139b701aca1ab4940781ffae8d8992a2f4ae60a6da68f8c480b295b6f", + "sha256_in_prefix": "aa2303b139b701aca1ab4940781ffae8d8992a2f4ae60a6da68f8c480b295b6f", + "size_in_bytes": 3249 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/utils/__pycache__/wheel.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "6256f2901b5a7bc6fabe8390d09a17072ed54deb8b7a305b6d8fe714b5a0f6c1", + "sha256_in_prefix": "6256f2901b5a7bc6fabe8390d09a17072ed54deb8b7a305b6d8fe714b5a0f6c1", + "size_in_bytes": 4361 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/utils/_jaraco_text.py", + "path_type": "hardlink", + "sha256": "caf0c67a54d5ba045ac8f68e17693869bd0acb8777b8e9007ee3908c04a32266", + "sha256_in_prefix": "caf0c67a54d5ba045ac8f68e17693869bd0acb8777b8e9007ee3908c04a32266", + "size_in_bytes": 3351 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/utils/_log.py", + "path_type": "hardlink", + "sha256": "fa31cb384fd31da673e4115c0a7a122fd11802d2749d77a6e3db3da1fe23bcac", + "sha256_in_prefix": "fa31cb384fd31da673e4115c0a7a122fd11802d2749d77a6e3db3da1fe23bcac", + "size_in_bytes": 1015 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/utils/appdirs.py", + "path_type": "hardlink", + "sha256": "b3081c4ca3a6ddd68b7974d6eafe41512d938b646f1271914181ffc835e4940a", + "sha256_in_prefix": "b3081c4ca3a6ddd68b7974d6eafe41512d938b646f1271914181ffc835e4940a", + "size_in_bytes": 1665 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/utils/compat.py", + "path_type": "hardlink", + "sha256": "002c817cb823dff5c6fa2039a26103ad7a833347102b38bc87c1d10489f31ba4", + "sha256_in_prefix": "002c817cb823dff5c6fa2039a26103ad7a833347102b38bc87c1d10489f31ba4", + "size_in_bytes": 1884 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/utils/compatibility_tags.py", + "path_type": "hardlink", + "sha256": "c9d8a7f101bc047a9846c3d8e0e2fa7266f8e026ea5e5d53d31c52f7b5611e49", + "sha256_in_prefix": "c9d8a7f101bc047a9846c3d8e0e2fa7266f8e026ea5e5d53d31c52f7b5611e49", + "size_in_bytes": 5377 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/utils/datetime.py", + "path_type": "hardlink", + "sha256": "9b6d58df002d41cfa38ba55e6fa93f33983a034672148e1e81c853767c21fa94", + "sha256_in_prefix": "9b6d58df002d41cfa38ba55e6fa93f33983a034672148e1e81c853767c21fa94", + "size_in_bytes": 242 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/utils/deprecation.py", + "path_type": "hardlink", + "sha256": "34aa3c56a2e2a09e279d75c6996e0a75ab3117dd04147919687797d5f4f4f02f", + "sha256_in_prefix": "34aa3c56a2e2a09e279d75c6996e0a75ab3117dd04147919687797d5f4f4f02f", + "size_in_bytes": 3627 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/utils/direct_url_helpers.py", + "path_type": "hardlink", + "sha256": "e85d6d736adc29a0999a07d5c2c13a39b21efcfbb1db799455803ed83f700857", + "sha256_in_prefix": "e85d6d736adc29a0999a07d5c2c13a39b21efcfbb1db799455803ed83f700857", + "size_in_bytes": 3206 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/utils/egg_link.py", + "path_type": "hardlink", + "sha256": "d0578f6685182afe11190dadeb1ef0e59e36ef06c0fd4a375999c092b82cbaaa", + "sha256_in_prefix": "d0578f6685182afe11190dadeb1ef0e59e36ef06c0fd4a375999c092b82cbaaa", + "size_in_bytes": 2463 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/utils/encoding.py", + "path_type": "hardlink", + "sha256": "aaab170ed8b03088d730488855268e8f01f96268ab09a2be748cdbebe5c9b0bd", + "sha256_in_prefix": "aaab170ed8b03088d730488855268e8f01f96268ab09a2be748cdbebe5c9b0bd", + "size_in_bytes": 1169 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/utils/entrypoints.py", + "path_type": "hardlink", + "sha256": "62584b4d1976a07040baa85cfb398bed4492ebb4cf5951c89a3780407ade6534", + "sha256_in_prefix": "62584b4d1976a07040baa85cfb398bed4492ebb4cf5951c89a3780407ade6534", + "size_in_bytes": 3064 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/utils/filesystem.py", + "path_type": "hardlink", + "sha256": "4613085d468d54c1a3737ae1b036a1590e0c6afbc440376a5ea82af85e9fa70f", + "sha256_in_prefix": "4613085d468d54c1a3737ae1b036a1590e0c6afbc440376a5ea82af85e9fa70f", + "size_in_bytes": 5122 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/utils/filetypes.py", + "path_type": "hardlink", + "sha256": "8bc5c04347850a8836e85c3dc95d186f5ca002a298075c3d0b3f67d1f8fc8195", + "sha256_in_prefix": "8bc5c04347850a8836e85c3dc95d186f5ca002a298075c3d0b3f67d1f8fc8195", + "size_in_bytes": 716 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/utils/glibc.py", + "path_type": "hardlink", + "sha256": "31eb31c6083704bc6178b671f9d49fdf46fa80aa4e81d557c3a5befae1d2b334", + "sha256_in_prefix": "31eb31c6083704bc6178b671f9d49fdf46fa80aa4e81d557c3a5befae1d2b334", + "size_in_bytes": 3113 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/utils/hashes.py", + "path_type": "hardlink", + "sha256": "3233a2802ef9cfaaa844c9201e21eaa2dedeab17f00d94ab11f94930f9be6c71", + "sha256_in_prefix": "3233a2802ef9cfaaa844c9201e21eaa2dedeab17f00d94ab11f94930f9be6c71", + "size_in_bytes": 5118 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/utils/logging.py", + "path_type": "hardlink", + "sha256": "7ddb6e649f802a4ab00d300d0ef19c044a6cb0bf1e97b4f58e7c24d429d99776", + "sha256_in_prefix": "7ddb6e649f802a4ab00d300d0ef19c044a6cb0bf1e97b4f58e7c24d429d99776", + "size_in_bytes": 11603 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/utils/misc.py", + "path_type": "hardlink", + "sha256": "7cd5f069e7a292f9d4b7808f30520be3e2106d90f1c638f88c3a730a2e19b0ec", + "sha256_in_prefix": "7cd5f069e7a292f9d4b7808f30520be3e2106d90f1c638f88c3a730a2e19b0ec", + "size_in_bytes": 23623 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/utils/models.py", + "path_type": "hardlink", + "sha256": "e46a18539f3a4abc5444cbc39ff8c13092278adbe2260e0ee7e88e53ee88d166", + "sha256_in_prefix": "e46a18539f3a4abc5444cbc39ff8c13092278adbe2260e0ee7e88e53ee88d166", + "size_in_bytes": 1193 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/utils/packaging.py", + "path_type": "hardlink", + "sha256": "e569baff1ee52ab96a5633c8e4c04dfd1bab7111f0558a10ecab2bb3ce1d7bbb", + "sha256_in_prefix": "e569baff1ee52ab96a5633c8e4c04dfd1bab7111f0558a10ecab2bb3ce1d7bbb", + "size_in_bytes": 2108 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/utils/setuptools_build.py", + "path_type": "hardlink", + "sha256": "a2e5e9b9dfa3792f313f24cfb1727e9b7e0d3ef2b9a2ce39a2d03375257f2091", + "sha256_in_prefix": "a2e5e9b9dfa3792f313f24cfb1727e9b7e0d3ef2b9a2ce39a2d03375257f2091", + "size_in_bytes": 4435 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/utils/subprocess.py", + "path_type": "hardlink", + "sha256": "cf376299bef98d52c4d465385a54d9d39e60733843ee7d72d714dc35ceef3594", + "sha256_in_prefix": "cf376299bef98d52c4d465385a54d9d39e60733843ee7d72d714dc35ceef3594", + "size_in_bytes": 9207 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/utils/temp_dir.py", + "path_type": "hardlink", + "sha256": "0d4030db6b85aee41d2b8de2d8bd8ae770be0838d108f780b01289a6efab1d0e", + "sha256_in_prefix": "0d4030db6b85aee41d2b8de2d8bd8ae770be0838d108f780b01289a6efab1d0e", + "size_in_bytes": 9312 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/utils/unpacking.py", + "path_type": "hardlink", + "sha256": "4816f6895d5cadbf3d30345310a63ce91e00fd43960294d09fd55055c3033a51", + "sha256_in_prefix": "4816f6895d5cadbf3d30345310a63ce91e00fd43960294d09fd55055c3033a51", + "size_in_bytes": 8821 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/utils/urls.py", + "path_type": "hardlink", + "sha256": "02169eb141a5fbd8adeaebc6e9fb053ceafdca716919a4cc938b795d35fb67f4", + "sha256_in_prefix": "02169eb141a5fbd8adeaebc6e9fb053ceafdca716919a4cc938b795d35fb67f4", + "size_in_bytes": 1759 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/utils/virtualenv.py", + "path_type": "hardlink", + "sha256": "4ba7fb72c628ad1a620fa72f9f78c849961cdc8f0f242e371f988c1694401035", + "sha256_in_prefix": "4ba7fb72c628ad1a620fa72f9f78c849961cdc8f0f242e371f988c1694401035", + "size_in_bytes": 3456 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/utils/wheel.py", + "path_type": "hardlink", + "sha256": "8b807050d1dab6dccdd22c72dc7040174e2d64f461d82731693eadf3abe2c241", + "sha256_in_prefix": "8b807050d1dab6dccdd22c72dc7040174e2d64f461d82731693eadf3abe2c241", + "size_in_bytes": 4499 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/vcs/__init__.py", + "path_type": "hardlink", + "sha256": "500aafce96e2d156d9a3751beac904799030fa8a08651fb35ff5a909bc720a85", + "sha256_in_prefix": "500aafce96e2d156d9a3751beac904799030fa8a08651fb35ff5a909bc720a85", + "size_in_bytes": 596 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/vcs/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "340168217b9bcf6aeeae2e125131570baf577aebea9b254057243534eaa3c3f6", + "sha256_in_prefix": "340168217b9bcf6aeeae2e125131570baf577aebea9b254057243534eaa3c3f6", + "size_in_bytes": 476 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/vcs/__pycache__/bazaar.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "5f3799a0f0bee78a88aab52d167332030a32f14e190b0871d0875fb92aa15038", + "sha256_in_prefix": "5f3799a0f0bee78a88aab52d167332030a32f14e190b0871d0875fb92aa15038", + "size_in_bytes": 3442 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/vcs/__pycache__/git.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "d593e812b6bad7c9c24b13af1d1d46171da8d22339600ec3fa68183c8a249b69", + "sha256_in_prefix": "d593e812b6bad7c9c24b13af1d1d46171da8d22339600ec3fa68183c8a249b69", + "size_in_bytes": 12365 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/vcs/__pycache__/mercurial.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "8f7ee3c09b6aaafa9a44ff815e9a93a9207f14fe797ca23747ef77e3d20b71a3", + "sha256_in_prefix": "8f7ee3c09b6aaafa9a44ff815e9a93a9207f14fe797ca23747ef77e3d20b71a3", + "size_in_bytes": 5036 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/vcs/__pycache__/subversion.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "8f7875f198d3bf0c0ed2d0f1b3f1952f84818a7c3ffbc5db0c07e77525172e29", + "sha256_in_prefix": "8f7875f198d3bf0c0ed2d0f1b3f1952f84818a7c3ffbc5db0c07e77525172e29", + "size_in_bytes": 8414 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/vcs/__pycache__/versioncontrol.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "48af04813f1167579b5fe6f9ca7fc5850a2744a584bcfb9c180b777daa1d78e4", + "sha256_in_prefix": "48af04813f1167579b5fe6f9ca7fc5850a2744a584bcfb9c180b777daa1d78e4", + "size_in_bytes": 21086 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/vcs/bazaar.py", + "path_type": "hardlink", + "sha256": "8f4a229f47e91911dc0850b111ca4f090a0512f03e0cc2d42ca7463fc36fefaa", + "sha256_in_prefix": "8f4a229f47e91911dc0850b111ca4f090a0512f03e0cc2d42ca7463fc36fefaa", + "size_in_bytes": 3519 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/vcs/git.py", + "path_type": "hardlink", + "sha256": "09e2811899e5eaeb24bef8e40145eb255c5b1c9ae94bf07fa727c57632f70917", + "sha256_in_prefix": "09e2811899e5eaeb24bef8e40145eb255c5b1c9ae94bf07fa727c57632f70917", + "size_in_bytes": 18121 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/vcs/mercurial.py", + "path_type": "hardlink", + "sha256": "a142ce8732765227bed3a775a2690bfbf19cea6786694932a20bea1bd642c8fb", + "sha256_in_prefix": "a142ce8732765227bed3a775a2690bfbf19cea6786694932a20bea1bd642c8fb", + "size_in_bytes": 5249 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/vcs/subversion.py", + "path_type": "hardlink", + "sha256": "be166cf0bf93360817a8cd5b6e197e1696f11374eb201e93827c7c7e1dd2d871", + "sha256_in_prefix": "be166cf0bf93360817a8cd5b6e197e1696f11374eb201e93827c7c7e1dd2d871", + "size_in_bytes": 11729 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/vcs/versioncontrol.py", + "path_type": "hardlink", + "sha256": "dde223b4e318bce639a8fe813182180d9dfbe424ae79cea44840746cea35712b", + "sha256_in_prefix": "dde223b4e318bce639a8fe813182180d9dfbe424ae79cea44840746cea35712b", + "size_in_bytes": 22787 + }, + { + "_path": "lib/python3.10/site-packages/pip/_internal/wheel_builder.py", + "path_type": "hardlink", + "sha256": "a934f3415f05e9bd6336c14275ad534500bc27b80afa6ee2b913602a8ec38faf", + "sha256_in_prefix": "a934f3415f05e9bd6336c14275ad534500bc27b80afa6ee2b913602a8ec38faf", + "size_in_bytes": 11801 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/__init__.py", + "path_type": "hardlink", + "sha256": "539d4d3f05dd03ec173a200d2109dc62370ca7ab7181e38be671f192c25ec9ab", + "sha256_in_prefix": "539d4d3f05dd03ec173a200d2109dc62370ca7ab7181e38be671f192c25ec9ab", + "size_in_bytes": 4993 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "2c990e1eda8e9ad84eccfcb94022e8371fd425740608eb867aac2e68fffb594a", + "sha256_in_prefix": "2c990e1eda8e9ad84eccfcb94022e8371fd425740608eb867aac2e68fffb594a", + "size_in_bytes": 3111 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/__pycache__/six.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "9f9675e267e7fdd304850bc6f1d4c602f5cad370449cc4f6d09d0626d0e46890", + "sha256_in_prefix": "9f9675e267e7fdd304850bc6f1d4c602f5cad370449cc4f6d09d0626d0e46890", + "size_in_bytes": 27543 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/__pycache__/typing_extensions.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "395c0cb630531e95f0ff5c140dd34b31c9fa49f25b7a02417580984f3a940802", + "sha256_in_prefix": "395c0cb630531e95f0ff5c140dd34b31c9fa49f25b7a02417580984f3a940802", + "size_in_bytes": 89079 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/cachecontrol/__init__.py", + "path_type": "hardlink", + "sha256": "72d1da80c8505eebd00dd9b84e2ad9af00ce4f91fca0134026acdd288eaca2f9", + "sha256_in_prefix": "72d1da80c8505eebd00dd9b84e2ad9af00ce4f91fca0134026acdd288eaca2f9", + "size_in_bytes": 676 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/cachecontrol/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "4373e6c477e337abbef62d874c54b5e20e2630453a75ba4729ed9e3d9b0f6b82", + "sha256_in_prefix": "4373e6c477e337abbef62d874c54b5e20e2630453a75ba4729ed9e3d9b0f6b82", + "size_in_bytes": 724 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/cachecontrol/__pycache__/_cmd.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c41d69f2e3c0ef079f3f542d5d6c03a837413fed5ac714fcfb829355162d8c33", + "sha256_in_prefix": "c41d69f2e3c0ef079f3f542d5d6c03a837413fed5ac714fcfb829355162d8c33", + "size_in_bytes": 1793 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/cachecontrol/__pycache__/adapter.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "ac860447333a2bf4b8ac504f97228bb3d125dd69770a848bfba3387316b5b3e8", + "sha256_in_prefix": "ac860447333a2bf4b8ac504f97228bb3d125dd69770a848bfba3387316b5b3e8", + "size_in_bytes": 4376 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/cachecontrol/__pycache__/cache.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "9d23a08c8af654433d5a3b140f801a74dfd4b4de34920c01979542b65102d0bc", + "sha256_in_prefix": "9d23a08c8af654433d5a3b140f801a74dfd4b4de34920c01979542b65102d0bc", + "size_in_bytes": 3237 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/cachecontrol/__pycache__/controller.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "7308a2a1534776d861629338d3fa3b4e27aefeefc3835277442b899aecc57768", + "sha256_in_prefix": "7308a2a1534776d861629338d3fa3b4e27aefeefc3835277442b899aecc57768", + "size_in_bytes": 10087 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/cachecontrol/__pycache__/filewrapper.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "4187624fa4341b48505cf5657bd91c8497f73ed6dd0a4b81c46f2b2b19d27ea2", + "sha256_in_prefix": "4187624fa4341b48505cf5657bd91c8497f73ed6dd0a4b81c46f2b2b19d27ea2", + "size_in_bytes": 3177 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/cachecontrol/__pycache__/heuristics.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "2bed8563f9b96624d0c3143577639b32c79e2a8c95d737bd9ea644c0b3e28868", + "sha256_in_prefix": "2bed8563f9b96624d0c3143577639b32c79e2a8c95d737bd9ea644c0b3e28868", + "size_in_bytes": 5352 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/cachecontrol/__pycache__/serialize.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "3a81f5a560f65d2935a1997124aa792061c557b4416b06b3b8ae6504e54c1990", + "sha256_in_prefix": "3a81f5a560f65d2935a1997124aa792061c557b4416b06b3b8ae6504e54c1990", + "size_in_bytes": 4066 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/cachecontrol/__pycache__/wrapper.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "6c27ac1734c940748943c3f7dd5f20a6f8a6319e31e7f23ed260084449fd9167", + "sha256_in_prefix": "6c27ac1734c940748943c3f7dd5f20a6f8a6319e31e7f23ed260084449fd9167", + "size_in_bytes": 1428 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/cachecontrol/_cmd.py", + "path_type": "hardlink", + "sha256": "8a2b2dd84a7326f0d5221300c57abc8859d306c89901dea2a65c5f98d6e83729", + "sha256_in_prefix": "8a2b2dd84a7326f0d5221300c57abc8859d306c89901dea2a65c5f98d6e83729", + "size_in_bytes": 1737 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/cachecontrol/adapter.py", + "path_type": "hardlink", + "sha256": "fc2716bd43fdd38f2a0198ec36a5626876dd70bb3d9a614d8b155fa4eee879b1", + "sha256_in_prefix": "fc2716bd43fdd38f2a0198ec36a5626876dd70bb3d9a614d8b155fa4eee879b1", + "size_in_bytes": 6392 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/cachecontrol/cache.py", + "path_type": "hardlink", + "sha256": "393423ef6b547fc0b5b8481ccdd97719cf2f925752cec4c84cab4318a331e33f", + "sha256_in_prefix": "393423ef6b547fc0b5b8481ccdd97719cf2f925752cec4c84cab4318a331e33f", + "size_in_bytes": 1952 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/cachecontrol/caches/__init__.py", + "path_type": "hardlink", + "sha256": "76daebae82b90670034751968c2675f5a674b45b0c7ef141b4b410535b29fda8", + "sha256_in_prefix": "76daebae82b90670034751968c2675f5a674b45b0c7ef141b4b410535b29fda8", + "size_in_bytes": 303 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/cachecontrol/caches/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "4a9aec817a68c1bad533c02c272eed1ba44f6f3e82944577eafbc0bbd61764db", + "sha256_in_prefix": "4a9aec817a68c1bad533c02c272eed1ba44f6f3e82944577eafbc0bbd61764db", + "size_in_bytes": 387 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/cachecontrol/caches/__pycache__/file_cache.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "2ccd1465a07c2625ae8ff78c4f855be705169880382e4c824d8e6ba9b0ab75aa", + "sha256_in_prefix": "2ccd1465a07c2625ae8ff78c4f855be705169880382e4c824d8e6ba9b0ab75aa", + "size_in_bytes": 5543 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/cachecontrol/caches/__pycache__/redis_cache.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c69f5df0703fa1f5f260358d7c8cc257eca3c46ceaefefbae52752e9ad7928e3", + "sha256_in_prefix": "c69f5df0703fa1f5f260358d7c8cc257eca3c46ceaefefbae52752e9ad7928e3", + "size_in_bytes": 2002 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/cachecontrol/caches/file_cache.py", + "path_type": "hardlink", + "sha256": "df3f0058a0febdf29e889a88ccb989c8862d476c9de93b21deed53c8b450a084", + "sha256_in_prefix": "df3f0058a0febdf29e889a88ccb989c8862d476c9de93b21deed53c8b450a084", + "size_in_bytes": 5352 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/cachecontrol/caches/redis_cache.py", + "path_type": "hardlink", + "sha256": "f6b9aac2d62efe58d5916ebfa0ba9b0bb11a5ff6bc613ff22ee9daf9e4b4760a", + "sha256_in_prefix": "f6b9aac2d62efe58d5916ebfa0ba9b0bb11a5ff6bc613ff22ee9daf9e4b4760a", + "size_in_bytes": 1386 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/cachecontrol/controller.py", + "path_type": "hardlink", + "sha256": "91e08503765a3556964f01dde85d73a9685be2fcaf371fd4bd9ba8e6221831fa", + "sha256_in_prefix": "91e08503765a3556964f01dde85d73a9685be2fcaf371fd4bd9ba8e6221831fa", + "size_in_bytes": 18384 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/cachecontrol/filewrapper.py", + "path_type": "hardlink", + "sha256": "493b6d1a620f06f673b766f9d5d50ec28597e5cadc302a4a64e8ac3377f904d7", + "sha256_in_prefix": "493b6d1a620f06f673b766f9d5d50ec28597e5cadc302a4a64e8ac3377f904d7", + "size_in_bytes": 4292 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/cachecontrol/heuristics.py", + "path_type": "hardlink", + "sha256": "7dd15b93d5bc21e2eb8ed788cff7cae268f61c3fd8ec239717651cf138234f57", + "sha256_in_prefix": "7dd15b93d5bc21e2eb8ed788cff7cae268f61c3fd8ec239717651cf138234f57", + "size_in_bytes": 4828 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/cachecontrol/py.typed", + "path_type": "hardlink", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size_in_bytes": 0 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/cachecontrol/serialize.py", + "path_type": "hardlink", + "sha256": "d1d1de31a0f0cac54002719596130e3f8b43962a2180d2b427193fcec3a25b1c", + "sha256_in_prefix": "d1d1de31a0f0cac54002719596130e3f8b43962a2180d2b427193fcec3a25b1c", + "size_in_bytes": 7173 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/cachecontrol/wrapper.py", + "path_type": "hardlink", + "sha256": "86c19cee0f101904d3fb87fcb60cf700ce6ac12720e853b405274b491744be95", + "sha256_in_prefix": "86c19cee0f101904d3fb87fcb60cf700ce6ac12720e853b405274b491744be95", + "size_in_bytes": 1417 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/certifi/__init__.py", + "path_type": "hardlink", + "sha256": "2ff8fe774918b80fcccc0dbfda1ada175a2f7fa293e834eab91755de9690c0e9", + "sha256_in_prefix": "2ff8fe774918b80fcccc0dbfda1ada175a2f7fa293e834eab91755de9690c0e9", + "size_in_bytes": 94 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/certifi/__main__.py", + "path_type": "hardlink", + "sha256": "d64dc2afde6f0b1c464460e58eb5b7c0c76965d2f73617f4bb59fe936a9db026", + "sha256_in_prefix": "d64dc2afde6f0b1c464460e58eb5b7c0c76965d2f73617f4bb59fe936a9db026", + "size_in_bytes": 255 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/certifi/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "9036164331a5cd6e6ff4996f4ac698a8eb28070855e40368e564fee2d213c6ee", + "sha256_in_prefix": "9036164331a5cd6e6ff4996f4ac698a8eb28070855e40368e564fee2d213c6ee", + "size_in_bytes": 266 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/certifi/__pycache__/__main__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "6dc3ad2689b84b683e13d7c6de72766810c399948d926956bbd32437be56d5a9", + "sha256_in_prefix": "6dc3ad2689b84b683e13d7c6de72766810c399948d926956bbd32437be56d5a9", + "size_in_bytes": 416 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/certifi/__pycache__/core.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "f170978bc48e3f763f3611dc9f8158b1af63c8a7b3ea95b391ec041cf0e175a4", + "sha256_in_prefix": "f170978bc48e3f763f3611dc9f8158b1af63c8a7b3ea95b391ec041cf0e175a4", + "size_in_bytes": 1886 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/certifi/cacert.pem", + "path_type": "hardlink", + "sha256": "794d039ffdf277c047e26f2c7d58f81a5865d8a0eb7024a0fac1164fea4d27cf", + "sha256_in_prefix": "794d039ffdf277c047e26f2c7d58f81a5865d8a0eb7024a0fac1164fea4d27cf", + "size_in_bytes": 281617 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/certifi/core.py", + "path_type": "hardlink", + "sha256": "67088eb2ffac0ffa2e5357edf30cbfc59dcb43b51b715cf2aa3d97372aec662b", + "sha256_in_prefix": "67088eb2ffac0ffa2e5357edf30cbfc59dcb43b51b715cf2aa3d97372aec662b", + "size_in_bytes": 4279 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/certifi/py.typed", + "path_type": "hardlink", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size_in_bytes": 0 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/__init__.py", + "path_type": "hardlink", + "sha256": "e7b47e1d2c63d0f5a620b30dd0616650da8431fac45526a65f28c3f96ebf7dbb", + "sha256_in_prefix": "e7b47e1d2c63d0f5a620b30dd0616650da8431fac45526a65f28c3f96ebf7dbb", + "size_in_bytes": 4797 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "1237b4f5a6bdfb84a71f475847cf1f4000c70d7e6b70c2ed4f8942e03ee0edcc", + "sha256_in_prefix": "1237b4f5a6bdfb84a71f475847cf1f4000c70d7e6b70c2ed4f8942e03ee0edcc", + "size_in_bytes": 3134 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/big5freq.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "e5381dc7ecf9c9f7dddd7883681bde2b24a637246e487d153095b78916633dd5", + "sha256_in_prefix": "e5381dc7ecf9c9f7dddd7883681bde2b24a637246e487d153095b78916633dd5", + "size_in_bytes": 27140 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/big5prober.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "04d182af07c52db509a20579701902c3d12d03f60cc6ca38211bf72a648a6f99", + "sha256_in_prefix": "04d182af07c52db509a20579701902c3d12d03f60cc6ca38211bf72a648a6f99", + "size_in_bytes": 1118 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/chardistribution.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "a9bf256cae7321df601f2f59e35ae8ae925b68893b4ba6260d3ab50258569153", + "sha256_in_prefix": "a9bf256cae7321df601f2f59e35ae8ae925b68893b4ba6260d3ab50258569153", + "size_in_bytes": 6535 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/charsetgroupprober.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "b1210b4a4f288bd463d18f2a674d96db609ee677818b1341804d0a0427b75f38", + "sha256_in_prefix": "b1210b4a4f288bd463d18f2a674d96db609ee677818b1341804d0a0427b75f38", + "size_in_bytes": 2385 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/charsetprober.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "036efd2debeaf8a57e04bb0f6c4206c41b60eba86774dac6c1d2ce669438bb89", + "sha256_in_prefix": "036efd2debeaf8a57e04bb0f6c4206c41b60eba86774dac6c1d2ce669438bb89", + "size_in_bytes": 3791 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/codingstatemachine.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "be4951d455c66a9d4f1a2e0635f62fc01e2e9059f8713f458cc8c4fef4d8adbc", + "sha256_in_prefix": "be4951d455c66a9d4f1a2e0635f62fc01e2e9059f8713f458cc8c4fef4d8adbc", + "size_in_bytes": 3028 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/codingstatemachinedict.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "cb368039518b337673f6fa39b7f46dd8d5632a86eaa76878b1e69533e6cc72ee", + "sha256_in_prefix": "cb368039518b337673f6fa39b7f46dd8d5632a86eaa76878b1e69533e6cc72ee", + "size_in_bytes": 657 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/cp949prober.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "416ed333944994524f618036b939de48b2c0bd268af7189775307ee9afa7c692", + "sha256_in_prefix": "416ed333944994524f618036b939de48b2c0bd268af7189775307ee9afa7c692", + "size_in_bytes": 1125 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/enums.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "503d2986c6cf322178131bedd2e6fe310b01cc57c33577a3ea15f4adb4dce7ac", + "sha256_in_prefix": "503d2986c6cf322178131bedd2e6fe310b01cc57c33577a3ea15f4adb4dce7ac", + "size_in_bytes": 2618 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/escprober.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "951fe803a9f7be891107259b53e9d99571bba4c8ad45904efbe2c998a93b4151", + "sha256_in_prefix": "951fe803a9f7be891107259b53e9d99571bba4c8ad45904efbe2c998a93b4151", + "size_in_bytes": 2776 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/escsm.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "a71ce8e2d94e3b516b68bcd1943bb756665dad296bb0a651d9267923b859646e", + "sha256_in_prefix": "a71ce8e2d94e3b516b68bcd1943bb756665dad296bb0a651d9267923b859646e", + "size_in_bytes": 8479 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/eucjpprober.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "e95c946782ddca1a1839e407ad5f2f8c3bc555ac0151fac86733f522c88e2a1e", + "sha256_in_prefix": "e95c946782ddca1a1839e407ad5f2f8c3bc555ac0151fac86733f522c88e2a1e", + "size_in_bytes": 2562 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/euckrfreq.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "9285228e0719806b01fa78920daa765e60df7e025b3070004a22953e6bf67c6f", + "sha256_in_prefix": "9285228e0719806b01fa78920daa765e60df7e025b3070004a22953e6bf67c6f", + "size_in_bytes": 12024 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/euckrprober.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "42098890ba3a8dae536c4c1d105da8f9ddd49cdb752b9fc89c20797e96e141ee", + "sha256_in_prefix": "42098890ba3a8dae536c4c1d105da8f9ddd49cdb752b9fc89c20797e96e141ee", + "size_in_bytes": 1126 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/euctwfreq.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "233142de14eee5a92cdaac6bb3ebc25e9714841fb94aa06d83cd287dd073ef04", + "sha256_in_prefix": "233142de14eee5a92cdaac6bb3ebc25e9714841fb94aa06d83cd287dd073ef04", + "size_in_bytes": 27144 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/euctwprober.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "a6a04591e1f7098b28f05e2e3d246d271f3a6eff85b2004801b88e080b441c9e", + "sha256_in_prefix": "a6a04591e1f7098b28f05e2e3d246d271f3a6eff85b2004801b88e080b441c9e", + "size_in_bytes": 1126 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/gb2312freq.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "524d8fccaa3bd3cc1bc25c0ba94e3c6e78a0a5ec212f225c0d43e87fcff2c797", + "sha256_in_prefix": "524d8fccaa3bd3cc1bc25c0ba94e3c6e78a0a5ec212f225c0d43e87fcff2c797", + "size_in_bytes": 19068 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/gb2312prober.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "7b7b9013ed7ea36c74dd03cf8b8aae0bf495c25e12efdd904ffd39b91f5e2536", + "sha256_in_prefix": "7b7b9013ed7ea36c74dd03cf8b8aae0bf495c25e12efdd904ffd39b91f5e2536", + "size_in_bytes": 1134 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/hebrewprober.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "a3d775c730b70a165605c9d5a930a77ded2af7eed8e41877ea0dcf2c8b335276", + "sha256_in_prefix": "a3d775c730b70a165605c9d5a930a77ded2af7eed8e41877ea0dcf2c8b335276", + "size_in_bytes": 3375 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/jisfreq.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "0f9bc8a2706cd8d1ec9029e39fc7e9777c1ade223715894f91e39ae96b8e0846", + "sha256_in_prefix": "0f9bc8a2706cd8d1ec9029e39fc7e9777c1ade223715894f91e39ae96b8e0846", + "size_in_bytes": 22096 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/johabfreq.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "b9c4ff7ad86bb61354c2775789fd5deec8e65d7e2c4f0e8e4c5b789088304340", + "sha256_in_prefix": "b9c4ff7ad86bb61354c2775789fd5deec8e65d7e2c4f0e8e4c5b789088304340", + "size_in_bytes": 138720 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/johabprober.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "834b57c50eaf39ad1598a666e693fceb1ac2e6c2cccd5506eb8ba04bbc644f7b", + "sha256_in_prefix": "834b57c50eaf39ad1598a666e693fceb1ac2e6c2cccd5506eb8ba04bbc644f7b", + "size_in_bytes": 1125 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/jpcntx.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "5307ca8d3476f3d43031c767321071092139487634c1c8d9845e80deb8bdc973", + "sha256_in_prefix": "5307ca8d3476f3d43031c767321071092139487634c1c8d9845e80deb8bdc973", + "size_in_bytes": 37946 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/langbulgarianmodel.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "639f4f433b82169e8e9f7271f950bc5801d0c4c73b3679833a9038523e9f25d3", + "sha256_in_prefix": "639f4f433b82169e8e9f7271f950bc5801d0c4c73b3679833a9038523e9f25d3", + "size_in_bytes": 47888 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/langgreekmodel.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c9f4641149485996f8a675e26766147ebf3b23193e9b3e6523a46b681dbb44b1", + "sha256_in_prefix": "c9f4641149485996f8a675e26766147ebf3b23193e9b3e6523a46b681dbb44b1", + "size_in_bytes": 46078 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/langhebrewmodel.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "a1cb17f15569bec79d6e136ec39fdd62336d87bb509049f57dfdbf45589fbe73", + "sha256_in_prefix": "a1cb17f15569bec79d6e136ec39fdd62336d87bb509049f57dfdbf45589fbe73", + "size_in_bytes": 44525 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/langhungarianmodel.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "aa38387a52fd14d6c9c5fc7e7e2bca08c8e18b1b1be7c97b596e389f9f170fd1", + "sha256_in_prefix": "aa38387a52fd14d6c9c5fc7e7e2bca08c8e18b1b1be7c97b596e389f9f170fd1", + "size_in_bytes": 47848 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/langrussianmodel.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "adf4ec0d57f48efec9a32bb62546083cb1734a7cc2e54989f48fe3208500476a", + "sha256_in_prefix": "adf4ec0d57f48efec9a32bb62546083cb1734a7cc2e54989f48fe3208500476a", + "size_in_bytes": 60989 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/langthaimodel.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "3e3c3003dceff27390e55533d6353dbd9d516b33240249a616212f3d560a8356", + "sha256_in_prefix": "3e3c3003dceff27390e55533d6353dbd9d516b33240249a616212f3d560a8356", + "size_in_bytes": 44701 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/langturkishmodel.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "f153467f336e8943fc60c69e8ad429f2a97ebc2aa2b93ec27661d95aecc51929", + "sha256_in_prefix": "f153467f336e8943fc60c69e8ad429f2a97ebc2aa2b93ec27661d95aecc51929", + "size_in_bytes": 44542 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/latin1prober.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "35b3d2df00d388af35b6be74f558dc9e59fa8428eb3ec7d18c82b3d2f91503d3", + "sha256_in_prefix": "35b3d2df00d388af35b6be74f558dc9e59fa8428eb3ec7d18c82b3d2f91503d3", + "size_in_bytes": 4524 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/macromanprober.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "5258146ad3443e696a858e262a9c4676e410f098a9b0442ca933a5be498065dc", + "sha256_in_prefix": "5258146ad3443e696a858e262a9c4676e410f098a9b0442ca933a5be498065dc", + "size_in_bytes": 4665 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/mbcharsetprober.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "7d98b2b75d507e58d503bfbcd68988cb11a3b5e45a088aec27385497723e915b", + "sha256_in_prefix": "7d98b2b75d507e58d503bfbcd68988cb11a3b5e45a088aec27385497723e915b", + "size_in_bytes": 2274 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/mbcsgroupprober.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "4c06a7687a7a3d0045c5a95bdd84ea778d9acc1e2584d23ec871a3b73fa22b97", + "sha256_in_prefix": "4c06a7687a7a3d0045c5a95bdd84ea778d9acc1e2584d23ec871a3b73fa22b97", + "size_in_bytes": 1222 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/mbcssm.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "3ca9cd6118f68d8847120879afebf2f20f028f0e2ad8289e36d83d48635ccf67", + "sha256_in_prefix": "3ca9cd6118f68d8847120879afebf2f20f028f0e2ad8289e36d83d48635ccf67", + "size_in_bytes": 20897 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/resultdict.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "9b4ce78ade13c6496b3d4566f37ed8270129562671ab3026e474df8aa83fc613", + "sha256_in_prefix": "9b4ce78ade13c6496b3d4566f37ed8270129562671ab3026e474df8aa83fc613", + "size_in_bytes": 537 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/sbcharsetprober.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "7bf897fef2dda86a1a0e7b81b31f153034b3c6d2865a351bd23f711c714c26e7", + "sha256_in_prefix": "7bf897fef2dda86a1a0e7b81b31f153034b3c6d2865a351bd23f711c714c26e7", + "size_in_bytes": 3643 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/sbcsgroupprober.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "e4a0c833bfa3997acee5e82209a83028afb9cc6d39eec713cc9f740e285df686", + "sha256_in_prefix": "e4a0c833bfa3997acee5e82209a83028afb9cc6d39eec713cc9f740e285df686", + "size_in_bytes": 1701 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/sjisprober.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "a1031b30377608088f96fffbd15100da9b1d404458cbdc4461cd308c4f43d48d", + "sha256_in_prefix": "a1031b30377608088f96fffbd15100da9b1d404458cbdc4461cd308c4f43d48d", + "size_in_bytes": 2600 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/universaldetector.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "83e9dbcd72ac7c054fdc0f85a481ebecfa526e24f944375697d66b48e2c86b31", + "sha256_in_prefix": "83e9dbcd72ac7c054fdc0f85a481ebecfa526e24f944375697d66b48e2c86b31", + "size_in_bytes": 7088 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/utf1632prober.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "009e4769a3ff5f4134dbcc7d607417336b9430e910044c6a99daa36d1fa0c118", + "sha256_in_prefix": "009e4769a3ff5f4134dbcc7d607417336b9430e910044c6a99daa36d1fa0c118", + "size_in_bytes": 6060 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/utf8prober.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "57bdcc7f402c554e105807753f1cb7428a8eb1865ce74ce30aa6ba856ee0308c", + "sha256_in_prefix": "57bdcc7f402c554e105807753f1cb7428a8eb1865ce74ce30aa6ba856ee0308c", + "size_in_bytes": 2070 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/__pycache__/version.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c224b5367ac22d62b0e7cd59c35bd139075f9d87b2ee5e4766960b49b008eec2", + "sha256_in_prefix": "c224b5367ac22d62b0e7cd59c35bd139075f9d87b2ee5e4766960b49b008eec2", + "size_in_bytes": 402 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/big5freq.py", + "path_type": "hardlink", + "sha256": "96d71f3fedcf8e53470a8a397b86bb0b8cfed838414d745f63a8db31b07b3f7d", + "sha256_in_prefix": "96d71f3fedcf8e53470a8a397b86bb0b8cfed838414d745f63a8db31b07b3f7d", + "size_in_bytes": 31274 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/big5prober.py", + "path_type": "hardlink", + "sha256": "94f31fc025fabf601a3e0bc587f7125997202c36d68850872d9fe9f5143dbb11", + "sha256_in_prefix": "94f31fc025fabf601a3e0bc587f7125997202c36d68850872d9fe9f5143dbb11", + "size_in_bytes": 1763 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/chardistribution.py", + "path_type": "hardlink", + "sha256": "d7707c5d41b8a170ee2dd5ef7db216c0b15e47e654db502a4d2d7371d38df1b5", + "sha256_in_prefix": "d7707c5d41b8a170ee2dd5ef7db216c0b15e47e654db502a4d2d7371d38df1b5", + "size_in_bytes": 10032 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/charsetgroupprober.py", + "path_type": "hardlink", + "sha256": "50a2b749a2190763c274a4884b4827bccb4b47d2495fad8cf9f649bb73a55b28", + "sha256_in_prefix": "50a2b749a2190763c274a4884b4827bccb4b47d2495fad8cf9f649bb73a55b28", + "size_in_bytes": 3915 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/charsetprober.py", + "path_type": "hardlink", + "sha256": "2f7b7cff020ea2ff1e9bebd958e71b91db2bc1ee3737afe0a8d879a47ed63dde", + "sha256_in_prefix": "2f7b7cff020ea2ff1e9bebd958e71b91db2bc1ee3737afe0a8d879a47ed63dde", + "size_in_bytes": 5420 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/cli/__init__.py", + "path_type": "hardlink", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size_in_bytes": 0 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/cli/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "8254ef167211ab320d9973a976734a481aec3ac297e704e5ad124fe7dc32b02a", + "sha256_in_prefix": "8254ef167211ab320d9973a976734a481aec3ac297e704e5ad124fe7dc32b02a", + "size_in_bytes": 157 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/cli/__pycache__/chardetect.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "325f7717071a9f8b63fb0c6421293289b4df937b3008430e20a78754589018d0", + "sha256_in_prefix": "325f7717071a9f8b63fb0c6421293289b4df937b3008430e20a78754589018d0", + "size_in_bytes": 2999 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/cli/chardetect.py", + "path_type": "hardlink", + "sha256": "ce26cc560e51a4a6fe304f7fec4606e1933649fd3b347710cd9d7653ead8261a", + "sha256_in_prefix": "ce26cc560e51a4a6fe304f7fec4606e1933649fd3b347710cd9d7653ead8261a", + "size_in_bytes": 3242 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/codingstatemachine.py", + "path_type": "hardlink", + "sha256": "2bb93af6cc378d8e439935e8489415b14b452102983d054e48926106e1afff21", + "sha256_in_prefix": "2bb93af6cc378d8e439935e8489415b14b452102983d054e48926106e1afff21", + "size_in_bytes": 3732 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/codingstatemachinedict.py", + "path_type": "hardlink", + "sha256": "d066371e2daa219bc3ace389dc0b6aa6933546c631affeba111e041e3b8c88c7", + "sha256_in_prefix": "d066371e2daa219bc3ace389dc0b6aa6933546c631affeba111e041e3b8c88c7", + "size_in_bytes": 542 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/cp949prober.py", + "path_type": "hardlink", + "sha256": "d2329157b7c40ae588d7aacd9e4b3464408a03589960220468ff00d59be35122", + "sha256_in_prefix": "d2329157b7c40ae588d7aacd9e4b3464408a03589960220468ff00d59be35122", + "size_in_bytes": 1860 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/enums.py", + "path_type": "hardlink", + "sha256": "4f3102899a0228d32a83053be9c3c278a58506a696bc074b31ebf9fdb0a4858f", + "sha256_in_prefix": "4f3102899a0228d32a83053be9c3c278a58506a696bc074b31ebf9fdb0a4858f", + "size_in_bytes": 1683 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/escprober.py", + "path_type": "hardlink", + "sha256": "2a1a38f17eb9c44d2c705ca521d7898ccd9b71bbd1befd21d1651b316ac90f70", + "sha256_in_prefix": "2a1a38f17eb9c44d2c705ca521d7898ccd9b71bbd1befd21d1651b316ac90f70", + "size_in_bytes": 4006 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/escsm.py", + "path_type": "hardlink", + "sha256": "02ac97a40d854050fb93e6ee06dcbfee2b461189219956bc5f4f4d2d1ba5dd03", + "sha256_in_prefix": "02ac97a40d854050fb93e6ee06dcbfee2b461189219956bc5f4f4d2d1ba5dd03", + "size_in_bytes": 12176 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/eucjpprober.py", + "path_type": "hardlink", + "sha256": "e4a61a33d7ecc64458cf0d5be64d1f2fe8fff9ecc8c3e8a3f6bf7b6bd307c4b6", + "sha256_in_prefix": "e4a61a33d7ecc64458cf0d5be64d1f2fe8fff9ecc8c3e8a3f6bf7b6bd307c4b6", + "size_in_bytes": 3934 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/euckrfreq.py", + "path_type": "hardlink", + "sha256": "de61ee46f5dfb2afd0710cac0d015bf2a4ae76f4e2a25ef50ba21cdb0e7bb4a3", + "sha256_in_prefix": "de61ee46f5dfb2afd0710cac0d015bf2a4ae76f4e2a25ef50ba21cdb0e7bb4a3", + "size_in_bytes": 13566 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/euckrprober.py", + "path_type": "hardlink", + "sha256": "862153eb0335ef8188c11bea0ec21cb8e73e743b2adae3ca30a6f257cfb55e77", + "sha256_in_prefix": "862153eb0335ef8188c11bea0ec21cb8e73e743b2adae3ca30a6f257cfb55e77", + "size_in_bytes": 1753 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/euctwfreq.py", + "path_type": "hardlink", + "sha256": "d9a9482c4d4b8797aa8852598f34643105e894d2511d8e6805077ebe66581453", + "sha256_in_prefix": "d9a9482c4d4b8797aa8852598f34643105e894d2511d8e6805077ebe66581453", + "size_in_bytes": 36913 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/euctwprober.py", + "path_type": "hardlink", + "sha256": "3716e935d06d5345452346ca7c67c39293fb4b6ffcffa1653bcedd547d28830b", + "sha256_in_prefix": "3716e935d06d5345452346ca7c67c39293fb4b6ffcffa1653bcedd547d28830b", + "size_in_bytes": 1753 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/gb2312freq.py", + "path_type": "hardlink", + "sha256": "e3d3ab757cc3f875eac1abe4aa3a3c67b82fb39f2138d3730e103230434d92f6", + "sha256_in_prefix": "e3d3ab757cc3f875eac1abe4aa3a3c67b82fb39f2138d3730e103230434d92f6", + "size_in_bytes": 20735 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/gb2312prober.py", + "path_type": "hardlink", + "sha256": "28f101b9e6922d2bc1a4578834cbb40fa4e01dc47dd1ee4f6906b089fcc5e28d", + "sha256_in_prefix": "28f101b9e6922d2bc1a4578834cbb40fa4e01dc47dd1ee4f6906b089fcc5e28d", + "size_in_bytes": 1759 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/hebrewprober.py", + "path_type": "hardlink", + "sha256": "f7a4ff2e3fce996f9f2bb26b487a23623c86ddfb0681bce4a13365799de47d81", + "sha256_in_prefix": "f7a4ff2e3fce996f9f2bb26b487a23623c86ddfb0681bce4a13365799de47d81", + "size_in_bytes": 14537 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/jisfreq.py", + "path_type": "hardlink", + "sha256": "9a6f2d7ebc2a86939ddf0cd9292e0d26a91805055c0df4ccd89890e5a5bddf61", + "sha256_in_prefix": "9a6f2d7ebc2a86939ddf0cd9292e0d26a91805055c0df4ccd89890e5a5bddf61", + "size_in_bytes": 25796 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/johabfreq.py", + "path_type": "hardlink", + "sha256": "741a4e606df81915fa48bf24fcb6d2f6bc593cc8cb8e8325819d373f3e479aa7", + "sha256_in_prefix": "741a4e606df81915fa48bf24fcb6d2f6bc593cc8cb8e8325819d373f3e479aa7", + "size_in_bytes": 42498 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/johabprober.py", + "path_type": "hardlink", + "sha256": "3b5430f67573467ba7eef669e1464cef0bc94aff56f78d66114f6e0cc9d8dc35", + "sha256_in_prefix": "3b5430f67573467ba7eef669e1464cef0bc94aff56f78d66114f6e0cc9d8dc35", + "size_in_bytes": 1752 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/jpcntx.py", + "path_type": "hardlink", + "sha256": "ba11eb61690bc44feb1793a41ca2279b41d4b2b8e02871d542fb6ddd472fa2d0", + "sha256_in_prefix": "ba11eb61690bc44feb1793a41ca2279b41d4b2b8e02871d542fb6ddd472fa2d0", + "size_in_bytes": 27055 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/langbulgarianmodel.py", + "path_type": "hardlink", + "sha256": "be66ef6053fc499912c6806f2e416a2a21f5b2399ae62864dcf4e9772ef546be", + "sha256_in_prefix": "be66ef6053fc499912c6806f2e416a2a21f5b2399ae62864dcf4e9772ef546be", + "size_in_bytes": 104562 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/langgreekmodel.py", + "path_type": "hardlink", + "sha256": "25f07b6eea638c91f6c375ff9989d0afd70903fec4b884c2d9c456d777d48de2", + "sha256_in_prefix": "25f07b6eea638c91f6c375ff9989d0afd70903fec4b884c2d9c456d777d48de2", + "size_in_bytes": 98484 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/langhebrewmodel.py", + "path_type": "hardlink", + "sha256": "dc75c768b40f34019c5e726390825fa333592d3bd32667f85b90308bacd144a7", + "sha256_in_prefix": "dc75c768b40f34019c5e726390825fa333592d3bd32667f85b90308bacd144a7", + "size_in_bytes": 98196 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/langhungarianmodel.py", + "path_type": "hardlink", + "sha256": "5b16de408c64bfc62d02988dab141cbe3fad33272ca08e17cbe7f09031e93ff6", + "sha256_in_prefix": "5b16de408c64bfc62d02988dab141cbe3fad33272ca08e17cbe7f09031e93ff6", + "size_in_bytes": 101363 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/langrussianmodel.py", + "path_type": "hardlink", + "sha256": "b37f796d367cec4493ad908e7605db12367d3f58863f00a5ffcc52b1a73f0cb6", + "sha256_in_prefix": "b37f796d367cec4493ad908e7605db12367d3f58863f00a5ffcc52b1a73f0cb6", + "size_in_bytes": 128035 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/langthaimodel.py", + "path_type": "hardlink", + "sha256": "edb265422b51a539d51800666d2ce71e72703870f2dc89e44efb45531d775902", + "sha256_in_prefix": "edb265422b51a539d51800666d2ce71e72703870f2dc89e44efb45531d775902", + "size_in_bytes": 102774 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/langturkishmodel.py", + "path_type": "hardlink", + "sha256": "5d8d1e19d4c8cb8790f578352d53d969c6fe501847051f9cab42293d51e8c0a7", + "sha256_in_prefix": "5d8d1e19d4c8cb8790f578352d53d969c6fe501847051f9cab42293d51e8c0a7", + "size_in_bytes": 95372 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/latin1prober.py", + "path_type": "hardlink", + "sha256": "a75e4412615b9905306ca2c2ee53895461c4670706e39b9b1196131aed352798", + "sha256_in_prefix": "a75e4412615b9905306ca2c2ee53895461c4670706e39b9b1196131aed352798", + "size_in_bytes": 5380 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/macromanprober.py", + "path_type": "hardlink", + "sha256": "f5a9dfce663a4c17d43c3c810ce758d3b92a9931e9675b4ad232fea7525670e6", + "sha256_in_prefix": "f5a9dfce663a4c17d43c3c810ce758d3b92a9931e9675b4ad232fea7525670e6", + "size_in_bytes": 6077 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/mbcharsetprober.py", + "path_type": "hardlink", + "sha256": "5abd3858d2381775ff57112f7ab346f87db983bbbe3030ca94db7e2468fefee5", + "sha256_in_prefix": "5abd3858d2381775ff57112f7ab346f87db983bbbe3030ca94db7e2468fefee5", + "size_in_bytes": 3715 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/mbcsgroupprober.py", + "path_type": "hardlink", + "sha256": "891a5a3418d5d0337060fbbfcfa4e21e0469c186a188cef3b48ff8919e14cfd0", + "sha256_in_prefix": "891a5a3418d5d0337060fbbfcfa4e21e0469c186a188cef3b48ff8919e14cfd0", + "size_in_bytes": 2131 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/mbcssm.py", + "path_type": "hardlink", + "sha256": "854b4fbc3620583680d9d59d80bb2c85bc117e6dd0e5846546881d99e454350c", + "sha256_in_prefix": "854b4fbc3620583680d9d59d80bb2c85bc117e6dd0e5846546881d99e454350c", + "size_in_bytes": 30391 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/metadata/__init__.py", + "path_type": "hardlink", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size_in_bytes": 0 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/metadata/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "91239a0a26e8dc8404dc2d26b5d1daa690ad00cd1a93ab7c8150ceb69d1780bb", + "sha256_in_prefix": "91239a0a26e8dc8404dc2d26b5d1daa690ad00cd1a93ab7c8150ceb69d1780bb", + "size_in_bytes": 162 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/metadata/__pycache__/languages.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c876a32c2aeac89a7c6fcc494401a5ab96eae488139d642d77ba633dcb189cc3", + "sha256_in_prefix": "c876a32c2aeac89a7c6fcc494401a5ab96eae488139d642d77ba633dcb189cc3", + "size_in_bytes": 8145 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/metadata/languages.py", + "path_type": "hardlink", + "sha256": "161bc121d645c5143e753c246ffd2669d44a815042694310cfd239c6a8c4e624", + "sha256_in_prefix": "161bc121d645c5143e753c246ffd2669d44a815042694310cfd239c6a8c4e624", + "size_in_bytes": 13560 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/py.typed", + "path_type": "hardlink", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size_in_bytes": 0 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/resultdict.py", + "path_type": "hardlink", + "sha256": "7b3e0546f37929a4a8b09789d96cd4c8a743760df91c3cbf4922cf5ca09db793", + "sha256_in_prefix": "7b3e0546f37929a4a8b09789d96cd4c8a743760df91c3cbf4922cf5ca09db793", + "size_in_bytes": 402 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/sbcharsetprober.py", + "path_type": "hardlink", + "sha256": "fa777717dd22ec6a572e37a12d51ea5411342a55b31af4143c44cb04d9f8a3a5", + "sha256_in_prefix": "fa777717dd22ec6a572e37a12d51ea5411342a55b31af4143c44cb04d9f8a3a5", + "size_in_bytes": 6400 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/sbcsgroupprober.py", + "path_type": "hardlink", + "sha256": "81c808d1f39f830ff76130a5a5badafcc371c321322777945eb6a82c761be7d1", + "sha256_in_prefix": "81c808d1f39f830ff76130a5a5badafcc371c321322777945eb6a82c761be7d1", + "size_in_bytes": 4137 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/sjisprober.py", + "path_type": "hardlink", + "sha256": "6aa42e7cccd1c38e99a45973998698793dbe9f398a6fe86672b029a6927ceb69", + "sha256_in_prefix": "6aa42e7cccd1c38e99a45973998698793dbe9f398a6fe86672b029a6927ceb69", + "size_in_bytes": 4007 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/universaldetector.py", + "path_type": "hardlink", + "sha256": "c5806b838c7475df569d3f2a7257c00d50fda2776b50d92a3e6bed7b5a5ae76d", + "sha256_in_prefix": "c5806b838c7475df569d3f2a7257c00d50fda2776b50d92a3e6bed7b5a5ae76d", + "size_in_bytes": 14848 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/utf1632prober.py", + "path_type": "hardlink", + "sha256": "a70d5ea4674c8f58431a20aed401eaab33847e35fc3157625bb3b50654fcf9e4", + "sha256_in_prefix": "a70d5ea4674c8f58431a20aed401eaab33847e35fc3157625bb3b50654fcf9e4", + "size_in_bytes": 8505 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/utf8prober.py", + "path_type": "hardlink", + "sha256": "f26d3c51be78f741f88d0e8b617bc5cac1ad80aa0ab0751ddb31ff8bcfd39d5c", + "sha256_in_prefix": "f26d3c51be78f741f88d0e8b617bc5cac1ad80aa0ab0751ddb31ff8bcfd39d5c", + "size_in_bytes": 2812 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/chardet/version.py", + "path_type": "hardlink", + "sha256": "946b4973118ce38433e026e4e2b6db9ab2b19cdaf5fbded4db94da99e2de859c", + "sha256_in_prefix": "946b4973118ce38433e026e4e2b6db9ab2b19cdaf5fbded4db94da99e2de859c", + "size_in_bytes": 244 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/colorama/__init__.py", + "path_type": "hardlink", + "sha256": "c1e3d0038536d2d2a060047248b102d38eee70d5fe83ca512e9601ba21e52dbf", + "sha256_in_prefix": "c1e3d0038536d2d2a060047248b102d38eee70d5fe83ca512e9601ba21e52dbf", + "size_in_bytes": 266 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/colorama/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "7ae10c95e34a1707777d56e5df9801a80664a9a304dfcf7b34ac8289cdf4f2f1", + "sha256_in_prefix": "7ae10c95e34a1707777d56e5df9801a80664a9a304dfcf7b34ac8289cdf4f2f1", + "size_in_bytes": 440 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/colorama/__pycache__/ansi.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "6873742d61cd2b346eb522ff97ad17161e69053cf7049b19933c47306edf8102", + "sha256_in_prefix": "6873742d61cd2b346eb522ff97ad17161e69053cf7049b19933c47306edf8102", + "size_in_bytes": 2966 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/colorama/__pycache__/ansitowin32.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "903855256ebe6f6cec37492ed9040dccbfdef78c738992d89998719ffb87f683", + "sha256_in_prefix": "903855256ebe6f6cec37492ed9040dccbfdef78c738992d89998719ffb87f683", + "size_in_bytes": 8478 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/colorama/__pycache__/initialise.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "6aa6cf02b1aed3188b98ea8106cc9ad6a6b6265f4e7032d3ceadf90fd92238b1", + "sha256_in_prefix": "6aa6cf02b1aed3188b98ea8106cc9ad6a6b6265f4e7032d3ceadf90fd92238b1", + "size_in_bytes": 2223 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/colorama/__pycache__/win32.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "3007f5f127a250bf25a05214637037254d9a683e3431317366e806dbee6a2131", + "sha256_in_prefix": "3007f5f127a250bf25a05214637037254d9a683e3431317366e806dbee6a2131", + "size_in_bytes": 4433 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/colorama/__pycache__/winterm.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "d9b3256add4d650a8a87cbdb17158ed8cd7b697e6c7b7e3c5ee89ffefd3caa25", + "sha256_in_prefix": "d9b3256add4d650a8a87cbdb17158ed8cd7b697e6c7b7e3c5ee89ffefd3caa25", + "size_in_bytes": 5129 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/colorama/ansi.py", + "path_type": "hardlink", + "sha256": "4e8a7811e12e69074159db5e28c11c18e4de29e175f50f96a3febf0a3e643b34", + "sha256_in_prefix": "4e8a7811e12e69074159db5e28c11c18e4de29e175f50f96a3febf0a3e643b34", + "size_in_bytes": 2522 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/colorama/ansitowin32.py", + "path_type": "hardlink", + "sha256": "bcf3586b73996f18dbb85c9a568d139a19b2d4567594a3160a74fba1d5e922d9", + "sha256_in_prefix": "bcf3586b73996f18dbb85c9a568d139a19b2d4567594a3160a74fba1d5e922d9", + "size_in_bytes": 11128 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/colorama/initialise.py", + "path_type": "hardlink", + "sha256": "fa1227cbce82957a37f62c61e624827d421ad9ffe1fdb80a4435bb82ab3e28b5", + "sha256_in_prefix": "fa1227cbce82957a37f62c61e624827d421ad9ffe1fdb80a4435bb82ab3e28b5", + "size_in_bytes": 3325 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/colorama/tests/__init__.py", + "path_type": "hardlink", + "sha256": "32480f004cc641df91ab4c343d95d25f62da7515a150409c8ac258f254ab9b84", + "sha256_in_prefix": "32480f004cc641df91ab4c343d95d25f62da7515a150409c8ac258f254ab9b84", + "size_in_bytes": 75 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/colorama/tests/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "ec68c518f1bcd3113f794229cf22ddf8456e6d872e6bfa5c71177b39017511d7", + "sha256_in_prefix": "ec68c518f1bcd3113f794229cf22ddf8456e6d872e6bfa5c71177b39017511d7", + "size_in_bytes": 160 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/colorama/tests/__pycache__/ansi_test.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "3ff05ba81ce64ba9d7b4e4990fdf507b4119c6de1a109bf5e0f6abd5d6b65208", + "sha256_in_prefix": "3ff05ba81ce64ba9d7b4e4990fdf507b4119c6de1a109bf5e0f6abd5d6b65208", + "size_in_bytes": 2252 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/colorama/tests/__pycache__/ansitowin32_test.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "617f61b1e6b2aedb28e883563eba38c693e1e38d715a1d32306ff5b50b804044", + "sha256_in_prefix": "617f61b1e6b2aedb28e883563eba38c693e1e38d715a1d32306ff5b50b804044", + "size_in_bytes": 11563 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/colorama/tests/__pycache__/initialise_test.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "f8d46565dfbfb0813f3f8c6f6b6ccc64a137fdaef9192a8cd2897e85a8ee96ec", + "sha256_in_prefix": "f8d46565dfbfb0813f3f8c6f6b6ccc64a137fdaef9192a8cd2897e85a8ee96ec", + "size_in_bytes": 6860 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/colorama/tests/__pycache__/isatty_test.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "293b181b36b963f19a6bfadd2bbfa1ec41f4fae048553448430bff78942a31dc", + "sha256_in_prefix": "293b181b36b963f19a6bfadd2bbfa1ec41f4fae048553448430bff78942a31dc", + "size_in_bytes": 2651 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/colorama/tests/__pycache__/utils.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "78a35cc414680e5f669d9beb930565a4e36b4c4553bfe2f9ae25b5b4a0d9ed19", + "sha256_in_prefix": "78a35cc414680e5f669d9beb930565a4e36b4c4553bfe2f9ae25b5b4a0d9ed19", + "size_in_bytes": 1560 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/colorama/tests/__pycache__/winterm_test.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "ff224c4554d32735d36f2c22c8e76cb0ccee448c924cf282056f4b67d06678da", + "sha256_in_prefix": "ff224c4554d32735d36f2c22c8e76cb0ccee448c924cf282056f4b67d06678da", + "size_in_bytes": 3153 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/colorama/tests/ansi_test.py", + "path_type": "hardlink", + "sha256": "15e5620eb50834865caf9d393c0c6f5380235f3d5ab048802ecf465cc87045a1", + "sha256_in_prefix": "15e5620eb50834865caf9d393c0c6f5380235f3d5ab048802ecf465cc87045a1", + "size_in_bytes": 2839 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/colorama/tests/ansitowin32_test.py", + "path_type": "hardlink", + "sha256": "44dec0221309e44a83b186828d5a3ea38bbc2730c3e2e9096e67af58a4bbd2b6", + "sha256_in_prefix": "44dec0221309e44a83b186828d5a3ea38bbc2730c3e2e9096e67af58a4bbd2b6", + "size_in_bytes": 10678 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/colorama/tests/initialise_test.py", + "path_type": "hardlink", + "sha256": "05b3f2f977f21f027accaa33b903af36f419cecc7dbdd6ffd1b6179fb86c0537", + "sha256_in_prefix": "05b3f2f977f21f027accaa33b903af36f419cecc7dbdd6ffd1b6179fb86c0537", + "size_in_bytes": 6741 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/colorama/tests/isatty_test.py", + "path_type": "hardlink", + "sha256": "3e0dba2d1a6fd3240307901cfacc605571bb86c035358bdaa45800a597d8cd98", + "sha256_in_prefix": "3e0dba2d1a6fd3240307901cfacc605571bb86c035358bdaa45800a597d8cd98", + "size_in_bytes": 1866 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/colorama/tests/utils.py", + "path_type": "hardlink", + "sha256": "d48211ca51b7f73e7e773ab4f51fe782e7f1c8f67182574d6ebc4ac541b018a1", + "sha256_in_prefix": "d48211ca51b7f73e7e773ab4f51fe782e7f1c8f67182574d6ebc4ac541b018a1", + "size_in_bytes": 1079 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/colorama/tests/winterm_test.py", + "path_type": "hardlink", + "sha256": "aa85853c48f29b9826d91b8cc297f7a4e8acddae6bfcf259142ccadb9e092fc0", + "sha256_in_prefix": "aa85853c48f29b9826d91b8cc297f7a4e8acddae6bfcf259142ccadb9e092fc0", + "size_in_bytes": 3709 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/colorama/win32.py", + "path_type": "hardlink", + "sha256": "61038ac0c4f0b4605bb18e1d2f91d84efc1378ff70210adae4cbcf35d769c59b", + "sha256_in_prefix": "61038ac0c4f0b4605bb18e1d2f91d84efc1378ff70210adae4cbcf35d769c59b", + "size_in_bytes": 6181 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/colorama/winterm.py", + "path_type": "hardlink", + "sha256": "5c24050c78cf8ba00760d759c32d2d034d87f89878f09a7e1ef0a378b78ba775", + "sha256_in_prefix": "5c24050c78cf8ba00760d759c32d2d034d87f89878f09a7e1ef0a378b78ba775", + "size_in_bytes": 7134 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/distlib/__init__.py", + "path_type": "hardlink", + "sha256": "849285ec51e8a9b9867249dc0ee108356a3f3989033621ce0ed61748c72f8dc7", + "sha256_in_prefix": "849285ec51e8a9b9867249dc0ee108356a3f3989033621ce0ed61748c72f8dc7", + "size_in_bytes": 625 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/distlib/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "735c7dd4836f2cfd3bb8742277047cc5e248058cb83683ec5c80aaedefd96379", + "sha256_in_prefix": "735c7dd4836f2cfd3bb8742277047cc5e248058cb83683ec5c80aaedefd96379", + "size_in_bytes": 1024 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/distlib/__pycache__/compat.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "ad32d4dd96dd338a5ed81b518166b4c2b8c3fe1ce987f061a55fa79cfd605dce", + "sha256_in_prefix": "ad32d4dd96dd338a5ed81b518166b4c2b8c3fe1ce987f061a55fa79cfd605dce", + "size_in_bytes": 31401 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/distlib/__pycache__/database.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "2e4364d9bcf3571b6b1ee2382c7189905eb8fc93f0c3cbce669894cb15ba23b6", + "sha256_in_prefix": "2e4364d9bcf3571b6b1ee2382c7189905eb8fc93f0c3cbce669894cb15ba23b6", + "size_in_bytes": 43138 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/distlib/__pycache__/index.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c07234afca246420f1f3aed3696beef0a54ef61b1e8289a76be804d15bd0ee45", + "sha256_in_prefix": "c07234afca246420f1f3aed3696beef0a54ef61b1e8289a76be804d15bd0ee45", + "size_in_bytes": 17261 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/distlib/__pycache__/locators.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "8692eb0bbd43726371dbfabb6bc9312d144fdefb07b07ee6726a839a135fca84", + "sha256_in_prefix": "8692eb0bbd43726371dbfabb6bc9312d144fdefb07b07ee6726a839a135fca84", + "size_in_bytes": 38288 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/distlib/__pycache__/manifest.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "0cc13bcdc4ef5c9fd17b34a7875d8118e1e5646de9ed28fa6934f25cc5d91111", + "sha256_in_prefix": "0cc13bcdc4ef5c9fd17b34a7875d8118e1e5646de9ed28fa6934f25cc5d91111", + "size_in_bytes": 10189 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/distlib/__pycache__/markers.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "7a90ea52aadac35a1d28e21eebd675d3870dc5b3197c06344d64af22e9e76931", + "sha256_in_prefix": "7a90ea52aadac35a1d28e21eebd675d3870dc5b3197c06344d64af22e9e76931", + "size_in_bytes": 5277 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/distlib/__pycache__/metadata.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "0e05f9c67c401312417a23cb7d5cb2df906c4529af48326cb8eb599a00e7f0fd", + "sha256_in_prefix": "0e05f9c67c401312417a23cb7d5cb2df906c4529af48326cb8eb599a00e7f0fd", + "size_in_bytes": 26992 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/distlib/__pycache__/resources.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "f786b8bb3f525579a2358fed487f9198f084a6e63655cef686b86eb36ecd31d3", + "sha256_in_prefix": "f786b8bb3f525579a2358fed487f9198f084a6e63655cef686b86eb36ecd31d3", + "size_in_bytes": 10998 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/distlib/__pycache__/scripts.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "322e81cc763970b588570ce3f7e7dfc2b41d9f08a03033769af9d4d52ada9dc1", + "sha256_in_prefix": "322e81cc763970b588570ce3f7e7dfc2b41d9f08a03033769af9d4d52ada9dc1", + "size_in_bytes": 11484 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/distlib/__pycache__/util.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "a6e1a3b54f011588b91828e4c3b7446cc282fe583fb896efe9479cecd82f53fe", + "sha256_in_prefix": "a6e1a3b54f011588b91828e4c3b7446cc282fe583fb896efe9479cecd82f53fe", + "size_in_bytes": 52102 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/distlib/__pycache__/version.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "6c9f4a71f2519bae6049aef937aaa73248e3b18a33ff63863ac60b6a45429851", + "sha256_in_prefix": "6c9f4a71f2519bae6049aef937aaa73248e3b18a33ff63863ac60b6a45429851", + "size_in_bytes": 20245 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/distlib/__pycache__/wheel.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "d59188ff0145602b044cb407e28c02fe290dc65b94c85cce8be41ea78febd23a", + "sha256_in_prefix": "d59188ff0145602b044cb407e28c02fe290dc65b94c85cce8be41ea78febd23a", + "size_in_bytes": 27640 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/distlib/compat.py", + "path_type": "hardlink", + "sha256": "527fae201bf2d36c3e0f6ebb386e15121b9d76a5a02a3f67364c5596d01bef9c", + "sha256_in_prefix": "527fae201bf2d36c3e0f6ebb386e15121b9d76a5a02a3f67364c5596d01bef9c", + "size_in_bytes": 41487 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/distlib/database.py", + "path_type": "hardlink", + "sha256": "d15f50becd15af16b617ffa12d68ad2325724627c9d290b1c8e23e904381c2c0", + "sha256_in_prefix": "d15f50becd15af16b617ffa12d68ad2325724627c9d290b1c8e23e904381c2c0", + "size_in_bytes": 51965 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/distlib/index.py", + "path_type": "hardlink", + "sha256": "9536f0dbaf2b4618fc770d6c89bdd567fd048521a0a093b714a27348530e69e0", + "sha256_in_prefix": "9536f0dbaf2b4618fc770d6c89bdd567fd048521a0a093b714a27348530e69e0", + "size_in_bytes": 20797 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/distlib/locators.py", + "path_type": "hardlink", + "sha256": "a35aff33cebf6d12da7d2a5eb66c9f5fc291b45bbefd0e7c69bbd0ae73929db0", + "sha256_in_prefix": "a35aff33cebf6d12da7d2a5eb66c9f5fc291b45bbefd0e7c69bbd0ae73929db0", + "size_in_bytes": 51767 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/distlib/manifest.py", + "path_type": "hardlink", + "sha256": "dea7e6026570c51a94d68db70257d7ad0199ce1ea0fc61b34c03ff1dbf42e734", + "sha256_in_prefix": "dea7e6026570c51a94d68db70257d7ad0199ce1ea0fc61b34c03ff1dbf42e734", + "size_in_bytes": 14168 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/distlib/markers.py", + "path_type": "hardlink", + "sha256": "9f70df3a1d72bd9ffc116edab4cca861e6455e36256b4373d22b509688c27740", + "sha256_in_prefix": "9f70df3a1d72bd9ffc116edab4cca861e6455e36256b4373d22b509688c27740", + "size_in_bytes": 5268 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/distlib/metadata.py", + "path_type": "hardlink", + "sha256": "a41f5667d9817e643173d39522574b4b90a33a8411bca02f530c10c8ac0a42d4", + "sha256_in_prefix": "a41f5667d9817e643173d39522574b4b90a33a8411bca02f530c10c8ac0a42d4", + "size_in_bytes": 39693 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/distlib/resources.py", + "path_type": "hardlink", + "sha256": "2f06cf92c73403524c6e2e979ee3dd301527f375fb04fb85356a8f184288ebdf", + "sha256_in_prefix": "2f06cf92c73403524c6e2e979ee3dd301527f375fb04fb85356a8f184288ebdf", + "size_in_bytes": 10820 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/distlib/scripts.py", + "path_type": "hardlink", + "sha256": "9d015737a1bb9ce58d0d4cb18ab51ea7edd63a526107b31cbc2b3dcce9e41932", + "sha256_in_prefix": "9d015737a1bb9ce58d0d4cb18ab51ea7edd63a526107b31cbc2b3dcce9e41932", + "size_in_bytes": 18315 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/distlib/util.py", + "path_type": "hardlink", + "sha256": "5d2ce7c448bf8b74f6d1426e695734a971f3e64b065025b5921625069acdfd01", + "sha256_in_prefix": "5d2ce7c448bf8b74f6d1426e695734a971f3e64b065025b5921625069acdfd01", + "size_in_bytes": 67530 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/distlib/version.py", + "path_type": "hardlink", + "sha256": "f695e476e721bdefda37b246ea22fd553615fe4a8d486a1cd83c25f09bb24a74", + "sha256_in_prefix": "f695e476e721bdefda37b246ea22fd553615fe4a8d486a1cd83c25f09bb24a74", + "size_in_bytes": 23747 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/distlib/wheel.py", + "path_type": "hardlink", + "sha256": "155402bdef2ef8bd10624e7e61365ceece1698d41dbe34564cad3c297cd9557e", + "sha256_in_prefix": "155402bdef2ef8bd10624e7e61365ceece1698d41dbe34564cad3c297cd9557e", + "size_in_bytes": 43958 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/distro/__init__.py", + "path_type": "hardlink", + "sha256": "d9f1e317e49f80fbe3c8d67588787fc23a96751fd8a393831f0642d232c13e17", + "sha256_in_prefix": "d9f1e317e49f80fbe3c8d67588787fc23a96751fd8a393831f0642d232c13e17", + "size_in_bytes": 981 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/distro/__main__.py", + "path_type": "hardlink", + "sha256": "6eef5ddd389fa0a72264572a441bb2815dc64ae4e19d50ff9b620ae1ccfde95b", + "sha256_in_prefix": "6eef5ddd389fa0a72264572a441bb2815dc64ae4e19d50ff9b620ae1ccfde95b", + "size_in_bytes": 64 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/distro/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "4108224ca1acb459860da5bbecae343a64230c1a206887a636aae81f59db284b", + "sha256_in_prefix": "4108224ca1acb459860da5bbecae343a64230c1a206887a636aae81f59db284b", + "size_in_bytes": 877 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/distro/__pycache__/__main__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "d96b1c1a76f62b5158b881965264aac8f6e07490998c0e5ccfe89560a0d2dfc9", + "sha256_in_prefix": "d96b1c1a76f62b5158b881965264aac8f6e07490998c0e5ccfe89560a0d2dfc9", + "size_in_bytes": 231 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/distro/__pycache__/distro.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "ccb20259f579b322aaaacd24a6348d55d6913ccbc6391550c253d7e5bf3d668e", + "sha256_in_prefix": "ccb20259f579b322aaaacd24a6348d55d6913ccbc6391550c253d7e5bf3d668e", + "size_in_bytes": 42025 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/distro/distro.py", + "path_type": "hardlink", + "sha256": "5193b52e3221b4508c7656e2cf7f608f7ada57e0267f7481c331b37c0a62307c", + "sha256_in_prefix": "5193b52e3221b4508c7656e2cf7f608f7ada57e0267f7481c331b37c0a62307c", + "size_in_bytes": 49330 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/distro/py.typed", + "path_type": "hardlink", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size_in_bytes": 0 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/idna/__init__.py", + "path_type": "hardlink", + "sha256": "28940dd5e401afc8882b948aac9e3b957bf11b4049ecb9b7f16e334f4bfff259", + "sha256_in_prefix": "28940dd5e401afc8882b948aac9e3b957bf11b4049ecb9b7f16e334f4bfff259", + "size_in_bytes": 849 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/idna/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "797a5b0e0bd097375894925a9752a99ea482c1c0b1478b8e7f5076a210febacb", + "sha256_in_prefix": "797a5b0e0bd097375894925a9752a99ea482c1c0b1478b8e7f5076a210febacb", + "size_in_bytes": 809 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/idna/__pycache__/codec.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "fd20e606e7c1734f781466205aaeaed3059157ef5ee8b76d8085eff265861ca6", + "sha256_in_prefix": "fd20e606e7c1734f781466205aaeaed3059157ef5ee8b76d8085eff265861ca6", + "size_in_bytes": 2780 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/idna/__pycache__/compat.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "b5a5f4bb55fe2327ad3013a3af913ecd998a8b81e8d8e14b3b9710d29792f061", + "sha256_in_prefix": "b5a5f4bb55fe2327ad3013a3af913ecd998a8b81e8d8e14b3b9710d29792f061", + "size_in_bytes": 709 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/idna/__pycache__/core.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "5e1b7493896bf31b6ea74d7ee4b4e36a065808d5d2a058663eecb3f37c3d2262", + "sha256_in_prefix": "5e1b7493896bf31b6ea74d7ee4b4e36a065808d5d2a058663eecb3f37c3d2262", + "size_in_bytes": 9638 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/idna/__pycache__/idnadata.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "59ec76a29255ec7fb86ff74288b30d2044558db61b4dda457b6b9e0ab3462bd7", + "sha256_in_prefix": "59ec76a29255ec7fb86ff74288b30d2044558db61b4dda457b6b9e0ab3462bd7", + "size_in_bytes": 38345 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/idna/__pycache__/intranges.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "ef1872d73aa6c98fe1a8e2eb8708276734cf6a66f172053a27da1d4fbd5be20c", + "sha256_in_prefix": "ef1872d73aa6c98fe1a8e2eb8708276734cf6a66f172053a27da1d4fbd5be20c", + "size_in_bytes": 1946 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/idna/__pycache__/package_data.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "59370787ec713c0d67ab38e57e538865b900a314c2a63441f12786417444c4d1", + "sha256_in_prefix": "59370787ec713c0d67ab38e57e538865b900a314c2a63441f12786417444c4d1", + "size_in_bytes": 173 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/idna/__pycache__/uts46data.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "a3f4596b3426bfe3d9927abed7960303aa3770a6f619b6db31ccd756ab4e2329", + "sha256_in_prefix": "a3f4596b3426bfe3d9927abed7960303aa3770a6f619b6db31ccd756ab4e2329", + "size_in_bytes": 152360 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/idna/codec.py", + "path_type": "hardlink", + "sha256": "ea5cb9a1d29faabcad293f7fed4ae51a49479dfd4348adabf42e9c48ce2c6b6f", + "sha256_in_prefix": "ea5cb9a1d29faabcad293f7fed4ae51a49479dfd4348adabf42e9c48ce2c6b6f", + "size_in_bytes": 3374 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/idna/compat.py", + "path_type": "hardlink", + "sha256": "d3fb0e114313e02570f5da03defc91857f345f5f4fc2a168501b3b816b05304e", + "sha256_in_prefix": "d3fb0e114313e02570f5da03defc91857f345f5f4fc2a168501b3b816b05304e", + "size_in_bytes": 321 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/idna/core.py", + "path_type": "hardlink", + "sha256": "d49c5c8702b39310529fb47fa02135da806edde56ec74573771a2598869ddb83", + "sha256_in_prefix": "d49c5c8702b39310529fb47fa02135da806edde56ec74573771a2598869ddb83", + "size_in_bytes": 12950 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/idna/idnadata.py", + "path_type": "hardlink", + "sha256": "c548ea2aa88957c1e8fd7cc1a40b6fe4916854f4aea4af92517bed8f28141eac", + "sha256_in_prefix": "c548ea2aa88957c1e8fd7cc1a40b6fe4916854f4aea4af92517bed8f28141eac", + "size_in_bytes": 44375 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/idna/intranges.py", + "path_type": "hardlink", + "sha256": "601af87d162e587ee44ca4b6b579458ccdb8645d4f76f722afe6b2c278889ea8", + "sha256_in_prefix": "601af87d162e587ee44ca4b6b579458ccdb8645d4f76f722afe6b2c278889ea8", + "size_in_bytes": 1881 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/idna/package_data.py", + "path_type": "hardlink", + "sha256": "0bf8c7273997f0f238c6ad23a7399c4ccc696f9943b2ae28e55cb1433955ad91", + "sha256_in_prefix": "0bf8c7273997f0f238c6ad23a7399c4ccc696f9943b2ae28e55cb1433955ad91", + "size_in_bytes": 21 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/idna/py.typed", + "path_type": "hardlink", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size_in_bytes": 0 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/idna/uts46data.py", + "path_type": "hardlink", + "sha256": "cef8d9536e2ce7cfee012f39d0c71dd0d9c3d17eff802300323cd634879425d7", + "sha256_in_prefix": "cef8d9536e2ce7cfee012f39d0c71dd0d9c3d17eff802300323cd634879425d7", + "size_in_bytes": 206539 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/msgpack/__init__.py", + "path_type": "hardlink", + "sha256": "8721a196799c264c6bc8904a0b75f9167129877ef9910a0bfe61bc2d952e5e06", + "sha256_in_prefix": "8721a196799c264c6bc8904a0b75f9167129877ef9910a0bfe61bc2d952e5e06", + "size_in_bytes": 1132 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/msgpack/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "9e52f52fb6722818fc2a771955cbfdc0a7af3c57d4b44a88454a9f083ab7a39f", + "sha256_in_prefix": "9e52f52fb6722818fc2a771955cbfdc0a7af3c57d4b44a88454a9f083ab7a39f", + "size_in_bytes": 1407 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/msgpack/__pycache__/exceptions.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "bcace68ce4a5552f1a85bebc57bb64f7803023735b2a36a25eaf56e0aaa9d967", + "sha256_in_prefix": "bcace68ce4a5552f1a85bebc57bb64f7803023735b2a36a25eaf56e0aaa9d967", + "size_in_bytes": 1770 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/msgpack/__pycache__/ext.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "6ff6996578fb5e80fa86e1fbf5c139d61e8adec5294090a743187bde4783728f", + "sha256_in_prefix": "6ff6996578fb5e80fa86e1fbf5c139d61e8adec5294090a743187bde4783728f", + "size_in_bytes": 6277 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/msgpack/__pycache__/fallback.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "048cd8afcf30ede12db0a12402c6c491bfa66f6bc3b4fc8b372ca48e5c39862f", + "sha256_in_prefix": "048cd8afcf30ede12db0a12402c6c491bfa66f6bc3b4fc8b372ca48e5c39862f", + "size_in_bytes": 25440 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/msgpack/exceptions.py", + "path_type": "hardlink", + "sha256": "7424d67a2f1da64accb100dc8d093be004e5f47b08047d326edf3338f36a3187", + "sha256_in_prefix": "7424d67a2f1da64accb100dc8d093be004e5f47b08047d326edf3338f36a3187", + "size_in_bytes": 1081 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/msgpack/ext.py", + "path_type": "hardlink", + "sha256": "0b930af0985560660558fbf1b0e46ca99027bce5de7d8439ee6d589b496e5b93", + "sha256_in_prefix": "0b930af0985560660558fbf1b0e46ca99027bce5de7d8439ee6d589b496e5b93", + "size_in_bytes": 6079 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/msgpack/fallback.py", + "path_type": "hardlink", + "sha256": "b6f3411f2c7115bb95942f066528444c2949c632e20cc3a36b85f0c32bcd9b68", + "sha256_in_prefix": "b6f3411f2c7115bb95942f066528444c2949c632e20cc3a36b85f0c32bcd9b68", + "size_in_bytes": 34544 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/packaging/__about__.py", + "path_type": "hardlink", + "sha256": "ba001220edb0d685321fcfc23aa4365ffb34ac38636e1402df2268703d378767", + "sha256_in_prefix": "ba001220edb0d685321fcfc23aa4365ffb34ac38636e1402df2268703d378767", + "size_in_bytes": 661 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/packaging/__init__.py", + "path_type": "hardlink", + "sha256": "6fd2a4e4c17b2b18612e07039a2516ba437e2dab561713dd36e8348e83e11d29", + "sha256_in_prefix": "6fd2a4e4c17b2b18612e07039a2516ba437e2dab561713dd36e8348e83e11d29", + "size_in_bytes": 497 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/packaging/__pycache__/__about__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "3fde662d326eae1d320fe419a33d8d1d7ad596dfc2e2a50b22fefbd0c5ae5df5", + "sha256_in_prefix": "3fde662d326eae1d320fe419a33d8d1d7ad596dfc2e2a50b22fefbd0c5ae5df5", + "size_in_bytes": 552 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/packaging/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "5a5f3ebefeb65c2d4c02afbf055dc9dfcb20f51aed7ec1866eea21b7cc93919f", + "sha256_in_prefix": "5a5f3ebefeb65c2d4c02afbf055dc9dfcb20f51aed7ec1866eea21b7cc93919f", + "size_in_bytes": 408 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/packaging/__pycache__/_manylinux.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "017889b56e54eb0af523229107ad05521a1149a3b30dec25de022fa4c34b73e4", + "sha256_in_prefix": "017889b56e54eb0af523229107ad05521a1149a3b30dec25de022fa4c34b73e4", + "size_in_bytes": 7262 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/packaging/__pycache__/_musllinux.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "d5d30f58ba6fc75b2f3c3d1ea8370aff585ef0c39c4414a3d15a432dda377029", + "sha256_in_prefix": "d5d30f58ba6fc75b2f3c3d1ea8370aff585ef0c39c4414a3d15a432dda377029", + "size_in_bytes": 4574 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/packaging/__pycache__/_structures.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "f791d63df6a29f7682dc7cba8d03db7f75f4c6b4a0f020afeb7ed629e49e3a77", + "sha256_in_prefix": "f791d63df6a29f7682dc7cba8d03db7f75f4c6b4a0f020afeb7ed629e49e3a77", + "size_in_bytes": 2667 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/packaging/__pycache__/markers.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "1d57d7e3a97d7e2fe4660f00f107379d6e942bf895c346fd2c4424e345ebf5b9", + "sha256_in_prefix": "1d57d7e3a97d7e2fe4660f00f107379d6e942bf895c346fd2c4424e345ebf5b9", + "size_in_bytes": 9249 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/packaging/__pycache__/requirements.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "146f9d51723112be0c7cadb431bd562a56582842810f2e4cdff322bbafae9670", + "sha256_in_prefix": "146f9d51723112be0c7cadb431bd562a56582842810f2e4cdff322bbafae9670", + "size_in_bytes": 3937 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/packaging/__pycache__/specifiers.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "1c5604ea8a1ec21d85da4b3fcb1f55cd1882b07cffc8c64894e6dc42d993f8f3", + "sha256_in_prefix": "1c5604ea8a1ec21d85da4b3fcb1f55cd1882b07cffc8c64894e6dc42d993f8f3", + "size_in_bytes": 21489 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/packaging/__pycache__/tags.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "ce5aa9d79e32abf2253f7626598b578d13463f19954165e652921e3e405217b0", + "sha256_in_prefix": "ce5aa9d79e32abf2253f7626598b578d13463f19954165e652921e3e405217b0", + "size_in_bytes": 12152 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/packaging/__pycache__/utils.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "19323ef89e3c0af0e897b77f9bfacb01430b9fc1f63f91d991a6e62472e4fdf3", + "sha256_in_prefix": "19323ef89e3c0af0e897b77f9bfacb01430b9fc1f63f91d991a6e62472e4fdf3", + "size_in_bytes": 3537 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/packaging/__pycache__/version.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "f7a7ac846a7a3c7cd1e675658f6cb7a420203e5ac9e59b765e8dd0409a04443e", + "sha256_in_prefix": "f7a7ac846a7a3c7cd1e675658f6cb7a420203e5ac9e59b765e8dd0409a04443e", + "size_in_bytes": 12887 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/packaging/_manylinux.py", + "path_type": "hardlink", + "sha256": "5dc6e25c1faa723bf76dca21a7a37df1332938fe3f8f79be88e03ca6d2b61966", + "sha256_in_prefix": "5dc6e25c1faa723bf76dca21a7a37df1332938fe3f8f79be88e03ca6d2b61966", + "size_in_bytes": 11488 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/packaging/_musllinux.py", + "path_type": "hardlink", + "sha256": "fca1a063fa9ceef84c1a9a2ab2cdb99f68622c234a46dbf3f660ab4bb824ab27", + "sha256_in_prefix": "fca1a063fa9ceef84c1a9a2ab2cdb99f68622c234a46dbf3f660ab4bb824ab27", + "size_in_bytes": 4378 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/packaging/_structures.py", + "path_type": "hardlink", + "sha256": "ab77953666d62461bf4b40e2b7f4b7028f2a42acffe4f6135c500a0597b9cabe", + "sha256_in_prefix": "ab77953666d62461bf4b40e2b7f4b7028f2a42acffe4f6135c500a0597b9cabe", + "size_in_bytes": 1431 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/packaging/markers.py", + "path_type": "hardlink", + "sha256": "00904e718f0eab4918739ef42aeb8f4e4beeaa302586e7da13673db0251b9bae", + "sha256_in_prefix": "00904e718f0eab4918739ef42aeb8f4e4beeaa302586e7da13673db0251b9bae", + "size_in_bytes": 8487 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/packaging/py.typed", + "path_type": "hardlink", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size_in_bytes": 0 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/packaging/requirements.py", + "path_type": "hardlink", + "sha256": "36d0e53c1b688e99f52140bce623233cdb149ae7e3a529709cd03e5dbe26e4d0", + "sha256_in_prefix": "36d0e53c1b688e99f52140bce623233cdb149ae7e3a529709cd03e5dbe26e4d0", + "size_in_bytes": 4676 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/packaging/specifiers.py", + "path_type": "hardlink", + "sha256": "2d1434905b07ae5e6a7dc14d10426b20562c9c81d05095d8f5f22c6a44ebaea1", + "sha256_in_prefix": "2d1434905b07ae5e6a7dc14d10426b20562c9c81d05095d8f5f22c6a44ebaea1", + "size_in_bytes": 30110 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/packaging/tags.py", + "path_type": "hardlink", + "sha256": "966b2718d889f02e03fcf7fd3db334aa06d9bc3f64981f65a590505196b747f6", + "sha256_in_prefix": "966b2718d889f02e03fcf7fd3db334aa06d9bc3f64981f65a590505196b747f6", + "size_in_bytes": 15699 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/packaging/utils.py", + "path_type": "hardlink", + "sha256": "7498de6addc14be4d89f546b505570b9f50c6ac6edccb7d8468cbf1d710d7854", + "sha256_in_prefix": "7498de6addc14be4d89f546b505570b9f50c6ac6edccb7d8468cbf1d710d7854", + "size_in_bytes": 4200 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/packaging/version.py", + "path_type": "hardlink", + "sha256": "fdf2d136b16bc5870755fca8f2f93d8fcb3a24cf0dff1b12c5516be91272728f", + "sha256_in_prefix": "fdf2d136b16bc5870755fca8f2f93d8fcb3a24cf0dff1b12c5516be91272728f", + "size_in_bytes": 14665 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pkg_resources/__init__.py", + "path_type": "hardlink", + "sha256": "85301e2423586fb749b1e20356c60ade63d07a9fe0a618f8b5087e6eca57f1b8", + "sha256_in_prefix": "85301e2423586fb749b1e20356c60ade63d07a9fe0a618f8b5087e6eca57f1b8", + "size_in_bytes": 109364 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pkg_resources/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "effe427e2f1cb68f0d2959c0cf4efc23fe1b9d9f0b07e69713f8cba95b1628a3", + "sha256_in_prefix": "effe427e2f1cb68f0d2959c0cf4efc23fe1b9d9f0b07e69713f8cba95b1628a3", + "size_in_bytes": 101023 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/platformdirs/__init__.py", + "path_type": "hardlink", + "sha256": "4a4844615c82fc75070ba297ee7e0cffa728c9132d101dfc40cc8e608017e989", + "sha256_in_prefix": "4a4844615c82fc75070ba297ee7e0cffa728c9132d101dfc40cc8e608017e989", + "size_in_bytes": 20155 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/platformdirs/__main__.py", + "path_type": "hardlink", + "sha256": "7d5bd2893cebdbe44ce88b235a38f87e468eb433a00e1516bfab00f7d768e024", + "sha256_in_prefix": "7d5bd2893cebdbe44ce88b235a38f87e468eb433a00e1516bfab00f7d768e024", + "size_in_bytes": 1476 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/platformdirs/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "2047028397230c9d73df6a11a3e9f52514dcabcceb98e6270cae244b2d0bda83", + "sha256_in_prefix": "2047028397230c9d73df6a11a3e9f52514dcabcceb98e6270cae244b2d0bda83", + "size_in_bytes": 14331 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/platformdirs/__pycache__/__main__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "791a93aa098b43f42a25c4056437f79df29df9a53a691ec7c37c092391f829cf", + "sha256_in_prefix": "791a93aa098b43f42a25c4056437f79df29df9a53a691ec7c37c092391f829cf", + "size_in_bytes": 1343 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/platformdirs/__pycache__/android.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "e61cc80988d556522a267a77ac95a5f4197617b71a3311d3e139e916474821d1", + "sha256_in_prefix": "e61cc80988d556522a267a77ac95a5f4197617b71a3311d3e139e916474821d1", + "size_in_bytes": 6581 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/platformdirs/__pycache__/api.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c4d86ea8abf63de321b601f82200441592dca3bacf05f1f2d57eb4f22f938425", + "sha256_in_prefix": "c4d86ea8abf63de321b601f82200441592dca3bacf05f1f2d57eb4f22f938425", + "size_in_bytes": 7579 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/platformdirs/__pycache__/macos.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "66618b8e7f7622f6df8ae0afeb676bc30e8ae1aeeaeda537ad7f20a5314ef7c4", + "sha256_in_prefix": "66618b8e7f7622f6df8ae0afeb676bc30e8ae1aeeaeda537ad7f20a5314ef7c4", + "size_in_bytes": 4220 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/platformdirs/__pycache__/unix.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "03a637c47f6fccfaf0b8860205008f360b309db956e58af8bd7fd81d0b74a4d7", + "sha256_in_prefix": "03a637c47f6fccfaf0b8860205008f360b309db956e58af8bd7fd81d0b74a4d7", + "size_in_bytes": 8811 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/platformdirs/__pycache__/version.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "148ce11fa23bb340c80c4bf624eb71a59607305b273c02708787fc583dd8ae9d", + "sha256_in_prefix": "148ce11fa23bb340c80c4bf624eb71a59607305b273c02708787fc583dd8ae9d", + "size_in_bytes": 252 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/platformdirs/__pycache__/windows.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "d643a2bb6a52e197bd8cfade7099859b93baddf0c229c585a2e3fbde4c41a4a5", + "sha256_in_prefix": "d643a2bb6a52e197bd8cfade7099859b93baddf0c229c585a2e3fbde4c41a4a5", + "size_in_bytes": 8585 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/platformdirs/android.py", + "path_type": "hardlink", + "sha256": "cbf10430ac18976f9bcd8043a2f92c4a7f26efaa27d0b75af1ec8992c55013d5", + "sha256_in_prefix": "cbf10430ac18976f9bcd8043a2f92c4a7f26efaa27d0b75af1ec8992c55013d5", + "size_in_bytes": 7211 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/platformdirs/api.py", + "path_type": "hardlink", + "sha256": "8d6b57d3a8c0272b58ae42433aa125b3dee60a4c87452664a2a5256cc2b941ec", + "sha256_in_prefix": "8d6b57d3a8c0272b58ae42433aa125b3dee60a4c87452664a2a5256cc2b941ec", + "size_in_bytes": 7132 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/platformdirs/macos.py", + "path_type": "hardlink", + "sha256": "2ee7953a85601960c1c106fc385c1791529f567df708cd4b9307f5f80f3ab514", + "sha256_in_prefix": "2ee7953a85601960c1c106fc385c1791529f567df708cd4b9307f5f80f3ab514", + "size_in_bytes": 3678 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/platformdirs/py.typed", + "path_type": "hardlink", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size_in_bytes": 0 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/platformdirs/unix.py", + "path_type": "hardlink", + "sha256": "db626147c658d1a2f14950859caadce9fd62cfa1afe362b6e036a3eda4e37d28", + "sha256_in_prefix": "db626147c658d1a2f14950859caadce9fd62cfa1afe362b6e036a3eda4e37d28", + "size_in_bytes": 8809 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/platformdirs/version.py", + "path_type": "hardlink", + "sha256": "99abd94d02092177dd7b011a4939fb116acd7cf656791a1f6feef8c6a5b97f63", + "sha256_in_prefix": "99abd94d02092177dd7b011a4939fb116acd7cf656791a1f6feef8c6a5b97f63", + "size_in_bytes": 160 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/platformdirs/windows.py", + "path_type": "hardlink", + "sha256": "e13b5b3c6a161b63d1808d75baab836bb79193c4dcc6f9d436eb8c19922d9d77", + "sha256_in_prefix": "e13b5b3c6a161b63d1808d75baab836bb79193c4dcc6f9d436eb8c19922d9d77", + "size_in_bytes": 9573 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/__init__.py", + "path_type": "hardlink", + "sha256": "e80b8396342dbdff3d0d3354c9633b937a1494ffe5abbd0d53e20d28ab5e3816", + "sha256_in_prefix": "e80b8396342dbdff3d0d3354c9633b937a1494ffe5abbd0d53e20d28ab5e3816", + "size_in_bytes": 2983 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/__main__.py", + "path_type": "hardlink", + "sha256": "7acf0428cbd78f9c93a087d0fa97f70efe539c879e33ab0c1342d6fa7e1e707a", + "sha256_in_prefix": "7acf0428cbd78f9c93a087d0fa97f70efe539c879e33ab0c1342d6fa7e1e707a", + "size_in_bytes": 353 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "e18ec420e2da325f7c741ef7781c13773150ee9df3652dada47304d9f146c272", + "sha256_in_prefix": "e18ec420e2da325f7c741ef7781c13773150ee9df3652dada47304d9f146c272", + "size_in_bytes": 2897 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/__pycache__/__main__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "fa789f177345019bd0cf94432487f1bf68fcc8cf728196ff6be65db0f7a8a9b9", + "sha256_in_prefix": "fa789f177345019bd0cf94432487f1bf68fcc8cf728196ff6be65db0f7a8a9b9", + "size_in_bytes": 550 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/__pycache__/cmdline.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "80333407989c3500a3b6ae8e6983c308080fb651ced15afc706a968da6ba6328", + "sha256_in_prefix": "80333407989c3500a3b6ae8e6983c308080fb651ced15afc706a968da6ba6328", + "size_in_bytes": 15565 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/__pycache__/console.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "edeafafe45bdfd7cd90bc50f3e9b1e33d7dc92e1645483df6e7975c5a33b5f57", + "sha256_in_prefix": "edeafafe45bdfd7cd90bc50f3e9b1e33d7dc92e1645483df6e7975c5a33b5f57", + "size_in_bytes": 1845 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/__pycache__/filter.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "973c95204ca790731b1399b954664f77097843666373c8af821b2c6b2da3dc98", + "sha256_in_prefix": "973c95204ca790731b1399b954664f77097843666373c8af821b2c6b2da3dc98", + "size_in_bytes": 2616 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/__pycache__/formatter.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "a04f7311f4028dd2875eab5d7493ee8f4597ab4d0cec57b843415ce7949e7385", + "sha256_in_prefix": "a04f7311f4028dd2875eab5d7493ee8f4597ab4d0cec57b843415ce7949e7385", + "size_in_bytes": 3918 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/__pycache__/lexer.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "f79e598b753426055957fa6c2d6d01d49dc1d288c769af047227287deb701991", + "sha256_in_prefix": "f79e598b753426055957fa6c2d6d01d49dc1d288c769af047227287deb701991", + "size_in_bytes": 26193 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/__pycache__/modeline.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "e9d3c418ba42b6c5d4b7f264c130d84684c730a180e65214df271632cfa8645b", + "sha256_in_prefix": "e9d3c418ba42b6c5d4b7f264c130d84684c730a180e65214df271632cfa8645b", + "size_in_bytes": 1154 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/__pycache__/plugin.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "99fe2394d14239d0e4d82c4b3b528d90761ede41ff642376de2729d50abcf318", + "sha256_in_prefix": "99fe2394d14239d0e4d82c4b3b528d90761ede41ff642376de2729d50abcf318", + "size_in_bytes": 2482 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/__pycache__/regexopt.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "35de4b7f5c5f2a6a2084ad7a41ee108f6df27e891a6b905a9e326ea842103022", + "sha256_in_prefix": "35de4b7f5c5f2a6a2084ad7a41ee108f6df27e891a6b905a9e326ea842103022", + "size_in_bytes": 2918 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/__pycache__/scanner.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "65e4fdd414b544c90bce4b268bea8bcb9a1adce878292ec011fe40e14455e4eb", + "sha256_in_prefix": "65e4fdd414b544c90bce4b268bea8bcb9a1adce878292ec011fe40e14455e4eb", + "size_in_bytes": 3520 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/__pycache__/sphinxext.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c90089060672343d0cbcd39586c9cdfce95711a6de511b1a588b1c9f6f358fb1", + "sha256_in_prefix": "c90089060672343d0cbcd39586c9cdfce95711a6de511b1a588b1c9f6f358fb1", + "size_in_bytes": 7083 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/__pycache__/style.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "9dc2e71d5a0b9691d2cf343b8df6ff20347e464b44b47f9d6c7be2313bdcc581", + "sha256_in_prefix": "9dc2e71d5a0b9691d2cf343b8df6ff20347e464b44b47f9d6c7be2313bdcc581", + "size_in_bytes": 4541 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/__pycache__/token.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "b720d5e43e07aa134c31d1feb912a94da78cfbd22bd0af9b17674b01b3a477fb", + "sha256_in_prefix": "b720d5e43e07aa134c31d1feb912a94da78cfbd22bd0af9b17674b01b3a477fb", + "size_in_bytes": 4633 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/__pycache__/unistring.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "fa36e0952129993cc6bf3dacf58eb39dce4adf983f1b1a32eb1020582bbe515d", + "sha256_in_prefix": "fa36e0952129993cc6bf3dacf58eb39dce4adf983f1b1a32eb1020582bbe515d", + "size_in_bytes": 31194 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/__pycache__/util.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "da9f9735e4b86c9878b9ca711f49d1bd2758574c9ce7302a5ad6cfe75f7f6a7b", + "sha256_in_prefix": "da9f9735e4b86c9878b9ca711f49d1bd2758574c9ce7302a5ad6cfe75f7f6a7b", + "size_in_bytes": 10166 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/cmdline.py", + "path_type": "hardlink", + "sha256": "6f2c58269f609e355eca1465677513320a3f2e191787569fbcdf30241b4071cf", + "sha256_in_prefix": "6f2c58269f609e355eca1465677513320a3f2e191787569fbcdf30241b4071cf", + "size_in_bytes": 23685 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/console.py", + "path_type": "hardlink", + "sha256": "db06795be53a4ee7490f5fcd2d4c237253296e898533dd6536fd75ffad2c7c66", + "sha256_in_prefix": "db06795be53a4ee7490f5fcd2d4c237253296e898533dd6536fd75ffad2c7c66", + "size_in_bytes": 1697 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/filter.py", + "path_type": "hardlink", + "sha256": "8f968b33d6bdc12c7a787d68cb8ef7a12909d3684658da6d065568e2cd60ff7d", + "sha256_in_prefix": "8f968b33d6bdc12c7a787d68cb8ef7a12909d3684658da6d065568e2cd60ff7d", + "size_in_bytes": 1938 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/filters/__init__.py", + "path_type": "hardlink", + "sha256": "87f928624505a3e1455318ece7ae091d4033ecedf226957023a7ca377318cc6d", + "sha256_in_prefix": "87f928624505a3e1455318ece7ae091d4033ecedf226957023a7ca377318cc6d", + "size_in_bytes": 40386 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/filters/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "7afcc19be08d1ad4ab786948fcf68048eea0dfe1c35addfb016cda194db5a78f", + "sha256_in_prefix": "7afcc19be08d1ad4ab786948fcf68048eea0dfe1c35addfb016cda194db5a78f", + "size_in_bytes": 29570 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/formatter.py", + "path_type": "hardlink", + "sha256": "27d38bf615cb24a664ee6a1480ac298d6f4735fe16949160fe8ffe67f4bfb536", + "sha256_in_prefix": "27d38bf615cb24a664ee6a1480ac298d6f4735fe16949160fe8ffe67f4bfb536", + "size_in_bytes": 4178 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/formatters/__init__.py", + "path_type": "hardlink", + "sha256": "ff180071d14aaf440d63087f8bdf0053d86f7cfdd7db0024844945711445dd4a", + "sha256_in_prefix": "ff180071d14aaf440d63087f8bdf0053d86f7cfdd7db0024844945711445dd4a", + "size_in_bytes": 5424 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/formatters/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "75a7a65de6ab611b8a6cbbd9eca23e557e3df74658b321ddcf7d761623c3e118", + "sha256_in_prefix": "75a7a65de6ab611b8a6cbbd9eca23e557e3df74658b321ddcf7d761623c3e118", + "size_in_bytes": 4970 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/formatters/__pycache__/_mapping.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "316a0f2f12c8f3937f9b92cf4c1a79a7e468456062fbea37518a7da3876f19c9", + "sha256_in_prefix": "316a0f2f12c8f3937f9b92cf4c1a79a7e468456062fbea37518a7da3876f19c9", + "size_in_bytes": 3962 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/formatters/__pycache__/bbcode.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "2c17a3806e9c95a9e6a4035b309d41c1990da5081f0c2872e684f21be5308c15", + "sha256_in_prefix": "2c17a3806e9c95a9e6a4035b309d41c1990da5081f0c2872e684f21be5308c15", + "size_in_bytes": 3047 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/formatters/__pycache__/groff.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c1d5023ca05fec7a6278e1e53b14e7ff41e4dda586195f8472f6285b86503268", + "sha256_in_prefix": "c1d5023ca05fec7a6278e1e53b14e7ff41e4dda586195f8472f6285b86503268", + "size_in_bytes": 4372 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/formatters/__pycache__/html.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "ec1fcf2837e503d2a7c2b35bb766fe865701a3ecb6854e9c2ab343fb24776acd", + "sha256_in_prefix": "ec1fcf2837e503d2a7c2b35bb766fe865701a3ecb6854e9c2ab343fb24776acd", + "size_in_bytes": 29125 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/formatters/__pycache__/img.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "f1278b87f090986ca56035f74b3d88881afbabee79148349d956c01c723caa6d", + "sha256_in_prefix": "f1278b87f090986ca56035f74b3d88881afbabee79148349d956c01c723caa6d", + "size_in_bytes": 17524 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/formatters/__pycache__/irc.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c1929d1a0430bae3c7d55eef3fc79373bf010e69c5a749c1c0c059941468135f", + "sha256_in_prefix": "c1929d1a0430bae3c7d55eef3fc79373bf010e69c5a749c1c0c059941468135f", + "size_in_bytes": 4060 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/formatters/__pycache__/latex.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "dccb472a1e2ad26318689e4e240e737c679797daafad01c47842566d0e84edad", + "sha256_in_prefix": "dccb472a1e2ad26318689e4e240e737c679797daafad01c47842566d0e84edad", + "size_in_bytes": 13760 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/formatters/__pycache__/other.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "910dd91e476bd96f44ae8ab0027faf25ff464814e5a4cf8476db7963281b2e28", + "sha256_in_prefix": "910dd91e476bd96f44ae8ab0027faf25ff464814e5a4cf8476db7963281b2e28", + "size_in_bytes": 4766 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/formatters/__pycache__/pangomarkup.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "06cc22af681d0137ca1648edc5687d9562c96e9f892d0539f17223297238dd73", + "sha256_in_prefix": "06cc22af681d0137ca1648edc5687d9562c96e9f892d0539f17223297238dd73", + "size_in_bytes": 2066 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/formatters/__pycache__/rtf.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "e3eb19771956e7d3bc422869cc3e397ecc906b57fdb892850cbff2a38dcb65fc", + "sha256_in_prefix": "e3eb19771956e7d3bc422869cc3e397ecc906b57fdb892850cbff2a38dcb65fc", + "size_in_bytes": 4096 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/formatters/__pycache__/svg.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "4c420666d86d8395f8a9b6a952253fd4ab5556293b0b68f1585477e143f4531e", + "sha256_in_prefix": "4c420666d86d8395f8a9b6a952253fd4ab5556293b0b68f1585477e143f4531e", + "size_in_bytes": 6294 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/formatters/__pycache__/terminal.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "40987a134b956195cbf612c7e7f7eb67298088ee86c005993c791b1c7222e52d", + "sha256_in_prefix": "40987a134b956195cbf612c7e7f7eb67298088ee86c005993c791b1c7222e52d", + "size_in_bytes": 3961 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/formatters/__pycache__/terminal256.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "ec638e24541d13559ef2f37b67c23da3adcf7009cd059f310d49c984dba38051", + "sha256_in_prefix": "ec638e24541d13559ef2f37b67c23da3adcf7009cd059f310d49c984dba38051", + "size_in_bytes": 9211 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/formatters/_mapping.py", + "path_type": "hardlink", + "sha256": "d42c37ec5b9094d69c9f144a9ad94f5f89f22e85fdfedb64a39670b1c354659e", + "sha256_in_prefix": "d42c37ec5b9094d69c9f144a9ad94f5f89f22e85fdfedb64a39670b1c354659e", + "size_in_bytes": 4176 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/formatters/bbcode.py", + "path_type": "hardlink", + "sha256": "af56fbc33593268b800c32e1f99d758918b8890c43d09289d6a1e5ea6398c6c0", + "sha256_in_prefix": "af56fbc33593268b800c32e1f99d758918b8890c43d09289d6a1e5ea6398c6c0", + "size_in_bytes": 3314 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/formatters/groff.py", + "path_type": "hardlink", + "sha256": "c72f197f7b573a8e8c5ab5e1ef23c65b1de5544920fc3858e02c66b036f4215a", + "sha256_in_prefix": "c72f197f7b573a8e8c5ab5e1ef23c65b1de5544920fc3858e02c66b036f4215a", + "size_in_bytes": 5094 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/formatters/html.py", + "path_type": "hardlink", + "sha256": "3c8cc0ca294da9a4f34923f6b250c6d950cb137a8d8a85b2dab82d492a2f8ae2", + "sha256_in_prefix": "3c8cc0ca294da9a4f34923f6b250c6d950cb137a8d8a85b2dab82d492a2f8ae2", + "size_in_bytes": 35610 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/formatters/img.py", + "path_type": "hardlink", + "sha256": "5ca5e6836fd738dad1e26b6ada37c453c5c2b28967dd54864f0f94622128932b", + "sha256_in_prefix": "5ca5e6836fd738dad1e26b6ada37c453c5c2b28967dd54864f0f94622128932b", + "size_in_bytes": 21938 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/formatters/irc.py", + "path_type": "hardlink", + "sha256": "129fa6f23777be814ee85bf9edc506166cfa25503aec8120ca204ec2fd0de1ad", + "sha256_in_prefix": "129fa6f23777be814ee85bf9edc506166cfa25503aec8120ca204ec2fd0de1ad", + "size_in_bytes": 4981 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/formatters/latex.py", + "path_type": "hardlink", + "sha256": "146cc9f98a924c4f33fefa163ddcef2d8e53abc8c4ff28231a333a757649f3e9", + "sha256_in_prefix": "146cc9f98a924c4f33fefa163ddcef2d8e53abc8c4ff28231a333a757649f3e9", + "size_in_bytes": 19351 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/formatters/other.py", + "path_type": "hardlink", + "sha256": "80fc6493905d0335930a06c41e0d65a4b8bed45e993e1e40fdaa2d80b5c79f38", + "sha256_in_prefix": "80fc6493905d0335930a06c41e0d65a4b8bed45e993e1e40fdaa2d80b5c79f38", + "size_in_bytes": 5073 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/formatters/pangomarkup.py", + "path_type": "hardlink", + "sha256": "e8b2a741cf32878f5ff34d9b174b0fbdbcdc938422bcc62aaa85c03da60ff2e5", + "sha256_in_prefix": "e8b2a741cf32878f5ff34d9b174b0fbdbcdc938422bcc62aaa85c03da60ff2e5", + "size_in_bytes": 2212 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/formatters/rtf.py", + "path_type": "hardlink", + "sha256": "680d2ffe9b16e8a648dcdd7c4ca0e27f178bea6705f040d770f5c3588e2f8554", + "sha256_in_prefix": "680d2ffe9b16e8a648dcdd7c4ca0e27f178bea6705f040d770f5c3588e2f8554", + "size_in_bytes": 5014 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/formatters/svg.py", + "path_type": "hardlink", + "sha256": "75038d5b2a5bcdfbf31820ed769dccfcd25ac12709bccd838876f1d64fb0c3b8", + "sha256_in_prefix": "75038d5b2a5bcdfbf31820ed769dccfcd25ac12709bccd838876f1d64fb0c3b8", + "size_in_bytes": 7335 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/formatters/terminal.py", + "path_type": "hardlink", + "sha256": "146faba6346916636988607837322e72fc6aeac4085c1dc7393a3699e4cab6b5", + "sha256_in_prefix": "146faba6346916636988607837322e72fc6aeac4085c1dc7393a3699e4cab6b5", + "size_in_bytes": 4674 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/formatters/terminal256.py", + "path_type": "hardlink", + "sha256": "d77489dc3e6915da99f7344e13a1db5a7043c07bce184f0696c9aa1a1a6b469e", + "sha256_in_prefix": "d77489dc3e6915da99f7344e13a1db5a7043c07bce184f0696c9aa1a1a6b469e", + "size_in_bytes": 11753 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/lexer.py", + "path_type": "hardlink", + "sha256": "d81a6a2e54f6131bce3a2eef9e32b99c1e05a7e9b9da57623da5cca31e6ec2e8", + "sha256_in_prefix": "d81a6a2e54f6131bce3a2eef9e32b99c1e05a7e9b9da57623da5cca31e6ec2e8", + "size_in_bytes": 34618 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/lexers/__init__.py", + "path_type": "hardlink", + "sha256": "8f92848b93bf550e464b9f47e3d97ed7483350e9162b197019e54c9463b630c9", + "sha256_in_prefix": "8f92848b93bf550e464b9f47e3d97ed7483350e9162b197019e54c9463b630c9", + "size_in_bytes": 12130 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/lexers/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "05d5faf0601899fba12fc97bcdc5bc683972e3426dfcae38c50a944d86b4fd4a", + "sha256_in_prefix": "05d5faf0601899fba12fc97bcdc5bc683972e3426dfcae38c50a944d86b4fd4a", + "size_in_bytes": 9964 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/lexers/__pycache__/_mapping.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "2094e2a21ba38b7661634052aaf1b09f307339a109785e292be46e40e1d7b939", + "sha256_in_prefix": "2094e2a21ba38b7661634052aaf1b09f307339a109785e292be46e40e1d7b939", + "size_in_bytes": 60909 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/lexers/__pycache__/python.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "ded64e872ec87bfa39d9ad79fff7653d56843148236bacc6cb3adc4e23d34a78", + "sha256_in_prefix": "ded64e872ec87bfa39d9ad79fff7653d56843148236bacc6cb3adc4e23d34a78", + "size_in_bytes": 29966 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/lexers/_mapping.py", + "path_type": "hardlink", + "sha256": "1edb38aff650f2271fb4633b82404f7840f9972552bf869f7c5817604e80a74e", + "sha256_in_prefix": "1edb38aff650f2271fb4633b82404f7840f9972552bf869f7c5817604e80a74e", + "size_in_bytes": 72281 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/lexers/python.py", + "path_type": "hardlink", + "sha256": "73b8e798a154f432f14c95b451bc17b7a67d149a9b06556c580d50afdc5203fc", + "sha256_in_prefix": "73b8e798a154f432f14c95b451bc17b7a67d149a9b06556c580d50afdc5203fc", + "size_in_bytes": 53424 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/modeline.py", + "path_type": "hardlink", + "sha256": "785daf3b82e9386a0fbc828a91b3df9f2badf214f852279b64fa5bf8160641d2", + "sha256_in_prefix": "785daf3b82e9386a0fbc828a91b3df9f2badf214f852279b64fa5bf8160641d2", + "size_in_bytes": 986 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/plugin.py", + "path_type": "hardlink", + "sha256": "8f5161df5d116d5d8343d9ef92692abe58f7f20772b982a594b9c6c5b73cb093", + "sha256_in_prefix": "8f5161df5d116d5d8343d9ef92692abe58f7f20772b982a594b9c6c5b73cb093", + "size_in_bytes": 2591 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/regexopt.py", + "path_type": "hardlink", + "sha256": "8e0d402e881c60653de93412f62b0197a742aefc39cb9fbe04ffcafae164ffcb", + "sha256_in_prefix": "8e0d402e881c60653de93412f62b0197a742aefc39cb9fbe04ffcafae164ffcb", + "size_in_bytes": 3072 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/scanner.py", + "path_type": "hardlink", + "sha256": "6ff9eee7f7f71c2812769e52fda351050d4c4829b86630f079cd8e993462724c", + "sha256_in_prefix": "6ff9eee7f7f71c2812769e52fda351050d4c4829b86630f079cd8e993462724c", + "size_in_bytes": 3092 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/sphinxext.py", + "path_type": "hardlink", + "sha256": "c011589b5f34a9e6bd24ab7ffd4ce14653513617333c31436aa183db5b1bbaca", + "sha256_in_prefix": "c011589b5f34a9e6bd24ab7ffd4ce14653513617333c31436aa183db5b1bbaca", + "size_in_bytes": 6882 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/style.py", + "path_type": "hardlink", + "sha256": "0b8ab2a09ad44e4abe395de23bef15cf752d598a49c124dd879fef94608674d4", + "sha256_in_prefix": "0b8ab2a09ad44e4abe395de23bef15cf752d598a49c124dd879fef94608674d4", + "size_in_bytes": 6257 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/styles/__init__.py", + "path_type": "hardlink", + "sha256": "85eec78d0c7bb02d1dda47d354b8d4b34275e66b53a0933a3356ebc089bdfbe4", + "sha256_in_prefix": "85eec78d0c7bb02d1dda47d354b8d4b34275e66b53a0933a3356ebc089bdfbe4", + "size_in_bytes": 3700 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/styles/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "6eefbe4413f01eb68bf2da8984f36e163714d263a48314405f550b8f1df4c228", + "sha256_in_prefix": "6eefbe4413f01eb68bf2da8984f36e163714d263a48314405f550b8f1df4c228", + "size_in_bytes": 3555 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/token.py", + "path_type": "hardlink", + "sha256": "b1e36c99c721f4e1075d88ab87c3a897bc3cc4385f3536cb8f9ac7002fa073fa", + "sha256_in_prefix": "b1e36c99c721f4e1075d88ab87c3a897bc3cc4385f3536cb8f9ac7002fa073fa", + "size_in_bytes": 6184 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/unistring.py", + "path_type": "hardlink", + "sha256": "15a51f1b5e0d04910a2d0a18f6a8fa258797ae961c2e62ae96085dc4e18568e7", + "sha256_in_prefix": "15a51f1b5e0d04910a2d0a18f6a8fa258797ae961c2e62ae96085dc4e18568e7", + "size_in_bytes": 63223 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pygments/util.py", + "path_type": "hardlink", + "sha256": "004558d2aa27cb210c82fe03a3674836baea500c149365d84aa1cceb9d2ecde9", + "sha256_in_prefix": "004558d2aa27cb210c82fe03a3674836baea500c149365d84aa1cceb9d2ecde9", + "size_in_bytes": 10230 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pyparsing/__init__.py", + "path_type": "hardlink", + "sha256": "f66d496c4d894cb7411b431be81d2511a663d7cd56c7972e3d7669b1b1c46201", + "sha256_in_prefix": "f66d496c4d894cb7411b431be81d2511a663d7cd56c7972e3d7669b1b1c46201", + "size_in_bytes": 9116 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pyparsing/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "2cd056cd135205305db1e2673de7b83391c0fe5f9f08e43b18f98f7265afd21d", + "sha256_in_prefix": "2cd056cd135205305db1e2673de7b83391c0fe5f9f08e43b18f98f7265afd21d", + "size_in_bytes": 7067 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pyparsing/__pycache__/actions.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "1e963c991fa0d2c9eba1ae79c4ce4444a7722400edfc02b1670161a77971541b", + "sha256_in_prefix": "1e963c991fa0d2c9eba1ae79c4ce4444a7722400edfc02b1670161a77971541b", + "size_in_bytes": 7613 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pyparsing/__pycache__/common.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "53384a4548baab387dbaa69e62ac1bad20e9602351fbea3f1ff820eaa4d57568", + "sha256_in_prefix": "53384a4548baab387dbaa69e62ac1bad20e9602351fbea3f1ff820eaa4d57568", + "size_in_bytes": 10141 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pyparsing/__pycache__/core.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "482de43465d985edd46715a4525306e6cdce6ff37f1bdb390955a2d56c0e3caf", + "sha256_in_prefix": "482de43465d985edd46715a4525306e6cdce6ff37f1bdb390955a2d56c0e3caf", + "size_in_bytes": 188204 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pyparsing/__pycache__/exceptions.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "08e57dc1d4db6ef92f15b630197cd8c056b1f0598f82ad42e9243534e3b75983", + "sha256_in_prefix": "08e57dc1d4db6ef92f15b630197cd8c056b1f0598f82ad42e9243534e3b75983", + "size_in_bytes": 9573 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pyparsing/__pycache__/helpers.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "1711cc98dfff050dffc15cbb3cae0bed2ff9a5c032453bc994e427770ff89f10", + "sha256_in_prefix": "1711cc98dfff050dffc15cbb3cae0bed2ff9a5c032453bc994e427770ff89f10", + "size_in_bytes": 35631 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pyparsing/__pycache__/results.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "1e54f5b9d024f3d766a7760928546d1e445f133625cb67c4987f7a2b776b8ff9", + "sha256_in_prefix": "1e54f5b9d024f3d766a7760928546d1e445f133625cb67c4987f7a2b776b8ff9", + "size_in_bytes": 25607 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pyparsing/__pycache__/testing.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "04f298cd1fb20b8ed14ff911379a7f50b3b7dfc800232ab2f16ddd8c6bd34158", + "sha256_in_prefix": "04f298cd1fb20b8ed14ff911379a7f50b3b7dfc800232ab2f16ddd8c6bd34158", + "size_in_bytes": 12107 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pyparsing/__pycache__/unicode.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "eef8e5ecc12a89d243f263b66816a5509f423c4bd9933a3b6c2db22bcdd54f36", + "sha256_in_prefix": "eef8e5ecc12a89d243f263b66816a5509f423c4bd9933a3b6c2db22bcdd54f36", + "size_in_bytes": 10220 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pyparsing/__pycache__/util.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "ab427244ca1f8f785b355f744b2463dc090cf05d76ad5c46cc653c08d4fe1ce1", + "sha256_in_prefix": "ab427244ca1f8f785b355f744b2463dc090cf05d76ad5c46cc653c08d4fe1ce1", + "size_in_bytes": 10014 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pyparsing/actions.py", + "path_type": "hardlink", + "sha256": "d39b9a20f3b39c93d0ed5811766182986e2c0e750fb7082fe6a39822a6cbd946", + "sha256_in_prefix": "d39b9a20f3b39c93d0ed5811766182986e2c0e750fb7082fe6a39822a6cbd946", + "size_in_bytes": 6567 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pyparsing/common.py", + "path_type": "hardlink", + "sha256": "a7eddcf37139f838e5905df91b43bdfa48d0469a1e8cffb6ff3d21c59f9ea25e", + "sha256_in_prefix": "a7eddcf37139f838e5905df91b43bdfa48d0469a1e8cffb6ff3d21c59f9ea25e", + "size_in_bytes": 13387 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pyparsing/core.py", + "path_type": "hardlink", + "sha256": "cafb9194ba57485f26824f908625b73952ea0fd4f4aec8fdb5b89b8511f861ac", + "sha256_in_prefix": "cafb9194ba57485f26824f908625b73952ea0fd4f4aec8fdb5b89b8511f861ac", + "size_in_bytes": 224445 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pyparsing/diagram/__init__.py", + "path_type": "hardlink", + "sha256": "9f19833a8605f4d5ee2da198cb4d6d2858e4351796265ac616e24d584893a3ce", + "sha256_in_prefix": "9f19833a8605f4d5ee2da198cb4d6d2858e4351796265ac616e24d584893a3ce", + "size_in_bytes": 24215 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pyparsing/diagram/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "33ffe43a094349c60cbbbf7139b8722b2728e10aaf6322677b04be76484e5292", + "sha256_in_prefix": "33ffe43a094349c60cbbbf7139b8722b2728e10aaf6322677b04be76484e5292", + "size_in_bytes": 16860 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pyparsing/exceptions.py", + "path_type": "hardlink", + "sha256": "e8973a5b5783641cf216ed49d18adc74d155042f9120dba3666bde4a707c471c", + "sha256_in_prefix": "e8973a5b5783641cf216ed49d18adc74d155042f9120dba3666bde4a707c471c", + "size_in_bytes": 9523 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pyparsing/helpers.py", + "path_type": "hardlink", + "sha256": "059247080f124b4a588a8df428641373dc36a8c39a2b862967b85cbc76e74e09", + "sha256_in_prefix": "059247080f124b4a588a8df428641373dc36a8c39a2b862967b85cbc76e74e09", + "size_in_bytes": 38646 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pyparsing/py.typed", + "path_type": "hardlink", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size_in_bytes": 0 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pyparsing/results.py", + "path_type": "hardlink", + "sha256": "f5dcaa43ec373237e6c566c5b7c2843d4e887d77b245da16a763a0f34dab5106", + "sha256_in_prefix": "f5dcaa43ec373237e6c566c5b7c2843d4e887d77b245da16a763a0f34dab5106", + "size_in_bytes": 26692 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pyparsing/testing.py", + "path_type": "hardlink", + "sha256": "7899dc834a7cdf39b51533ef33d6ae353ea86af22f5da89b9911437f5aa6c246", + "sha256_in_prefix": "7899dc834a7cdf39b51533ef33d6ae353ea86af22f5da89b9911437f5aa6c246", + "size_in_bytes": 13488 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pyparsing/unicode.py", + "path_type": "hardlink", + "sha256": "7c03ddb098804456e43c08a1e8d918af2d1da63e233ea7a5195325138c16156f", + "sha256_in_prefix": "7c03ddb098804456e43c08a1e8d918af2d1da63e233ea7a5195325138c16156f", + "size_in_bytes": 10646 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pyparsing/util.py", + "path_type": "hardlink", + "sha256": "bd33334ddc120f257c77f75282ab944dd5a0045a00fd6df49dfc44243b2c8514", + "sha256_in_prefix": "bd33334ddc120f257c77f75282ab944dd5a0045a00fd6df49dfc44243b2c8514", + "size_in_bytes": 8670 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pyproject_hooks/__init__.py", + "path_type": "hardlink", + "sha256": "9027a19b2d146816bda15303ed9219ae7b307e73f72d767996f9cd2402f92413", + "sha256_in_prefix": "9027a19b2d146816bda15303ed9219ae7b307e73f72d767996f9cd2402f92413", + "size_in_bytes": 491 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pyproject_hooks/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "881311ac3f70a1232669e80069e67775ffd3fffb01052fc71aa037e8595bfe8d", + "sha256_in_prefix": "881311ac3f70a1232669e80069e67775ffd3fffb01052fc71aa037e8595bfe8d", + "size_in_bytes": 548 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pyproject_hooks/__pycache__/_compat.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "664012a801f1fbaad62c5e1597a0ef79ea41bb193e717e0a475ae99273d73183", + "sha256_in_prefix": "664012a801f1fbaad62c5e1597a0ef79ea41bb193e717e0a475ae99273d73183", + "size_in_bytes": 299 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pyproject_hooks/__pycache__/_impl.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "6cd419bb2f8e27fddf07f7b7b0cb36a8473fbbf04da41323c6bfcf6992c94adf", + "sha256_in_prefix": "6cd419bb2f8e27fddf07f7b7b0cb36a8473fbbf04da41323c6bfcf6992c94adf", + "size_in_bytes": 11351 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pyproject_hooks/_compat.py", + "path_type": "hardlink", + "sha256": "6f2e9ebeb627aa48ac88cf8c41cbce2ace5b80333394e4a066a44736a7f4e331", + "sha256_in_prefix": "6f2e9ebeb627aa48ac88cf8c41cbce2ace5b80333394e4a066a44736a7f4e331", + "size_in_bytes": 138 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pyproject_hooks/_impl.py", + "path_type": "hardlink", + "sha256": "eb5189c73422a742089e1b8eebd648e466cd43cd97103501ff51a0e7f2ad5287", + "sha256_in_prefix": "eb5189c73422a742089e1b8eebd648e466cd43cd97103501ff51a0e7f2ad5287", + "size_in_bytes": 11920 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pyproject_hooks/_in_process/__init__.py", + "path_type": "hardlink", + "sha256": "f604004e9b5b1647a5908cb439f5851000b3ab15c93100d6087f6b04e0195704", + "sha256_in_prefix": "f604004e9b5b1647a5908cb439f5851000b3ab15c93100d6087f6b04e0195704", + "size_in_bytes": 546 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pyproject_hooks/_in_process/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "b92dd5dbf0055252685755b5b0430c7e1b9a2fc2cc8382a29e799244e2c086d3", + "sha256_in_prefix": "b92dd5dbf0055252685755b5b0430c7e1b9a2fc2cc8382a29e799244e2c086d3", + "size_in_bytes": 786 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pyproject_hooks/_in_process/__pycache__/_in_process.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "236ce07351e670b5a067c341d88fe20e5ac5fa13546142196e8d9b4718be6aef", + "sha256_in_prefix": "236ce07351e670b5a067c341d88fe20e5ac5fa13546142196e8d9b4718be6aef", + "size_in_bytes": 9668 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/pyproject_hooks/_in_process/_in_process.py", + "path_type": "hardlink", + "sha256": "9b66f7e1cf75ec85b9a3e43fe936081e5b0af6549494d8b2ac84d3507ff3c1ec", + "sha256_in_prefix": "9b66f7e1cf75ec85b9a3e43fe936081e5b0af6549494d8b2ac84d3507ff3c1ec", + "size_in_bytes": 10927 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/requests/__init__.py", + "path_type": "hardlink", + "sha256": "a30ba3a1be1d938e528b2e0462d6c2291eb0705a61ec4d386bfbff3ae01a7010", + "sha256_in_prefix": "a30ba3a1be1d938e528b2e0462d6c2291eb0705a61ec4d386bfbff3ae01a7010", + "size_in_bytes": 5169 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/requests/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "464a7a63d23e7e9f1d227cef57e8b33da1f06f483cb4a05a428521b689fcfb6d", + "sha256_in_prefix": "464a7a63d23e7e9f1d227cef57e8b33da1f06f483cb4a05a428521b689fcfb6d", + "size_in_bytes": 3969 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/requests/__pycache__/__version__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "6643a37c4c940ccb849c72b527c06400a7c7c6d418a15132592a1a8bdca16e95", + "sha256_in_prefix": "6643a37c4c940ccb849c72b527c06400a7c7c6d418a15132592a1a8bdca16e95", + "size_in_bytes": 512 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/requests/__pycache__/_internal_utils.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "9dfe5dfbac9dbe133f0b2f264a7b9005eeba7a775d02687654c1c865d95ed1be", + "sha256_in_prefix": "9dfe5dfbac9dbe133f0b2f264a7b9005eeba7a775d02687654c1c865d95ed1be", + "size_in_bytes": 1588 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/requests/__pycache__/adapters.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "026a8abfc2531d693541fa73bc3c42b0ca850e083f8b52756a9ce9ca20d87401", + "sha256_in_prefix": "026a8abfc2531d693541fa73bc3c42b0ca850e083f8b52756a9ce9ca20d87401", + "size_in_bytes": 16174 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/requests/__pycache__/api.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "b490669fba82f0f286e3e4a92d8569398c4ea7ec16efc04f73d5d3ba65baf9a2", + "sha256_in_prefix": "b490669fba82f0f286e3e4a92d8569398c4ea7ec16efc04f73d5d3ba65baf9a2", + "size_in_bytes": 6688 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/requests/__pycache__/auth.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "04065e7751aac604c0082b5d289102166079e2ae234dbc88990e63aebdb0a4a4", + "sha256_in_prefix": "04065e7751aac604c0082b5d289102166079e2ae234dbc88990e63aebdb0a4a4", + "size_in_bytes": 8084 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/requests/__pycache__/certs.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "367c928af82e254aa533d0f26d0ddfbfd1ad16fbe65de10bd9ea181a9170e2da", + "sha256_in_prefix": "367c928af82e254aa533d0f26d0ddfbfd1ad16fbe65de10bd9ea181a9170e2da", + "size_in_bytes": 771 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/requests/__pycache__/compat.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "fc894b66460fe17e0b6854f71d5d6916a2b61d34bbbb9f647786f8a9e444c12a", + "sha256_in_prefix": "fc894b66460fe17e0b6854f71d5d6916a2b61d34bbbb9f647786f8a9e444c12a", + "size_in_bytes": 1333 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/requests/__pycache__/cookies.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "2e94d122f37cd5887af2eac8a6063dafdc9154917ce5c45b9bde835eb74c3df1", + "sha256_in_prefix": "2e94d122f37cd5887af2eac8a6063dafdc9154917ce5c45b9bde835eb74c3df1", + "size_in_bytes": 18653 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/requests/__pycache__/exceptions.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "6250c8d49d7e814bcdc2fd0ec133d133d04ed4ce54de3551f6465e273ccf91ee", + "sha256_in_prefix": "6250c8d49d7e814bcdc2fd0ec133d133d04ed4ce54de3551f6465e273ccf91ee", + "size_in_bytes": 5703 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/requests/__pycache__/help.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "bc39609a8474013be8a88643711d096f3d0b18e97e5bd51fcb732a47045e6495", + "sha256_in_prefix": "bc39609a8474013be8a88643711d096f3d0b18e97e5bd51fcb732a47045e6495", + "size_in_bytes": 2829 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/requests/__pycache__/hooks.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "ce66de4b79583d476f1fec4653aff245d26f387775d3b265fd513af60a3a3f93", + "sha256_in_prefix": "ce66de4b79583d476f1fec4653aff245d26f387775d3b265fd513af60a3a3f93", + "size_in_bytes": 956 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/requests/__pycache__/models.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "34cac582e15f9fbc6d8541365b6a710aa31df1e5eb2ba1995fdcde3017d72d39", + "sha256_in_prefix": "34cac582e15f9fbc6d8541365b6a710aa31df1e5eb2ba1995fdcde3017d72d39", + "size_in_bytes": 24228 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/requests/__pycache__/packages.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "fcda5cd429c112c5c69bfe4327139e716e180e1b48cfe9a0bd119b999750dc29", + "sha256_in_prefix": "fcda5cd429c112c5c69bfe4327139e716e180e1b48cfe9a0bd119b999750dc29", + "size_in_bytes": 470 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/requests/__pycache__/sessions.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c626d12277f7e35d4a6f2a631c7c2966a86740ee4730351f120379cbff35d769", + "sha256_in_prefix": "c626d12277f7e35d4a6f2a631c7c2966a86740ee4730351f120379cbff35d769", + "size_in_bytes": 19556 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/requests/__pycache__/status_codes.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "e32914c8ef2e873832580ed2d9f6b2d358b644758892d6fd177bbf0ff63dd3e0", + "sha256_in_prefix": "e32914c8ef2e873832580ed2d9f6b2d358b644758892d6fd177bbf0ff63dd3e0", + "size_in_bytes": 4635 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/requests/__pycache__/structures.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "bdfe6df460b0c3f30678d05c6db64c4f4ec48a41d66e201ec536ee427af2afd8", + "sha256_in_prefix": "bdfe6df460b0c3f30678d05c6db64c4f4ec48a41d66e201ec536ee427af2afd8", + "size_in_bytes": 4400 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/requests/__pycache__/utils.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "3304d31a2ae713f5bf09437041fd3fcce3273bcba8bacdd0f735f64b454b6cdc", + "sha256_in_prefix": "3304d31a2ae713f5bf09437041fd3fcce3273bcba8bacdd0f735f64b454b6cdc", + "size_in_bytes": 24409 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/requests/__version__.py", + "path_type": "hardlink", + "sha256": "b2c237133b7b3dac6090e5b8e4686dc0f51c968fd23bfca0b489b803be0839fc", + "sha256_in_prefix": "b2c237133b7b3dac6090e5b8e4686dc0f51c968fd23bfca0b489b803be0839fc", + "size_in_bytes": 435 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/requests/_internal_utils.py", + "path_type": "hardlink", + "sha256": "9cc4329abe21b37d93a95a3901b0ab99c24486f3d487bc57965bb2ab0b252e24", + "sha256_in_prefix": "9cc4329abe21b37d93a95a3901b0ab99c24486f3d487bc57965bb2ab0b252e24", + "size_in_bytes": 1495 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/requests/adapters.py", + "path_type": "hardlink", + "sha256": "89d8fa7197087772f9c4d35e27b89e38bb70ddac0993903ae3151f7ad1f0ab73", + "sha256_in_prefix": "89d8fa7197087772f9c4d35e27b89e38bb70ddac0993903ae3151f7ad1f0ab73", + "size_in_bytes": 19697 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/requests/api.py", + "path_type": "hardlink", + "sha256": "abad71717ab8b668889abbdc4952d36c5c82883d85f8bffe8562866f3e32f2f8", + "sha256_in_prefix": "abad71717ab8b668889abbdc4952d36c5c82883d85f8bffe8562866f3e32f2f8", + "size_in_bytes": 6449 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/requests/auth.py", + "path_type": "hardlink", + "sha256": "87e1cb955c7d8fcaca57985f480c9c3f60293928254f3efb474b73eea09b6c41", + "sha256_in_prefix": "87e1cb955c7d8fcaca57985f480c9c3f60293928254f3efb474b73eea09b6c41", + "size_in_bytes": 10187 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/requests/certs.py", + "path_type": "hardlink", + "sha256": "3d53e8a01d233f986464450b482c02d3be39df65056d1d8fb60bb4239cf0982b", + "sha256_in_prefix": "3d53e8a01d233f986464450b482c02d3be39df65056d1d8fb60bb4239cf0982b", + "size_in_bytes": 575 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/requests/compat.py", + "path_type": "hardlink", + "sha256": "2212bdaaec97d1146e59335c83a7762464803946ccea6ca6da9ff65e32d3c1fe", + "sha256_in_prefix": "2212bdaaec97d1146e59335c83a7762464803946ccea6ca6da9ff65e32d3c1fe", + "size_in_bytes": 1286 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/requests/cookies.py", + "path_type": "hardlink", + "sha256": "903de43447028fe9b16ed7f97c9b12693f3a786a046290f75f4092829ce5ec13", + "sha256_in_prefix": "903de43447028fe9b16ed7f97c9b12693f3a786a046290f75f4092829ce5ec13", + "size_in_bytes": 18560 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/requests/exceptions.py", + "path_type": "hardlink", + "sha256": "140fbf915c016768e15dab9172d37f7b01d52b6e5bf9f8f4033cb3d531d0d0a9", + "sha256_in_prefix": "140fbf915c016768e15dab9172d37f7b01d52b6e5bf9f8f4033cb3d531d0d0a9", + "size_in_bytes": 3823 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/requests/help.py", + "path_type": "hardlink", + "sha256": "167000925bfc3069bfa9bd948a50d0812ea5d1c52db620852948f1d339f65cd0", + "sha256_in_prefix": "167000925bfc3069bfa9bd948a50d0812ea5d1c52db620852948f1d339f65cd0", + "size_in_bytes": 3879 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/requests/hooks.py", + "path_type": "hardlink", + "sha256": "0a2bb2b221c0dfd57951f702057148c7cdc8ac3a6ec1f37d45c4d482fdbc7ed4", + "sha256_in_prefix": "0a2bb2b221c0dfd57951f702057148c7cdc8ac3a6ec1f37d45c4d482fdbc7ed4", + "size_in_bytes": 733 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/requests/models.py", + "path_type": "hardlink", + "sha256": "74367e893868b64cbe368abdcb2f7b71410986bdf09d8ea6bfec51fde3e0fe59", + "sha256_in_prefix": "74367e893868b64cbe368abdcb2f7b71410986bdf09d8ea6bfec51fde3e0fe59", + "size_in_bytes": 35288 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/requests/packages.py", + "path_type": "hardlink", + "sha256": "9e32665627d8e1a49cb6e5b73cfe441510b18c4c0c4433ba27f7de1b674a5ac2", + "sha256_in_prefix": "9e32665627d8e1a49cb6e5b73cfe441510b18c4c0c4433ba27f7de1b674a5ac2", + "size_in_bytes": 695 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/requests/sessions.py", + "path_type": "hardlink", + "sha256": "f8bbd3ceb3ed7ad493ad1ddbbb1bb85e176032b2452c1d6ae43ecffbe2f65e1c", + "sha256_in_prefix": "f8bbd3ceb3ed7ad493ad1ddbbb1bb85e176032b2452c1d6ae43ecffbe2f65e1c", + "size_in_bytes": 30373 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/requests/status_codes.py", + "path_type": "hardlink", + "sha256": "16f1e64f9b87fbfba29ad473e611fd5426eded557e35e8b627dba96de8fa8fc8", + "sha256_in_prefix": "16f1e64f9b87fbfba29ad473e611fd5426eded557e35e8b627dba96de8fa8fc8", + "size_in_bytes": 4235 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/requests/structures.py", + "path_type": "hardlink", + "sha256": "f886e6855cf4e92fb968f499b94b6167afba0fd5ce8d1b935c739a6d8d38d573", + "sha256_in_prefix": "f886e6855cf4e92fb968f499b94b6167afba0fd5ce8d1b935c739a6d8d38d573", + "size_in_bytes": 2912 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/requests/utils.py", + "path_type": "hardlink", + "sha256": "90e3e7d2a603eb1453cdac5ba937588922270591e5eb7efd009b32220cd818b6", + "sha256_in_prefix": "90e3e7d2a603eb1453cdac5ba937588922270591e5eb7efd009b32220cd818b6", + "size_in_bytes": 33460 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/resolvelib/__init__.py", + "path_type": "hardlink", + "sha256": "879d3d4dd11ca5be7ee382689da5377b1d93335e465412e333d08d08fc274d3b", + "sha256_in_prefix": "879d3d4dd11ca5be7ee382689da5377b1d93335e465412e333d08d08fc274d3b", + "size_in_bytes": 537 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/resolvelib/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "bb362a28d35a3ca6e4c1a46b2965ccb5d4b90f6ce2cc70620d6d53882d818708", + "sha256_in_prefix": "bb362a28d35a3ca6e4c1a46b2965ccb5d4b90f6ce2cc70620d6d53882d818708", + "size_in_bytes": 568 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/resolvelib/__pycache__/providers.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "5b8564258264b07ffaabacf294687b024778c119fcd5c7debba22cc09f9c7f7f", + "sha256_in_prefix": "5b8564258264b07ffaabacf294687b024778c119fcd5c7debba22cc09f9c7f7f", + "size_in_bytes": 6618 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/resolvelib/__pycache__/reporters.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "bf4e51578f69861cbd2df3fd009a7eaa4acc12c11751ec1767187bf2748d31b1", + "sha256_in_prefix": "bf4e51578f69861cbd2df3fd009a7eaa4acc12c11751ec1767187bf2748d31b1", + "size_in_bytes": 2571 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/resolvelib/__pycache__/resolvers.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "597fd8e6a1a029b412066f23bf0d1a7f2adc34c9ad747813a6ec2af831efc4d2", + "sha256_in_prefix": "597fd8e6a1a029b412066f23bf0d1a7f2adc34c9ad747813a6ec2af831efc4d2", + "size_in_bytes": 17399 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/resolvelib/__pycache__/structs.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "25970352ab3976d640b266c8b0bb6ec1ceaa42be947e7bed9ad007befb1d0c71", + "sha256_in_prefix": "25970352ab3976d640b266c8b0bb6ec1ceaa42be947e7bed9ad007befb1d0c71", + "size_in_bytes": 7227 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/resolvelib/compat/__init__.py", + "path_type": "hardlink", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size_in_bytes": 0 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/resolvelib/compat/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "d8b507f77e3012d0c23fe4b2b6bf29da6fb89a16228ec57b04cf4ba421af5cb8", + "sha256_in_prefix": "d8b507f77e3012d0c23fe4b2b6bf29da6fb89a16228ec57b04cf4ba421af5cb8", + "size_in_bytes": 163 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/resolvelib/compat/__pycache__/collections_abc.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "48bb745b41f77d5135466bb3badd0f48312a7e75ded91f4f76dafe89b7e74580", + "sha256_in_prefix": "48bb745b41f77d5135466bb3badd0f48312a7e75ded91f4f76dafe89b7e74580", + "size_in_bytes": 339 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/resolvelib/compat/collections_abc.py", + "path_type": "hardlink", + "sha256": "bb2f31519f8d0c4c3dd7ab6e8145e6f0783008688c3b47fe45c767a647d77ceb", + "sha256_in_prefix": "bb2f31519f8d0c4c3dd7ab6e8145e6f0783008688c3b47fe45c767a647d77ceb", + "size_in_bytes": 156 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/resolvelib/providers.py", + "path_type": "hardlink", + "sha256": "7eebaf56b09eb6ee60b313c1e37111ca37cef1a45e4b7ac5407a4382222d6ece", + "sha256_in_prefix": "7eebaf56b09eb6ee60b313c1e37111ca37cef1a45e4b7ac5407a4382222d6ece", + "size_in_bytes": 5871 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/resolvelib/py.typed", + "path_type": "hardlink", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size_in_bytes": 0 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/resolvelib/reporters.py", + "path_type": "hardlink", + "sha256": "4d26d1996cd3736eb0d2082c5756f15697960c1f10348adeeadc1897b1886411", + "sha256_in_prefix": "4d26d1996cd3736eb0d2082c5756f15697960c1f10348adeeadc1897b1886411", + "size_in_bytes": 1601 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/resolvelib/resolvers.py", + "path_type": "hardlink", + "sha256": "1bcaec2d94aaeb883956622afa507b51c209d608c0c48409993178444665790d", + "sha256_in_prefix": "1bcaec2d94aaeb883956622afa507b51c209d608c0c48409993178444665790d", + "size_in_bytes": 20511 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/resolvelib/structs.py", + "path_type": "hardlink", + "sha256": "d3fd7f5cef33fc22e17a03f75697fd549df325c7cb9b434e1d133e8b4624cf7a", + "sha256_in_prefix": "d3fd7f5cef33fc22e17a03f75697fd549df325c7cb9b434e1d133e8b4624cf7a", + "size_in_bytes": 4963 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__init__.py", + "path_type": "hardlink", + "sha256": "751c6320bf926c5558d2adc88d232b7e00531eb9b52d90e02ceca0541c226197", + "sha256_in_prefix": "751c6320bf926c5558d2adc88d232b7e00531eb9b52d90e02ceca0541c226197", + "size_in_bytes": 6090 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__main__.py", + "path_type": "hardlink", + "sha256": "4d3f2c6fd3d39ec9ca861ac6b8790b3748dd37476d2a1b4f904afd0a27436cf3", + "sha256_in_prefix": "4d3f2c6fd3d39ec9ca861ac6b8790b3748dd37476d2a1b4f904afd0a27436cf3", + "size_in_bytes": 8478 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "4c2a8c79ba7096383b0f495f694e6600e2974f3255a74321b72851c94a3ad17d", + "sha256_in_prefix": "4c2a8c79ba7096383b0f495f694e6600e2974f3255a74321b72851c94a3ad17d", + "size_in_bytes": 6075 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/__main__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "a38043b678cfc8cde2e224f3c61889cde057b73741ddc93bd0bf37012dfa6d50", + "sha256_in_prefix": "a38043b678cfc8cde2e224f3c61889cde057b73741ddc93bd0bf37012dfa6d50", + "size_in_bytes": 7145 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_cell_widths.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "19850302d1b0ccfa140cea8afd1b697c99753876158c97c334ee64647da861ce", + "sha256_in_prefix": "19850302d1b0ccfa140cea8afd1b697c99753876158c97c334ee64647da861ce", + "size_in_bytes": 7776 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_emoji_codes.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "d6dc962d95945a83204c3b68f6069baf781995423c36e6fcbc8b12dc3d25f1d4", + "sha256_in_prefix": "d6dc962d95945a83204c3b68f6069baf781995423c36e6fcbc8b12dc3d25f1d4", + "size_in_bytes": 360016 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_emoji_replace.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "0c7ac70c552d2755f4066a5c2ba2e6211ff6abb5ce604eadb5558e890c26c819", + "sha256_in_prefix": "0c7ac70c552d2755f4066a5c2ba2e6211ff6abb5ce604eadb5558e890c26c819", + "size_in_bytes": 1156 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_export_format.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "a96d8084df02044fd5546a03b7ad7c9e3578a29e784c0ad3ff9ce27571653758", + "sha256_in_prefix": "a96d8084df02044fd5546a03b7ad7c9e3578a29e784c0ad3ff9ce27571653758", + "size_in_bytes": 2259 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_extension.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "7dda90e8cc2466e1589c8d501a236246ee4c77bce64ca680d5dd1ce03794600b", + "sha256_in_prefix": "7dda90e8cc2466e1589c8d501a236246ee4c77bce64ca680d5dd1ce03794600b", + "size_in_bytes": 457 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_fileno.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "9e004e31cb721d7cf5f3c0d76f41f5dd0579c91433bf505dc42417e332731d62", + "sha256_in_prefix": "9e004e31cb721d7cf5f3c0d76f41f5dd0579c91433bf505dc42417e332731d62", + "size_in_bytes": 750 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_inspect.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "180de43b84571bd3d464f67916261719acd7e13bbb6c440fac73f45933c9bc28", + "sha256_in_prefix": "180de43b84571bd3d464f67916261719acd7e13bbb6c440fac73f45933c9bc28", + "size_in_bytes": 8634 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_log_render.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "e82433ca8b3839fe90b7da3d97d653d0e4ae1a708e120b4a5a784dd9a7461525", + "sha256_in_prefix": "e82433ca8b3839fe90b7da3d97d653d0e4ae1a708e120b4a5a784dd9a7461525", + "size_in_bytes": 2602 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_loop.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "9935a98cc5f67763ffc8c47995a2ffef416b3d59614101d30651bf90bec33d94", + "sha256_in_prefix": "9935a98cc5f67763ffc8c47995a2ffef416b3d59614101d30651bf90bec33d94", + "size_in_bytes": 1254 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_null_file.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c4a618a6c77c865a042b666a5034a09dfc1f88663f881848d3c3deec1d4d3c82", + "sha256_in_prefix": "c4a618a6c77c865a042b666a5034a09dfc1f88663f881848d3c3deec1d4d3c82", + "size_in_bytes": 3201 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_palettes.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "479087b864c8db3bc25aa88fe2e72a42b486639833aef199f4b802553b0efcf9", + "sha256_in_prefix": "479087b864c8db3bc25aa88fe2e72a42b486639833aef199f4b802553b0efcf9", + "size_in_bytes": 5059 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_pick.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "5ead11dd4b3affdb98e3ae6608a1117a31801e2b90221b091c9c54b5a01efd94", + "sha256_in_prefix": "5ead11dd4b3affdb98e3ae6608a1117a31801e2b90221b091c9c54b5a01efd94", + "size_in_bytes": 602 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_ratio.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "00983ae4c5dfffaad671a5f410e42d26cb46bec59995fcbf03f16d5352aac13a", + "sha256_in_prefix": "00983ae4c5dfffaad671a5f410e42d26cb46bec59995fcbf03f16d5352aac13a", + "size_in_bytes": 5119 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_spinners.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "8ff7cfc4b0b74b0302b55105729f585ce7f544bdaf63ecec8fe9a0cc5491003e", + "sha256_in_prefix": "8ff7cfc4b0b74b0302b55105729f585ce7f544bdaf63ecec8fe9a0cc5491003e", + "size_in_bytes": 12233 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_stack.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "1bf77f449f207d01cb746f2a078630f130ade2d95a76526f5b52a905acd36496", + "sha256_in_prefix": "1bf77f449f207d01cb746f2a078630f130ade2d95a76526f5b52a905acd36496", + "size_in_bytes": 800 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_timer.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c5cfed99ca5ba392103a953706a9e03a5c1e8bc6f744c0233866f90e8ef80188", + "sha256_in_prefix": "c5cfed99ca5ba392103a953706a9e03a5c1e8bc6f744c0233866f90e8ef80188", + "size_in_bytes": 649 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_win32_console.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "328bcbcf4b0ec0c6a53df86b991942a9f6dbeadd778d00f269db0f9d2db410d6", + "sha256_in_prefix": "328bcbcf4b0ec0c6a53df86b991942a9f6dbeadd778d00f269db0f9d2db410d6", + "size_in_bytes": 18969 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_windows.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "3fdd62a2564fc6601c5b3058327751fff8a3db165a37754d1ba1de9f469e249c", + "sha256_in_prefix": "3fdd62a2564fc6601c5b3058327751fff8a3db165a37754d1ba1de9f469e249c", + "size_in_bytes": 1751 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_windows_renderer.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "5fc18c680e384a539c7af7d617ba6a389e1f03a44b792419b5c51db7d696ed82", + "sha256_in_prefix": "5fc18c680e384a539c7af7d617ba6a389e1f03a44b792419b5c51db7d696ed82", + "size_in_bytes": 2005 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_wrap.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "77812796815e1e87ceb6d86f96f42be4a47d977864d41b3b922afa5652b5d412", + "sha256_in_prefix": "77812796815e1e87ceb6d86f96f42be4a47d977864d41b3b922afa5652b5d412", + "size_in_bytes": 1513 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/abc.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "b1dce194605b7dbfcc2830e4879e58a6dda4d37bc5638b3c8c1ea28a482e6f3d", + "sha256_in_prefix": "b1dce194605b7dbfcc2830e4879e58a6dda4d37bc5638b3c8c1ea28a482e6f3d", + "size_in_bytes": 1276 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/align.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "73c0c6d33856757032905ac08da42fcbf5f898f58bb23514a1805f039c3f1acd", + "sha256_in_prefix": "73c0c6d33856757032905ac08da42fcbf5f898f58bb23514a1805f039c3f1acd", + "size_in_bytes": 7904 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/ansi.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c8d817aad8c93feb2cfd3ede3c6620e5d02b355a562705cef4aa6494b39f53d7", + "sha256_in_prefix": "c8d817aad8c93feb2cfd3ede3c6620e5d02b355a562705cef4aa6494b39f53d7", + "size_in_bytes": 5942 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/bar.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "b323ba72a93810f498769270aa820c03dd4aa73d37c6f39d604d4549f8b9219e", + "sha256_in_prefix": "b323ba72a93810f498769270aa820c03dd4aa73d37c6f39d604d4549f8b9219e", + "size_in_bytes": 2945 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/box.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "963db199103cf520e94c9d3328b95176463271709c46ec7bd84d7e0ca84f90d7", + "sha256_in_prefix": "963db199103cf520e94c9d3328b95176463271709c46ec7bd84d7e0ca84f90d7", + "size_in_bytes": 8365 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/cells.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "b9e12c3824468267bea6965c45b8330e1dee7a60505fff4e083a3baea43e240b", + "sha256_in_prefix": "b9e12c3824468267bea6965c45b8330e1dee7a60505fff4e083a3baea43e240b", + "size_in_bytes": 4115 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/color.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "6a10644ceb4309b1c5df9f16c733688fd908275d7d5d0b19c5f6543b4c96285d", + "sha256_in_prefix": "6a10644ceb4309b1c5df9f16c733688fd908275d7d5d0b19c5f6543b4c96285d", + "size_in_bytes": 17682 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/color_triplet.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "75771d6411d3e6454a9061955a30e3c5a95f7ab7125c1cf95200872ea9532ffd", + "sha256_in_prefix": "75771d6411d3e6454a9061955a30e3c5a95f7ab7125c1cf95200872ea9532ffd", + "size_in_bytes": 1399 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/columns.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "de8a0ec3ae03522994fc184c6d82d42cf73459453ec9e3ada2369446c1d252b2", + "sha256_in_prefix": "de8a0ec3ae03522994fc184c6d82d42cf73459453ec9e3ada2369446c1d252b2", + "size_in_bytes": 6159 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/console.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c5d1d7025d49041d0f20a6e000a9d990d9175ac08f24ef502d2bed5a40819acb", + "sha256_in_prefix": "c5d1d7025d49041d0f20a6e000a9d990d9175ac08f24ef502d2bed5a40819acb", + "size_in_bytes": 82760 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/constrain.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "b042207d24a71e9650bbc62ba6b9338e5ba77a2135e133dba0722750248cb829", + "sha256_in_prefix": "b042207d24a71e9650bbc62ba6b9338e5ba77a2135e133dba0722750248cb829", + "size_in_bytes": 1716 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/containers.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "71d82581ff0846b66e66440904042ba2df2ff28094c560cc0da9754d1cd93667", + "sha256_in_prefix": "71d82581ff0846b66e66440904042ba2df2ff28094c560cc0da9754d1cd93667", + "size_in_bytes": 6448 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/control.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "9fc003f3b5167757662184498623f4ff5d6397ffede39d745d0df294f266257f", + "sha256_in_prefix": "9fc003f3b5167757662184498623f4ff5d6397ffede39d745d0df294f266257f", + "size_in_bytes": 8121 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/default_styles.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "d849fe17927e3466059fbb2508963ddde9c887675571085c015dd5a33fb96dbe", + "sha256_in_prefix": "d849fe17927e3466059fbb2508963ddde9c887675571085c015dd5a33fb96dbe", + "size_in_bytes": 6205 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/diagnose.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c4293f062f75d01f2842ad6682c1332f6b7d213f5f9e7429018b4346bc2b2a75", + "sha256_in_prefix": "c4293f062f75d01f2842ad6682c1332f6b7d213f5f9e7429018b4346bc2b2a75", + "size_in_bytes": 1183 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/emoji.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "a44c3dba88cba2aed3e78fad51371e2d733f6e76bb43595da820743e0f8e5b64", + "sha256_in_prefix": "a44c3dba88cba2aed3e78fad51371e2d733f6e76bb43595da820743e0f8e5b64", + "size_in_bytes": 3229 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/errors.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "5fda56496e27eac6497af7a88762ab1121283dba89916ba8adb9775c9f4fd575", + "sha256_in_prefix": "5fda56496e27eac6497af7a88762ab1121283dba89916ba8adb9775c9f4fd575", + "size_in_bytes": 1489 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/file_proxy.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "63ac3518af5e723c039904f463a30787680b2347f17dc358e17ea2777e6a8ea5", + "sha256_in_prefix": "63ac3518af5e723c039904f463a30787680b2347f17dc358e17ea2777e6a8ea5", + "size_in_bytes": 2362 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/filesize.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "168be941d33b02245de47b00dca682ca30f73480ee26813545ce798007ec768f", + "sha256_in_prefix": "168be941d33b02245de47b00dca682ca30f73480ee26813545ce798007ec768f", + "size_in_bytes": 2579 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/highlighter.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "29a7abd80ca011aa1db125e89b28e2c5c783a4c8a0201c781fd08e1d2422de9d", + "sha256_in_prefix": "29a7abd80ca011aa1db125e89b28e2c5c783a4c8a0201c781fd08e1d2422de9d", + "size_in_bytes": 8021 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/json.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "d3729c146c883dbccba66b38d323cbc9cf7107aee73ddebc0560c6f7062b775f", + "sha256_in_prefix": "d3729c146c883dbccba66b38d323cbc9cf7107aee73ddebc0560c6f7062b775f", + "size_in_bytes": 4693 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/jupyter.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "e75789fa1b3f8b3abc3d5a952573d13741015604ca2ab6097a749b1ec4068f1c", + "sha256_in_prefix": "e75789fa1b3f8b3abc3d5a952573d13741015604ca2ab6097a749b1ec4068f1c", + "size_in_bytes": 3961 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/layout.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "35c5ae41ac211a5bf507c3f501f4c875db493ef69086d0a23f182afb4fed2538", + "sha256_in_prefix": "35c5ae41ac211a5bf507c3f501f4c875db493ef69086d0a23f182afb4fed2538", + "size_in_bytes": 14609 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/live.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "dafdd5821adb7bbfe17406f6c45d21af28dbbc984cdbff9f2600338c9521e1c9", + "sha256_in_prefix": "dafdd5821adb7bbfe17406f6c45d21af28dbbc984cdbff9f2600338c9521e1c9", + "size_in_bytes": 11639 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/live_render.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "86cc083f3d02d247687ff878f8bd1287630a3a5e1cc3e94bf8359aa0b484f5e3", + "sha256_in_prefix": "86cc083f3d02d247687ff878f8bd1287630a3a5e1cc3e94bf8359aa0b484f5e3", + "size_in_bytes": 3364 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/logging.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "6cf060f1c65f31eda26ff7c004792f441bcbb2ab186e083640d42abbc76a4a6b", + "sha256_in_prefix": "6cf060f1c65f31eda26ff7c004792f441bcbb2ab186e083640d42abbc76a4a6b", + "size_in_bytes": 9870 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/markup.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "8cbc91043b235c79dfb3eecdcf27d9347b70f493b003fa38def19b2662528b35", + "sha256_in_prefix": "8cbc91043b235c79dfb3eecdcf27d9347b70f493b003fa38def19b2662528b35", + "size_in_bytes": 5903 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/measure.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "b9810b06ee350bd4ac5fbe70bb5c7da9894bdd4cc32494060043619fc462b8b8", + "sha256_in_prefix": "b9810b06ee350bd4ac5fbe70bb5c7da9894bdd4cc32494060043619fc462b8b8", + "size_in_bytes": 5038 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/padding.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "112cc0adb8ba05fa90a42bd539dfb1e64d5485b7cade9a5c4a3d9ab41fd7e654", + "sha256_in_prefix": "112cc0adb8ba05fa90a42bd539dfb1e64d5485b7cade9a5c4a3d9ab41fd7e654", + "size_in_bytes": 4444 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/pager.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "2830d97811a32927940227a3fab13348e6c4e75b23625cd54e98a3eb3bada39c", + "sha256_in_prefix": "2830d97811a32927940227a3fab13348e6c4e75b23625cd54e98a3eb3bada39c", + "size_in_bytes": 1438 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/palette.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "43159700fc1f80acb1168de67488f77dbcfffd00f7114fe55a534783245e8279", + "sha256_in_prefix": "43159700fc1f80acb1168de67488f77dbcfffd00f7114fe55a534783245e8279", + "size_in_bytes": 3670 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/panel.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "91ef6f768f37e523969bf766b21ee85609504fed335ee1bab8d27ccdc7f6066d", + "sha256_in_prefix": "91ef6f768f37e523969bf766b21ee85609504fed335ee1bab8d27ccdc7f6066d", + "size_in_bytes": 7390 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/pretty.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c0a4d3e62a4d4d5b87001cbcebfd924a8f0791208ad886d6355572e977da0526", + "sha256_in_prefix": "c0a4d3e62a4d4d5b87001cbcebfd924a8f0791208ad886d6355572e977da0526", + "size_in_bytes": 27479 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/progress.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c5f781582c92800b7d67b4114485808ddbc659e902efdd7c3496e0524d191b0e", + "sha256_in_prefix": "c5f781582c92800b7d67b4114485808ddbc659e902efdd7c3496e0524d191b0e", + "size_in_bytes": 53968 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/progress_bar.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "9fd338c3518bc9fe1bdac4c19137193ab4fc1f874f78bbf500d61d3d079fd4fa", + "sha256_in_prefix": "9fd338c3518bc9fe1bdac4c19137193ab4fc1f874f78bbf500d61d3d079fd4fa", + "size_in_bytes": 6873 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/prompt.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "0b7279c057c85e48a43768a062fd448508ac2f2da49ade8847efad32bddf4176", + "sha256_in_prefix": "0b7279c057c85e48a43768a062fd448508ac2f2da49ade8847efad32bddf4176", + "size_in_bytes": 11261 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/protocol.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "e76b004383f7b926ffed88f6a27b6b89102ccd045a0f4c77e325b59da5a37609", + "sha256_in_prefix": "e76b004383f7b926ffed88f6a27b6b89102ccd045a0f4c77e325b59da5a37609", + "size_in_bytes": 1314 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/region.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "84ae084905f7e5b70f0efa269e40276b2adbc2857c067108a4c26e09ae57c5a4", + "sha256_in_prefix": "84ae084905f7e5b70f0efa269e40276b2adbc2857c067108a4c26e09ae57c5a4", + "size_in_bytes": 489 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/repr.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c96571f39834e90476d8a41fc92a31d3e35769909c9ba1ab7a8b6916ce2a3cc2", + "sha256_in_prefix": "c96571f39834e90476d8a41fc92a31d3e35769909c9ba1ab7a8b6916ce2a3cc2", + "size_in_bytes": 4058 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/rule.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "41878e4ca597d027e9c8e5aeb43a6bc4f590428da12134e30dc2317a8d943053", + "sha256_in_prefix": "41878e4ca597d027e9c8e5aeb43a6bc4f590428da12134e30dc2317a8d943053", + "size_in_bytes": 3905 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/scope.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "5a8cc70fb3f259ad82c25825e540be35987ef6867258fff54ebbaa24a554767c", + "sha256_in_prefix": "5a8cc70fb3f259ad82c25825e540be35987ef6867258fff54ebbaa24a554767c", + "size_in_bytes": 2951 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/screen.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "e2f38688c3b8ddae3b874ee74595fdc454b991903d4e9ef2cd7263c736f691c2", + "sha256_in_prefix": "e2f38688c3b8ddae3b874ee74595fdc454b991903d4e9ef2cd7263c736f691c2", + "size_in_bytes": 1841 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/segment.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "eb677be1e4c0a7ca76e8bb7ded07656a6084b1ee2acc0631e19de827ac2fcc9b", + "sha256_in_prefix": "eb677be1e4c0a7ca76e8bb7ded07656a6084b1ee2acc0631e19de827ac2fcc9b", + "size_in_bytes": 20745 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/spinner.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "30abb46c5fe49356be44b9392a852dedbb6894b669f277b50788837d0c446070", + "sha256_in_prefix": "30abb46c5fe49356be44b9392a852dedbb6894b669f277b50788837d0c446070", + "size_in_bytes": 4362 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/status.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "6dcfa664d377ec965c0f92cb4b71373ede37b059b2b0206ce5cd096f4facd77f", + "sha256_in_prefix": "6dcfa664d377ec965c0f92cb4b71373ede37b059b2b0206ce5cd096f4facd77f", + "size_in_bytes": 4555 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/style.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "168e2286ab9862ae924cb72eff5a2f1f70e10c5602054120be69f5fa031c700b", + "sha256_in_prefix": "168e2286ab9862ae924cb72eff5a2f1f70e10c5602054120be69f5fa031c700b", + "size_in_bytes": 21292 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/styled.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "9ea3d864ccaef97b3c84f5ee4962c3758fc72c7619fa31bffa7718ddfb0060ab", + "sha256_in_prefix": "9ea3d864ccaef97b3c84f5ee4962c3758fc72c7619fa31bffa7718ddfb0060ab", + "size_in_bytes": 1725 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/syntax.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "9aeac93d9804d6eb148307a3042c5e15c223187b1e9e6efcaa130edddb40eda4", + "sha256_in_prefix": "9aeac93d9804d6eb148307a3042c5e15c223187b1e9e6efcaa130edddb40eda4", + "size_in_bytes": 25712 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/table.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "9deadd051bccafd937d9ebb10d3e45181eb788c6bf9ea5fca72ca4ec3020806d", + "sha256_in_prefix": "9deadd051bccafd937d9ebb10d3e45181eb788c6bf9ea5fca72ca4ec3020806d", + "size_in_bytes": 29904 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/terminal_theme.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "ad563c6fe943f854f285fd09271ec0dea4b70fa0be5d63830073be1b07531a3c", + "sha256_in_prefix": "ad563c6fe943f854f285fd09271ec0dea4b70fa0be5d63830073be1b07531a3c", + "size_in_bytes": 2978 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/text.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "b35da8e575411c799ff1807d6bcd9612baccd1deccaf815c4d1f4b4ef8a006ac", + "sha256_in_prefix": "b35da8e575411c799ff1807d6bcd9612baccd1deccaf815c4d1f4b4ef8a006ac", + "size_in_bytes": 40066 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/theme.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "94992c029e3aefd6adece2f6533aaa9ac7e2dbc86bc51cd1a12336195901b432", + "sha256_in_prefix": "94992c029e3aefd6adece2f6533aaa9ac7e2dbc86bc51cd1a12336195901b432", + "size_in_bytes": 4800 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/themes.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "2e1a012f623d6a25ea11713374f87592cd71a7d97475a1dc0946f32819bc9272", + "sha256_in_prefix": "2e1a012f623d6a25ea11713374f87592cd71a7d97475a1dc0946f32819bc9272", + "size_in_bytes": 255 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/traceback.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "6ac287a58a39fda5e89424a773e76dffa4cad7f24b9f289139f82585a4182390", + "sha256_in_prefix": "6ac287a58a39fda5e89424a773e76dffa4cad7f24b9f289139f82585a4182390", + "size_in_bytes": 21671 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/tree.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "2041ad2b2168040e0071be16ad76d7907fbff6d50a7dc8faf1e1ffded5a61b21", + "sha256_in_prefix": "2041ad2b2168040e0071be16ad76d7907fbff6d50a7dc8faf1e1ffded5a61b21", + "size_in_bytes": 7296 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/_cell_widths.py", + "path_type": "hardlink", + "sha256": "da7e048898b75fdb2a22ad0ed7a91467fcf2e9460c777c457c286529f9d6d477", + "sha256_in_prefix": "da7e048898b75fdb2a22ad0ed7a91467fcf2e9460c777c457c286529f9d6d477", + "size_in_bytes": 10096 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/_emoji_codes.py", + "path_type": "hardlink", + "sha256": "86ed552fd9db55da6926b5688a356c85195c4517bfbf7763bb7326776b0a65d6", + "sha256_in_prefix": "86ed552fd9db55da6926b5688a356c85195c4517bfbf7763bb7326776b0a65d6", + "size_in_bytes": 140235 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/_emoji_replace.py", + "path_type": "hardlink", + "sha256": "9fe91c7adb04531d99526850adf78c35cfad79e1a1a6e490e45f153c1b32bc3a", + "sha256_in_prefix": "9fe91c7adb04531d99526850adf78c35cfad79e1a1a6e490e45f153c1b32bc3a", + "size_in_bytes": 1064 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/_export_format.py", + "path_type": "hardlink", + "sha256": "ab1815de72a75d0bb585f6e7455b303d8cbe030220d57d0b482e3b70ae6cf239", + "sha256_in_prefix": "ab1815de72a75d0bb585f6e7455b303d8cbe030220d57d0b482e3b70ae6cf239", + "size_in_bytes": 2100 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/_extension.py", + "path_type": "hardlink", + "sha256": "5ede3b41a7022b062bbb38c38be80e06aef6e0945e0e3f429bdc548b97ebfb7e", + "sha256_in_prefix": "5ede3b41a7022b062bbb38c38be80e06aef6e0945e0e3f429bdc548b97ebfb7e", + "size_in_bytes": 265 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/_fileno.py", + "path_type": "hardlink", + "sha256": "1d66713f90b66a331b1ebcaf01066c79f9557d0a06cec28e1f3286b0b0fcca74", + "sha256_in_prefix": "1d66713f90b66a331b1ebcaf01066c79f9557d0a06cec28e1f3286b0b0fcca74", + "size_in_bytes": 799 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/_inspect.py", + "path_type": "hardlink", + "sha256": "a19246c37d5eeb87705d20a6ac39ef65bc156f564a8567d4f30237556a218c99", + "sha256_in_prefix": "a19246c37d5eeb87705d20a6ac39ef65bc156f564a8567d4f30237556a218c99", + "size_in_bytes": 9695 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/_log_render.py", + "path_type": "hardlink", + "sha256": "d41c88d0f035669c5963708624e2b9e218e5ab85fe073fdba088c8a8277c2a7b", + "sha256_in_prefix": "d41c88d0f035669c5963708624e2b9e218e5ab85fe073fdba088c8a8277c2a7b", + "size_in_bytes": 3225 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/_loop.py", + "path_type": "hardlink", + "sha256": "855ffa08b7683e6d2f6b6d96a70e332aa334458b33dd36715e3d0fa12fbd7834", + "sha256_in_prefix": "855ffa08b7683e6d2f6b6d96a70e332aa334458b33dd36715e3d0fa12fbd7834", + "size_in_bytes": 1236 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/_null_file.py", + "path_type": "hardlink", + "sha256": "b4649793fbfe21999b8f5180cc78adf00de460840c882a55b0215fb02fbf289e", + "sha256_in_prefix": "b4649793fbfe21999b8f5180cc78adf00de460840c882a55b0215fb02fbf289e", + "size_in_bytes": 1387 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/_palettes.py", + "path_type": "hardlink", + "sha256": "71d7afd4940a67426f960b95f62a478339d3767be52335050c16f422dd8fce32", + "sha256_in_prefix": "71d7afd4940a67426f960b95f62a478339d3767be52335050c16f422dd8fce32", + "size_in_bytes": 7063 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/_pick.py", + "path_type": "hardlink", + "sha256": "7af0edf10378945e428b0ad421794e2429ed8ad0423ac23764b3c42005512c95", + "sha256_in_prefix": "7af0edf10378945e428b0ad421794e2429ed8ad0423ac23764b3c42005512c95", + "size_in_bytes": 423 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/_ratio.py", + "path_type": "hardlink", + "sha256": "da52d29622f4db963e60c7dd7c66eeb644037af85cc83a9cf83b54616f6653bd", + "sha256_in_prefix": "da52d29622f4db963e60c7dd7c66eeb644037af85cc83a9cf83b54616f6653bd", + "size_in_bytes": 5472 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/_spinners.py", + "path_type": "hardlink", + "sha256": "536af5fe0ff5cd28ec8e251d00449cda200c7378b8ae2fd2f0f60fea4439cf52", + "sha256_in_prefix": "536af5fe0ff5cd28ec8e251d00449cda200c7378b8ae2fd2f0f60fea4439cf52", + "size_in_bytes": 19919 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/_stack.py", + "path_type": "hardlink", + "sha256": "f82f0e2bbaf19f7b0851d570c59041a5e1e12335f4788f9533731e9987da5e6d", + "sha256_in_prefix": "f82f0e2bbaf19f7b0851d570c59041a5e1e12335f4788f9533731e9987da5e6d", + "size_in_bytes": 351 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/_timer.py", + "path_type": "hardlink", + "sha256": "cde9716d3ea83c566736bc163e973592d51e013f957387ee15c4592d018bb4c2", + "sha256_in_prefix": "cde9716d3ea83c566736bc163e973592d51e013f957387ee15c4592d018bb4c2", + "size_in_bytes": 417 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/_win32_console.py", + "path_type": "hardlink", + "sha256": "3f4bf12367dc9ddca6d545354b7ed703343342793263b62a00a9b19b6e3f82e8", + "sha256_in_prefix": "3f4bf12367dc9ddca6d545354b7ed703343342793263b62a00a9b19b6e3f82e8", + "size_in_bytes": 22820 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/_windows.py", + "path_type": "hardlink", + "sha256": "76f365f5399f3f3355c622a4e560c58a112b679efdea0d940bdf8a186c9f5e69", + "sha256_in_prefix": "76f365f5399f3f3355c622a4e560c58a112b679efdea0d940bdf8a186c9f5e69", + "size_in_bytes": 1926 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/_windows_renderer.py", + "path_type": "hardlink", + "sha256": "b7be192f7c6e0c23f79e64e9f691f52f92e223671a909b9045095e1c225eae59", + "sha256_in_prefix": "b7be192f7c6e0c23f79e64e9f691f52f92e223671a909b9045095e1c225eae59", + "size_in_bytes": 2783 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/_wrap.py", + "path_type": "hardlink", + "sha256": "c5f57ff6dd1283aaf38a69ab0ebbbc7c25665256a56007072c37eb2599db6f04", + "sha256_in_prefix": "c5f57ff6dd1283aaf38a69ab0ebbbc7c25665256a56007072c37eb2599db6f04", + "size_in_bytes": 1840 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/abc.py", + "path_type": "hardlink", + "sha256": "38df84f99a924a1799f3c56b297d8cdcf5e915b18451464f31afc07f497ee1fd", + "sha256_in_prefix": "38df84f99a924a1799f3c56b297d8cdcf5e915b18451464f31afc07f497ee1fd", + "size_in_bytes": 890 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/align.py", + "path_type": "hardlink", + "sha256": "262f98a247e48677deff1326af82128d9074ed3257820042398a186be1c302bf", + "sha256_in_prefix": "262f98a247e48677deff1326af82128d9074ed3257820042398a186be1c302bf", + "size_in_bytes": 10368 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/ansi.py", + "path_type": "hardlink", + "sha256": "883eb9df6418aa7066ea1003ba52a3ad5f25f24149fbd7c4568a072471f784c8", + "sha256_in_prefix": "883eb9df6418aa7066ea1003ba52a3ad5f25f24149fbd7c4568a072471f784c8", + "size_in_bytes": 6906 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/bar.py", + "path_type": "hardlink", + "sha256": "6bb503df4dc171c442ac48468df304969bf94456088a7680840baa62a854be6c", + "sha256_in_prefix": "6bb503df4dc171c442ac48468df304969bf94456088a7680840baa62a854be6c", + "size_in_bytes": 3264 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/box.py", + "path_type": "hardlink", + "sha256": "149ea72378c3ee1d97345535dfc6c952dd8762658e9516e5b68084b8801985ec", + "sha256_in_prefix": "149ea72378c3ee1d97345535dfc6c952dd8762658e9516e5b68084b8801985ec", + "size_in_bytes": 9842 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/cells.py", + "path_type": "hardlink", + "sha256": "eb6ef3b49b3dcce2fedfc1c9ee45c17ab47e813f0a05f602f14cc4c0c243618a", + "sha256_in_prefix": "eb6ef3b49b3dcce2fedfc1c9ee45c17ab47e813f0a05f602f14cc4c0c243618a", + "size_in_bytes": 4509 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/color.py", + "path_type": "hardlink", + "sha256": "f4687de7c5377fbe5655d2d3782d14f679064e7da7d309e88caa49ea34049081", + "sha256_in_prefix": "f4687de7c5377fbe5655d2d3782d14f679064e7da7d309e88caa49ea34049081", + "size_in_bytes": 18224 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/color_triplet.py", + "path_type": "hardlink", + "sha256": "de585091d25bbd63e82c33be0276089805a626f579765818342559f7b39168de", + "sha256_in_prefix": "de585091d25bbd63e82c33be0276089805a626f579765818342559f7b39168de", + "size_in_bytes": 1054 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/columns.py", + "path_type": "hardlink", + "sha256": "1d45f429c326f5db0a362d757d36e233f876883b65f3248269573195a944ceaf", + "sha256_in_prefix": "1d45f429c326f5db0a362d757d36e233f876883b65f3248269573195a944ceaf", + "size_in_bytes": 7131 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/console.py", + "path_type": "hardlink", + "sha256": "a43be46cb92fb5920c230431fe3919fac7b2365e331812ef897a165ed7bd7f08", + "sha256_in_prefix": "a43be46cb92fb5920c230431fe3919fac7b2365e331812ef897a165ed7bd7f08", + "size_in_bytes": 99218 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/constrain.py", + "path_type": "hardlink", + "sha256": "d5520fb82f0082d296adc9dc42b8c1758a80dc9556cacbba8d9a35aeb87b73b4", + "sha256_in_prefix": "d5520fb82f0082d296adc9dc42b8c1758a80dc9556cacbba8d9a35aeb87b73b4", + "size_in_bytes": 1288 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/containers.py", + "path_type": "hardlink", + "sha256": "68a826e540c79f9366ba2e8825a29db1985b1c2961fd7ec3fbf5a0f0486bafbb", + "sha256_in_prefix": "68a826e540c79f9366ba2e8825a29db1985b1c2961fd7ec3fbf5a0f0486bafbb", + "size_in_bytes": 5497 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/control.py", + "path_type": "hardlink", + "sha256": "0d29074d440ba2b7d211100a13fa1300450579f667669e1b41be2af2b1db2b0b", + "sha256_in_prefix": "0d29074d440ba2b7d211100a13fa1300450579f667669e1b41be2af2b1db2b0b", + "size_in_bytes": 6630 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/default_styles.py", + "path_type": "hardlink", + "sha256": "f857b7d7c90c548fc8c1c88ae4f3a94e170ed3ef43609ebb4d900de839669663", + "sha256_in_prefix": "f857b7d7c90c548fc8c1c88ae4f3a94e170ed3ef43609ebb4d900de839669663", + "size_in_bytes": 8082 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/diagnose.py", + "path_type": "hardlink", + "sha256": "6a7eaea2ec2128f025bd0858a4d3691aaf44272b1f3083afbc26cede84a8476e", + "sha256_in_prefix": "6a7eaea2ec2128f025bd0858a4d3691aaf44272b1f3083afbc26cede84a8476e", + "size_in_bytes": 972 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/emoji.py", + "path_type": "hardlink", + "sha256": "a264c5f5ab1a027b0ce322d8f78791ffd7604514a6d651d4b335f6d03d726024", + "sha256_in_prefix": "a264c5f5ab1a027b0ce322d8f78791ffd7604514a6d651d4b335f6d03d726024", + "size_in_bytes": 2501 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/errors.py", + "path_type": "hardlink", + "sha256": "e693f729ce5de1027f734285b31adfca18e23d57bb275ccea9215b140cdc57e6", + "sha256_in_prefix": "e693f729ce5de1027f734285b31adfca18e23d57bb275ccea9215b140cdc57e6", + "size_in_bytes": 642 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/file_proxy.py", + "path_type": "hardlink", + "sha256": "4e5f531cc0d9f8f9395a6f2c23580683f5390e1bac9b10fe159d1f51b714d16d", + "sha256_in_prefix": "4e5f531cc0d9f8f9395a6f2c23580683f5390e1bac9b10fe159d1f51b714d16d", + "size_in_bytes": 1683 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/filesize.py", + "path_type": "hardlink", + "sha256": "f5f4cb00f080c079815dd46feca654d7de234a036b45be96c7b448a0182a78a6", + "sha256_in_prefix": "f5f4cb00f080c079815dd46feca654d7de234a036b45be96c7b448a0182a78a6", + "size_in_bytes": 2508 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/highlighter.py", + "path_type": "hardlink", + "sha256": "a770b5838418cdecc529d47b345f4484f6f3403bdd3d48464604b21861263e4a", + "sha256_in_prefix": "a770b5838418cdecc529d47b345f4484f6f3403bdd3d48464604b21861263e4a", + "size_in_bytes": 9584 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/json.py", + "path_type": "hardlink", + "sha256": "118a7db9c8fe9c38d80e41c257a324d6f7bc9d43a9b852da5bbe97e74322b363", + "sha256_in_prefix": "118a7db9c8fe9c38d80e41c257a324d6f7bc9d43a9b852da5bbe97e74322b363", + "size_in_bytes": 5032 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/jupyter.py", + "path_type": "hardlink", + "sha256": "432a0aa04ffc21d09baed8921e9f53b1348dc931d8d053b9c2113b8ce4ddf541", + "sha256_in_prefix": "432a0aa04ffc21d09baed8921e9f53b1348dc931d8d053b9c2113b8ce4ddf541", + "size_in_bytes": 3252 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/layout.py", + "path_type": "hardlink", + "sha256": "44560be8774216c1dff5646972f8b7c3e7e98fef0ee5d319f16f7a55d28d75b2", + "sha256_in_prefix": "44560be8774216c1dff5646972f8b7c3e7e98fef0ee5d319f16f7a55d28d75b2", + "size_in_bytes": 14007 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/live.py", + "path_type": "hardlink", + "sha256": "bd9cd8beeedfab096fdc6b61976c62c350dcfcef3456519c095d03387c02c833", + "sha256_in_prefix": "bd9cd8beeedfab096fdc6b61976c62c350dcfcef3456519c095d03387c02c833", + "size_in_bytes": 14273 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/live_render.py", + "path_type": "hardlink", + "sha256": "cc4966dcfadf488be339c7b6f331131cc2147fda45612500e68d007e58143fae", + "sha256_in_prefix": "cc4966dcfadf488be339c7b6f331131cc2147fda45612500e68d007e58143fae", + "size_in_bytes": 3667 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/logging.py", + "path_type": "hardlink", + "sha256": "b81f9c07edd0e1b9970cb2e96ce5a4985be2c3e15d7b7f73c8c57ab4a2765874", + "sha256_in_prefix": "b81f9c07edd0e1b9970cb2e96ce5a4985be2c3e15d7b7f73c8c57ab4a2765874", + "size_in_bytes": 11903 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/markup.py", + "path_type": "hardlink", + "sha256": "c73178b8069f884784603258b7fbd49c9386a1353c46b1fe3c7ed67166178c28", + "sha256_in_prefix": "c73178b8069f884784603258b7fbd49c9386a1353c46b1fe3c7ed67166178c28", + "size_in_bytes": 8198 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/measure.py", + "path_type": "hardlink", + "sha256": "1e6ac8257f2c5914c76e087c33111acbff37564a8d5bfef4b3c68a3f965c608f", + "sha256_in_prefix": "1e6ac8257f2c5914c76e087c33111acbff37564a8d5bfef4b3c68a3f965c608f", + "size_in_bytes": 5305 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/padding.py", + "path_type": "hardlink", + "sha256": "913146b1d19ed28b3bb572e71caa704c8f7409712fadc79e6460ac866272e73c", + "sha256_in_prefix": "913146b1d19ed28b3bb572e71caa704c8f7409712fadc79e6460ac866272e73c", + "size_in_bytes": 4970 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/pager.py", + "path_type": "hardlink", + "sha256": "48efc44c114a6e0de7fc080ecd79b8d52bf7e98c57032237fd1f8a398dbfb927", + "sha256_in_prefix": "48efc44c114a6e0de7fc080ecd79b8d52bf7e98c57032237fd1f8a398dbfb927", + "size_in_bytes": 828 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/palette.py", + "path_type": "hardlink", + "sha256": "9489ef4753830d3d9fdd464c7cbd60aeaedd63fa4374a1f0e1b75480e19a3386", + "sha256_in_prefix": "9489ef4753830d3d9fdd464c7cbd60aeaedd63fa4374a1f0e1b75480e19a3386", + "size_in_bytes": 3396 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/panel.py", + "path_type": "hardlink", + "sha256": "c0631ee3427c2821a04283342f28d112b986224bf66ec600ef54425d3843d311", + "sha256_in_prefix": "c0631ee3427c2821a04283342f28d112b986224bf66ec600ef54425d3843d311", + "size_in_bytes": 10574 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/pretty.py", + "path_type": "hardlink", + "sha256": "78b11837dc5568c36e03a1095589b8962ec774e1f10aa9952af9cea89a7216dd", + "sha256_in_prefix": "78b11837dc5568c36e03a1095589b8962ec774e1f10aa9952af9cea89a7216dd", + "size_in_bytes": 35852 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/progress.py", + "path_type": "hardlink", + "sha256": "9f8285f6f932f3fe6261e5dcc993c4bf3c8ba655a50ef14b90ce4923406cd3c0", + "sha256_in_prefix": "9f8285f6f932f3fe6261e5dcc993c4bf3c8ba655a50ef14b90ce4923406cd3c0", + "size_in_bytes": 59706 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/progress_bar.py", + "path_type": "hardlink", + "sha256": "704a017e473794bc2a6dae172ac529cb8bd240a0e1d9043927627de3e002168a", + "sha256_in_prefix": "704a017e473794bc2a6dae172ac529cb8bd240a0e1d9043927627de3e002168a", + "size_in_bytes": 8165 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/prompt.py", + "path_type": "hardlink", + "sha256": "c74996fa920fa1d24ce2bcba82b82698bae5f15669f7d92a72676705eef46180", + "sha256_in_prefix": "c74996fa920fa1d24ce2bcba82b82698bae5f15669f7d92a72676705eef46180", + "size_in_bytes": 11303 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/protocol.py", + "path_type": "hardlink", + "sha256": "e611c70c3347724764f22587e7311b8becee215485e616d4da3228e3b47b9531", + "sha256_in_prefix": "e611c70c3347724764f22587e7311b8becee215485e616d4da3228e3b47b9531", + "size_in_bytes": 1391 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/py.typed", + "path_type": "hardlink", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size_in_bytes": 0 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/region.py", + "path_type": "hardlink", + "sha256": "acd4fdc59ad56536085d90b43589f8d42250c1835b47e29e70f3b14e042f07c6", + "sha256_in_prefix": "acd4fdc59ad56536085d90b43589f8d42250c1835b47e29e70f3b14e042f07c6", + "size_in_bytes": 166 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/repr.py", + "path_type": "hardlink", + "sha256": "f59f28b4e98cfadcb19f24e876f5e579cb4feb49706a18c68834eb6ebc4f4938", + "sha256_in_prefix": "f59f28b4e98cfadcb19f24e876f5e579cb4feb49706a18c68834eb6ebc4f4938", + "size_in_bytes": 4431 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/rule.py", + "path_type": "hardlink", + "sha256": "d1f35a4bf68445add43117374f958ca4dfecba6b43c5f6a8af6cb7a1fd5fb419", + "sha256_in_prefix": "d1f35a4bf68445add43117374f958ca4dfecba6b43c5f6a8af6cb7a1fd5fb419", + "size_in_bytes": 4602 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/scope.py", + "path_type": "hardlink", + "sha256": "4cc514f2aa35eed872a9008faa30cb62983f514d64e6a55df96c2226f9c955ab", + "sha256_in_prefix": "4cc514f2aa35eed872a9008faa30cb62983f514d64e6a55df96c2226f9c955ab", + "size_in_bytes": 2843 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/screen.py", + "path_type": "hardlink", + "sha256": "628791784494871ef882ba9bd264926fd960861cac5a6147621b1b3154235cef", + "sha256_in_prefix": "628791784494871ef882ba9bd264926fd960861cac5a6147621b1b3154235cef", + "size_in_bytes": 1591 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/segment.py", + "path_type": "hardlink", + "sha256": "5cb9c9105bdc5776e3695ccc3542627a6de7f25bef23d4c9e4f4eef881b6b938", + "sha256_in_prefix": "5cb9c9105bdc5776e3695ccc3542627a6de7f25bef23d4c9e4f4eef881b6b938", + "size_in_bytes": 24247 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/spinner.py", + "path_type": "hardlink", + "sha256": "d799280a61740d0783f3e936f0ba6de97ff3250525cc4860a3fe80eaecb8ee57", + "sha256_in_prefix": "d799280a61740d0783f3e936f0ba6de97ff3250525cc4860a3fe80eaecb8ee57", + "size_in_bytes": 4339 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/status.py", + "path_type": "hardlink", + "sha256": "809b085c865e4a8deeacecb14548ece95ae15f9099ac0d0dc4843e7718429f0a", + "sha256_in_prefix": "809b085c865e4a8deeacecb14548ece95ae15f9099ac0d0dc4843e7718429f0a", + "size_in_bytes": 4425 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/style.py", + "path_type": "hardlink", + "sha256": "de18a8707ff837cbf0466dfef32156ccceed4b08e312f7a7ebd5ea59ab124303", + "sha256_in_prefix": "de18a8707ff837cbf0466dfef32156ccceed4b08e312f7a7ebd5ea59ab124303", + "size_in_bytes": 27073 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/styled.py", + "path_type": "hardlink", + "sha256": "799367cc6ac8e248bfe78a606373a3d13fb1de5c5d5d3621e3faf20c1db8c015", + "sha256_in_prefix": "799367cc6ac8e248bfe78a606373a3d13fb1de5c5d5d3621e3faf20c1db8c015", + "size_in_bytes": 1258 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/syntax.py", + "path_type": "hardlink", + "sha256": "8e00e25422ba72947436604ea59988bbe51de1e696edf1ef8c96640db8e97120", + "sha256_in_prefix": "8e00e25422ba72947436604ea59988bbe51de1e696edf1ef8c96640db8e97120", + "size_in_bytes": 35173 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/table.py", + "path_type": "hardlink", + "sha256": "f96cdeb0bf9524ab1a883537bb2733a49307cba5426927b0058270c7c46e748f", + "sha256_in_prefix": "f96cdeb0bf9524ab1a883537bb2733a49307cba5426927b0058270c7c46e748f", + "size_in_bytes": 39684 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/terminal_theme.py", + "path_type": "hardlink", + "sha256": "d63e7eb9f25f9ef940a3942c8bf0026625c39b0317cea826141c8e6d3f7ec896", + "sha256_in_prefix": "d63e7eb9f25f9ef940a3942c8bf0026625c39b0317cea826141c8e6d3f7ec896", + "size_in_bytes": 3370 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/text.py", + "path_type": "hardlink", + "sha256": "ffc2419526aed1cdb3f0434e64c8b5849eccd59198e34f04e3e8578c7cb28350", + "sha256_in_prefix": "ffc2419526aed1cdb3f0434e64c8b5849eccd59198e34f04e3e8578c7cb28350", + "size_in_bytes": 45525 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/theme.py", + "path_type": "hardlink", + "sha256": "6de9452688330345b41f2b1069b29a1ce7374561f6928ddf400261a0df8015da", + "sha256_in_prefix": "6de9452688330345b41f2b1069b29a1ce7374561f6928ddf400261a0df8015da", + "size_in_bytes": 3777 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/themes.py", + "path_type": "hardlink", + "sha256": "d318132e8cdf69b79b62d709b43742e50917e4855411abe2a83509261e185459", + "sha256_in_prefix": "d318132e8cdf69b79b62d709b43742e50917e4855411abe2a83509261e185459", + "size_in_bytes": 102 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/traceback.py", + "path_type": "hardlink", + "sha256": "c822d5ac2b72a0534435df66926db1786dca9aa913c07f71a4538eee9d81ab40", + "sha256_in_prefix": "c822d5ac2b72a0534435df66926db1786dca9aa913c07f71a4538eee9d81ab40", + "size_in_bytes": 29604 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/rich/tree.py", + "path_type": "hardlink", + "sha256": "04c6d460d8d2f6ea1d34f7efb58fe8766534f4603943370c6d0e5c2598659502", + "sha256_in_prefix": "04c6d460d8d2f6ea1d34f7efb58fe8766534f4603943370c6d0e5c2598659502", + "size_in_bytes": 9169 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/six.py", + "path_type": "hardlink", + "sha256": "4ce39f422ee71467ccac8bed76beb05f8c321c7f0ceda9279ae2dfa3670106b3", + "sha256_in_prefix": "4ce39f422ee71467ccac8bed76beb05f8c321c7f0ceda9279ae2dfa3670106b3", + "size_in_bytes": 34549 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/tenacity/__init__.py", + "path_type": "hardlink", + "sha256": "de4bc02fa28296af06168d8a16198ecec9112920d023eb9bae57d9f00404108d", + "sha256_in_prefix": "de4bc02fa28296af06168d8a16198ecec9112920d023eb9bae57d9f00404108d", + "size_in_bytes": 20493 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/tenacity/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "3779066dbe1f60fd1b522cf3b013d7e26dc55ace3f8ee6c37892a820accc2b8e", + "sha256_in_prefix": "3779066dbe1f60fd1b522cf3b013d7e26dc55ace3f8ee6c37892a820accc2b8e", + "size_in_bytes": 17220 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/tenacity/__pycache__/_asyncio.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "9c4d15212d142701d338cecbb74adb5b65f6cdc45fc35bdd9a0a73f825f2aa1a", + "sha256_in_prefix": "9c4d15212d142701d338cecbb74adb5b65f6cdc45fc35bdd9a0a73f825f2aa1a", + "size_in_bytes": 2834 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/tenacity/__pycache__/_utils.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "1d502ed9c77508f5d2a3bc24b9b6b0974991ed1a76acc9e003dfbf959e13e0f2", + "sha256_in_prefix": "1d502ed9c77508f5d2a3bc24b9b6b0974991ed1a76acc9e003dfbf959e13e0f2", + "size_in_bytes": 1467 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/tenacity/__pycache__/after.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "e15dc4cc8c49f3fdeb434a2f90a8c6cc5178cf60747e9b332dda2a8eac5ba871", + "sha256_in_prefix": "e15dc4cc8c49f3fdeb434a2f90a8c6cc5178cf60747e9b332dda2a8eac5ba871", + "size_in_bytes": 1241 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/tenacity/__pycache__/before.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "57e1e2eae34ac83c4df5642a09ef917a83c668f64bd74a37c3571224ac0f9185", + "sha256_in_prefix": "57e1e2eae34ac83c4df5642a09ef917a83c668f64bd74a37c3571224ac0f9185", + "size_in_bytes": 1119 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/tenacity/__pycache__/before_sleep.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "585541d32d60685d30501d9b3d7ba3a6657822a3153a16dd2c6472f8997d576b", + "sha256_in_prefix": "585541d32d60685d30501d9b3d7ba3a6657822a3153a16dd2c6472f8997d576b", + "size_in_bytes": 1549 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/tenacity/__pycache__/nap.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "34e709c47fc4c31141e5e555748b7a03f0aa505a8b2d0c62fdcac10e12a13313", + "sha256_in_prefix": "34e709c47fc4c31141e5e555748b7a03f0aa505a8b2d0c62fdcac10e12a13313", + "size_in_bytes": 1161 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/tenacity/__pycache__/retry.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "9fd76910c3e5d5c9e91e65a0d8526de9e314154dd91bc44677e42100fa56202a", + "sha256_in_prefix": "9fd76910c3e5d5c9e91e65a0d8526de9e314154dd91bc44677e42100fa56202a", + "size_in_bytes": 9733 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/tenacity/__pycache__/stop.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "e1e71922cb080f786608fed55f432ac3fb604ff403c112baadcdbbb58e4afbfc", + "sha256_in_prefix": "e1e71922cb080f786608fed55f432ac3fb604ff403c112baadcdbbb58e4afbfc", + "size_in_bytes": 4287 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/tenacity/__pycache__/tornadoweb.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "b00e36be00b6984070bfb10c6c6a94d8b922a670796d9f43e24b18b6f2dfefe7", + "sha256_in_prefix": "b00e36be00b6984070bfb10c6c6a94d8b922a670796d9f43e24b18b6f2dfefe7", + "size_in_bytes": 1726 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/tenacity/__pycache__/wait.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "142496959a199941bc3982a68a5817b9f6c829857fe724af5345a05a74f94df3", + "sha256_in_prefix": "142496959a199941bc3982a68a5817b9f6c829857fe724af5345a05a74f94df3", + "size_in_bytes": 9248 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/tenacity/_asyncio.py", + "path_type": "hardlink", + "sha256": "422eb0810b066bd31089b611cb7397a9c0d0b30219674d1d2cea1250637eea8f", + "sha256_in_prefix": "422eb0810b066bd31089b611cb7397a9c0d0b30219674d1d2cea1250637eea8f", + "size_in_bytes": 3551 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/tenacity/_utils.py", + "path_type": "hardlink", + "sha256": "b9bb3a6bbb318f72433512960b2094da3e6bd4207bae0c8e360673619aba0ffe", + "sha256_in_prefix": "b9bb3a6bbb318f72433512960b2094da3e6bd4207bae0c8e360673619aba0ffe", + "size_in_bytes": 2179 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/tenacity/after.py", + "path_type": "hardlink", + "sha256": "4b934221249c3de22b2b021e5d1c1d265de457d4389ea65f9cd3c3c7a1dffff8", + "sha256_in_prefix": "4b934221249c3de22b2b021e5d1c1d265de457d4389ea65f9cd3c3c7a1dffff8", + "size_in_bytes": 1682 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/tenacity/before.py", + "path_type": "hardlink", + "sha256": "748644f609814df7e2b1fc0d90ad05d7117018f578d6ee462bbd146383e2e4a7", + "sha256_in_prefix": "748644f609814df7e2b1fc0d90ad05d7117018f578d6ee462bbd146383e2e4a7", + "size_in_bytes": 1562 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/tenacity/before_sleep.py", + "path_type": "hardlink", + "sha256": "626a6037d63b1c6947f7b536e2fbeafd859be5d79a2b8fc36e20fc66e166cbe1", + "sha256_in_prefix": "626a6037d63b1c6947f7b536e2fbeafd859be5d79a2b8fc36e20fc66e166cbe1", + "size_in_bytes": 2372 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/tenacity/nap.py", + "path_type": "hardlink", + "sha256": "7d15af9f3d5a2336c8abd029de00240198031faa28e73c4cad4e99395072ab42", + "sha256_in_prefix": "7d15af9f3d5a2336c8abd029de00240198031faa28e73c4cad4e99395072ab42", + "size_in_bytes": 1383 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/tenacity/py.typed", + "path_type": "hardlink", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size_in_bytes": 0 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/tenacity/retry.py", + "path_type": "hardlink", + "sha256": "8ebcc3fe6c40e66493504762601ed21e9c65b6384f4986529d24404dbfa08117", + "sha256_in_prefix": "8ebcc3fe6c40e66493504762601ed21e9c65b6384f4986529d24404dbfa08117", + "size_in_bytes": 8746 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/tenacity/stop.py", + "path_type": "hardlink", + "sha256": "60c26ced98197cd0fae4f44baa5181fda8297c65e57a6c7fe479b83ca9c1aa94", + "sha256_in_prefix": "60c26ced98197cd0fae4f44baa5181fda8297c65e57a6c7fe479b83ca9c1aa94", + "size_in_bytes": 3086 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/tenacity/tornadoweb.py", + "path_type": "hardlink", + "sha256": "a68dbdfc5d4cb7ca99a6c1635fb115c004f4c9d0bf35b5626bd8158bb47fc170", + "sha256_in_prefix": "a68dbdfc5d4cb7ca99a6c1635fb115c004f4c9d0bf35b5626bd8158bb47fc170", + "size_in_bytes": 2142 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/tenacity/wait.py", + "path_type": "hardlink", + "sha256": "dc57012680838329b5dbf74deb17caf02d6044e6341e7e0d488daef31bf9d2e1", + "sha256_in_prefix": "dc57012680838329b5dbf74deb17caf02d6044e6341e7e0d488daef31bf9d2e1", + "size_in_bytes": 8024 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/tomli/__init__.py", + "path_type": "hardlink", + "sha256": "26153057ae830758381efb7551009531d7c2bbe220015f055e6bc353da27c5de", + "sha256_in_prefix": "26153057ae830758381efb7551009531d7c2bbe220015f055e6bc353da27c5de", + "size_in_bytes": 396 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/tomli/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "2d1788f149595b33d9a1e4c296572b550c95ba741fe6dbfa8b0272efa952a9bc", + "sha256_in_prefix": "2d1788f149595b33d9a1e4c296572b550c95ba741fe6dbfa8b0272efa952a9bc", + "size_in_bytes": 317 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/tomli/__pycache__/_parser.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "415d77b2f7eb8fe239e686878f6afa5ebf498d3be31fcf6cbd05b52a776fe88f", + "sha256_in_prefix": "415d77b2f7eb8fe239e686878f6afa5ebf498d3be31fcf6cbd05b52a776fe88f", + "size_in_bytes": 17031 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/tomli/__pycache__/_re.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "8681b55608bd673c9ff73e856966a11041b5be83412f216cdda76760f7998c45", + "sha256_in_prefix": "8681b55608bd673c9ff73e856966a11041b5be83412f216cdda76760f7998c45", + "size_in_bytes": 2863 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/tomli/__pycache__/_types.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "5e54f6f4d29777c7db096da56e797b9cd432ecdba89b9b4c97387c550bc96320", + "sha256_in_prefix": "5e54f6f4d29777c7db096da56e797b9cd432ecdba89b9b4c97387c550bc96320", + "size_in_bytes": 287 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/tomli/_parser.py", + "path_type": "hardlink", + "sha256": "83df8435a00b4be07c768918a42bb35056a55a5a20ed3f922183232d9496aed3", + "sha256_in_prefix": "83df8435a00b4be07c768918a42bb35056a55a5a20ed3f922183232d9496aed3", + "size_in_bytes": 22633 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/tomli/_re.py", + "path_type": "hardlink", + "sha256": "75b8e0e428594f6dca6bdcfd0c73977ddb52a4fc147dd80c5e78fc34ea25cbec", + "sha256_in_prefix": "75b8e0e428594f6dca6bdcfd0c73977ddb52a4fc147dd80c5e78fc34ea25cbec", + "size_in_bytes": 2943 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/tomli/_types.py", + "path_type": "hardlink", + "sha256": "f864c6d9552a929c7032ace654ee05ef26ca75d21b027b801d77e65907138b74", + "sha256_in_prefix": "f864c6d9552a929c7032ace654ee05ef26ca75d21b027b801d77e65907138b74", + "size_in_bytes": 254 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/tomli/py.typed", + "path_type": "hardlink", + "sha256": "f0f8f2675695a10a5156fb7bd66bafbaae6a13e8d315990af862c792175e6e67", + "sha256_in_prefix": "f0f8f2675695a10a5156fb7bd66bafbaae6a13e8d315990af862c792175e6e67", + "size_in_bytes": 26 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/truststore/__init__.py", + "path_type": "hardlink", + "sha256": "ab34cb487f0fbc0918d5fafa410daf57e2b013f33cdf0757ba0b6925a3ff01b3", + "sha256_in_prefix": "ab34cb487f0fbc0918d5fafa410daf57e2b013f33cdf0757ba0b6925a3ff01b3", + "size_in_bytes": 403 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/truststore/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c68d6389a41e8457d3541e311e5dcb59a8f1eb4bfd10fd8f62c3cc9ae12c7f4b", + "sha256_in_prefix": "c68d6389a41e8457d3541e311e5dcb59a8f1eb4bfd10fd8f62c3cc9ae12c7f4b", + "size_in_bytes": 514 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/truststore/__pycache__/_api.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "735bb09ad2f6eea7025f97f9dbb71eb1f05555ae2d4f7bfe26cf0994594d65c9", + "sha256_in_prefix": "735bb09ad2f6eea7025f97f9dbb71eb1f05555ae2d4f7bfe26cf0994594d65c9", + "size_in_bytes": 9703 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/truststore/__pycache__/_macos.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "374fec501a51ab1eccba48a00e4b958c3a3cef13adf9880dae1471df50a697ec", + "sha256_in_prefix": "374fec501a51ab1eccba48a00e4b958c3a3cef13adf9880dae1471df50a697ec", + "size_in_bytes": 8611 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/truststore/__pycache__/_openssl.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "9b0ceb368b04fb518d132bd3b1cf789912addedba7b9fe65959d5537c7543d01", + "sha256_in_prefix": "9b0ceb368b04fb518d132bd3b1cf789912addedba7b9fe65959d5537c7543d01", + "size_in_bytes": 1444 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/truststore/__pycache__/_ssl_constants.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "2e9bc3f3445677b438e3aa793e4269f03f616b442b3e68c1f4a361d41f14f547", + "sha256_in_prefix": "2e9bc3f3445677b438e3aa793e4269f03f616b442b3e68c1f4a361d41f14f547", + "size_in_bytes": 758 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/truststore/__pycache__/_windows.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "99913aab3434618f68ffc3a376ce4df72972c44cbaf3efd98fe09ddf072b4a80", + "sha256_in_prefix": "99913aab3434618f68ffc3a376ce4df72972c44cbaf3efd98fe09ddf072b4a80", + "size_in_bytes": 10383 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/truststore/_api.py", + "path_type": "hardlink", + "sha256": "c63b84bbfae51f885c7494d1388984c8e12a770f85f2de6f3b61f6053a18d11a", + "sha256_in_prefix": "c63b84bbfae51f885c7494d1388984c8e12a770f85f2de6f3b61f6053a18d11a", + "size_in_bytes": 9893 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/truststore/_macos.py", + "path_type": "hardlink", + "sha256": "063bc02a80235e17483eec69635db81c9205b300dbd29abc0e3ca7cc9395c2a7", + "sha256_in_prefix": "063bc02a80235e17483eec69635db81c9205b300dbd29abc0e3ca7cc9395c2a7", + "size_in_bytes": 17694 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/truststore/_openssl.py", + "path_type": "hardlink", + "sha256": "2cb519ed919a8a8fa2e5da4a2a328249e4ae7e69fa4fca62f650dc167bd2caad", + "sha256_in_prefix": "2cb519ed919a8a8fa2e5da4a2a328249e4ae7e69fa4fca62f650dc167bd2caad", + "size_in_bytes": 2324 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/truststore/_ssl_constants.py", + "path_type": "hardlink", + "sha256": "3540f87d529d483d36ae2efe75bd2d9ced15a8b3fd687bb3992b5c5bbb40974f", + "sha256_in_prefix": "3540f87d529d483d36ae2efe75bd2d9ced15a8b3fd687bb3992b5c5bbb40974f", + "size_in_bytes": 1130 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/truststore/_windows.py", + "path_type": "hardlink", + "sha256": "d71fc485139e27d40ad6c3008df9d90bb6b0608f149c12582fe4e30025182380", + "sha256_in_prefix": "d71fc485139e27d40ad6c3008df9d90bb6b0608f149c12582fe4e30025182380", + "size_in_bytes": 17468 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/truststore/py.typed", + "path_type": "hardlink", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size_in_bytes": 0 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/typing_extensions.py", + "path_type": "hardlink", + "sha256": "116a5ca72427566738f04f5f4b23c6b3ebd780770093db50001408c6632c0869", + "sha256_in_prefix": "116a5ca72427566738f04f5f4b23c6b3ebd780770093db50001408c6632c0869", + "size_in_bytes": 111130 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/__init__.py", + "path_type": "hardlink", + "sha256": "8972dc6222724a7d0635b58e3990c30298012f52603f8e0467c8b5efad12f0c7", + "sha256_in_prefix": "8972dc6222724a7d0635b58e3990c30298012f52603f8e0467c8b5efad12f0c7", + "size_in_bytes": 3333 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "52644315dbbf55a36aae8a6a794ee09169163cdfe4b5557beab8ea7eab1411b0", + "sha256_in_prefix": "52644315dbbf55a36aae8a6a794ee09169163cdfe4b5557beab8ea7eab1411b0", + "size_in_bytes": 2471 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/__pycache__/_collections.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "636a3fa6fc94e3ade50a8d1a22889cdfe7fe6d4163d6a9a160c3c6fe3fc767e7", + "sha256_in_prefix": "636a3fa6fc94e3ade50a8d1a22889cdfe7fe6d4163d6a9a160c3c6fe3fc767e7", + "size_in_bytes": 10825 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/__pycache__/_version.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "29b6681b9419659826ffb4c5873b3151cac4041443aed865cf10322d6b1b879f", + "sha256_in_prefix": "29b6681b9419659826ffb4c5873b3151cac4041443aed865cf10322d6b1b879f", + "size_in_bytes": 176 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/__pycache__/connection.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "9f93c5747916c5163f06fe61bb72da77d65e682d056eedf486515fb7db6a0efa", + "sha256_in_prefix": "9f93c5747916c5163f06fe61bb72da77d65e682d056eedf486515fb7db6a0efa", + "size_in_bytes": 13663 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/__pycache__/connectionpool.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "23e9efc5e5c36c352a637dbc2784cab734240c2be516b0366133a2911c361f4c", + "sha256_in_prefix": "23e9efc5e5c36c352a637dbc2784cab734240c2be516b0366133a2911c361f4c", + "size_in_bytes": 25745 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/__pycache__/exceptions.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "7857acf73bca39331093d2592e96ef7484f1b211a15cc7d1bbdccba86cb07e0f", + "sha256_in_prefix": "7857acf73bca39331093d2592e96ef7484f1b211a15cc7d1bbdccba86cb07e0f", + "size_in_bytes": 10956 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/__pycache__/fields.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "19907a39fce01171d168d8ebb7c64c9db5fd2dcd1d069ff1ac21c8a02de28bae", + "sha256_in_prefix": "19907a39fce01171d168d8ebb7c64c9db5fd2dcd1d069ff1ac21c8a02de28bae", + "size_in_bytes": 8145 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/__pycache__/filepost.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "09626fe16e6fa7eafae8e9d9f7b90b522534906273a0638afa31f09265fea232", + "sha256_in_prefix": "09626fe16e6fa7eafae8e9d9f7b90b522534906273a0638afa31f09265fea232", + "size_in_bytes": 2712 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/__pycache__/poolmanager.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "427d98ca0542af0f0dfe1146b75164bdaf975db2d5b5483010a9c171fdfb370d", + "sha256_in_prefix": "427d98ca0542af0f0dfe1146b75164bdaf975db2d5b5483010a9c171fdfb370d", + "size_in_bytes": 15026 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/__pycache__/request.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "e6e2e7e126badb9a7f71291008164cc12d80d9f712fbb6eecaec45dd663db2e9", + "sha256_in_prefix": "e6e2e7e126badb9a7f71291008164cc12d80d9f712fbb6eecaec45dd663db2e9", + "size_in_bytes": 6344 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/__pycache__/response.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "e221d803bd689ee1ed20bc84b89dd7b71de638200d36426c6d4b215d5ee22a6d", + "sha256_in_prefix": "e221d803bd689ee1ed20bc84b89dd7b71de638200d36426c6d4b215d5ee22a6d", + "size_in_bytes": 22462 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/_collections.py", + "path_type": "hardlink", + "sha256": "469d6657206073f52501ca7a3376add6c909057479278dcd6b0453bd6da0fd76", + "sha256_in_prefix": "469d6657206073f52501ca7a3376add6c909057479278dcd6b0453bd6da0fd76", + "size_in_bytes": 10811 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/_version.py", + "path_type": "hardlink", + "sha256": "6b3a0ceccec15000e5da406131547a3cf7f61a104323dd267b57dc9f34f075cc", + "sha256_in_prefix": "6b3a0ceccec15000e5da406131547a3cf7f61a104323dd267b57dc9f34f075cc", + "size_in_bytes": 64 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/connection.py", + "path_type": "hardlink", + "sha256": "f7693db5dff2e0f1224c88cdb9f0946b5373301dc9df0d0b11dca89188179d6f", + "sha256_in_prefix": "f7693db5dff2e0f1224c88cdb9f0946b5373301dc9df0d0b11dca89188179d6f", + "size_in_bytes": 20300 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/connectionpool.py", + "path_type": "hardlink", + "sha256": "22d5436ac0e73d13cff51f1b37163bb4f0650bbdb89c9f679715605c6fd22db2", + "sha256_in_prefix": "22d5436ac0e73d13cff51f1b37163bb4f0650bbdb89c9f679715605c6fd22db2", + "size_in_bytes": 39990 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/__init__.py", + "path_type": "hardlink", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size_in_bytes": 0 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "f707ad8531b2110f857d489555440f9cb8852b7bbe6b0f3114a404053f72999c", + "sha256_in_prefix": "f707ad8531b2110f857d489555440f9cb8852b7bbe6b0f3114a404053f72999c", + "size_in_bytes": 161 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/__pycache__/_appengine_environ.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "46623de22f31d5a8a525933f1b3b614e33b3b5bc24d6425e21c020d41e37fe30", + "sha256_in_prefix": "46623de22f31d5a8a525933f1b3b614e33b3b5bc24d6425e21c020d41e37fe30", + "size_in_bytes": 1341 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/__pycache__/appengine.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "b6f0e92a8d7b82b893ad1212bb036579cc6555c0552e95efbbdfc5f7bd373cfc", + "sha256_in_prefix": "b6f0e92a8d7b82b893ad1212bb036579cc6555c0552e95efbbdfc5f7bd373cfc", + "size_in_bytes": 8158 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/__pycache__/ntlmpool.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "51094f81322cfb7ff541ca11de6e1b84445f1682609f51e0b1f58d2514d111c8", + "sha256_in_prefix": "51094f81322cfb7ff541ca11de6e1b84445f1682609f51e0b1f58d2514d111c8", + "size_in_bytes": 3585 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/__pycache__/pyopenssl.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "94e7d71ed8fa200886cd9e2720f0f255f98ba0cd891115c659c263cfd0932e34", + "sha256_in_prefix": "94e7d71ed8fa200886cd9e2720f0f255f98ba0cd891115c659c263cfd0932e34", + "size_in_bytes": 15771 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/__pycache__/securetransport.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "f2e98515a603ff143812b3e36ae8b83d68a066103cb16f2bcd6d520eb0409791", + "sha256_in_prefix": "f2e98515a603ff143812b3e36ae8b83d68a066103cb16f2bcd6d520eb0409791", + "size_in_bytes": 21903 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/__pycache__/socks.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "4ab61f893b4011d61a68eb0e3afbcb3ca4c8c2868016da607cb2706a72926ac6", + "sha256_in_prefix": "4ab61f893b4011d61a68eb0e3afbcb3ca4c8c2868016da607cb2706a72926ac6", + "size_in_bytes": 5563 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/_appengine_environ.py", + "path_type": "hardlink", + "sha256": "6c36f2384856d8228b25c42a00a032ac41cdf9a925b321c52aaeaf17c645b269", + "sha256_in_prefix": "6c36f2384856d8228b25c42a00a032ac41cdf9a925b321c52aaeaf17c645b269", + "size_in_bytes": 957 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/_securetransport/__init__.py", + "path_type": "hardlink", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size_in_bytes": 0 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/_securetransport/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "cacbdbb60874be684368966f7fa863a69c27e7180434839dc8cb345ce6295ecb", + "sha256_in_prefix": "cacbdbb60874be684368966f7fa863a69c27e7180434839dc8cb345ce6295ecb", + "size_in_bytes": 178 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/_securetransport/__pycache__/bindings.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "5fe2cd93e2d08e0405e5c81cf32cf17e6475ddca1e3876ab99dd603903a18fd0", + "sha256_in_prefix": "5fe2cd93e2d08e0405e5c81cf32cf17e6475ddca1e3876ab99dd603903a18fd0", + "size_in_bytes": 10674 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/_securetransport/__pycache__/low_level.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "2673079b2508bf890644273cfbd7cfcc436768704262b8ddc1ed10b508c597b3", + "sha256_in_prefix": "2673079b2508bf890644273cfbd7cfcc436768704262b8ddc1ed10b508c597b3", + "size_in_bytes": 9061 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/_securetransport/bindings.py", + "path_type": "hardlink", + "sha256": "e1793ae2a2243c1b74f40e6af9120552e0e135cf665e29556a99bb5a7627cd1c", + "sha256_in_prefix": "e1793ae2a2243c1b74f40e6af9120552e0e135cf665e29556a99bb5a7627cd1c", + "size_in_bytes": 17632 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/_securetransport/low_level.py", + "path_type": "hardlink", + "sha256": "076241076fcd44fd36c4ae8309ad4f6bd22ec6b3f0c730f365b8b14246fb53d3", + "sha256_in_prefix": "076241076fcd44fd36c4ae8309ad4f6bd22ec6b3f0c730f365b8b14246fb53d3", + "size_in_bytes": 13922 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/appengine.py", + "path_type": "hardlink", + "sha256": "551ebc780544d77ee5c53823043c029dae5488165338a6b4d408fffb905a0b3e", + "sha256_in_prefix": "551ebc780544d77ee5c53823043c029dae5488165338a6b4d408fffb905a0b3e", + "size_in_bytes": 11036 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/ntlmpool.py", + "path_type": "hardlink", + "sha256": "3657e45bb58c756f338aab9da298c7a16dbdf688350535a2d0878889baae1709", + "sha256_in_prefix": "3657e45bb58c756f338aab9da298c7a16dbdf688350535a2d0878889baae1709", + "size_in_bytes": 4528 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/pyopenssl.py", + "path_type": "hardlink", + "sha256": "843261e0c87263fa7ea0a9457187106954110efe86326046b96f728f1c9e7a33", + "sha256_in_prefix": "843261e0c87263fa7ea0a9457187106954110efe86326046b96f728f1c9e7a33", + "size_in_bytes": 17081 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/securetransport.py", + "path_type": "hardlink", + "sha256": "ca165d9958d8e8f23a11e15ba7ba983a9ebebe9d5192fd8d32e3866848fba667", + "sha256_in_prefix": "ca165d9958d8e8f23a11e15ba7ba983a9ebebe9d5192fd8d32e3866848fba667", + "size_in_bytes": 34448 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/socks.py", + "path_type": "hardlink", + "sha256": "6918bd7965e8f5911bf795d4c5e7f8676d421659e78db122028f473ac7a832de", + "sha256_in_prefix": "6918bd7965e8f5911bf795d4c5e7f8676d421659e78db122028f473ac7a832de", + "size_in_bytes": 7097 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/exceptions.py", + "path_type": "hardlink", + "sha256": "d0c9e7a372874cd7d745f63beb7f0db9f38f9146fa9973a6f8baa3fb8c76c3c0", + "sha256_in_prefix": "d0c9e7a372874cd7d745f63beb7f0db9f38f9146fa9973a6f8baa3fb8c76c3c0", + "size_in_bytes": 8217 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/fields.py", + "path_type": "hardlink", + "sha256": "92f2c30a0fc9987d652e3514118fc52d2f14858ee106f0cfb951136d8f2676b3", + "sha256_in_prefix": "92f2c30a0fc9987d652e3514118fc52d2f14858ee106f0cfb951136d8f2676b3", + "size_in_bytes": 8579 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/filepost.py", + "path_type": "hardlink", + "sha256": "e5bfeaaa04475652fbb8bb5d018073061f861e653901f255b7fd8dd174b73de6", + "sha256_in_prefix": "e5bfeaaa04475652fbb8bb5d018073061f861e653901f255b7fd8dd174b73de6", + "size_in_bytes": 2440 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/packages/__init__.py", + "path_type": "hardlink", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size_in_bytes": 0 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/packages/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "b6a22bfe51c846109fcbf9e5a730c981fb9d1d2c0bcb8628de38cbb43e647740", + "sha256_in_prefix": "b6a22bfe51c846109fcbf9e5a730c981fb9d1d2c0bcb8628de38cbb43e647740", + "size_in_bytes": 162 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/packages/__pycache__/six.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "a88f91e7ef0a1bed32ce7acec93210b424875b71943e5446084a03ee1c7ecdba", + "sha256_in_prefix": "a88f91e7ef0a1bed32ce7acec93210b424875b71943e5446084a03ee1c7ecdba", + "size_in_bytes": 27616 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/packages/backports/__init__.py", + "path_type": "hardlink", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size_in_bytes": 0 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/packages/backports/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "67f20bca75a46e07248577171ea00a86eb9949089dc1d8893724361780462974", + "sha256_in_prefix": "67f20bca75a46e07248577171ea00a86eb9949089dc1d8893724361780462974", + "size_in_bytes": 172 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/packages/backports/__pycache__/makefile.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "213c6849d9f0fb799d42eeefb7d49c7c8c1c7d9c84b677551d4ddd49d538dba0", + "sha256_in_prefix": "213c6849d9f0fb799d42eeefb7d49c7c8c1c7d9c84b677551d4ddd49d538dba0", + "size_in_bytes": 1272 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/packages/backports/__pycache__/weakref_finalize.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "e9352201598c6f9a4e43e18eab193efb806c6406c4b748cb1a3bef1c37d20e00", + "sha256_in_prefix": "e9352201598c6f9a4e43e18eab193efb806c6406c4b748cb1a3bef1c37d20e00", + "size_in_bytes": 4870 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/packages/backports/makefile.py", + "path_type": "hardlink", + "sha256": "9dbcedde2d1a80f54fd3b8eaaa08e16988cc9ae022fd6e44d04cb0662bd53bc1", + "sha256_in_prefix": "9dbcedde2d1a80f54fd3b8eaaa08e16988cc9ae022fd6e44d04cb0662bd53bc1", + "size_in_bytes": 1417 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/packages/backports/weakref_finalize.py", + "path_type": "hardlink", + "sha256": "b5109a97938084d491c9bd03847a7edfc02d2250ac44ff01c45dcd5feeaba880", + "sha256_in_prefix": "b5109a97938084d491c9bd03847a7edfc02d2250ac44ff01c45dcd5feeaba880", + "size_in_bytes": 5343 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/packages/six.py", + "path_type": "hardlink", + "sha256": "6fd2ccd30057bfb13b4ab6c28c09b8c3037e86b1fe88dc6fd7c2e058d30c28fa", + "sha256_in_prefix": "6fd2ccd30057bfb13b4ab6c28c09b8c3037e86b1fe88dc6fd7c2e058d30c28fa", + "size_in_bytes": 34665 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/poolmanager.py", + "path_type": "hardlink", + "sha256": "d22f1c260aeaba9cdaebb2013d9feef635ef9d2c6be54065544894a9d90fb582", + "sha256_in_prefix": "d22f1c260aeaba9cdaebb2013d9feef635ef9d2c6be54065544894a9d90fb582", + "size_in_bytes": 19752 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/request.py", + "path_type": "hardlink", + "sha256": "61358536bed023087b1355bd75d7bd2ccefbbf65564c9e55efc5ee4d3c3b0f50", + "sha256_in_prefix": "61358536bed023087b1355bd75d7bd2ccefbbf65564c9e55efc5ee4d3c3b0f50", + "size_in_bytes": 6691 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/response.py", + "path_type": "hardlink", + "sha256": "7e60c9005906ef5b854e7fac5524e1d88c345a6717418aa46d18e286fc018d4f", + "sha256_in_prefix": "7e60c9005906ef5b854e7fac5524e1d88c345a6717418aa46d18e286fc018d4f", + "size_in_bytes": 30641 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/util/__init__.py", + "path_type": "hardlink", + "sha256": "2449929a6aaa2f26b0f0fe75814226661f06c20f62d7349ef83a2a022b67da77", + "sha256_in_prefix": "2449929a6aaa2f26b0f0fe75814226661f06c20f62d7349ef83a2a022b67da77", + "size_in_bytes": 1155 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/util/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "0cac42599ca3b182a4b370bb18c0be4ba95a6e947c991a3bd76e39cdb54e9b3b", + "sha256_in_prefix": "0cac42599ca3b182a4b370bb18c0be4ba95a6e947c991a3bd76e39cdb54e9b3b", + "size_in_bytes": 1071 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/util/__pycache__/connection.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "976f4f0f03d37ed557068c7220b08397ad18226efa7025f7fc3e8bdfc0e73e1e", + "sha256_in_prefix": "976f4f0f03d37ed557068c7220b08397ad18226efa7025f7fc3e8bdfc0e73e1e", + "size_in_bytes": 3399 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/util/__pycache__/proxy.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "133c2816f612381ebf38610cc7c2fe88dccc4db95f3c1f332cf214288ebf7080", + "sha256_in_prefix": "133c2816f612381ebf38610cc7c2fe88dccc4db95f3c1f332cf214288ebf7080", + "size_in_bytes": 1304 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/util/__pycache__/queue.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "119ce857e73465c8ea55f191db0210c0284d6cd640914c6ceda8e0b29bb3a2f6", + "sha256_in_prefix": "119ce857e73465c8ea55f191db0210c0284d6cd640914c6ceda8e0b29bb3a2f6", + "size_in_bytes": 1026 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/util/__pycache__/request.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "fac2c362734c71211ca8e37ada09ae5c051757b94402c71ef38e9b2e697f027a", + "sha256_in_prefix": "fac2c362734c71211ca8e37ada09ae5c051757b94402c71ef38e9b2e697f027a", + "size_in_bytes": 3333 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/util/__pycache__/response.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "768ab695d44016a6600b3762687162e914756039f9e411bba361bf687dadd701", + "sha256_in_prefix": "768ab695d44016a6600b3762687162e914756039f9e411bba361bf687dadd701", + "size_in_bytes": 2319 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/util/__pycache__/retry.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "8f6eca7f27972948c61103b057c00c287e245b8157b66124136d86a90af54338", + "sha256_in_prefix": "8f6eca7f27972948c61103b057c00c287e245b8157b66124136d86a90af54338", + "size_in_bytes": 16119 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/util/__pycache__/ssl_.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "a7fd3e19ffe22dc81105fee31ab57c56a3c9badf8894a1c33df3d7e907fbf8e9", + "sha256_in_prefix": "a7fd3e19ffe22dc81105fee31ab57c56a3c9badf8894a1c33df3d7e907fbf8e9", + "size_in_bytes": 11271 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/util/__pycache__/ssl_match_hostname.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "e41f0cafc66d9c6fd3f69b77df7e75a46491d6cc7e60ea532b1a1967f786053b", + "sha256_in_prefix": "e41f0cafc66d9c6fd3f69b77df7e75a46491d6cc7e60ea532b1a1967f786053b", + "size_in_bytes": 3223 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/util/__pycache__/ssltransport.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "3c647271721194f1c66749fdca98a50fbacfd01369acc113a206fa1f0d9acb1d", + "sha256_in_prefix": "3c647271721194f1c66749fdca98a50fbacfd01369acc113a206fa1f0d9acb1d", + "size_in_bytes": 7361 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/util/__pycache__/timeout.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "df4bf59953f460d6768b13f7617b84100e6e8c1012a9eb9105c9526eb553672d", + "sha256_in_prefix": "df4bf59953f460d6768b13f7617b84100e6e8c1012a9eb9105c9526eb553672d", + "size_in_bytes": 9098 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/util/__pycache__/url.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "9f0f24d22e081f829b3c59b89856b3dff82b062bfd87ffbc78bc67a0d28d9fa8", + "sha256_in_prefix": "9f0f24d22e081f829b3c59b89856b3dff82b062bfd87ffbc78bc67a0d28d9fa8", + "size_in_bytes": 10675 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/util/__pycache__/wait.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "0bc9af756f0a0eb7fd5ed5106342f86fc56df64a1fcf4a25d69c783ee7c836d2", + "sha256_in_prefix": "0bc9af756f0a0eb7fd5ed5106342f86fc56df64a1fcf4a25d69c783ee7c836d2", + "size_in_bytes": 3055 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/util/connection.py", + "path_type": "hardlink", + "sha256": "e4bc760753d6dbd2b1067d93d3190dd420604416b780654904aa10a11a201159", + "sha256_in_prefix": "e4bc760753d6dbd2b1067d93d3190dd420604416b780654904aa10a11a201159", + "size_in_bytes": 4901 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/util/proxy.py", + "path_type": "hardlink", + "sha256": "cd4bcf3c226ba7a74e17437818055b39c97aa3ee2e5ca4ab1a24e492be6f512e", + "sha256_in_prefix": "cd4bcf3c226ba7a74e17437818055b39c97aa3ee2e5ca4ab1a24e492be6f512e", + "size_in_bytes": 1605 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/util/queue.py", + "path_type": "hardlink", + "sha256": "9d1817f3f797fbf564bf1a17d3de905a8cfc3ecd101d4004c482c263fecf9dc3", + "sha256_in_prefix": "9d1817f3f797fbf564bf1a17d3de905a8cfc3ecd101d4004c482c263fecf9dc3", + "size_in_bytes": 498 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/util/request.py", + "path_type": "hardlink", + "sha256": "0b4394b76b5c53a2d189027b61834ff46bcfad2be5ef388805e910fb99e50599", + "sha256_in_prefix": "0b4394b76b5c53a2d189027b61834ff46bcfad2be5ef388805e910fb99e50599", + "size_in_bytes": 3997 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/util/response.py", + "path_type": "hardlink", + "sha256": "189a60dc4822f6a6895d1c01879c2ff8c36e4566a7e4122ee34a117a8c563f6f", + "sha256_in_prefix": "189a60dc4822f6a6895d1c01879c2ff8c36e4566a7e4122ee34a117a8c563f6f", + "size_in_bytes": 3510 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/util/retry.py", + "path_type": "hardlink", + "sha256": "67a5847f9d7c7933973f98ebe50490f60a892340d562ddd7b3710a9d86939aeb", + "sha256_in_prefix": "67a5847f9d7c7933973f98ebe50490f60a892340d562ddd7b3710a9d86939aeb", + "size_in_bytes": 22013 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/util/ssl_.py", + "path_type": "hardlink", + "sha256": "5f8f80a96f756983e13f1ebec5b7faeb21c540a6eaa9f0bfe59b785a42d7d477", + "sha256_in_prefix": "5f8f80a96f756983e13f1ebec5b7faeb21c540a6eaa9f0bfe59b785a42d7d477", + "size_in_bytes": 17177 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/util/ssl_match_hostname.py", + "path_type": "hardlink", + "sha256": "22be1c65512398093c8140081d64a2ef0b4e3bcdd4098001636c450f5425fd60", + "sha256_in_prefix": "22be1c65512398093c8140081d64a2ef0b4e3bcdd4098001636c450f5425fd60", + "size_in_bytes": 5758 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/util/ssltransport.py", + "path_type": "hardlink", + "sha256": "340faee6b313ac3143142f10cd129410a306d39eb584e0f8a814ebdd9e29bfa1", + "sha256_in_prefix": "340faee6b313ac3143142f10cd129410a306d39eb584e0f8a814ebdd9e29bfa1", + "size_in_bytes": 6895 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/util/timeout.py", + "path_type": "hardlink", + "sha256": "730ab874c93cee624748192d2b59a2609fbce46fb74f74664f6d2fed2142a67a", + "sha256_in_prefix": "730ab874c93cee624748192d2b59a2609fbce46fb74f74664f6d2fed2142a67a", + "size_in_bytes": 10168 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/util/url.py", + "path_type": "hardlink", + "sha256": "942004ecce66c80f040dd5b4b09bb2c9985507d2bf8f7f258d684702715a5a81", + "sha256_in_prefix": "942004ecce66c80f040dd5b4b09bb2c9985507d2bf8f7f258d684702715a5a81", + "size_in_bytes": 14296 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/urllib3/util/wait.py", + "path_type": "hardlink", + "sha256": "7ce5f4fdf6a8cc6d8fee25688d0a04d666f277078dc93726fa15c47c5ad3b4b2", + "sha256_in_prefix": "7ce5f4fdf6a8cc6d8fee25688d0a04d666f277078dc93726fa15c47c5ad3b4b2", + "size_in_bytes": 5403 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/vendor.txt", + "path_type": "hardlink", + "sha256": "e0d2a4edf42156c670d14fb4ce69bd4362e01b268f5da7056e7240692d10e846", + "sha256_in_prefix": "e0d2a4edf42156c670d14fb4ce69bd4362e01b268f5da7056e7240692d10e846", + "size_in_bytes": 493 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/webencodings/__init__.py", + "path_type": "hardlink", + "sha256": "a8e04922e3f2ff8072607e96fdb360245faa610d83a14f9d2ac0eee724560978", + "sha256_in_prefix": "a8e04922e3f2ff8072607e96fdb360245faa610d83a14f9d2ac0eee724560978", + "size_in_bytes": 10579 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/webencodings/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "4895a1870f77a3efc45f71c38a54c3f070f80dfd9bc228d4fd2fd7f945ae08e0", + "sha256_in_prefix": "4895a1870f77a3efc45f71c38a54c3f070f80dfd9bc228d4fd2fd7f945ae08e0", + "size_in_bytes": 9708 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/webencodings/__pycache__/labels.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "629af76f8600c75d39d01ef45acbe6edd99a6374dacf208bdf2d2fda6e644c09", + "sha256_in_prefix": "629af76f8600c75d39d01ef45acbe6edd99a6374dacf208bdf2d2fda6e644c09", + "size_in_bytes": 5198 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/webencodings/__pycache__/mklabels.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "b1f44b093279377569f742eb445d673010e69c7a35ad583081d72ee03cfd10b3", + "sha256_in_prefix": "b1f44b093279377569f742eb445d673010e69c7a35ad583081d72ee03cfd10b3", + "size_in_bytes": 1903 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/webencodings/__pycache__/tests.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "5a866f16ca3fa07af5159b69fcc1f44177878b9255ed8db27192a723805c27b9", + "sha256_in_prefix": "5a866f16ca3fa07af5159b69fcc1f44177878b9255ed8db27192a723805c27b9", + "size_in_bytes": 5005 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/webencodings/__pycache__/x_user_defined.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "6218a6fd8a36b1d978ab53d10aecd9aeffe4883663b435d3b1982c7f04d64572", + "sha256_in_prefix": "6218a6fd8a36b1d978ab53d10aecd9aeffe4883663b435d3b1982c7f04d64572", + "size_in_bytes": 2554 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/webencodings/labels.py", + "path_type": "hardlink", + "sha256": "e003bf2b14dd76a1adacbf67b3b9003e36f409c37ac6c088c5b2b7ec763daf71", + "sha256_in_prefix": "e003bf2b14dd76a1adacbf67b3b9003e36f409c37ac6c088c5b2b7ec763daf71", + "size_in_bytes": 8979 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/webencodings/mklabels.py", + "path_type": "hardlink", + "sha256": "19821ecb09e968b9cfd064a273c2c55a0774515bcefe5d4d73a62817ef3b47fe", + "sha256_in_prefix": "19821ecb09e968b9cfd064a273c2c55a0774515bcefe5d4d73a62817ef3b47fe", + "size_in_bytes": 1305 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/webencodings/tests.py", + "path_type": "hardlink", + "sha256": "3ad18bca384d6357ef916d46bcb27f155f59a2a0bd027ca3afbab79314dbccdb", + "sha256_in_prefix": "3ad18bca384d6357ef916d46bcb27f155f59a2a0bd027ca3afbab79314dbccdb", + "size_in_bytes": 6563 + }, + { + "_path": "lib/python3.10/site-packages/pip/_vendor/webencodings/x_user_defined.py", + "path_type": "hardlink", + "sha256": "c8ea9649d9a9cad19f52087f67a258803361a1cf81007cb279e4f5e45af8dad3", + "sha256_in_prefix": "c8ea9649d9a9cad19f52087f67a258803361a1cf81007cb279e4f5e45af8dad3", + "size_in_bytes": 4307 + }, + { + "_path": "lib/python3.10/site-packages/pip/py.typed", + "path_type": "hardlink", + "sha256": "10156fbcf4539ff788a73e5ee50ced48276b317ed0c1ded53fddd14a82256762", + "sha256_in_prefix": "10156fbcf4539ff788a73e5ee50ced48276b317ed0c1ded53fddd14a82256762", + "size_in_bytes": 286 + } + ], + "paths_version": 1 + }, + "requested_spec": "None", + "sha256": "eb38f82c554fbc36664304cc91b719f55f82421fcfb650edc3b695c87add2a50", + "size": 2816873, + "subdir": "osx-arm64", + "timestamp": 1715097127000, + "url": "https://repo.anaconda.com/pkgs/main/osx-arm64/pip-24.0-py310hca03da5_0.conda", + "version": "24.0" +} \ No newline at end of file diff --git a/crates/pet-conda/tests/unix/conda_envs/user_home/miniconda3/envs/myenv/conda-meta/python-3.10.14-hb885b13_1.json b/crates/pet-conda/tests/unix/conda_envs/user_home/miniconda3/envs/myenv/conda-meta/python-3.10.14-hb885b13_1.json new file mode 100644 index 00000000..8a159391 --- /dev/null +++ b/crates/pet-conda/tests/unix/conda_envs/user_home/miniconda3/envs/myenv/conda-meta/python-3.10.14-hb885b13_1.json @@ -0,0 +1,16514 @@ +{ + "build": "hb885b13_1", + "build_number": 1, + "channel": "https://repo.anaconda.com/pkgs/main/osx-arm64", + "constrains": [], + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "libffi >=3.4,<3.5", + "libffi >=3.4,<4.0a0", + "ncurses >=6.4,<7.0a0", + "openssl >=3.0.13,<4.0a0", + "readline >=8.1.2,<9.0a0", + "sqlite >=3.45.3,<4.0a0", + "tk >=8.6.14,<8.7.0a0", + "tzdata", + "xz >=5.4.6,<6.0a0", + "zlib >=1.2.13,<1.3.0a0", + "pip" + ], + "extracted_package_dir": "/Users/donjayamanne/.pyenv/versions/miniconda3-latest/pkgs/python-3.10.14-hb885b13_1", + "files": [ + "bin/2to3", + "bin/2to3-3.10", + "bin/idle3", + "bin/idle3.10", + "bin/pydoc", + "bin/pydoc3", + "bin/pydoc3.10", + "bin/python", + "bin/python3", + "bin/python3-config", + "bin/python3.1", + "bin/python3.10", + "bin/python3.10-config", + "include/python3.10/Python.h", + "include/python3.10/abstract.h", + "include/python3.10/bltinmodule.h", + "include/python3.10/boolobject.h", + "include/python3.10/bytearrayobject.h", + "include/python3.10/bytesobject.h", + "include/python3.10/cellobject.h", + "include/python3.10/ceval.h", + "include/python3.10/classobject.h", + "include/python3.10/code.h", + "include/python3.10/codecs.h", + "include/python3.10/compile.h", + "include/python3.10/complexobject.h", + "include/python3.10/context.h", + "include/python3.10/cpython/abstract.h", + "include/python3.10/cpython/bytearrayobject.h", + "include/python3.10/cpython/bytesobject.h", + "include/python3.10/cpython/ceval.h", + "include/python3.10/cpython/code.h", + "include/python3.10/cpython/compile.h", + "include/python3.10/cpython/dictobject.h", + "include/python3.10/cpython/fileobject.h", + "include/python3.10/cpython/fileutils.h", + "include/python3.10/cpython/frameobject.h", + "include/python3.10/cpython/import.h", + "include/python3.10/cpython/initconfig.h", + "include/python3.10/cpython/interpreteridobject.h", + "include/python3.10/cpython/listobject.h", + "include/python3.10/cpython/methodobject.h", + "include/python3.10/cpython/object.h", + "include/python3.10/cpython/objimpl.h", + "include/python3.10/cpython/odictobject.h", + "include/python3.10/cpython/picklebufobject.h", + "include/python3.10/cpython/pyctype.h", + "include/python3.10/cpython/pydebug.h", + "include/python3.10/cpython/pyerrors.h", + "include/python3.10/cpython/pyfpe.h", + "include/python3.10/cpython/pylifecycle.h", + "include/python3.10/cpython/pymem.h", + "include/python3.10/cpython/pystate.h", + "include/python3.10/cpython/pythonrun.h", + "include/python3.10/cpython/pytime.h", + "include/python3.10/cpython/sysmodule.h", + "include/python3.10/cpython/traceback.h", + "include/python3.10/cpython/tupleobject.h", + "include/python3.10/cpython/unicodeobject.h", + "include/python3.10/datetime.h", + "include/python3.10/descrobject.h", + "include/python3.10/dictobject.h", + "include/python3.10/dynamic_annotations.h", + "include/python3.10/enumobject.h", + "include/python3.10/errcode.h", + "include/python3.10/eval.h", + "include/python3.10/exports.h", + "include/python3.10/fileobject.h", + "include/python3.10/fileutils.h", + "include/python3.10/floatobject.h", + "include/python3.10/frameobject.h", + "include/python3.10/funcobject.h", + "include/python3.10/genericaliasobject.h", + "include/python3.10/genobject.h", + "include/python3.10/import.h", + "include/python3.10/internal/pycore_abstract.h", + "include/python3.10/internal/pycore_accu.h", + "include/python3.10/internal/pycore_asdl.h", + "include/python3.10/internal/pycore_ast.h", + "include/python3.10/internal/pycore_ast_state.h", + "include/python3.10/internal/pycore_atomic.h", + "include/python3.10/internal/pycore_atomic_funcs.h", + "include/python3.10/internal/pycore_bitutils.h", + "include/python3.10/internal/pycore_blocks_output_buffer.h", + "include/python3.10/internal/pycore_bytes_methods.h", + "include/python3.10/internal/pycore_call.h", + "include/python3.10/internal/pycore_ceval.h", + "include/python3.10/internal/pycore_code.h", + "include/python3.10/internal/pycore_compile.h", + "include/python3.10/internal/pycore_condvar.h", + "include/python3.10/internal/pycore_context.h", + "include/python3.10/internal/pycore_dtoa.h", + "include/python3.10/internal/pycore_fileutils.h", + "include/python3.10/internal/pycore_format.h", + "include/python3.10/internal/pycore_gc.h", + "include/python3.10/internal/pycore_getopt.h", + "include/python3.10/internal/pycore_gil.h", + "include/python3.10/internal/pycore_hamt.h", + "include/python3.10/internal/pycore_hashtable.h", + "include/python3.10/internal/pycore_import.h", + "include/python3.10/internal/pycore_initconfig.h", + "include/python3.10/internal/pycore_interp.h", + "include/python3.10/internal/pycore_list.h", + "include/python3.10/internal/pycore_long.h", + "include/python3.10/internal/pycore_moduleobject.h", + "include/python3.10/internal/pycore_object.h", + "include/python3.10/internal/pycore_parser.h", + "include/python3.10/internal/pycore_pathconfig.h", + "include/python3.10/internal/pycore_pyarena.h", + "include/python3.10/internal/pycore_pyerrors.h", + "include/python3.10/internal/pycore_pyhash.h", + "include/python3.10/internal/pycore_pylifecycle.h", + "include/python3.10/internal/pycore_pymem.h", + "include/python3.10/internal/pycore_pystate.h", + "include/python3.10/internal/pycore_runtime.h", + "include/python3.10/internal/pycore_structseq.h", + "include/python3.10/internal/pycore_symtable.h", + "include/python3.10/internal/pycore_sysmodule.h", + "include/python3.10/internal/pycore_traceback.h", + "include/python3.10/internal/pycore_tuple.h", + "include/python3.10/internal/pycore_ucnhash.h", + "include/python3.10/internal/pycore_unionobject.h", + "include/python3.10/internal/pycore_warnings.h", + "include/python3.10/interpreteridobject.h", + "include/python3.10/intrcheck.h", + "include/python3.10/iterobject.h", + "include/python3.10/listobject.h", + "include/python3.10/longintrepr.h", + "include/python3.10/longobject.h", + "include/python3.10/marshal.h", + "include/python3.10/memoryobject.h", + "include/python3.10/methodobject.h", + "include/python3.10/modsupport.h", + "include/python3.10/moduleobject.h", + "include/python3.10/namespaceobject.h", + "include/python3.10/object.h", + "include/python3.10/objimpl.h", + "include/python3.10/opcode.h", + "include/python3.10/osdefs.h", + "include/python3.10/osmodule.h", + "include/python3.10/patchlevel.h", + "include/python3.10/py_curses.h", + "include/python3.10/pycapsule.h", + "include/python3.10/pyconfig.h", + "include/python3.10/pydtrace.h", + "include/python3.10/pyerrors.h", + "include/python3.10/pyexpat.h", + "include/python3.10/pyframe.h", + "include/python3.10/pyhash.h", + "include/python3.10/pylifecycle.h", + "include/python3.10/pymacconfig.h", + "include/python3.10/pymacro.h", + "include/python3.10/pymath.h", + "include/python3.10/pymem.h", + "include/python3.10/pyport.h", + "include/python3.10/pystate.h", + "include/python3.10/pystrcmp.h", + "include/python3.10/pystrhex.h", + "include/python3.10/pystrtod.h", + "include/python3.10/pythonrun.h", + "include/python3.10/pythread.h", + "include/python3.10/rangeobject.h", + "include/python3.10/setobject.h", + "include/python3.10/sliceobject.h", + "include/python3.10/structmember.h", + "include/python3.10/structseq.h", + "include/python3.10/sysmodule.h", + "include/python3.10/token.h", + "include/python3.10/traceback.h", + "include/python3.10/tracemalloc.h", + "include/python3.10/tupleobject.h", + "include/python3.10/typeslots.h", + "include/python3.10/unicodeobject.h", + "include/python3.10/warnings.h", + "include/python3.10/weakrefobject.h", + "lib/libpython3.10.dylib", + "lib/pkgconfig/python-3.10-embed.pc", + "lib/pkgconfig/python-3.10.pc", + "lib/pkgconfig/python3-embed.pc", + "lib/pkgconfig/python3.pc", + "lib/python3.1", + "lib/python3.10/LICENSE.txt", + "lib/python3.10/__future__.py", + "lib/python3.10/__phello__.foo.py", + "lib/python3.10/__pycache__/__future__.cpython-310.pyc", + "lib/python3.10/__pycache__/__phello__.foo.cpython-310.pyc", + "lib/python3.10/__pycache__/_aix_support.cpython-310.pyc", + "lib/python3.10/__pycache__/_bootsubprocess.cpython-310.pyc", + "lib/python3.10/__pycache__/_collections_abc.cpython-310.pyc", + "lib/python3.10/__pycache__/_compat_pickle.cpython-310.pyc", + "lib/python3.10/__pycache__/_compression.cpython-310.pyc", + "lib/python3.10/__pycache__/_markupbase.cpython-310.pyc", + "lib/python3.10/__pycache__/_osx_support.cpython-310.pyc", + "lib/python3.10/__pycache__/_py_abc.cpython-310.pyc", + "lib/python3.10/__pycache__/_pydecimal.cpython-310.pyc", + "lib/python3.10/__pycache__/_pyio.cpython-310.pyc", + "lib/python3.10/__pycache__/_sitebuiltins.cpython-310.pyc", + "lib/python3.10/__pycache__/_strptime.cpython-310.pyc", + "lib/python3.10/__pycache__/_sysconfigdata__darwin_darwin.cpython-310.pyc", + "lib/python3.10/__pycache__/_sysconfigdata_arm64_apple_darwin20_0_0.cpython-310.pyc", + "lib/python3.10/__pycache__/_threading_local.cpython-310.pyc", + "lib/python3.10/__pycache__/_weakrefset.cpython-310.pyc", + "lib/python3.10/__pycache__/abc.cpython-310.pyc", + "lib/python3.10/__pycache__/aifc.cpython-310.pyc", + "lib/python3.10/__pycache__/antigravity.cpython-310.pyc", + "lib/python3.10/__pycache__/argparse.cpython-310.pyc", + "lib/python3.10/__pycache__/ast.cpython-310.pyc", + "lib/python3.10/__pycache__/asynchat.cpython-310.pyc", + "lib/python3.10/__pycache__/asyncore.cpython-310.pyc", + "lib/python3.10/__pycache__/base64.cpython-310.pyc", + "lib/python3.10/__pycache__/bdb.cpython-310.pyc", + "lib/python3.10/__pycache__/binhex.cpython-310.pyc", + "lib/python3.10/__pycache__/bisect.cpython-310.pyc", + "lib/python3.10/__pycache__/bz2.cpython-310.pyc", + "lib/python3.10/__pycache__/cProfile.cpython-310.pyc", + "lib/python3.10/__pycache__/calendar.cpython-310.pyc", + "lib/python3.10/__pycache__/cgi.cpython-310.pyc", + "lib/python3.10/__pycache__/cgitb.cpython-310.pyc", + "lib/python3.10/__pycache__/chunk.cpython-310.pyc", + "lib/python3.10/__pycache__/cmd.cpython-310.pyc", + "lib/python3.10/__pycache__/code.cpython-310.pyc", + "lib/python3.10/__pycache__/codecs.cpython-310.pyc", + "lib/python3.10/__pycache__/codeop.cpython-310.pyc", + "lib/python3.10/__pycache__/colorsys.cpython-310.pyc", + "lib/python3.10/__pycache__/compileall.cpython-310.pyc", + "lib/python3.10/__pycache__/configparser.cpython-310.pyc", + "lib/python3.10/__pycache__/contextlib.cpython-310.pyc", + "lib/python3.10/__pycache__/contextvars.cpython-310.pyc", + "lib/python3.10/__pycache__/copy.cpython-310.pyc", + "lib/python3.10/__pycache__/copyreg.cpython-310.pyc", + "lib/python3.10/__pycache__/crypt.cpython-310.pyc", + "lib/python3.10/__pycache__/csv.cpython-310.pyc", + "lib/python3.10/__pycache__/dataclasses.cpython-310.pyc", + "lib/python3.10/__pycache__/datetime.cpython-310.pyc", + "lib/python3.10/__pycache__/decimal.cpython-310.pyc", + "lib/python3.10/__pycache__/difflib.cpython-310.pyc", + "lib/python3.10/__pycache__/dis.cpython-310.pyc", + "lib/python3.10/__pycache__/doctest.cpython-310.pyc", + "lib/python3.10/__pycache__/enum.cpython-310.pyc", + "lib/python3.10/__pycache__/filecmp.cpython-310.pyc", + "lib/python3.10/__pycache__/fileinput.cpython-310.pyc", + "lib/python3.10/__pycache__/fnmatch.cpython-310.pyc", + "lib/python3.10/__pycache__/fractions.cpython-310.pyc", + "lib/python3.10/__pycache__/ftplib.cpython-310.pyc", + "lib/python3.10/__pycache__/functools.cpython-310.pyc", + "lib/python3.10/__pycache__/genericpath.cpython-310.pyc", + "lib/python3.10/__pycache__/getopt.cpython-310.pyc", + "lib/python3.10/__pycache__/getpass.cpython-310.pyc", + "lib/python3.10/__pycache__/gettext.cpython-310.pyc", + "lib/python3.10/__pycache__/glob.cpython-310.pyc", + "lib/python3.10/__pycache__/graphlib.cpython-310.pyc", + "lib/python3.10/__pycache__/gzip.cpython-310.pyc", + "lib/python3.10/__pycache__/hashlib.cpython-310.pyc", + "lib/python3.10/__pycache__/heapq.cpython-310.pyc", + "lib/python3.10/__pycache__/hmac.cpython-310.pyc", + "lib/python3.10/__pycache__/imaplib.cpython-310.pyc", + "lib/python3.10/__pycache__/imghdr.cpython-310.pyc", + "lib/python3.10/__pycache__/imp.cpython-310.pyc", + "lib/python3.10/__pycache__/inspect.cpython-310.pyc", + "lib/python3.10/__pycache__/io.cpython-310.pyc", + "lib/python3.10/__pycache__/ipaddress.cpython-310.pyc", + "lib/python3.10/__pycache__/keyword.cpython-310.pyc", + "lib/python3.10/__pycache__/linecache.cpython-310.pyc", + "lib/python3.10/__pycache__/locale.cpython-310.pyc", + "lib/python3.10/__pycache__/lzma.cpython-310.pyc", + "lib/python3.10/__pycache__/mailbox.cpython-310.pyc", + "lib/python3.10/__pycache__/mailcap.cpython-310.pyc", + "lib/python3.10/__pycache__/mimetypes.cpython-310.pyc", + "lib/python3.10/__pycache__/modulefinder.cpython-310.pyc", + "lib/python3.10/__pycache__/netrc.cpython-310.pyc", + "lib/python3.10/__pycache__/nntplib.cpython-310.pyc", + "lib/python3.10/__pycache__/ntpath.cpython-310.pyc", + "lib/python3.10/__pycache__/nturl2path.cpython-310.pyc", + "lib/python3.10/__pycache__/numbers.cpython-310.pyc", + "lib/python3.10/__pycache__/opcode.cpython-310.pyc", + "lib/python3.10/__pycache__/operator.cpython-310.pyc", + "lib/python3.10/__pycache__/optparse.cpython-310.pyc", + "lib/python3.10/__pycache__/os.cpython-310.pyc", + "lib/python3.10/__pycache__/pathlib.cpython-310.pyc", + "lib/python3.10/__pycache__/pdb.cpython-310.pyc", + "lib/python3.10/__pycache__/pickle.cpython-310.pyc", + "lib/python3.10/__pycache__/pickletools.cpython-310.pyc", + "lib/python3.10/__pycache__/pipes.cpython-310.pyc", + "lib/python3.10/__pycache__/pkgutil.cpython-310.pyc", + "lib/python3.10/__pycache__/platform.cpython-310.pyc", + "lib/python3.10/__pycache__/plistlib.cpython-310.pyc", + "lib/python3.10/__pycache__/poplib.cpython-310.pyc", + "lib/python3.10/__pycache__/posixpath.cpython-310.pyc", + "lib/python3.10/__pycache__/pprint.cpython-310.pyc", + "lib/python3.10/__pycache__/profile.cpython-310.pyc", + "lib/python3.10/__pycache__/pstats.cpython-310.pyc", + "lib/python3.10/__pycache__/pty.cpython-310.pyc", + "lib/python3.10/__pycache__/py_compile.cpython-310.pyc", + "lib/python3.10/__pycache__/pyclbr.cpython-310.pyc", + "lib/python3.10/__pycache__/pydoc.cpython-310.pyc", + "lib/python3.10/__pycache__/queue.cpython-310.pyc", + "lib/python3.10/__pycache__/quopri.cpython-310.pyc", + "lib/python3.10/__pycache__/random.cpython-310.pyc", + "lib/python3.10/__pycache__/re.cpython-310.pyc", + "lib/python3.10/__pycache__/reprlib.cpython-310.pyc", + "lib/python3.10/__pycache__/rlcompleter.cpython-310.pyc", + "lib/python3.10/__pycache__/runpy.cpython-310.pyc", + "lib/python3.10/__pycache__/sched.cpython-310.pyc", + "lib/python3.10/__pycache__/secrets.cpython-310.pyc", + "lib/python3.10/__pycache__/selectors.cpython-310.pyc", + "lib/python3.10/__pycache__/shelve.cpython-310.pyc", + "lib/python3.10/__pycache__/shlex.cpython-310.pyc", + "lib/python3.10/__pycache__/shutil.cpython-310.pyc", + "lib/python3.10/__pycache__/signal.cpython-310.pyc", + "lib/python3.10/__pycache__/site.cpython-310.pyc", + "lib/python3.10/__pycache__/smtpd.cpython-310.pyc", + "lib/python3.10/__pycache__/smtplib.cpython-310.pyc", + "lib/python3.10/__pycache__/sndhdr.cpython-310.pyc", + "lib/python3.10/__pycache__/socket.cpython-310.pyc", + "lib/python3.10/__pycache__/socketserver.cpython-310.pyc", + "lib/python3.10/__pycache__/sre_compile.cpython-310.pyc", + "lib/python3.10/__pycache__/sre_constants.cpython-310.pyc", + "lib/python3.10/__pycache__/sre_parse.cpython-310.pyc", + "lib/python3.10/__pycache__/ssl.cpython-310.pyc", + "lib/python3.10/__pycache__/stat.cpython-310.pyc", + "lib/python3.10/__pycache__/statistics.cpython-310.pyc", + "lib/python3.10/__pycache__/string.cpython-310.pyc", + "lib/python3.10/__pycache__/stringprep.cpython-310.pyc", + "lib/python3.10/__pycache__/struct.cpython-310.pyc", + "lib/python3.10/__pycache__/subprocess.cpython-310.pyc", + "lib/python3.10/__pycache__/sunau.cpython-310.pyc", + "lib/python3.10/__pycache__/symtable.cpython-310.pyc", + "lib/python3.10/__pycache__/sysconfig.cpython-310.pyc", + "lib/python3.10/__pycache__/tabnanny.cpython-310.pyc", + "lib/python3.10/__pycache__/tarfile.cpython-310.pyc", + "lib/python3.10/__pycache__/telnetlib.cpython-310.pyc", + "lib/python3.10/__pycache__/tempfile.cpython-310.pyc", + "lib/python3.10/__pycache__/textwrap.cpython-310.pyc", + "lib/python3.10/__pycache__/this.cpython-310.pyc", + "lib/python3.10/__pycache__/threading.cpython-310.pyc", + "lib/python3.10/__pycache__/timeit.cpython-310.pyc", + "lib/python3.10/__pycache__/token.cpython-310.pyc", + "lib/python3.10/__pycache__/tokenize.cpython-310.pyc", + "lib/python3.10/__pycache__/trace.cpython-310.pyc", + "lib/python3.10/__pycache__/traceback.cpython-310.pyc", + "lib/python3.10/__pycache__/tracemalloc.cpython-310.pyc", + "lib/python3.10/__pycache__/tty.cpython-310.pyc", + "lib/python3.10/__pycache__/turtle.cpython-310.pyc", + "lib/python3.10/__pycache__/types.cpython-310.pyc", + "lib/python3.10/__pycache__/typing.cpython-310.pyc", + "lib/python3.10/__pycache__/uu.cpython-310.pyc", + "lib/python3.10/__pycache__/uuid.cpython-310.pyc", + "lib/python3.10/__pycache__/warnings.cpython-310.pyc", + "lib/python3.10/__pycache__/wave.cpython-310.pyc", + "lib/python3.10/__pycache__/weakref.cpython-310.pyc", + "lib/python3.10/__pycache__/webbrowser.cpython-310.pyc", + "lib/python3.10/__pycache__/xdrlib.cpython-310.pyc", + "lib/python3.10/__pycache__/zipapp.cpython-310.pyc", + "lib/python3.10/__pycache__/zipfile.cpython-310.pyc", + "lib/python3.10/__pycache__/zipimport.cpython-310.pyc", + "lib/python3.10/_aix_support.py", + "lib/python3.10/_bootsubprocess.py", + "lib/python3.10/_collections_abc.py", + "lib/python3.10/_compat_pickle.py", + "lib/python3.10/_compression.py", + "lib/python3.10/_markupbase.py", + "lib/python3.10/_osx_support.py", + "lib/python3.10/_py_abc.py", + "lib/python3.10/_pydecimal.py", + "lib/python3.10/_pyio.py", + "lib/python3.10/_sitebuiltins.py", + "lib/python3.10/_strptime.py", + "lib/python3.10/_sysconfigdata__darwin_darwin.py", + "lib/python3.10/_sysconfigdata__darwin_darwin.py.orig", + "lib/python3.10/_sysconfigdata_arm64_apple_darwin20_0_0.py", + "lib/python3.10/_threading_local.py", + "lib/python3.10/_weakrefset.py", + "lib/python3.10/abc.py", + "lib/python3.10/aifc.py", + "lib/python3.10/antigravity.py", + "lib/python3.10/argparse.py", + "lib/python3.10/ast.py", + "lib/python3.10/asynchat.py", + "lib/python3.10/asyncio/__init__.py", + "lib/python3.10/asyncio/__main__.py", + "lib/python3.10/asyncio/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/__main__.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/base_events.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/base_futures.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/base_subprocess.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/base_tasks.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/constants.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/coroutines.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/events.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/exceptions.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/format_helpers.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/futures.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/locks.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/log.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/mixins.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/proactor_events.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/protocols.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/queues.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/runners.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/selector_events.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/sslproto.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/staggered.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/streams.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/subprocess.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/tasks.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/threads.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/transports.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/trsock.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/unix_events.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/windows_events.cpython-310.pyc", + "lib/python3.10/asyncio/__pycache__/windows_utils.cpython-310.pyc", + "lib/python3.10/asyncio/base_events.py", + "lib/python3.10/asyncio/base_futures.py", + "lib/python3.10/asyncio/base_subprocess.py", + "lib/python3.10/asyncio/base_tasks.py", + "lib/python3.10/asyncio/constants.py", + "lib/python3.10/asyncio/coroutines.py", + "lib/python3.10/asyncio/events.py", + "lib/python3.10/asyncio/exceptions.py", + "lib/python3.10/asyncio/format_helpers.py", + "lib/python3.10/asyncio/futures.py", + "lib/python3.10/asyncio/locks.py", + "lib/python3.10/asyncio/log.py", + "lib/python3.10/asyncio/mixins.py", + "lib/python3.10/asyncio/proactor_events.py", + "lib/python3.10/asyncio/protocols.py", + "lib/python3.10/asyncio/queues.py", + "lib/python3.10/asyncio/runners.py", + "lib/python3.10/asyncio/selector_events.py", + "lib/python3.10/asyncio/sslproto.py", + "lib/python3.10/asyncio/staggered.py", + "lib/python3.10/asyncio/streams.py", + "lib/python3.10/asyncio/subprocess.py", + "lib/python3.10/asyncio/tasks.py", + "lib/python3.10/asyncio/threads.py", + "lib/python3.10/asyncio/transports.py", + "lib/python3.10/asyncio/trsock.py", + "lib/python3.10/asyncio/unix_events.py", + "lib/python3.10/asyncio/windows_events.py", + "lib/python3.10/asyncio/windows_utils.py", + "lib/python3.10/asyncore.py", + "lib/python3.10/base64.py", + "lib/python3.10/bdb.py", + "lib/python3.10/binhex.py", + "lib/python3.10/bisect.py", + "lib/python3.10/bz2.py", + "lib/python3.10/cProfile.py", + "lib/python3.10/calendar.py", + "lib/python3.10/cgi.py", + "lib/python3.10/cgitb.py", + "lib/python3.10/chunk.py", + "lib/python3.10/cmd.py", + "lib/python3.10/code.py", + "lib/python3.10/codecs.py", + "lib/python3.10/codeop.py", + "lib/python3.10/collections/__init__.py", + "lib/python3.10/collections/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/collections/__pycache__/abc.cpython-310.pyc", + "lib/python3.10/collections/abc.py", + "lib/python3.10/colorsys.py", + "lib/python3.10/compileall.py", + "lib/python3.10/concurrent/__init__.py", + "lib/python3.10/concurrent/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/concurrent/futures/__init__.py", + "lib/python3.10/concurrent/futures/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/concurrent/futures/__pycache__/_base.cpython-310.pyc", + "lib/python3.10/concurrent/futures/__pycache__/process.cpython-310.pyc", + "lib/python3.10/concurrent/futures/__pycache__/thread.cpython-310.pyc", + "lib/python3.10/concurrent/futures/_base.py", + "lib/python3.10/concurrent/futures/process.py", + "lib/python3.10/concurrent/futures/thread.py", + "lib/python3.10/config-3.10-darwin/Makefile", + "lib/python3.10/config-3.10-darwin/Setup", + "lib/python3.10/config-3.10-darwin/Setup.local", + "lib/python3.10/config-3.10-darwin/__pycache__/python-config.cpython-310.pyc", + "lib/python3.10/config-3.10-darwin/config.c", + "lib/python3.10/config-3.10-darwin/config.c.in", + "lib/python3.10/config-3.10-darwin/install-sh", + "lib/python3.10/config-3.10-darwin/makesetup", + "lib/python3.10/config-3.10-darwin/python-config.py", + "lib/python3.10/config-3.10-darwin/python.o", + "lib/python3.10/configparser.py", + "lib/python3.10/contextlib.py", + "lib/python3.10/contextvars.py", + "lib/python3.10/copy.py", + "lib/python3.10/copyreg.py", + "lib/python3.10/crypt.py", + "lib/python3.10/csv.py", + "lib/python3.10/ctypes/__init__.py", + "lib/python3.10/ctypes/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/ctypes/__pycache__/_aix.cpython-310.pyc", + "lib/python3.10/ctypes/__pycache__/_endian.cpython-310.pyc", + "lib/python3.10/ctypes/__pycache__/util.cpython-310.pyc", + "lib/python3.10/ctypes/__pycache__/wintypes.cpython-310.pyc", + "lib/python3.10/ctypes/_aix.py", + "lib/python3.10/ctypes/_endian.py", + "lib/python3.10/ctypes/macholib/README.ctypes", + "lib/python3.10/ctypes/macholib/__init__.py", + "lib/python3.10/ctypes/macholib/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/ctypes/macholib/__pycache__/dyld.cpython-310.pyc", + "lib/python3.10/ctypes/macholib/__pycache__/dylib.cpython-310.pyc", + "lib/python3.10/ctypes/macholib/__pycache__/framework.cpython-310.pyc", + "lib/python3.10/ctypes/macholib/dyld.py", + "lib/python3.10/ctypes/macholib/dylib.py", + "lib/python3.10/ctypes/macholib/fetch_macholib", + "lib/python3.10/ctypes/macholib/fetch_macholib.bat", + "lib/python3.10/ctypes/macholib/framework.py", + "lib/python3.10/ctypes/util.py", + "lib/python3.10/ctypes/wintypes.py", + "lib/python3.10/curses/__init__.py", + "lib/python3.10/curses/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/curses/__pycache__/ascii.cpython-310.pyc", + "lib/python3.10/curses/__pycache__/has_key.cpython-310.pyc", + "lib/python3.10/curses/__pycache__/panel.cpython-310.pyc", + "lib/python3.10/curses/__pycache__/textpad.cpython-310.pyc", + "lib/python3.10/curses/ascii.py", + "lib/python3.10/curses/has_key.py", + "lib/python3.10/curses/panel.py", + "lib/python3.10/curses/textpad.py", + "lib/python3.10/dataclasses.py", + "lib/python3.10/datetime.py", + "lib/python3.10/dbm/__init__.py", + "lib/python3.10/dbm/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/dbm/__pycache__/dumb.cpython-310.pyc", + "lib/python3.10/dbm/__pycache__/gnu.cpython-310.pyc", + "lib/python3.10/dbm/__pycache__/ndbm.cpython-310.pyc", + "lib/python3.10/dbm/dumb.py", + "lib/python3.10/dbm/gnu.py", + "lib/python3.10/dbm/ndbm.py", + "lib/python3.10/decimal.py", + "lib/python3.10/difflib.py", + "lib/python3.10/dis.py", + "lib/python3.10/distutils/README", + "lib/python3.10/distutils/__init__.py", + "lib/python3.10/distutils/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/_msvccompiler.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/archive_util.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/bcppcompiler.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/ccompiler.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/cmd.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/config.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/core.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/cygwinccompiler.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/debug.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/dep_util.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/dir_util.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/dist.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/errors.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/extension.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/fancy_getopt.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/file_util.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/filelist.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/log.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/msvc9compiler.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/msvccompiler.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/spawn.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/sysconfig.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/text_file.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/unixccompiler.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/util.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/version.cpython-310.pyc", + "lib/python3.10/distutils/__pycache__/versionpredicate.cpython-310.pyc", + "lib/python3.10/distutils/_msvccompiler.py", + "lib/python3.10/distutils/archive_util.py", + "lib/python3.10/distutils/bcppcompiler.py", + "lib/python3.10/distutils/ccompiler.py", + "lib/python3.10/distutils/cmd.py", + "lib/python3.10/distutils/command/__init__.py", + "lib/python3.10/distutils/command/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/distutils/command/__pycache__/bdist.cpython-310.pyc", + "lib/python3.10/distutils/command/__pycache__/bdist_dumb.cpython-310.pyc", + "lib/python3.10/distutils/command/__pycache__/bdist_msi.cpython-310.pyc", + "lib/python3.10/distutils/command/__pycache__/bdist_rpm.cpython-310.pyc", + "lib/python3.10/distutils/command/__pycache__/build.cpython-310.pyc", + "lib/python3.10/distutils/command/__pycache__/build_clib.cpython-310.pyc", + "lib/python3.10/distutils/command/__pycache__/build_ext.cpython-310.pyc", + "lib/python3.10/distutils/command/__pycache__/build_py.cpython-310.pyc", + "lib/python3.10/distutils/command/__pycache__/build_scripts.cpython-310.pyc", + "lib/python3.10/distutils/command/__pycache__/check.cpython-310.pyc", + "lib/python3.10/distutils/command/__pycache__/clean.cpython-310.pyc", + "lib/python3.10/distutils/command/__pycache__/config.cpython-310.pyc", + "lib/python3.10/distutils/command/__pycache__/install.cpython-310.pyc", + "lib/python3.10/distutils/command/__pycache__/install_data.cpython-310.pyc", + "lib/python3.10/distutils/command/__pycache__/install_egg_info.cpython-310.pyc", + "lib/python3.10/distutils/command/__pycache__/install_headers.cpython-310.pyc", + "lib/python3.10/distutils/command/__pycache__/install_lib.cpython-310.pyc", + "lib/python3.10/distutils/command/__pycache__/install_scripts.cpython-310.pyc", + "lib/python3.10/distutils/command/__pycache__/register.cpython-310.pyc", + "lib/python3.10/distutils/command/__pycache__/sdist.cpython-310.pyc", + "lib/python3.10/distutils/command/__pycache__/upload.cpython-310.pyc", + "lib/python3.10/distutils/command/bdist.py", + "lib/python3.10/distutils/command/bdist_dumb.py", + "lib/python3.10/distutils/command/bdist_msi.py", + "lib/python3.10/distutils/command/bdist_rpm.py", + "lib/python3.10/distutils/command/build.py", + "lib/python3.10/distutils/command/build_clib.py", + "lib/python3.10/distutils/command/build_ext.py", + "lib/python3.10/distutils/command/build_py.py", + "lib/python3.10/distutils/command/build_scripts.py", + "lib/python3.10/distutils/command/check.py", + "lib/python3.10/distutils/command/clean.py", + "lib/python3.10/distutils/command/command_template", + "lib/python3.10/distutils/command/config.py", + "lib/python3.10/distutils/command/install.py", + "lib/python3.10/distutils/command/install_data.py", + "lib/python3.10/distutils/command/install_egg_info.py", + "lib/python3.10/distutils/command/install_headers.py", + "lib/python3.10/distutils/command/install_lib.py", + "lib/python3.10/distutils/command/install_scripts.py", + "lib/python3.10/distutils/command/register.py", + "lib/python3.10/distutils/command/sdist.py", + "lib/python3.10/distutils/command/upload.py", + "lib/python3.10/distutils/config.py", + "lib/python3.10/distutils/core.py", + "lib/python3.10/distutils/cygwinccompiler.py", + "lib/python3.10/distutils/debug.py", + "lib/python3.10/distutils/dep_util.py", + "lib/python3.10/distutils/dir_util.py", + "lib/python3.10/distutils/dist.py", + "lib/python3.10/distutils/errors.py", + "lib/python3.10/distutils/extension.py", + "lib/python3.10/distutils/fancy_getopt.py", + "lib/python3.10/distutils/file_util.py", + "lib/python3.10/distutils/filelist.py", + "lib/python3.10/distutils/log.py", + "lib/python3.10/distutils/msvc9compiler.py", + "lib/python3.10/distutils/msvccompiler.py", + "lib/python3.10/distutils/spawn.py", + "lib/python3.10/distutils/sysconfig.py", + "lib/python3.10/distutils/tests/Setup.sample", + "lib/python3.10/distutils/tests/__init__.py", + "lib/python3.10/distutils/tests/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/support.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_archive_util.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_bdist.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_bdist_dumb.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_bdist_msi.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_bdist_rpm.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_build.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_build_clib.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_build_ext.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_build_py.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_build_scripts.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_check.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_clean.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_cmd.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_config.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_config_cmd.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_core.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_cygwinccompiler.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_dep_util.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_dir_util.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_dist.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_extension.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_file_util.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_filelist.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_install.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_install_data.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_install_headers.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_install_lib.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_install_scripts.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_log.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_msvc9compiler.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_msvccompiler.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_register.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_sdist.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_spawn.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_sysconfig.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_text_file.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_unixccompiler.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_upload.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_util.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_version.cpython-310.pyc", + "lib/python3.10/distutils/tests/__pycache__/test_versionpredicate.cpython-310.pyc", + "lib/python3.10/distutils/tests/includetest.rst", + "lib/python3.10/distutils/tests/support.py", + "lib/python3.10/distutils/tests/test_archive_util.py", + "lib/python3.10/distutils/tests/test_bdist.py", + "lib/python3.10/distutils/tests/test_bdist_dumb.py", + "lib/python3.10/distutils/tests/test_bdist_msi.py", + "lib/python3.10/distutils/tests/test_bdist_rpm.py", + "lib/python3.10/distutils/tests/test_build.py", + "lib/python3.10/distutils/tests/test_build_clib.py", + "lib/python3.10/distutils/tests/test_build_ext.py", + "lib/python3.10/distutils/tests/test_build_py.py", + "lib/python3.10/distutils/tests/test_build_scripts.py", + "lib/python3.10/distutils/tests/test_check.py", + "lib/python3.10/distutils/tests/test_clean.py", + "lib/python3.10/distutils/tests/test_cmd.py", + "lib/python3.10/distutils/tests/test_config.py", + "lib/python3.10/distutils/tests/test_config_cmd.py", + "lib/python3.10/distutils/tests/test_core.py", + "lib/python3.10/distutils/tests/test_cygwinccompiler.py", + "lib/python3.10/distutils/tests/test_dep_util.py", + "lib/python3.10/distutils/tests/test_dir_util.py", + "lib/python3.10/distutils/tests/test_dist.py", + "lib/python3.10/distutils/tests/test_extension.py", + "lib/python3.10/distutils/tests/test_file_util.py", + "lib/python3.10/distutils/tests/test_filelist.py", + "lib/python3.10/distutils/tests/test_install.py", + "lib/python3.10/distutils/tests/test_install_data.py", + "lib/python3.10/distutils/tests/test_install_headers.py", + "lib/python3.10/distutils/tests/test_install_lib.py", + "lib/python3.10/distutils/tests/test_install_scripts.py", + "lib/python3.10/distutils/tests/test_log.py", + "lib/python3.10/distutils/tests/test_msvc9compiler.py", + "lib/python3.10/distutils/tests/test_msvccompiler.py", + "lib/python3.10/distutils/tests/test_register.py", + "lib/python3.10/distutils/tests/test_sdist.py", + "lib/python3.10/distutils/tests/test_spawn.py", + "lib/python3.10/distutils/tests/test_sysconfig.py", + "lib/python3.10/distutils/tests/test_text_file.py", + "lib/python3.10/distutils/tests/test_unixccompiler.py", + "lib/python3.10/distutils/tests/test_upload.py", + "lib/python3.10/distutils/tests/test_util.py", + "lib/python3.10/distutils/tests/test_version.py", + "lib/python3.10/distutils/tests/test_versionpredicate.py", + "lib/python3.10/distutils/tests/xxmodule.c", + "lib/python3.10/distutils/text_file.py", + "lib/python3.10/distutils/unixccompiler.py", + "lib/python3.10/distutils/util.py", + "lib/python3.10/distutils/version.py", + "lib/python3.10/distutils/versionpredicate.py", + "lib/python3.10/doctest.py", + "lib/python3.10/email/__init__.py", + "lib/python3.10/email/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/email/__pycache__/_encoded_words.cpython-310.pyc", + "lib/python3.10/email/__pycache__/_header_value_parser.cpython-310.pyc", + "lib/python3.10/email/__pycache__/_parseaddr.cpython-310.pyc", + "lib/python3.10/email/__pycache__/_policybase.cpython-310.pyc", + "lib/python3.10/email/__pycache__/base64mime.cpython-310.pyc", + "lib/python3.10/email/__pycache__/charset.cpython-310.pyc", + "lib/python3.10/email/__pycache__/contentmanager.cpython-310.pyc", + "lib/python3.10/email/__pycache__/encoders.cpython-310.pyc", + "lib/python3.10/email/__pycache__/errors.cpython-310.pyc", + "lib/python3.10/email/__pycache__/feedparser.cpython-310.pyc", + "lib/python3.10/email/__pycache__/generator.cpython-310.pyc", + "lib/python3.10/email/__pycache__/header.cpython-310.pyc", + "lib/python3.10/email/__pycache__/headerregistry.cpython-310.pyc", + "lib/python3.10/email/__pycache__/iterators.cpython-310.pyc", + "lib/python3.10/email/__pycache__/message.cpython-310.pyc", + "lib/python3.10/email/__pycache__/parser.cpython-310.pyc", + "lib/python3.10/email/__pycache__/policy.cpython-310.pyc", + "lib/python3.10/email/__pycache__/quoprimime.cpython-310.pyc", + "lib/python3.10/email/__pycache__/utils.cpython-310.pyc", + "lib/python3.10/email/_encoded_words.py", + "lib/python3.10/email/_header_value_parser.py", + "lib/python3.10/email/_parseaddr.py", + "lib/python3.10/email/_policybase.py", + "lib/python3.10/email/architecture.rst", + "lib/python3.10/email/base64mime.py", + "lib/python3.10/email/charset.py", + "lib/python3.10/email/contentmanager.py", + "lib/python3.10/email/encoders.py", + "lib/python3.10/email/errors.py", + "lib/python3.10/email/feedparser.py", + "lib/python3.10/email/generator.py", + "lib/python3.10/email/header.py", + "lib/python3.10/email/headerregistry.py", + "lib/python3.10/email/iterators.py", + "lib/python3.10/email/message.py", + "lib/python3.10/email/mime/__init__.py", + "lib/python3.10/email/mime/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/email/mime/__pycache__/application.cpython-310.pyc", + "lib/python3.10/email/mime/__pycache__/audio.cpython-310.pyc", + "lib/python3.10/email/mime/__pycache__/base.cpython-310.pyc", + "lib/python3.10/email/mime/__pycache__/image.cpython-310.pyc", + "lib/python3.10/email/mime/__pycache__/message.cpython-310.pyc", + "lib/python3.10/email/mime/__pycache__/multipart.cpython-310.pyc", + "lib/python3.10/email/mime/__pycache__/nonmultipart.cpython-310.pyc", + "lib/python3.10/email/mime/__pycache__/text.cpython-310.pyc", + "lib/python3.10/email/mime/application.py", + "lib/python3.10/email/mime/audio.py", + "lib/python3.10/email/mime/base.py", + "lib/python3.10/email/mime/image.py", + "lib/python3.10/email/mime/message.py", + "lib/python3.10/email/mime/multipart.py", + "lib/python3.10/email/mime/nonmultipart.py", + "lib/python3.10/email/mime/text.py", + "lib/python3.10/email/parser.py", + "lib/python3.10/email/policy.py", + "lib/python3.10/email/quoprimime.py", + "lib/python3.10/email/utils.py", + "lib/python3.10/encodings/__init__.py", + "lib/python3.10/encodings/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/aliases.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/ascii.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/base64_codec.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/big5.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/big5hkscs.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/bz2_codec.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/charmap.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp037.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp1006.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp1026.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp1125.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp1140.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp1250.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp1251.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp1252.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp1253.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp1254.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp1255.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp1256.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp1257.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp1258.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp273.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp424.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp437.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp500.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp720.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp737.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp775.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp850.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp852.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp855.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp856.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp857.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp858.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp860.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp861.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp862.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp863.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp864.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp865.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp866.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp869.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp874.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp875.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp932.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp949.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/cp950.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/euc_jis_2004.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/euc_jisx0213.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/euc_jp.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/euc_kr.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/gb18030.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/gb2312.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/gbk.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/hex_codec.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/hp_roman8.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/hz.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/idna.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/iso2022_jp.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/iso2022_jp_1.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/iso2022_jp_2.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/iso2022_jp_2004.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/iso2022_jp_3.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/iso2022_jp_ext.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/iso2022_kr.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/iso8859_1.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/iso8859_10.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/iso8859_11.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/iso8859_13.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/iso8859_14.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/iso8859_15.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/iso8859_16.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/iso8859_2.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/iso8859_3.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/iso8859_4.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/iso8859_5.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/iso8859_6.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/iso8859_7.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/iso8859_8.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/iso8859_9.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/johab.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/koi8_r.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/koi8_t.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/koi8_u.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/kz1048.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/latin_1.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/mac_arabic.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/mac_croatian.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/mac_cyrillic.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/mac_farsi.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/mac_greek.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/mac_iceland.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/mac_latin2.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/mac_roman.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/mac_romanian.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/mac_turkish.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/mbcs.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/oem.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/palmos.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/ptcp154.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/punycode.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/quopri_codec.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/raw_unicode_escape.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/rot_13.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/shift_jis.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/shift_jis_2004.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/shift_jisx0213.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/tis_620.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/undefined.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/unicode_escape.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/utf_16.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/utf_16_be.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/utf_16_le.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/utf_32.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/utf_32_be.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/utf_32_le.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/utf_7.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/utf_8.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/utf_8_sig.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/uu_codec.cpython-310.pyc", + "lib/python3.10/encodings/__pycache__/zlib_codec.cpython-310.pyc", + "lib/python3.10/encodings/aliases.py", + "lib/python3.10/encodings/ascii.py", + "lib/python3.10/encodings/base64_codec.py", + "lib/python3.10/encodings/big5.py", + "lib/python3.10/encodings/big5hkscs.py", + "lib/python3.10/encodings/bz2_codec.py", + "lib/python3.10/encodings/charmap.py", + "lib/python3.10/encodings/cp037.py", + "lib/python3.10/encodings/cp1006.py", + "lib/python3.10/encodings/cp1026.py", + "lib/python3.10/encodings/cp1125.py", + "lib/python3.10/encodings/cp1140.py", + "lib/python3.10/encodings/cp1250.py", + "lib/python3.10/encodings/cp1251.py", + "lib/python3.10/encodings/cp1252.py", + "lib/python3.10/encodings/cp1253.py", + "lib/python3.10/encodings/cp1254.py", + "lib/python3.10/encodings/cp1255.py", + "lib/python3.10/encodings/cp1256.py", + "lib/python3.10/encodings/cp1257.py", + "lib/python3.10/encodings/cp1258.py", + "lib/python3.10/encodings/cp273.py", + "lib/python3.10/encodings/cp424.py", + "lib/python3.10/encodings/cp437.py", + "lib/python3.10/encodings/cp500.py", + "lib/python3.10/encodings/cp720.py", + "lib/python3.10/encodings/cp737.py", + "lib/python3.10/encodings/cp775.py", + "lib/python3.10/encodings/cp850.py", + "lib/python3.10/encodings/cp852.py", + "lib/python3.10/encodings/cp855.py", + "lib/python3.10/encodings/cp856.py", + "lib/python3.10/encodings/cp857.py", + "lib/python3.10/encodings/cp858.py", + "lib/python3.10/encodings/cp860.py", + "lib/python3.10/encodings/cp861.py", + "lib/python3.10/encodings/cp862.py", + "lib/python3.10/encodings/cp863.py", + "lib/python3.10/encodings/cp864.py", + "lib/python3.10/encodings/cp865.py", + "lib/python3.10/encodings/cp866.py", + "lib/python3.10/encodings/cp869.py", + "lib/python3.10/encodings/cp874.py", + "lib/python3.10/encodings/cp875.py", + "lib/python3.10/encodings/cp932.py", + "lib/python3.10/encodings/cp949.py", + "lib/python3.10/encodings/cp950.py", + "lib/python3.10/encodings/euc_jis_2004.py", + "lib/python3.10/encodings/euc_jisx0213.py", + "lib/python3.10/encodings/euc_jp.py", + "lib/python3.10/encodings/euc_kr.py", + "lib/python3.10/encodings/gb18030.py", + "lib/python3.10/encodings/gb2312.py", + "lib/python3.10/encodings/gbk.py", + "lib/python3.10/encodings/hex_codec.py", + "lib/python3.10/encodings/hp_roman8.py", + "lib/python3.10/encodings/hz.py", + "lib/python3.10/encodings/idna.py", + "lib/python3.10/encodings/iso2022_jp.py", + "lib/python3.10/encodings/iso2022_jp_1.py", + "lib/python3.10/encodings/iso2022_jp_2.py", + "lib/python3.10/encodings/iso2022_jp_2004.py", + "lib/python3.10/encodings/iso2022_jp_3.py", + "lib/python3.10/encodings/iso2022_jp_ext.py", + "lib/python3.10/encodings/iso2022_kr.py", + "lib/python3.10/encodings/iso8859_1.py", + "lib/python3.10/encodings/iso8859_10.py", + "lib/python3.10/encodings/iso8859_11.py", + "lib/python3.10/encodings/iso8859_13.py", + "lib/python3.10/encodings/iso8859_14.py", + "lib/python3.10/encodings/iso8859_15.py", + "lib/python3.10/encodings/iso8859_16.py", + "lib/python3.10/encodings/iso8859_2.py", + "lib/python3.10/encodings/iso8859_3.py", + "lib/python3.10/encodings/iso8859_4.py", + "lib/python3.10/encodings/iso8859_5.py", + "lib/python3.10/encodings/iso8859_6.py", + "lib/python3.10/encodings/iso8859_7.py", + "lib/python3.10/encodings/iso8859_8.py", + "lib/python3.10/encodings/iso8859_9.py", + "lib/python3.10/encodings/johab.py", + "lib/python3.10/encodings/koi8_r.py", + "lib/python3.10/encodings/koi8_t.py", + "lib/python3.10/encodings/koi8_u.py", + "lib/python3.10/encodings/kz1048.py", + "lib/python3.10/encodings/latin_1.py", + "lib/python3.10/encodings/mac_arabic.py", + "lib/python3.10/encodings/mac_croatian.py", + "lib/python3.10/encodings/mac_cyrillic.py", + "lib/python3.10/encodings/mac_farsi.py", + "lib/python3.10/encodings/mac_greek.py", + "lib/python3.10/encodings/mac_iceland.py", + "lib/python3.10/encodings/mac_latin2.py", + "lib/python3.10/encodings/mac_roman.py", + "lib/python3.10/encodings/mac_romanian.py", + "lib/python3.10/encodings/mac_turkish.py", + "lib/python3.10/encodings/mbcs.py", + "lib/python3.10/encodings/oem.py", + "lib/python3.10/encodings/palmos.py", + "lib/python3.10/encodings/ptcp154.py", + "lib/python3.10/encodings/punycode.py", + "lib/python3.10/encodings/quopri_codec.py", + "lib/python3.10/encodings/raw_unicode_escape.py", + "lib/python3.10/encodings/rot_13.py", + "lib/python3.10/encodings/shift_jis.py", + "lib/python3.10/encodings/shift_jis_2004.py", + "lib/python3.10/encodings/shift_jisx0213.py", + "lib/python3.10/encodings/tis_620.py", + "lib/python3.10/encodings/undefined.py", + "lib/python3.10/encodings/unicode_escape.py", + "lib/python3.10/encodings/utf_16.py", + "lib/python3.10/encodings/utf_16_be.py", + "lib/python3.10/encodings/utf_16_le.py", + "lib/python3.10/encodings/utf_32.py", + "lib/python3.10/encodings/utf_32_be.py", + "lib/python3.10/encodings/utf_32_le.py", + "lib/python3.10/encodings/utf_7.py", + "lib/python3.10/encodings/utf_8.py", + "lib/python3.10/encodings/utf_8_sig.py", + "lib/python3.10/encodings/uu_codec.py", + "lib/python3.10/encodings/zlib_codec.py", + "lib/python3.10/ensurepip/__init__.py", + "lib/python3.10/ensurepip/__main__.py", + "lib/python3.10/ensurepip/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/ensurepip/__pycache__/__main__.cpython-310.pyc", + "lib/python3.10/ensurepip/__pycache__/_uninstall.cpython-310.pyc", + "lib/python3.10/ensurepip/_bundled/__init__.py", + "lib/python3.10/ensurepip/_bundled/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/ensurepip/_bundled/pip-23.0.1-py3-none-any.whl", + "lib/python3.10/ensurepip/_bundled/setuptools-65.5.0-py3-none-any.whl", + "lib/python3.10/ensurepip/_uninstall.py", + "lib/python3.10/enum.py", + "lib/python3.10/filecmp.py", + "lib/python3.10/fileinput.py", + "lib/python3.10/fnmatch.py", + "lib/python3.10/fractions.py", + "lib/python3.10/ftplib.py", + "lib/python3.10/functools.py", + "lib/python3.10/genericpath.py", + "lib/python3.10/getopt.py", + "lib/python3.10/getpass.py", + "lib/python3.10/gettext.py", + "lib/python3.10/glob.py", + "lib/python3.10/graphlib.py", + "lib/python3.10/gzip.py", + "lib/python3.10/hashlib.py", + "lib/python3.10/heapq.py", + "lib/python3.10/hmac.py", + "lib/python3.10/html/__init__.py", + "lib/python3.10/html/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/html/__pycache__/entities.cpython-310.pyc", + "lib/python3.10/html/__pycache__/parser.cpython-310.pyc", + "lib/python3.10/html/entities.py", + "lib/python3.10/html/parser.py", + "lib/python3.10/http/__init__.py", + "lib/python3.10/http/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/http/__pycache__/client.cpython-310.pyc", + "lib/python3.10/http/__pycache__/cookiejar.cpython-310.pyc", + "lib/python3.10/http/__pycache__/cookies.cpython-310.pyc", + "lib/python3.10/http/__pycache__/server.cpython-310.pyc", + "lib/python3.10/http/client.py", + "lib/python3.10/http/cookiejar.py", + "lib/python3.10/http/cookies.py", + "lib/python3.10/http/server.py", + "lib/python3.10/idlelib/CREDITS.txt", + "lib/python3.10/idlelib/ChangeLog", + "lib/python3.10/idlelib/HISTORY.txt", + "lib/python3.10/idlelib/Icons/README.txt", + "lib/python3.10/idlelib/Icons/folder.gif", + "lib/python3.10/idlelib/Icons/idle.ico", + "lib/python3.10/idlelib/Icons/idle_16.gif", + "lib/python3.10/idlelib/Icons/idle_16.png", + "lib/python3.10/idlelib/Icons/idle_256.png", + "lib/python3.10/idlelib/Icons/idle_32.gif", + "lib/python3.10/idlelib/Icons/idle_32.png", + "lib/python3.10/idlelib/Icons/idle_48.gif", + "lib/python3.10/idlelib/Icons/idle_48.png", + "lib/python3.10/idlelib/Icons/minusnode.gif", + "lib/python3.10/idlelib/Icons/openfolder.gif", + "lib/python3.10/idlelib/Icons/plusnode.gif", + "lib/python3.10/idlelib/Icons/python.gif", + "lib/python3.10/idlelib/Icons/tk.gif", + "lib/python3.10/idlelib/NEWS.txt", + "lib/python3.10/idlelib/NEWS2x.txt", + "lib/python3.10/idlelib/README.txt", + "lib/python3.10/idlelib/TODO.txt", + "lib/python3.10/idlelib/__init__.py", + "lib/python3.10/idlelib/__main__.py", + "lib/python3.10/idlelib/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/__main__.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/autocomplete.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/autocomplete_w.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/autoexpand.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/browser.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/calltip.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/calltip_w.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/codecontext.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/colorizer.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/config.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/config_key.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/configdialog.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/debugger.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/debugger_r.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/debugobj.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/debugobj_r.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/delegator.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/dynoption.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/editor.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/filelist.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/format.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/grep.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/help.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/help_about.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/history.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/hyperparser.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/idle.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/iomenu.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/macosx.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/mainmenu.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/multicall.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/outwin.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/parenmatch.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/pathbrowser.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/percolator.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/pyparse.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/pyshell.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/query.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/redirector.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/replace.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/rpc.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/run.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/runscript.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/scrolledlist.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/search.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/searchbase.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/searchengine.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/sidebar.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/squeezer.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/stackviewer.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/statusbar.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/textview.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/tooltip.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/tree.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/undo.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/util.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/window.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/zoomheight.cpython-310.pyc", + "lib/python3.10/idlelib/__pycache__/zzdummy.cpython-310.pyc", + "lib/python3.10/idlelib/autocomplete.py", + "lib/python3.10/idlelib/autocomplete_w.py", + "lib/python3.10/idlelib/autoexpand.py", + "lib/python3.10/idlelib/browser.py", + "lib/python3.10/idlelib/calltip.py", + "lib/python3.10/idlelib/calltip_w.py", + "lib/python3.10/idlelib/codecontext.py", + "lib/python3.10/idlelib/colorizer.py", + "lib/python3.10/idlelib/config-extensions.def", + "lib/python3.10/idlelib/config-highlight.def", + "lib/python3.10/idlelib/config-keys.def", + "lib/python3.10/idlelib/config-main.def", + "lib/python3.10/idlelib/config.py", + "lib/python3.10/idlelib/config_key.py", + "lib/python3.10/idlelib/configdialog.py", + "lib/python3.10/idlelib/debugger.py", + "lib/python3.10/idlelib/debugger_r.py", + "lib/python3.10/idlelib/debugobj.py", + "lib/python3.10/idlelib/debugobj_r.py", + "lib/python3.10/idlelib/delegator.py", + "lib/python3.10/idlelib/dynoption.py", + "lib/python3.10/idlelib/editor.py", + "lib/python3.10/idlelib/extend.txt", + "lib/python3.10/idlelib/filelist.py", + "lib/python3.10/idlelib/format.py", + "lib/python3.10/idlelib/grep.py", + "lib/python3.10/idlelib/help.html", + "lib/python3.10/idlelib/help.py", + "lib/python3.10/idlelib/help_about.py", + "lib/python3.10/idlelib/history.py", + "lib/python3.10/idlelib/hyperparser.py", + "lib/python3.10/idlelib/idle.bat", + "lib/python3.10/idlelib/idle.py", + "lib/python3.10/idlelib/idle.pyw", + "lib/python3.10/idlelib/idle_test/README.txt", + "lib/python3.10/idlelib/idle_test/__init__.py", + "lib/python3.10/idlelib/idle_test/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/htest.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/mock_idle.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/mock_tk.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/template.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_autocomplete.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_autocomplete_w.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_autoexpand.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_browser.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_calltip.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_calltip_w.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_codecontext.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_colorizer.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_config.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_config_key.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_configdialog.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_debugger.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_debugger_r.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_debugobj.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_debugobj_r.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_delegator.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_editmenu.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_editor.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_filelist.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_format.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_grep.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_help.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_help_about.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_history.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_hyperparser.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_iomenu.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_macosx.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_mainmenu.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_multicall.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_outwin.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_parenmatch.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_pathbrowser.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_percolator.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_pyparse.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_pyshell.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_query.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_redirector.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_replace.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_rpc.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_run.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_runscript.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_scrolledlist.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_search.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_searchbase.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_searchengine.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_sidebar.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_squeezer.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_stackviewer.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_statusbar.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_text.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_textview.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_tooltip.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_tree.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_undo.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_util.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_warning.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_window.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_zoomheight.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/test_zzdummy.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/__pycache__/tkinter_testing_utils.cpython-310.pyc", + "lib/python3.10/idlelib/idle_test/example_noext", + "lib/python3.10/idlelib/idle_test/example_stub.pyi", + "lib/python3.10/idlelib/idle_test/htest.py", + "lib/python3.10/idlelib/idle_test/mock_idle.py", + "lib/python3.10/idlelib/idle_test/mock_tk.py", + "lib/python3.10/idlelib/idle_test/template.py", + "lib/python3.10/idlelib/idle_test/test_autocomplete.py", + "lib/python3.10/idlelib/idle_test/test_autocomplete_w.py", + "lib/python3.10/idlelib/idle_test/test_autoexpand.py", + "lib/python3.10/idlelib/idle_test/test_browser.py", + "lib/python3.10/idlelib/idle_test/test_calltip.py", + "lib/python3.10/idlelib/idle_test/test_calltip_w.py", + "lib/python3.10/idlelib/idle_test/test_codecontext.py", + "lib/python3.10/idlelib/idle_test/test_colorizer.py", + "lib/python3.10/idlelib/idle_test/test_config.py", + "lib/python3.10/idlelib/idle_test/test_config_key.py", + "lib/python3.10/idlelib/idle_test/test_configdialog.py", + "lib/python3.10/idlelib/idle_test/test_debugger.py", + "lib/python3.10/idlelib/idle_test/test_debugger_r.py", + "lib/python3.10/idlelib/idle_test/test_debugobj.py", + "lib/python3.10/idlelib/idle_test/test_debugobj_r.py", + "lib/python3.10/idlelib/idle_test/test_delegator.py", + "lib/python3.10/idlelib/idle_test/test_editmenu.py", + "lib/python3.10/idlelib/idle_test/test_editor.py", + "lib/python3.10/idlelib/idle_test/test_filelist.py", + "lib/python3.10/idlelib/idle_test/test_format.py", + "lib/python3.10/idlelib/idle_test/test_grep.py", + "lib/python3.10/idlelib/idle_test/test_help.py", + "lib/python3.10/idlelib/idle_test/test_help_about.py", + "lib/python3.10/idlelib/idle_test/test_history.py", + "lib/python3.10/idlelib/idle_test/test_hyperparser.py", + "lib/python3.10/idlelib/idle_test/test_iomenu.py", + "lib/python3.10/idlelib/idle_test/test_macosx.py", + "lib/python3.10/idlelib/idle_test/test_mainmenu.py", + "lib/python3.10/idlelib/idle_test/test_multicall.py", + "lib/python3.10/idlelib/idle_test/test_outwin.py", + "lib/python3.10/idlelib/idle_test/test_parenmatch.py", + "lib/python3.10/idlelib/idle_test/test_pathbrowser.py", + "lib/python3.10/idlelib/idle_test/test_percolator.py", + "lib/python3.10/idlelib/idle_test/test_pyparse.py", + "lib/python3.10/idlelib/idle_test/test_pyshell.py", + "lib/python3.10/idlelib/idle_test/test_query.py", + "lib/python3.10/idlelib/idle_test/test_redirector.py", + "lib/python3.10/idlelib/idle_test/test_replace.py", + "lib/python3.10/idlelib/idle_test/test_rpc.py", + "lib/python3.10/idlelib/idle_test/test_run.py", + "lib/python3.10/idlelib/idle_test/test_runscript.py", + "lib/python3.10/idlelib/idle_test/test_scrolledlist.py", + "lib/python3.10/idlelib/idle_test/test_search.py", + "lib/python3.10/idlelib/idle_test/test_searchbase.py", + "lib/python3.10/idlelib/idle_test/test_searchengine.py", + "lib/python3.10/idlelib/idle_test/test_sidebar.py", + "lib/python3.10/idlelib/idle_test/test_squeezer.py", + "lib/python3.10/idlelib/idle_test/test_stackviewer.py", + "lib/python3.10/idlelib/idle_test/test_statusbar.py", + "lib/python3.10/idlelib/idle_test/test_text.py", + "lib/python3.10/idlelib/idle_test/test_textview.py", + "lib/python3.10/idlelib/idle_test/test_tooltip.py", + "lib/python3.10/idlelib/idle_test/test_tree.py", + "lib/python3.10/idlelib/idle_test/test_undo.py", + "lib/python3.10/idlelib/idle_test/test_util.py", + "lib/python3.10/idlelib/idle_test/test_warning.py", + "lib/python3.10/idlelib/idle_test/test_window.py", + "lib/python3.10/idlelib/idle_test/test_zoomheight.py", + "lib/python3.10/idlelib/idle_test/test_zzdummy.py", + "lib/python3.10/idlelib/idle_test/tkinter_testing_utils.py", + "lib/python3.10/idlelib/iomenu.py", + "lib/python3.10/idlelib/macosx.py", + "lib/python3.10/idlelib/mainmenu.py", + "lib/python3.10/idlelib/multicall.py", + "lib/python3.10/idlelib/outwin.py", + "lib/python3.10/idlelib/parenmatch.py", + "lib/python3.10/idlelib/pathbrowser.py", + "lib/python3.10/idlelib/percolator.py", + "lib/python3.10/idlelib/pyparse.py", + "lib/python3.10/idlelib/pyshell.py", + "lib/python3.10/idlelib/query.py", + "lib/python3.10/idlelib/redirector.py", + "lib/python3.10/idlelib/replace.py", + "lib/python3.10/idlelib/rpc.py", + "lib/python3.10/idlelib/run.py", + "lib/python3.10/idlelib/runscript.py", + "lib/python3.10/idlelib/scrolledlist.py", + "lib/python3.10/idlelib/search.py", + "lib/python3.10/idlelib/searchbase.py", + "lib/python3.10/idlelib/searchengine.py", + "lib/python3.10/idlelib/sidebar.py", + "lib/python3.10/idlelib/squeezer.py", + "lib/python3.10/idlelib/stackviewer.py", + "lib/python3.10/idlelib/statusbar.py", + "lib/python3.10/idlelib/textview.py", + "lib/python3.10/idlelib/tooltip.py", + "lib/python3.10/idlelib/tree.py", + "lib/python3.10/idlelib/undo.py", + "lib/python3.10/idlelib/util.py", + "lib/python3.10/idlelib/window.py", + "lib/python3.10/idlelib/zoomheight.py", + "lib/python3.10/idlelib/zzdummy.py", + "lib/python3.10/imaplib.py", + "lib/python3.10/imghdr.py", + "lib/python3.10/imp.py", + "lib/python3.10/importlib/__init__.py", + "lib/python3.10/importlib/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/importlib/__pycache__/_abc.cpython-310.pyc", + "lib/python3.10/importlib/__pycache__/_adapters.cpython-310.pyc", + "lib/python3.10/importlib/__pycache__/_bootstrap.cpython-310.pyc", + "lib/python3.10/importlib/__pycache__/_bootstrap_external.cpython-310.pyc", + "lib/python3.10/importlib/__pycache__/_common.cpython-310.pyc", + "lib/python3.10/importlib/__pycache__/abc.cpython-310.pyc", + "lib/python3.10/importlib/__pycache__/machinery.cpython-310.pyc", + "lib/python3.10/importlib/__pycache__/readers.cpython-310.pyc", + "lib/python3.10/importlib/__pycache__/resources.cpython-310.pyc", + "lib/python3.10/importlib/__pycache__/util.cpython-310.pyc", + "lib/python3.10/importlib/_abc.py", + "lib/python3.10/importlib/_adapters.py", + "lib/python3.10/importlib/_bootstrap.py", + "lib/python3.10/importlib/_bootstrap_external.py", + "lib/python3.10/importlib/_common.py", + "lib/python3.10/importlib/abc.py", + "lib/python3.10/importlib/machinery.py", + "lib/python3.10/importlib/metadata/__init__.py", + "lib/python3.10/importlib/metadata/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/importlib/metadata/__pycache__/_adapters.cpython-310.pyc", + "lib/python3.10/importlib/metadata/__pycache__/_collections.cpython-310.pyc", + "lib/python3.10/importlib/metadata/__pycache__/_functools.cpython-310.pyc", + "lib/python3.10/importlib/metadata/__pycache__/_itertools.cpython-310.pyc", + "lib/python3.10/importlib/metadata/__pycache__/_meta.cpython-310.pyc", + "lib/python3.10/importlib/metadata/__pycache__/_text.cpython-310.pyc", + "lib/python3.10/importlib/metadata/_adapters.py", + "lib/python3.10/importlib/metadata/_collections.py", + "lib/python3.10/importlib/metadata/_functools.py", + "lib/python3.10/importlib/metadata/_itertools.py", + "lib/python3.10/importlib/metadata/_meta.py", + "lib/python3.10/importlib/metadata/_text.py", + "lib/python3.10/importlib/readers.py", + "lib/python3.10/importlib/resources.py", + "lib/python3.10/importlib/util.py", + "lib/python3.10/inspect.py", + "lib/python3.10/io.py", + "lib/python3.10/ipaddress.py", + "lib/python3.10/json/__init__.py", + "lib/python3.10/json/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/json/__pycache__/decoder.cpython-310.pyc", + "lib/python3.10/json/__pycache__/encoder.cpython-310.pyc", + "lib/python3.10/json/__pycache__/scanner.cpython-310.pyc", + "lib/python3.10/json/__pycache__/tool.cpython-310.pyc", + "lib/python3.10/json/decoder.py", + "lib/python3.10/json/encoder.py", + "lib/python3.10/json/scanner.py", + "lib/python3.10/json/tool.py", + "lib/python3.10/keyword.py", + "lib/python3.10/lib-dynload/_asyncio.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_bisect.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_blake2.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_bz2.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_codecs_cn.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_codecs_hk.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_codecs_iso2022.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_codecs_jp.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_codecs_kr.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_codecs_tw.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_contextvars.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_crypt.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_csv.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_ctypes.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_ctypes_test.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_curses.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_curses_panel.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_datetime.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_dbm.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_decimal.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_elementtree.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_hashlib.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_heapq.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_json.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_lsprof.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_lzma.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_md5.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_multibytecodec.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_multiprocessing.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_opcode.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_pickle.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_posixshmem.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_posixsubprocess.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_queue.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_random.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_scproxy.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_sha1.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_sha256.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_sha3.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_sha512.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_socket.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_sqlite3.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_ssl.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_statistics.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_struct.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_testbuffer.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_testcapi.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_testclinic.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_testimportmultiple.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_testinternalcapi.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_testmultiphase.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_tkinter.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_uuid.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_xxsubinterpreters.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_xxtestfuzz.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/_zoneinfo.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/array.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/audioop.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/binascii.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/cmath.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/fcntl.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/grp.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/math.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/mmap.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/nis.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/pyexpat.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/readline.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/resource.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/select.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/syslog.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/termios.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/unicodedata.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/xxlimited.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/xxlimited_35.cpython-310-darwin.so", + "lib/python3.10/lib-dynload/zlib.cpython-310-darwin.so", + "lib/python3.10/lib2to3/Grammar.txt", + "lib/python3.10/lib2to3/Grammar3.10.14.final.0.pickle", + "lib/python3.10/lib2to3/PatternGrammar.txt", + "lib/python3.10/lib2to3/PatternGrammar3.10.14.final.0.pickle", + "lib/python3.10/lib2to3/__init__.py", + "lib/python3.10/lib2to3/__main__.py", + "lib/python3.10/lib2to3/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/lib2to3/__pycache__/__main__.cpython-310.pyc", + "lib/python3.10/lib2to3/__pycache__/btm_matcher.cpython-310.pyc", + "lib/python3.10/lib2to3/__pycache__/btm_utils.cpython-310.pyc", + "lib/python3.10/lib2to3/__pycache__/fixer_base.cpython-310.pyc", + "lib/python3.10/lib2to3/__pycache__/fixer_util.cpython-310.pyc", + "lib/python3.10/lib2to3/__pycache__/main.cpython-310.pyc", + "lib/python3.10/lib2to3/__pycache__/patcomp.cpython-310.pyc", + "lib/python3.10/lib2to3/__pycache__/pygram.cpython-310.pyc", + "lib/python3.10/lib2to3/__pycache__/pytree.cpython-310.pyc", + "lib/python3.10/lib2to3/__pycache__/refactor.cpython-310.pyc", + "lib/python3.10/lib2to3/btm_matcher.py", + "lib/python3.10/lib2to3/btm_utils.py", + "lib/python3.10/lib2to3/fixer_base.py", + "lib/python3.10/lib2to3/fixer_util.py", + "lib/python3.10/lib2to3/fixes/__init__.py", + "lib/python3.10/lib2to3/fixes/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_apply.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_asserts.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_basestring.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_buffer.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_dict.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_except.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_exec.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_execfile.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_exitfunc.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_filter.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_funcattrs.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_future.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_getcwdu.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_has_key.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_idioms.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_import.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_imports.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_imports2.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_input.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_intern.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_isinstance.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_itertools.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_itertools_imports.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_long.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_map.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_metaclass.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_methodattrs.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_ne.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_next.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_nonzero.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_numliterals.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_operator.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_paren.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_print.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_raise.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_raw_input.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_reduce.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_reload.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_renames.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_repr.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_set_literal.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_standarderror.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_sys_exc.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_throw.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_tuple_params.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_types.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_unicode.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_urllib.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_ws_comma.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_xrange.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_xreadlines.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/__pycache__/fix_zip.cpython-310.pyc", + "lib/python3.10/lib2to3/fixes/fix_apply.py", + "lib/python3.10/lib2to3/fixes/fix_asserts.py", + "lib/python3.10/lib2to3/fixes/fix_basestring.py", + "lib/python3.10/lib2to3/fixes/fix_buffer.py", + "lib/python3.10/lib2to3/fixes/fix_dict.py", + "lib/python3.10/lib2to3/fixes/fix_except.py", + "lib/python3.10/lib2to3/fixes/fix_exec.py", + "lib/python3.10/lib2to3/fixes/fix_execfile.py", + "lib/python3.10/lib2to3/fixes/fix_exitfunc.py", + "lib/python3.10/lib2to3/fixes/fix_filter.py", + "lib/python3.10/lib2to3/fixes/fix_funcattrs.py", + "lib/python3.10/lib2to3/fixes/fix_future.py", + "lib/python3.10/lib2to3/fixes/fix_getcwdu.py", + "lib/python3.10/lib2to3/fixes/fix_has_key.py", + "lib/python3.10/lib2to3/fixes/fix_idioms.py", + "lib/python3.10/lib2to3/fixes/fix_import.py", + "lib/python3.10/lib2to3/fixes/fix_imports.py", + "lib/python3.10/lib2to3/fixes/fix_imports2.py", + "lib/python3.10/lib2to3/fixes/fix_input.py", + "lib/python3.10/lib2to3/fixes/fix_intern.py", + "lib/python3.10/lib2to3/fixes/fix_isinstance.py", + "lib/python3.10/lib2to3/fixes/fix_itertools.py", + "lib/python3.10/lib2to3/fixes/fix_itertools_imports.py", + "lib/python3.10/lib2to3/fixes/fix_long.py", + "lib/python3.10/lib2to3/fixes/fix_map.py", + "lib/python3.10/lib2to3/fixes/fix_metaclass.py", + "lib/python3.10/lib2to3/fixes/fix_methodattrs.py", + "lib/python3.10/lib2to3/fixes/fix_ne.py", + "lib/python3.10/lib2to3/fixes/fix_next.py", + "lib/python3.10/lib2to3/fixes/fix_nonzero.py", + "lib/python3.10/lib2to3/fixes/fix_numliterals.py", + "lib/python3.10/lib2to3/fixes/fix_operator.py", + "lib/python3.10/lib2to3/fixes/fix_paren.py", + "lib/python3.10/lib2to3/fixes/fix_print.py", + "lib/python3.10/lib2to3/fixes/fix_raise.py", + "lib/python3.10/lib2to3/fixes/fix_raw_input.py", + "lib/python3.10/lib2to3/fixes/fix_reduce.py", + "lib/python3.10/lib2to3/fixes/fix_reload.py", + "lib/python3.10/lib2to3/fixes/fix_renames.py", + "lib/python3.10/lib2to3/fixes/fix_repr.py", + "lib/python3.10/lib2to3/fixes/fix_set_literal.py", + "lib/python3.10/lib2to3/fixes/fix_standarderror.py", + "lib/python3.10/lib2to3/fixes/fix_sys_exc.py", + "lib/python3.10/lib2to3/fixes/fix_throw.py", + "lib/python3.10/lib2to3/fixes/fix_tuple_params.py", + "lib/python3.10/lib2to3/fixes/fix_types.py", + "lib/python3.10/lib2to3/fixes/fix_unicode.py", + "lib/python3.10/lib2to3/fixes/fix_urllib.py", + "lib/python3.10/lib2to3/fixes/fix_ws_comma.py", + "lib/python3.10/lib2to3/fixes/fix_xrange.py", + "lib/python3.10/lib2to3/fixes/fix_xreadlines.py", + "lib/python3.10/lib2to3/fixes/fix_zip.py", + "lib/python3.10/lib2to3/main.py", + "lib/python3.10/lib2to3/patcomp.py", + "lib/python3.10/lib2to3/pgen2/__init__.py", + "lib/python3.10/lib2to3/pgen2/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/lib2to3/pgen2/__pycache__/conv.cpython-310.pyc", + "lib/python3.10/lib2to3/pgen2/__pycache__/driver.cpython-310.pyc", + "lib/python3.10/lib2to3/pgen2/__pycache__/grammar.cpython-310.pyc", + "lib/python3.10/lib2to3/pgen2/__pycache__/literals.cpython-310.pyc", + "lib/python3.10/lib2to3/pgen2/__pycache__/parse.cpython-310.pyc", + "lib/python3.10/lib2to3/pgen2/__pycache__/pgen.cpython-310.pyc", + "lib/python3.10/lib2to3/pgen2/__pycache__/token.cpython-310.pyc", + "lib/python3.10/lib2to3/pgen2/__pycache__/tokenize.cpython-310.pyc", + "lib/python3.10/lib2to3/pgen2/conv.py", + "lib/python3.10/lib2to3/pgen2/driver.py", + "lib/python3.10/lib2to3/pgen2/grammar.py", + "lib/python3.10/lib2to3/pgen2/literals.py", + "lib/python3.10/lib2to3/pgen2/parse.py", + "lib/python3.10/lib2to3/pgen2/pgen.py", + "lib/python3.10/lib2to3/pgen2/token.py", + "lib/python3.10/lib2to3/pgen2/tokenize.py", + "lib/python3.10/lib2to3/pygram.py", + "lib/python3.10/lib2to3/pytree.py", + "lib/python3.10/lib2to3/refactor.py", + "lib/python3.10/lib2to3/tests/__init__.py", + "lib/python3.10/lib2to3/tests/__main__.py", + "lib/python3.10/lib2to3/tests/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/lib2to3/tests/__pycache__/__main__.cpython-310.pyc", + "lib/python3.10/lib2to3/tests/__pycache__/pytree_idempotency.cpython-310.pyc", + "lib/python3.10/lib2to3/tests/__pycache__/support.cpython-310.pyc", + "lib/python3.10/lib2to3/tests/__pycache__/test_all_fixers.cpython-310.pyc", + "lib/python3.10/lib2to3/tests/__pycache__/test_fixers.cpython-310.pyc", + "lib/python3.10/lib2to3/tests/__pycache__/test_main.cpython-310.pyc", + "lib/python3.10/lib2to3/tests/__pycache__/test_parser.cpython-310.pyc", + "lib/python3.10/lib2to3/tests/__pycache__/test_pytree.cpython-310.pyc", + "lib/python3.10/lib2to3/tests/__pycache__/test_refactor.cpython-310.pyc", + "lib/python3.10/lib2to3/tests/__pycache__/test_util.cpython-310.pyc", + "lib/python3.10/lib2to3/tests/data/README", + "lib/python3.10/lib2to3/tests/data/__pycache__/infinite_recursion.cpython-310.pyc", + "lib/python3.10/lib2to3/tests/data/__pycache__/py3_test_grammar.cpython-310.pyc", + "lib/python3.10/lib2to3/tests/data/bom.py", + "lib/python3.10/lib2to3/tests/data/crlf.py", + "lib/python3.10/lib2to3/tests/data/different_encoding.py", + "lib/python3.10/lib2to3/tests/data/false_encoding.py", + "lib/python3.10/lib2to3/tests/data/fixers/__pycache__/bad_order.cpython-310.pyc", + "lib/python3.10/lib2to3/tests/data/fixers/__pycache__/no_fixer_cls.cpython-310.pyc", + "lib/python3.10/lib2to3/tests/data/fixers/__pycache__/parrot_example.cpython-310.pyc", + "lib/python3.10/lib2to3/tests/data/fixers/bad_order.py", + "lib/python3.10/lib2to3/tests/data/fixers/myfixes/__init__.py", + "lib/python3.10/lib2to3/tests/data/fixers/myfixes/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/lib2to3/tests/data/fixers/myfixes/__pycache__/fix_explicit.cpython-310.pyc", + "lib/python3.10/lib2to3/tests/data/fixers/myfixes/__pycache__/fix_first.cpython-310.pyc", + "lib/python3.10/lib2to3/tests/data/fixers/myfixes/__pycache__/fix_last.cpython-310.pyc", + "lib/python3.10/lib2to3/tests/data/fixers/myfixes/__pycache__/fix_parrot.cpython-310.pyc", + "lib/python3.10/lib2to3/tests/data/fixers/myfixes/__pycache__/fix_preorder.cpython-310.pyc", + "lib/python3.10/lib2to3/tests/data/fixers/myfixes/fix_explicit.py", + "lib/python3.10/lib2to3/tests/data/fixers/myfixes/fix_first.py", + "lib/python3.10/lib2to3/tests/data/fixers/myfixes/fix_last.py", + "lib/python3.10/lib2to3/tests/data/fixers/myfixes/fix_parrot.py", + "lib/python3.10/lib2to3/tests/data/fixers/myfixes/fix_preorder.py", + "lib/python3.10/lib2to3/tests/data/fixers/no_fixer_cls.py", + "lib/python3.10/lib2to3/tests/data/fixers/parrot_example.py", + "lib/python3.10/lib2to3/tests/data/infinite_recursion.py", + "lib/python3.10/lib2to3/tests/data/py2_test_grammar.py", + "lib/python3.10/lib2to3/tests/data/py3_test_grammar.py", + "lib/python3.10/lib2to3/tests/pytree_idempotency.py", + "lib/python3.10/lib2to3/tests/support.py", + "lib/python3.10/lib2to3/tests/test_all_fixers.py", + "lib/python3.10/lib2to3/tests/test_fixers.py", + "lib/python3.10/lib2to3/tests/test_main.py", + "lib/python3.10/lib2to3/tests/test_parser.py", + "lib/python3.10/lib2to3/tests/test_pytree.py", + "lib/python3.10/lib2to3/tests/test_refactor.py", + "lib/python3.10/lib2to3/tests/test_util.py", + "lib/python3.10/linecache.py", + "lib/python3.10/locale.py", + "lib/python3.10/logging/__init__.py", + "lib/python3.10/logging/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/logging/__pycache__/config.cpython-310.pyc", + "lib/python3.10/logging/__pycache__/handlers.cpython-310.pyc", + "lib/python3.10/logging/config.py", + "lib/python3.10/logging/handlers.py", + "lib/python3.10/lzma.py", + "lib/python3.10/mailbox.py", + "lib/python3.10/mailcap.py", + "lib/python3.10/mimetypes.py", + "lib/python3.10/modulefinder.py", + "lib/python3.10/multiprocessing/__init__.py", + "lib/python3.10/multiprocessing/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/multiprocessing/__pycache__/connection.cpython-310.pyc", + "lib/python3.10/multiprocessing/__pycache__/context.cpython-310.pyc", + "lib/python3.10/multiprocessing/__pycache__/forkserver.cpython-310.pyc", + "lib/python3.10/multiprocessing/__pycache__/heap.cpython-310.pyc", + "lib/python3.10/multiprocessing/__pycache__/managers.cpython-310.pyc", + "lib/python3.10/multiprocessing/__pycache__/pool.cpython-310.pyc", + "lib/python3.10/multiprocessing/__pycache__/popen_fork.cpython-310.pyc", + "lib/python3.10/multiprocessing/__pycache__/popen_forkserver.cpython-310.pyc", + "lib/python3.10/multiprocessing/__pycache__/popen_spawn_posix.cpython-310.pyc", + "lib/python3.10/multiprocessing/__pycache__/popen_spawn_win32.cpython-310.pyc", + "lib/python3.10/multiprocessing/__pycache__/process.cpython-310.pyc", + "lib/python3.10/multiprocessing/__pycache__/queues.cpython-310.pyc", + "lib/python3.10/multiprocessing/__pycache__/reduction.cpython-310.pyc", + "lib/python3.10/multiprocessing/__pycache__/resource_sharer.cpython-310.pyc", + "lib/python3.10/multiprocessing/__pycache__/resource_tracker.cpython-310.pyc", + "lib/python3.10/multiprocessing/__pycache__/shared_memory.cpython-310.pyc", + "lib/python3.10/multiprocessing/__pycache__/sharedctypes.cpython-310.pyc", + "lib/python3.10/multiprocessing/__pycache__/spawn.cpython-310.pyc", + "lib/python3.10/multiprocessing/__pycache__/synchronize.cpython-310.pyc", + "lib/python3.10/multiprocessing/__pycache__/util.cpython-310.pyc", + "lib/python3.10/multiprocessing/connection.py", + "lib/python3.10/multiprocessing/context.py", + "lib/python3.10/multiprocessing/dummy/__init__.py", + "lib/python3.10/multiprocessing/dummy/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/multiprocessing/dummy/__pycache__/connection.cpython-310.pyc", + "lib/python3.10/multiprocessing/dummy/connection.py", + "lib/python3.10/multiprocessing/forkserver.py", + "lib/python3.10/multiprocessing/heap.py", + "lib/python3.10/multiprocessing/managers.py", + "lib/python3.10/multiprocessing/pool.py", + "lib/python3.10/multiprocessing/popen_fork.py", + "lib/python3.10/multiprocessing/popen_forkserver.py", + "lib/python3.10/multiprocessing/popen_spawn_posix.py", + "lib/python3.10/multiprocessing/popen_spawn_win32.py", + "lib/python3.10/multiprocessing/process.py", + "lib/python3.10/multiprocessing/queues.py", + "lib/python3.10/multiprocessing/reduction.py", + "lib/python3.10/multiprocessing/resource_sharer.py", + "lib/python3.10/multiprocessing/resource_tracker.py", + "lib/python3.10/multiprocessing/shared_memory.py", + "lib/python3.10/multiprocessing/sharedctypes.py", + "lib/python3.10/multiprocessing/spawn.py", + "lib/python3.10/multiprocessing/synchronize.py", + "lib/python3.10/multiprocessing/util.py", + "lib/python3.10/netrc.py", + "lib/python3.10/nntplib.py", + "lib/python3.10/ntpath.py", + "lib/python3.10/nturl2path.py", + "lib/python3.10/numbers.py", + "lib/python3.10/opcode.py", + "lib/python3.10/operator.py", + "lib/python3.10/optparse.py", + "lib/python3.10/os.py", + "lib/python3.10/pathlib.py", + "lib/python3.10/pdb.py", + "lib/python3.10/pickle.py", + "lib/python3.10/pickletools.py", + "lib/python3.10/pipes.py", + "lib/python3.10/pkgutil.py", + "lib/python3.10/platform.py", + "lib/python3.10/plistlib.py", + "lib/python3.10/poplib.py", + "lib/python3.10/posixpath.py", + "lib/python3.10/pprint.py", + "lib/python3.10/profile.py", + "lib/python3.10/pstats.py", + "lib/python3.10/pty.py", + "lib/python3.10/py_compile.py", + "lib/python3.10/pyclbr.py", + "lib/python3.10/pydoc.py", + "lib/python3.10/pydoc_data/__init__.py", + "lib/python3.10/pydoc_data/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/pydoc_data/__pycache__/topics.cpython-310.pyc", + "lib/python3.10/pydoc_data/_pydoc.css", + "lib/python3.10/pydoc_data/topics.py", + "lib/python3.10/queue.py", + "lib/python3.10/quopri.py", + "lib/python3.10/random.py", + "lib/python3.10/re.py", + "lib/python3.10/reprlib.py", + "lib/python3.10/rlcompleter.py", + "lib/python3.10/runpy.py", + "lib/python3.10/sched.py", + "lib/python3.10/secrets.py", + "lib/python3.10/selectors.py", + "lib/python3.10/shelve.py", + "lib/python3.10/shlex.py", + "lib/python3.10/shutil.py", + "lib/python3.10/signal.py", + "lib/python3.10/site-packages/README.txt", + "lib/python3.10/site.py", + "lib/python3.10/smtpd.py", + "lib/python3.10/smtplib.py", + "lib/python3.10/sndhdr.py", + "lib/python3.10/socket.py", + "lib/python3.10/socketserver.py", + "lib/python3.10/sqlite3/__init__.py", + "lib/python3.10/sqlite3/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/sqlite3/__pycache__/dbapi2.cpython-310.pyc", + "lib/python3.10/sqlite3/__pycache__/dump.cpython-310.pyc", + "lib/python3.10/sqlite3/dbapi2.py", + "lib/python3.10/sqlite3/dump.py", + "lib/python3.10/sre_compile.py", + "lib/python3.10/sre_constants.py", + "lib/python3.10/sre_parse.py", + "lib/python3.10/ssl.py", + "lib/python3.10/stat.py", + "lib/python3.10/statistics.py", + "lib/python3.10/string.py", + "lib/python3.10/stringprep.py", + "lib/python3.10/struct.py", + "lib/python3.10/subprocess.py", + "lib/python3.10/sunau.py", + "lib/python3.10/symtable.py", + "lib/python3.10/sysconfig.py", + "lib/python3.10/tabnanny.py", + "lib/python3.10/tarfile.py", + "lib/python3.10/telnetlib.py", + "lib/python3.10/tempfile.py", + "lib/python3.10/test/__init__.py", + "lib/python3.10/test/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/test/__pycache__/test_script_helper.cpython-310.pyc", + "lib/python3.10/test/__pycache__/test_support.cpython-310.pyc", + "lib/python3.10/test/support/__init__.py", + "lib/python3.10/test/support/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/test/support/__pycache__/bytecode_helper.cpython-310.pyc", + "lib/python3.10/test/support/__pycache__/hashlib_helper.cpython-310.pyc", + "lib/python3.10/test/support/__pycache__/import_helper.cpython-310.pyc", + "lib/python3.10/test/support/__pycache__/interpreters.cpython-310.pyc", + "lib/python3.10/test/support/__pycache__/logging_helper.cpython-310.pyc", + "lib/python3.10/test/support/__pycache__/os_helper.cpython-310.pyc", + "lib/python3.10/test/support/__pycache__/script_helper.cpython-310.pyc", + "lib/python3.10/test/support/__pycache__/socket_helper.cpython-310.pyc", + "lib/python3.10/test/support/__pycache__/testresult.cpython-310.pyc", + "lib/python3.10/test/support/__pycache__/threading_helper.cpython-310.pyc", + "lib/python3.10/test/support/__pycache__/warnings_helper.cpython-310.pyc", + "lib/python3.10/test/support/bytecode_helper.py", + "lib/python3.10/test/support/hashlib_helper.py", + "lib/python3.10/test/support/import_helper.py", + "lib/python3.10/test/support/interpreters.py", + "lib/python3.10/test/support/logging_helper.py", + "lib/python3.10/test/support/os_helper.py", + "lib/python3.10/test/support/script_helper.py", + "lib/python3.10/test/support/socket_helper.py", + "lib/python3.10/test/support/testresult.py", + "lib/python3.10/test/support/threading_helper.py", + "lib/python3.10/test/support/warnings_helper.py", + "lib/python3.10/test/test_script_helper.py", + "lib/python3.10/test/test_support.py", + "lib/python3.10/textwrap.py", + "lib/python3.10/this.py", + "lib/python3.10/threading.py", + "lib/python3.10/timeit.py", + "lib/python3.10/tkinter/__init__.py", + "lib/python3.10/tkinter/__main__.py", + "lib/python3.10/tkinter/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/tkinter/__pycache__/__main__.cpython-310.pyc", + "lib/python3.10/tkinter/__pycache__/colorchooser.cpython-310.pyc", + "lib/python3.10/tkinter/__pycache__/commondialog.cpython-310.pyc", + "lib/python3.10/tkinter/__pycache__/constants.cpython-310.pyc", + "lib/python3.10/tkinter/__pycache__/dialog.cpython-310.pyc", + "lib/python3.10/tkinter/__pycache__/dnd.cpython-310.pyc", + "lib/python3.10/tkinter/__pycache__/filedialog.cpython-310.pyc", + "lib/python3.10/tkinter/__pycache__/font.cpython-310.pyc", + "lib/python3.10/tkinter/__pycache__/messagebox.cpython-310.pyc", + "lib/python3.10/tkinter/__pycache__/scrolledtext.cpython-310.pyc", + "lib/python3.10/tkinter/__pycache__/simpledialog.cpython-310.pyc", + "lib/python3.10/tkinter/__pycache__/tix.cpython-310.pyc", + "lib/python3.10/tkinter/__pycache__/ttk.cpython-310.pyc", + "lib/python3.10/tkinter/colorchooser.py", + "lib/python3.10/tkinter/commondialog.py", + "lib/python3.10/tkinter/constants.py", + "lib/python3.10/tkinter/dialog.py", + "lib/python3.10/tkinter/dnd.py", + "lib/python3.10/tkinter/filedialog.py", + "lib/python3.10/tkinter/font.py", + "lib/python3.10/tkinter/messagebox.py", + "lib/python3.10/tkinter/scrolledtext.py", + "lib/python3.10/tkinter/simpledialog.py", + "lib/python3.10/tkinter/tix.py", + "lib/python3.10/tkinter/ttk.py", + "lib/python3.10/token.py", + "lib/python3.10/tokenize.py", + "lib/python3.10/trace.py", + "lib/python3.10/traceback.py", + "lib/python3.10/tracemalloc.py", + "lib/python3.10/tty.py", + "lib/python3.10/turtle.py", + "lib/python3.10/turtledemo/__init__.py", + "lib/python3.10/turtledemo/__main__.py", + "lib/python3.10/turtledemo/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/turtledemo/__pycache__/__main__.cpython-310.pyc", + "lib/python3.10/turtledemo/__pycache__/bytedesign.cpython-310.pyc", + "lib/python3.10/turtledemo/__pycache__/chaos.cpython-310.pyc", + "lib/python3.10/turtledemo/__pycache__/clock.cpython-310.pyc", + "lib/python3.10/turtledemo/__pycache__/colormixer.cpython-310.pyc", + "lib/python3.10/turtledemo/__pycache__/forest.cpython-310.pyc", + "lib/python3.10/turtledemo/__pycache__/fractalcurves.cpython-310.pyc", + "lib/python3.10/turtledemo/__pycache__/lindenmayer.cpython-310.pyc", + "lib/python3.10/turtledemo/__pycache__/minimal_hanoi.cpython-310.pyc", + "lib/python3.10/turtledemo/__pycache__/nim.cpython-310.pyc", + "lib/python3.10/turtledemo/__pycache__/paint.cpython-310.pyc", + "lib/python3.10/turtledemo/__pycache__/peace.cpython-310.pyc", + "lib/python3.10/turtledemo/__pycache__/penrose.cpython-310.pyc", + "lib/python3.10/turtledemo/__pycache__/planet_and_moon.cpython-310.pyc", + "lib/python3.10/turtledemo/__pycache__/rosette.cpython-310.pyc", + "lib/python3.10/turtledemo/__pycache__/round_dance.cpython-310.pyc", + "lib/python3.10/turtledemo/__pycache__/sorting_animate.cpython-310.pyc", + "lib/python3.10/turtledemo/__pycache__/tree.cpython-310.pyc", + "lib/python3.10/turtledemo/__pycache__/two_canvases.cpython-310.pyc", + "lib/python3.10/turtledemo/__pycache__/yinyang.cpython-310.pyc", + "lib/python3.10/turtledemo/bytedesign.py", + "lib/python3.10/turtledemo/chaos.py", + "lib/python3.10/turtledemo/clock.py", + "lib/python3.10/turtledemo/colormixer.py", + "lib/python3.10/turtledemo/forest.py", + "lib/python3.10/turtledemo/fractalcurves.py", + "lib/python3.10/turtledemo/lindenmayer.py", + "lib/python3.10/turtledemo/minimal_hanoi.py", + "lib/python3.10/turtledemo/nim.py", + "lib/python3.10/turtledemo/paint.py", + "lib/python3.10/turtledemo/peace.py", + "lib/python3.10/turtledemo/penrose.py", + "lib/python3.10/turtledemo/planet_and_moon.py", + "lib/python3.10/turtledemo/rosette.py", + "lib/python3.10/turtledemo/round_dance.py", + "lib/python3.10/turtledemo/sorting_animate.py", + "lib/python3.10/turtledemo/tree.py", + "lib/python3.10/turtledemo/turtle.cfg", + "lib/python3.10/turtledemo/two_canvases.py", + "lib/python3.10/turtledemo/yinyang.py", + "lib/python3.10/types.py", + "lib/python3.10/typing.py", + "lib/python3.10/unittest/__init__.py", + "lib/python3.10/unittest/__main__.py", + "lib/python3.10/unittest/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/unittest/__pycache__/__main__.cpython-310.pyc", + "lib/python3.10/unittest/__pycache__/_log.cpython-310.pyc", + "lib/python3.10/unittest/__pycache__/async_case.cpython-310.pyc", + "lib/python3.10/unittest/__pycache__/case.cpython-310.pyc", + "lib/python3.10/unittest/__pycache__/loader.cpython-310.pyc", + "lib/python3.10/unittest/__pycache__/main.cpython-310.pyc", + "lib/python3.10/unittest/__pycache__/mock.cpython-310.pyc", + "lib/python3.10/unittest/__pycache__/result.cpython-310.pyc", + "lib/python3.10/unittest/__pycache__/runner.cpython-310.pyc", + "lib/python3.10/unittest/__pycache__/signals.cpython-310.pyc", + "lib/python3.10/unittest/__pycache__/suite.cpython-310.pyc", + "lib/python3.10/unittest/__pycache__/util.cpython-310.pyc", + "lib/python3.10/unittest/_log.py", + "lib/python3.10/unittest/async_case.py", + "lib/python3.10/unittest/case.py", + "lib/python3.10/unittest/loader.py", + "lib/python3.10/unittest/main.py", + "lib/python3.10/unittest/mock.py", + "lib/python3.10/unittest/result.py", + "lib/python3.10/unittest/runner.py", + "lib/python3.10/unittest/signals.py", + "lib/python3.10/unittest/suite.py", + "lib/python3.10/unittest/util.py", + "lib/python3.10/urllib/__init__.py", + "lib/python3.10/urllib/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/urllib/__pycache__/error.cpython-310.pyc", + "lib/python3.10/urllib/__pycache__/parse.cpython-310.pyc", + "lib/python3.10/urllib/__pycache__/request.cpython-310.pyc", + "lib/python3.10/urllib/__pycache__/response.cpython-310.pyc", + "lib/python3.10/urllib/__pycache__/robotparser.cpython-310.pyc", + "lib/python3.10/urllib/error.py", + "lib/python3.10/urllib/parse.py", + "lib/python3.10/urllib/request.py", + "lib/python3.10/urllib/response.py", + "lib/python3.10/urllib/robotparser.py", + "lib/python3.10/uu.py", + "lib/python3.10/uuid.py", + "lib/python3.10/venv/__init__.py", + "lib/python3.10/venv/__main__.py", + "lib/python3.10/venv/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/venv/__pycache__/__main__.cpython-310.pyc", + "lib/python3.10/venv/scripts/common/Activate.ps1", + "lib/python3.10/venv/scripts/common/activate", + "lib/python3.10/venv/scripts/posix/activate.csh", + "lib/python3.10/venv/scripts/posix/activate.fish", + "lib/python3.10/warnings.py", + "lib/python3.10/wave.py", + "lib/python3.10/weakref.py", + "lib/python3.10/webbrowser.py", + "lib/python3.10/wsgiref/__init__.py", + "lib/python3.10/wsgiref/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/wsgiref/__pycache__/handlers.cpython-310.pyc", + "lib/python3.10/wsgiref/__pycache__/headers.cpython-310.pyc", + "lib/python3.10/wsgiref/__pycache__/simple_server.cpython-310.pyc", + "lib/python3.10/wsgiref/__pycache__/util.cpython-310.pyc", + "lib/python3.10/wsgiref/__pycache__/validate.cpython-310.pyc", + "lib/python3.10/wsgiref/handlers.py", + "lib/python3.10/wsgiref/headers.py", + "lib/python3.10/wsgiref/simple_server.py", + "lib/python3.10/wsgiref/util.py", + "lib/python3.10/wsgiref/validate.py", + "lib/python3.10/xdrlib.py", + "lib/python3.10/xml/__init__.py", + "lib/python3.10/xml/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/xml/dom/NodeFilter.py", + "lib/python3.10/xml/dom/__init__.py", + "lib/python3.10/xml/dom/__pycache__/NodeFilter.cpython-310.pyc", + "lib/python3.10/xml/dom/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/xml/dom/__pycache__/domreg.cpython-310.pyc", + "lib/python3.10/xml/dom/__pycache__/expatbuilder.cpython-310.pyc", + "lib/python3.10/xml/dom/__pycache__/minicompat.cpython-310.pyc", + "lib/python3.10/xml/dom/__pycache__/minidom.cpython-310.pyc", + "lib/python3.10/xml/dom/__pycache__/pulldom.cpython-310.pyc", + "lib/python3.10/xml/dom/__pycache__/xmlbuilder.cpython-310.pyc", + "lib/python3.10/xml/dom/domreg.py", + "lib/python3.10/xml/dom/expatbuilder.py", + "lib/python3.10/xml/dom/minicompat.py", + "lib/python3.10/xml/dom/minidom.py", + "lib/python3.10/xml/dom/pulldom.py", + "lib/python3.10/xml/dom/xmlbuilder.py", + "lib/python3.10/xml/etree/ElementInclude.py", + "lib/python3.10/xml/etree/ElementPath.py", + "lib/python3.10/xml/etree/ElementTree.py", + "lib/python3.10/xml/etree/__init__.py", + "lib/python3.10/xml/etree/__pycache__/ElementInclude.cpython-310.pyc", + "lib/python3.10/xml/etree/__pycache__/ElementPath.cpython-310.pyc", + "lib/python3.10/xml/etree/__pycache__/ElementTree.cpython-310.pyc", + "lib/python3.10/xml/etree/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/xml/etree/__pycache__/cElementTree.cpython-310.pyc", + "lib/python3.10/xml/etree/cElementTree.py", + "lib/python3.10/xml/parsers/__init__.py", + "lib/python3.10/xml/parsers/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/xml/parsers/__pycache__/expat.cpython-310.pyc", + "lib/python3.10/xml/parsers/expat.py", + "lib/python3.10/xml/sax/__init__.py", + "lib/python3.10/xml/sax/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/xml/sax/__pycache__/_exceptions.cpython-310.pyc", + "lib/python3.10/xml/sax/__pycache__/expatreader.cpython-310.pyc", + "lib/python3.10/xml/sax/__pycache__/handler.cpython-310.pyc", + "lib/python3.10/xml/sax/__pycache__/saxutils.cpython-310.pyc", + "lib/python3.10/xml/sax/__pycache__/xmlreader.cpython-310.pyc", + "lib/python3.10/xml/sax/_exceptions.py", + "lib/python3.10/xml/sax/expatreader.py", + "lib/python3.10/xml/sax/handler.py", + "lib/python3.10/xml/sax/saxutils.py", + "lib/python3.10/xml/sax/xmlreader.py", + "lib/python3.10/xmlrpc/__init__.py", + "lib/python3.10/xmlrpc/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/xmlrpc/__pycache__/client.cpython-310.pyc", + "lib/python3.10/xmlrpc/__pycache__/server.cpython-310.pyc", + "lib/python3.10/xmlrpc/client.py", + "lib/python3.10/xmlrpc/server.py", + "lib/python3.10/zipapp.py", + "lib/python3.10/zipfile.py", + "lib/python3.10/zipimport.py", + "lib/python3.10/zoneinfo/__init__.py", + "lib/python3.10/zoneinfo/__pycache__/__init__.cpython-310.pyc", + "lib/python3.10/zoneinfo/__pycache__/_common.cpython-310.pyc", + "lib/python3.10/zoneinfo/__pycache__/_tzpath.cpython-310.pyc", + "lib/python3.10/zoneinfo/__pycache__/_zoneinfo.cpython-310.pyc", + "lib/python3.10/zoneinfo/_common.py", + "lib/python3.10/zoneinfo/_tzpath.py", + "lib/python3.10/zoneinfo/_zoneinfo.py", + "share/man/man1/python3.1", + "share/man/man1/python3.10.1" + ], + "fn": "python-3.10.14-hb885b13_1.conda", + "license": "PSF-2.0", + "link": { + "source": "/Users/donjayamanne/.pyenv/versions/miniconda3-latest/pkgs/python-3.10.14-hb885b13_1", + "type": 1 + }, + "md5": "e588c2babb9f2bbfe336b1fc6239efd2", + "name": "python", + "package_tarball_full_path": "/Users/donjayamanne/.pyenv/versions/miniconda3-latest/pkgs/python-3.10.14-hb885b13_1.conda", + "paths_data": { + "paths": [ + { + "_path": "bin/2to3", + "path_type": "softlink", + "sha256": "63e3bc71edf1069d553dd65b9656a3af72dacc18d3879816c0d7ca56c7a99e5a", + "size_in_bytes": 347 + }, + { + "_path": "bin/2to3-3.10", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_9afkyeq1z4/croot/python-split_1715024112201/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_p", + "sha256": "63e3bc71edf1069d553dd65b9656a3af72dacc18d3879816c0d7ca56c7a99e5a", + "sha256_in_prefix": "07381dde907f3702d27b53f026da059884b24ceabfa7bd6df8295ba186bb2e32", + "size_in_bytes": 347 + }, + { + "_path": "bin/idle3", + "path_type": "softlink", + "sha256": "4c06b6d6230a1bebb604eeb1d53abdc8124ec9780c8ee1a824a36837c31ca764", + "size_in_bytes": 345 + }, + { + "_path": "bin/idle3.10", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_9afkyeq1z4/croot/python-split_1715024112201/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_p", + "sha256": "4c06b6d6230a1bebb604eeb1d53abdc8124ec9780c8ee1a824a36837c31ca764", + "sha256_in_prefix": "0c25c701aaf24084bfdaf6f6963e600ebf93d5a7c3a12972ddf1363e3c326441", + "size_in_bytes": 345 + }, + { + "_path": "bin/pydoc", + "path_type": "softlink", + "sha256": "5be6fb185a727d55053317514cb6e16d7d1f728f1424d3aaedac38f89a51c48f", + "size_in_bytes": 330 + }, + { + "_path": "bin/pydoc3", + "path_type": "softlink", + "sha256": "5be6fb185a727d55053317514cb6e16d7d1f728f1424d3aaedac38f89a51c48f", + "size_in_bytes": 330 + }, + { + "_path": "bin/pydoc3.10", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_9afkyeq1z4/croot/python-split_1715024112201/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_p", + "sha256": "5be6fb185a727d55053317514cb6e16d7d1f728f1424d3aaedac38f89a51c48f", + "sha256_in_prefix": "ce63e8c738443dab28a303b1df78d38adee9c38732f55cd3d83307bfbcf832ce", + "size_in_bytes": 330 + }, + { + "_path": "bin/python", + "path_type": "softlink", + "sha256": "6eff3c533c756370bcc64c57d09e25eefc7b7f5a39049db10a8f31c9e1010f5b", + "size_in_bytes": 3864080 + }, + { + "_path": "bin/python3", + "path_type": "softlink", + "sha256": "6eff3c533c756370bcc64c57d09e25eefc7b7f5a39049db10a8f31c9e1010f5b", + "size_in_bytes": 3864080 + }, + { + "_path": "bin/python3-config", + "path_type": "softlink", + "sha256": "c707b82a8c5cc53054769d40dc72386fd3d7ac3cf1719e5721b85e680eecb6ba", + "size_in_bytes": 2289 + }, + { + "_path": "bin/python3.1", + "path_type": "softlink", + "sha256": "6eff3c533c756370bcc64c57d09e25eefc7b7f5a39049db10a8f31c9e1010f5b", + "size_in_bytes": 3864080 + }, + { + "_path": "bin/python3.10", + "file_mode": "binary", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_9afkyeq1z4/croot/python-split_1715024112201/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_p", + "sha256": "6eff3c533c756370bcc64c57d09e25eefc7b7f5a39049db10a8f31c9e1010f5b", + "sha256_in_prefix": "4b8330e350f6a45c0fdb0cd473b566938db4fd7f9475613bb37d7578eaa21846", + "size_in_bytes": 3864080 + }, + { + "_path": "bin/python3.10-config", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_9afkyeq1z4/croot/python-split_1715024112201/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_p", + "sha256": "c707b82a8c5cc53054769d40dc72386fd3d7ac3cf1719e5721b85e680eecb6ba", + "sha256_in_prefix": "bf233aab74afc434e8cbbe86c64a58e9124b3cd2ed328404db9fd808b9f4155a", + "size_in_bytes": 2289 + }, + { + "_path": "include/python3.10/Python.h", + "path_type": "hardlink", + "sha256": "70b04c40833bdfcdd72b0d3771afe67c74340ff2683b7d26b0dc8e95289263a7", + "sha256_in_prefix": "70b04c40833bdfcdd72b0d3771afe67c74340ff2683b7d26b0dc8e95289263a7", + "size_in_bytes": 3224 + }, + { + "_path": "include/python3.10/abstract.h", + "path_type": "hardlink", + "sha256": "8fa291e5ece081b3cbf643fc451f3fc9620571d98471413fca29aeb38ed8b721", + "sha256_in_prefix": "8fa291e5ece081b3cbf643fc451f3fc9620571d98471413fca29aeb38ed8b721", + "size_in_bytes": 31405 + }, + { + "_path": "include/python3.10/bltinmodule.h", + "path_type": "hardlink", + "sha256": "1b5101b4b85409fd910032713906800bbb83580503036469c2a60ac8e80b8f72", + "sha256_in_prefix": "1b5101b4b85409fd910032713906800bbb83580503036469c2a60ac8e80b8f72", + "size_in_bytes": 264 + }, + { + "_path": "include/python3.10/boolobject.h", + "path_type": "hardlink", + "sha256": "3b042a5d69f1eb92648007a1b988490a7a9177c8ac353aad05d786356a313a9f", + "sha256_in_prefix": "3b042a5d69f1eb92648007a1b988490a7a9177c8ac353aad05d786356a313a9f", + "size_in_bytes": 1224 + }, + { + "_path": "include/python3.10/bytearrayobject.h", + "path_type": "hardlink", + "sha256": "a6f332edc796f35283c9ea75bc59b525c82be52129cea32e3371974de08d6ee1", + "sha256_in_prefix": "a6f332edc796f35283c9ea75bc59b525c82be52129cea32e3371974de08d6ee1", + "size_in_bytes": 1484 + }, + { + "_path": "include/python3.10/bytesobject.h", + "path_type": "hardlink", + "sha256": "bd8631c90c3726af7c24380026abc169f76404e14962221a3b53b194e076b504", + "sha256_in_prefix": "bd8631c90c3726af7c24380026abc169f76404e14962221a3b53b194e076b504", + "size_in_bytes": 2593 + }, + { + "_path": "include/python3.10/cellobject.h", + "path_type": "hardlink", + "sha256": "6a68c1f0d44d668f8080e409d174763cfe75ae11f8c4c667b8e8749a5ae0425d", + "sha256_in_prefix": "6a68c1f0d44d668f8080e409d174763cfe75ae11f8c4c667b8e8749a5ae0425d", + "size_in_bytes": 720 + }, + { + "_path": "include/python3.10/ceval.h", + "path_type": "hardlink", + "sha256": "ea78be9d45a17b75b1dd89b6661300a726dc41bce140d63d03bb4e2b44ae564a", + "sha256_in_prefix": "ea78be9d45a17b75b1dd89b6661300a726dc41bce140d63d03bb4e2b44ae564a", + "size_in_bytes": 5703 + }, + { + "_path": "include/python3.10/classobject.h", + "path_type": "hardlink", + "sha256": "0a644a89790992499ad174d492c8d29778d95966498ee569ad8c6d90da54c054", + "sha256_in_prefix": "0a644a89790992499ad174d492c8d29778d95966498ee569ad8c6d90da54c054", + "size_in_bytes": 1657 + }, + { + "_path": "include/python3.10/code.h", + "path_type": "hardlink", + "sha256": "de21eeb3ae7f1314e296727bd6db61cfe496e177a230ed75071e7af5b02d88b5", + "sha256_in_prefix": "de21eeb3ae7f1314e296727bd6db61cfe496e177a230ed75071e7af5b02d88b5", + "size_in_bytes": 318 + }, + { + "_path": "include/python3.10/codecs.h", + "path_type": "hardlink", + "sha256": "0ca3c6e55e7ff62872b47aeeb7379d784b03ebfc61bbd029b67485fe783baac5", + "sha256_in_prefix": "0ca3c6e55e7ff62872b47aeeb7379d784b03ebfc61bbd029b67485fe783baac5", + "size_in_bytes": 7071 + }, + { + "_path": "include/python3.10/compile.h", + "path_type": "hardlink", + "sha256": "28676e6ff63848c7e812c34bb79cd81dfccbc0a9ffc56d5b1439b304df3771ea", + "sha256_in_prefix": "28676e6ff63848c7e812c34bb79cd81dfccbc0a9ffc56d5b1439b304df3771ea", + "size_in_bytes": 520 + }, + { + "_path": "include/python3.10/complexobject.h", + "path_type": "hardlink", + "sha256": "7c224e629e3d2576ccbf045773863dcbef566f89b78d2a78e61418cae9c282cc", + "sha256_in_prefix": "7c224e629e3d2576ccbf045773863dcbef566f89b78d2a78e61418cae9c282cc", + "size_in_bytes": 1806 + }, + { + "_path": "include/python3.10/context.h", + "path_type": "hardlink", + "sha256": "012ef77a9683a015e68728c4f43014921a04db0626c1dc9fbcc48a87d4e1012f", + "sha256_in_prefix": "012ef77a9683a015e68728c4f43014921a04db0626c1dc9fbcc48a87d4e1012f", + "size_in_bytes": 1962 + }, + { + "_path": "include/python3.10/cpython/abstract.h", + "path_type": "hardlink", + "sha256": "b13d64198e99f84bea5012b9231b775a806c33a58e9e41f8d4ae18c1f75807b4", + "sha256_in_prefix": "b13d64198e99f84bea5012b9231b775a806c33a58e9e41f8d4ae18c1f75807b4", + "size_in_bytes": 14054 + }, + { + "_path": "include/python3.10/cpython/bytearrayobject.h", + "path_type": "hardlink", + "sha256": "6c0ff5534ded2fb01ade071fad06e1561ea3ecb55970c4a79b86fd471fa9bd71", + "sha256_in_prefix": "6c0ff5534ded2fb01ade071fad06e1561ea3ecb55970c4a79b86fd471fa9bd71", + "size_in_bytes": 769 + }, + { + "_path": "include/python3.10/cpython/bytesobject.h", + "path_type": "hardlink", + "sha256": "4d11542b30bc0192c2da85de501abce1efc420792595f8186b6b637f9d640f81", + "sha256_in_prefix": "4d11542b30bc0192c2da85de501abce1efc420792595f8186b6b637f9d640f81", + "size_in_bytes": 4119 + }, + { + "_path": "include/python3.10/cpython/ceval.h", + "path_type": "hardlink", + "sha256": "44ad300f734116a2d7a454f762155f20e3d15e92f4ae7ca58f6f7a43b01a7af2", + "sha256_in_prefix": "44ad300f734116a2d7a454f762155f20e3d15e92f4ae7ca58f6f7a43b01a7af2", + "size_in_bytes": 1468 + }, + { + "_path": "include/python3.10/cpython/code.h", + "path_type": "hardlink", + "sha256": "6a1c95f95b2c6bfc764d4331f65455d2b369176eed6e9a1b9164a3d0a2ccee68", + "sha256_in_prefix": "6a1c95f95b2c6bfc764d4331f65455d2b369176eed6e9a1b9164a3d0a2ccee68", + "size_in_bytes": 7570 + }, + { + "_path": "include/python3.10/cpython/compile.h", + "path_type": "hardlink", + "sha256": "87cc83e0e8b89cb0db751222e8104ce05ae694e90affc82c46a78a1f33b59560", + "sha256_in_prefix": "87cc83e0e8b89cb0db751222e8104ce05ae694e90affc82c46a78a1f33b59560", + "size_in_bytes": 2218 + }, + { + "_path": "include/python3.10/cpython/dictobject.h", + "path_type": "hardlink", + "sha256": "4a518731894c42e68002f9e8684a8f28922a1f5aec691c8b3c26b0559bee46a7", + "sha256_in_prefix": "4a518731894c42e68002f9e8684a8f28922a1f5aec691c8b3c26b0559bee46a7", + "size_in_bytes": 3734 + }, + { + "_path": "include/python3.10/cpython/fileobject.h", + "path_type": "hardlink", + "sha256": "fd6bc941073264fcfd5d4447247f2f2cd160faa67df665ec87259773134270be", + "sha256_in_prefix": "fd6bc941073264fcfd5d4447247f2f2cd160faa67df665ec87259773134270be", + "size_in_bytes": 723 + }, + { + "_path": "include/python3.10/cpython/fileutils.h", + "path_type": "hardlink", + "sha256": "4e7f87aadde1de522a6572ed40e7e43403874499f583320d6d96152e032cf15a", + "sha256_in_prefix": "4e7f87aadde1de522a6572ed40e7e43403874499f583320d6d96152e032cf15a", + "size_in_bytes": 4267 + }, + { + "_path": "include/python3.10/cpython/frameobject.h", + "path_type": "hardlink", + "sha256": "57c0eeeea52ec1239c04b963e1c87d37f83300c17f399f90085d980d9250a0d4", + "sha256_in_prefix": "57c0eeeea52ec1239c04b963e1c87d37f83300c17f399f90085d980d9250a0d4", + "size_in_bytes": 3152 + }, + { + "_path": "include/python3.10/cpython/import.h", + "path_type": "hardlink", + "sha256": "dc0e0f96bdde8dfbc5549cabc219a37268e86f6289e254acc349be220260bc28", + "sha256_in_prefix": "dc0e0f96bdde8dfbc5549cabc219a37268e86f6289e254acc349be220260bc28", + "size_in_bytes": 1630 + }, + { + "_path": "include/python3.10/cpython/initconfig.h", + "path_type": "hardlink", + "sha256": "0f13f74ceb46d3259d8ebdd0be61cfe8d050882fc03fd482b2642a0c81f7cada", + "sha256_in_prefix": "0f13f74ceb46d3259d8ebdd0be61cfe8d050882fc03fd482b2642a0c81f7cada", + "size_in_bytes": 7597 + }, + { + "_path": "include/python3.10/cpython/interpreteridobject.h", + "path_type": "hardlink", + "sha256": "8fc79784d556245d7b7f382063ef3797e3aebd0a6b375a95027dd63a5dfa30b6", + "sha256_in_prefix": "8fc79784d556245d7b7f382063ef3797e3aebd0a6b375a95027dd63a5dfa30b6", + "size_in_bytes": 387 + }, + { + "_path": "include/python3.10/cpython/listobject.h", + "path_type": "hardlink", + "sha256": "54a8c329c95c5ff936284e789c9bdbb8a023d325a4b49290b25f156b4bf4fd5a", + "sha256_in_prefix": "54a8c329c95c5ff936284e789c9bdbb8a023d325a4b49290b25f156b4bf4fd5a", + "size_in_bytes": 1243 + }, + { + "_path": "include/python3.10/cpython/methodobject.h", + "path_type": "hardlink", + "sha256": "d0356e04561a145b08aeb5c457d69443fd43875415844cba57aae3f5ec77c6be", + "sha256_in_prefix": "d0356e04561a145b08aeb5c457d69443fd43875415844cba57aae3f5ec77c6be", + "size_in_bytes": 1399 + }, + { + "_path": "include/python3.10/cpython/object.h", + "path_type": "hardlink", + "sha256": "62dc9ee480a1688a64b46458ba6d5752946a41c8c98c5e91c646f751ab06a59d", + "sha256_in_prefix": "62dc9ee480a1688a64b46458ba6d5752946a41c8c98c5e91c646f751ab06a59d", + "size_in_bytes": 19613 + }, + { + "_path": "include/python3.10/cpython/objimpl.h", + "path_type": "hardlink", + "sha256": "a9cb586f7d01b430c267f54c3c31a3ab0c35682f01409a366a4b1fd15d3844a2", + "sha256_in_prefix": "a9cb586f7d01b430c267f54c3c31a3ab0c35682f01409a366a4b1fd15d3844a2", + "size_in_bytes": 3356 + }, + { + "_path": "include/python3.10/cpython/odictobject.h", + "path_type": "hardlink", + "sha256": "ff2b0d77aea871c1edd6f63209489fe70c7c11d4da9c3e2f6ef6858cdb004a0d", + "sha256_in_prefix": "ff2b0d77aea871c1edd6f63209489fe70c7c11d4da9c3e2f6ef6858cdb004a0d", + "size_in_bytes": 1299 + }, + { + "_path": "include/python3.10/cpython/picklebufobject.h", + "path_type": "hardlink", + "sha256": "da3dd5626150aa4e00a4a0199baa582b4db9b9362412a44f9ac20ca80b0086ca", + "sha256_in_prefix": "da3dd5626150aa4e00a4a0199baa582b4db9b9362412a44f9ac20ca80b0086ca", + "size_in_bytes": 846 + }, + { + "_path": "include/python3.10/cpython/pyctype.h", + "path_type": "hardlink", + "sha256": "10b5ccbc210fd2832e9c34849a3952e8db75f0016add89188358b1da6a8f3dbb", + "sha256_in_prefix": "10b5ccbc210fd2832e9c34849a3952e8db75f0016add89188358b1da6a8f3dbb", + "size_in_bytes": 1387 + }, + { + "_path": "include/python3.10/cpython/pydebug.h", + "path_type": "hardlink", + "sha256": "872f99a8bd4d03d9edf3a2d539a137810749c04ee36da531088d3823f74e8e01", + "sha256_in_prefix": "872f99a8bd4d03d9edf3a2d539a137810749c04ee36da531088d3823f74e8e01", + "size_in_bytes": 1093 + }, + { + "_path": "include/python3.10/cpython/pyerrors.h", + "path_type": "hardlink", + "sha256": "6acd662d252f443195eae92bd034d6e318adc0fcd8cd3c758aed2626c77268a9", + "sha256_in_prefix": "6acd662d252f443195eae92bd034d6e318adc0fcd8cd3c758aed2626c77268a9", + "size_in_bytes": 5476 + }, + { + "_path": "include/python3.10/cpython/pyfpe.h", + "path_type": "hardlink", + "sha256": "ea7bfa7d891a0b5372d8b40a57d1b466b7824296e5c3f8d50b1a7cde084429b7", + "sha256_in_prefix": "ea7bfa7d891a0b5372d8b40a57d1b466b7824296e5c3f8d50b1a7cde084429b7", + "size_in_bytes": 444 + }, + { + "_path": "include/python3.10/cpython/pylifecycle.h", + "path_type": "hardlink", + "sha256": "17f4c4198b21510a89fef782ecefaab8afe8c64812674ccaf4df563fcf31a222", + "sha256_in_prefix": "17f4c4198b21510a89fef782ecefaab8afe8c64812674ccaf4df563fcf31a222", + "size_in_bytes": 2095 + }, + { + "_path": "include/python3.10/cpython/pymem.h", + "path_type": "hardlink", + "sha256": "8a3795a9350b10548e8ad6d37dad69be2abd3870a751e67faa32a19a090608db", + "sha256_in_prefix": "8a3795a9350b10548e8ad6d37dad69be2abd3870a751e67faa32a19a090608db", + "size_in_bytes": 3379 + }, + { + "_path": "include/python3.10/cpython/pystate.h", + "path_type": "hardlink", + "sha256": "87381eb1de1a207514496b1d7c7a0ed477c8dc2f569c22dafe77ba8bca953f9b", + "sha256_in_prefix": "87381eb1de1a207514496b1d7c7a0ed477c8dc2f569c22dafe77ba8bca953f9b", + "size_in_bytes": 11914 + }, + { + "_path": "include/python3.10/cpython/pythonrun.h", + "path_type": "hardlink", + "sha256": "da9ac8ec2ae5ac970ca607a1779c0cb519b2fa67992a70171689191ffa4bfc8c", + "sha256_in_prefix": "da9ac8ec2ae5ac970ca607a1779c0cb519b2fa67992a70171689191ffa4bfc8c", + "size_in_bytes": 4811 + }, + { + "_path": "include/python3.10/cpython/pytime.h", + "path_type": "hardlink", + "sha256": "47b9238d98c2634ade6f9a7d93d3e6be7a3634f783c0b5b1918c24eaa7250d0d", + "sha256_in_prefix": "47b9238d98c2634ade6f9a7d93d3e6be7a3634f783c0b5b1918c24eaa7250d0d", + "size_in_bytes": 9196 + }, + { + "_path": "include/python3.10/cpython/sysmodule.h", + "path_type": "hardlink", + "sha256": "fd31927001b8cc323e82e8d2526d5f022823aabae3885368288e1f59ea471f40", + "sha256_in_prefix": "fd31927001b8cc323e82e8d2526d5f022823aabae3885368288e1f59ea471f40", + "size_in_bytes": 506 + }, + { + "_path": "include/python3.10/cpython/traceback.h", + "path_type": "hardlink", + "sha256": "0e0b89cc4e8733f23d07c3e46e87b53e4accc7c27471ed7f997c93b3b39b84fc", + "sha256_in_prefix": "0e0b89cc4e8733f23d07c3e46e87b53e4accc7c27471ed7f997c93b3b39b84fc", + "size_in_bytes": 404 + }, + { + "_path": "include/python3.10/cpython/tupleobject.h", + "path_type": "hardlink", + "sha256": "cbd0b66e2034cc8d2e5d3acab21bd7339c8e6a4046ea97d6736126ff1a2cf521", + "sha256_in_prefix": "cbd0b66e2034cc8d2e5d3acab21bd7339c8e6a4046ea97d6736126ff1a2cf521", + "size_in_bytes": 975 + }, + { + "_path": "include/python3.10/cpython/unicodeobject.h", + "path_type": "hardlink", + "sha256": "211b6e05e38a995d9bb62de99566607a0d2a36b33657a94776560e0ddc4d6fa9", + "sha256_in_prefix": "211b6e05e38a995d9bb62de99566607a0d2a36b33657a94776560e0ddc4d6fa9", + "size_in_bytes": 44284 + }, + { + "_path": "include/python3.10/datetime.h", + "path_type": "hardlink", + "sha256": "7cd737123510f5ddc334cc2550c832bd1ecc1be73b47e46f4c4a5c3ccb9ac1f5", + "sha256_in_prefix": "7cd737123510f5ddc334cc2550c832bd1ecc1be73b47e46f4c4a5c3ccb9ac1f5", + "size_in_bytes": 9635 + }, + { + "_path": "include/python3.10/descrobject.h", + "path_type": "hardlink", + "sha256": "44b4ebe9baf5b325fb79946f9bad3080c77386359b112f03476f1d1854f7b00f", + "sha256_in_prefix": "44b4ebe9baf5b325fb79946f9bad3080c77386359b112f03476f1d1854f7b00f", + "size_in_bytes": 3002 + }, + { + "_path": "include/python3.10/dictobject.h", + "path_type": "hardlink", + "sha256": "4ce1828fefe39470df01f54f3ab1bca679ccd72c19ebfece6b55368fba96ac2d", + "sha256_in_prefix": "4ce1828fefe39470df01f54f3ab1bca679ccd72c19ebfece6b55368fba96ac2d", + "size_in_bytes": 3853 + }, + { + "_path": "include/python3.10/dynamic_annotations.h", + "path_type": "hardlink", + "sha256": "3e4366f7d082835049730358d277a5ad7a60e16d1601f5622f0a045a37c152ac", + "sha256_in_prefix": "3e4366f7d082835049730358d277a5ad7a60e16d1601f5622f0a045a37c152ac", + "size_in_bytes": 22471 + }, + { + "_path": "include/python3.10/enumobject.h", + "path_type": "hardlink", + "sha256": "2244fe250db9995068fe74dce0e23fd70c12b03fd94751d98b773be8f64896b6", + "sha256_in_prefix": "2244fe250db9995068fe74dce0e23fd70c12b03fd94751d98b773be8f64896b6", + "size_in_bytes": 253 + }, + { + "_path": "include/python3.10/errcode.h", + "path_type": "hardlink", + "sha256": "685786771fcc416cba7f3c51e4d5e42af088b29d28fe6661a4b7ac67db27d9b4", + "sha256_in_prefix": "685786771fcc416cba7f3c51e4d5e42af088b29d28fe6661a4b7ac67db27d9b4", + "size_in_bytes": 1700 + }, + { + "_path": "include/python3.10/eval.h", + "path_type": "hardlink", + "sha256": "8ae7000ff2b0801e8be1af374cdb7aea7fce42517c97dd7eff40861cc707c4ca", + "sha256_in_prefix": "8ae7000ff2b0801e8be1af374cdb7aea7fce42517c97dd7eff40861cc707c4ca", + "size_in_bytes": 831 + }, + { + "_path": "include/python3.10/exports.h", + "path_type": "hardlink", + "sha256": "f9242de8f731846164d4446745dd2a737ccdf83f754099018edc90485b1cd445", + "sha256_in_prefix": "f9242de8f731846164d4446745dd2a737ccdf83f754099018edc90485b1cd445", + "size_in_bytes": 1098 + }, + { + "_path": "include/python3.10/fileobject.h", + "path_type": "hardlink", + "sha256": "4c89937726e6c30d62c361b48567a2de1c0533e7dc8ae8f805d9939842d00a7c", + "sha256_in_prefix": "4c89937726e6c30d62c361b48567a2de1c0533e7dc8ae8f805d9939842d00a7c", + "size_in_bytes": 1571 + }, + { + "_path": "include/python3.10/fileutils.h", + "path_type": "hardlink", + "sha256": "95c65af8238d2dedc03fdfc55bf30db0442db8e7c21e6da270548c03365e0274", + "sha256_in_prefix": "95c65af8238d2dedc03fdfc55bf30db0442db8e7c21e6da270548c03365e0274", + "size_in_bytes": 508 + }, + { + "_path": "include/python3.10/floatobject.h", + "path_type": "hardlink", + "sha256": "20bf507cf87f2b3574f1bd1ffd873e3fc6741cc0891b94fdbcf4237bd34b3f6b", + "sha256_in_prefix": "20bf507cf87f2b3574f1bd1ffd873e3fc6741cc0891b94fdbcf4237bd34b3f6b", + "size_in_bytes": 4360 + }, + { + "_path": "include/python3.10/frameobject.h", + "path_type": "hardlink", + "sha256": "b69efe6636f05e79e50b5a1f46e3ed2602ac5d5eda9fb57a2d58d4cdc99edfb7", + "sha256_in_prefix": "b69efe6636f05e79e50b5a1f46e3ed2602ac5d5eda9fb57a2d58d4cdc99edfb7", + "size_in_bytes": 337 + }, + { + "_path": "include/python3.10/funcobject.h", + "path_type": "hardlink", + "sha256": "f6f08f50fd83a0d2d0d2f7ed4b855990e101813331f9d2a8a2aee2b3e59faab1", + "sha256_in_prefix": "f6f08f50fd83a0d2d0d2f7ed4b855990e101813331f9d2a8a2aee2b3e59faab1", + "size_in_bytes": 4257 + }, + { + "_path": "include/python3.10/genericaliasobject.h", + "path_type": "hardlink", + "sha256": "0e53a0b18c114be68eccea9ffd1dd577e204b1f0ada4d3aedc8e7ee0c80fc7f8", + "sha256_in_prefix": "0e53a0b18c114be68eccea9ffd1dd577e204b1f0ada4d3aedc8e7ee0c80fc7f8", + "size_in_bytes": 334 + }, + { + "_path": "include/python3.10/genobject.h", + "path_type": "hardlink", + "sha256": "078f30dc42929446625c6e8bc995392c58224897377a945060fb2527704576ad", + "sha256_in_prefix": "078f30dc42929446625c6e8bc995392c58224897377a945060fb2527704576ad", + "size_in_bytes": 3347 + }, + { + "_path": "include/python3.10/import.h", + "path_type": "hardlink", + "sha256": "f32a4d416cf558d49d797f8d67d9078917258ed5af1daa734755c8be2c8c76b2", + "sha256_in_prefix": "f32a4d416cf558d49d797f8d67d9078917258ed5af1daa734755c8be2c8c76b2", + "size_in_bytes": 3026 + }, + { + "_path": "include/python3.10/internal/pycore_abstract.h", + "path_type": "hardlink", + "sha256": "ac474dbc0e522a5b59cff25c50f02eb75b08bf60b9056d84bdfd06d7202e9af3", + "sha256_in_prefix": "ac474dbc0e522a5b59cff25c50f02eb75b08bf60b9056d84bdfd06d7202e9af3", + "size_in_bytes": 479 + }, + { + "_path": "include/python3.10/internal/pycore_accu.h", + "path_type": "hardlink", + "sha256": "0af5cf048f515646d68566bd8786e973c45a501f23782d80961e390b116adb2b", + "sha256_in_prefix": "0af5cf048f515646d68566bd8786e973c45a501f23782d80961e390b116adb2b", + "size_in_bytes": 1126 + }, + { + "_path": "include/python3.10/internal/pycore_asdl.h", + "path_type": "hardlink", + "sha256": "09bb323e0a4658ffd5b7ee1f9efec74c4ec18cadce97a76c863df5d1fb2e2559", + "sha256_in_prefix": "09bb323e0a4658ffd5b7ee1f9efec74c4ec18cadce97a76c863df5d1fb2e2559", + "size_in_bytes": 2971 + }, + { + "_path": "include/python3.10/internal/pycore_ast.h", + "path_type": "hardlink", + "sha256": "3dcc46771065bb322c71b3e1332675616c25e11dcd19fd76606b85643671d161", + "sha256_in_prefix": "3dcc46771065bb322c71b3e1332675616c25e11dcd19fd76606b85643671d161", + "size_in_bytes": 28828 + }, + { + "_path": "include/python3.10/internal/pycore_ast_state.h", + "path_type": "hardlink", + "sha256": "54a70b39ad33292983bb2b62817ea1d9b9d2357382b9c6e0f3e74e8842e54c9a", + "sha256_in_prefix": "54a70b39ad33292983bb2b62817ea1d9b9d2357382b9c6e0f3e74e8842e54c9a", + "size_in_bytes": 6457 + }, + { + "_path": "include/python3.10/internal/pycore_atomic.h", + "path_type": "hardlink", + "sha256": "95e7118e799ad3faafc8e58a29b2d1f1a4bb94e1aac3273e042f379f8e12d4e6", + "sha256_in_prefix": "95e7118e799ad3faafc8e58a29b2d1f1a4bb94e1aac3273e042f379f8e12d4e6", + "size_in_bytes": 16979 + }, + { + "_path": "include/python3.10/internal/pycore_atomic_funcs.h", + "path_type": "hardlink", + "sha256": "9d5cfa13ad863a0cc1b0ab06861c1f8cfbdc7d730b9c4603e5777a608263d399", + "sha256_in_prefix": "9d5cfa13ad863a0cc1b0ab06861c1f8cfbdc7d730b9c4603e5777a608263d399", + "size_in_bytes": 2438 + }, + { + "_path": "include/python3.10/internal/pycore_bitutils.h", + "path_type": "hardlink", + "sha256": "89e4de7907d949dc9d48c4a919bfdaaab429e9eb82c8329ede41b198125dbdf3", + "sha256_in_prefix": "89e4de7907d949dc9d48c4a919bfdaaab429e9eb82c8329ede41b198125dbdf3", + "size_in_bytes": 5271 + }, + { + "_path": "include/python3.10/internal/pycore_blocks_output_buffer.h", + "path_type": "hardlink", + "sha256": "03fed5054d0d78e3711e73995e484fefb81495c063a5b9ef555c0395d7fc1ebc", + "sha256_in_prefix": "03fed5054d0d78e3711e73995e484fefb81495c063a5b9ef555c0395d7fc1ebc", + "size_in_bytes": 8688 + }, + { + "_path": "include/python3.10/internal/pycore_bytes_methods.h", + "path_type": "hardlink", + "sha256": "1534326dbf027e9bb472be5ccf8b82fab48f3282cc7f6a61629b801fc80afc00", + "sha256_in_prefix": "1534326dbf027e9bb472be5ccf8b82fab48f3282cc7f6a61629b801fc80afc00", + "size_in_bytes": 3384 + }, + { + "_path": "include/python3.10/internal/pycore_call.h", + "path_type": "hardlink", + "sha256": "99ca19ee267b138ed3412505413d3c252cda8b049c42cc7f6f7395d2b438bae6", + "sha256_in_prefix": "99ca19ee267b138ed3412505413d3c252cda8b049c42cc7f6f7395d2b438bae6", + "size_in_bytes": 870 + }, + { + "_path": "include/python3.10/internal/pycore_ceval.h", + "path_type": "hardlink", + "sha256": "a4a18f5e721f650bcf813bd5930f1ecc14fc801488bb5039c250e101e8951b01", + "sha256_in_prefix": "a4a18f5e721f650bcf813bd5930f1ecc14fc801488bb5039c250e101e8951b01", + "size_in_bytes": 3484 + }, + { + "_path": "include/python3.10/internal/pycore_code.h", + "path_type": "hardlink", + "sha256": "461064e166dd278fd527e0bd6215cd04d28abf9d2ca2c9d23ca098425ff806a1", + "sha256_in_prefix": "461064e166dd278fd527e0bd6215cd04d28abf9d2ca2c9d23ca098425ff806a1", + "size_in_bytes": 696 + }, + { + "_path": "include/python3.10/internal/pycore_compile.h", + "path_type": "hardlink", + "sha256": "21506bc00cb04a89618141c76e31b831c0fafdade423c3e5273b98560e0a6d72", + "sha256_in_prefix": "21506bc00cb04a89618141c76e31b831c0fafdade423c3e5273b98560e0a6d72", + "size_in_bytes": 1045 + }, + { + "_path": "include/python3.10/internal/pycore_condvar.h", + "path_type": "hardlink", + "sha256": "3d37e1739052022a8d120096ffc8521e29a4a930c339a70e315dade3fadd62f5", + "sha256_in_prefix": "3d37e1739052022a8d120096ffc8521e29a4a930c339a70e315dade3fadd62f5", + "size_in_bytes": 2809 + }, + { + "_path": "include/python3.10/internal/pycore_context.h", + "path_type": "hardlink", + "sha256": "d8b138e68e09678167dd9e615f036865da3880d6e423ea087f7b87e69a828cbd", + "sha256_in_prefix": "d8b138e68e09678167dd9e615f036865da3880d6e423ea087f7b87e69a828cbd", + "size_in_bytes": 822 + }, + { + "_path": "include/python3.10/internal/pycore_dtoa.h", + "path_type": "hardlink", + "sha256": "fb94584844dc81a7f8093119cc8119790d31c57c53e7ba462d6c9e47ccde6d86", + "sha256_in_prefix": "fb94584844dc81a7f8093119cc8119790d31c57c53e7ba462d6c9e47ccde6d86", + "size_in_bytes": 646 + }, + { + "_path": "include/python3.10/internal/pycore_fileutils.h", + "path_type": "hardlink", + "sha256": "f52733d98961556de9190dff2c8f5453bcd16cb0113b3b93a25e1bf99e68961f", + "sha256_in_prefix": "f52733d98961556de9190dff2c8f5453bcd16cb0113b3b93a25e1bf99e68961f", + "size_in_bytes": 1704 + }, + { + "_path": "include/python3.10/internal/pycore_format.h", + "path_type": "hardlink", + "sha256": "253cc77e6d11ba20d297813e064650fa965b3653f150bd85f805b94db5f3a98d", + "sha256_in_prefix": "253cc77e6d11ba20d297813e064650fa965b3653f150bd85f805b94db5f3a98d", + "size_in_bytes": 480 + }, + { + "_path": "include/python3.10/internal/pycore_gc.h", + "path_type": "hardlink", + "sha256": "cd380a8a2649d6980a5bd912d3acc3d94eebcba5d1350acae26167e43c60662b", + "sha256_in_prefix": "cd380a8a2649d6980a5bd912d3acc3d94eebcba5d1350acae26167e43c60662b", + "size_in_bytes": 6859 + }, + { + "_path": "include/python3.10/internal/pycore_getopt.h", + "path_type": "hardlink", + "sha256": "e93393067b66b557b0300e05c10ee904d4be54cadfb214c5328a9225ad199452", + "sha256_in_prefix": "e93393067b66b557b0300e05c10ee904d4be54cadfb214c5328a9225ad199452", + "size_in_bytes": 490 + }, + { + "_path": "include/python3.10/internal/pycore_gil.h", + "path_type": "hardlink", + "sha256": "cf455aacd5651e5b43547ebe69bb324eab84238d92665df53c1df32434bd0d9b", + "sha256_in_prefix": "cf455aacd5651e5b43547ebe69bb324eab84238d92665df53c1df32434bd0d9b", + "size_in_bytes": 1565 + }, + { + "_path": "include/python3.10/internal/pycore_hamt.h", + "path_type": "hardlink", + "sha256": "a5650972b76b05a4319421a5122493310f0a63bdcee7a068a0c57f79abdd55f4", + "sha256_in_prefix": "a5650972b76b05a4319421a5122493310f0a63bdcee7a068a0c57f79abdd55f4", + "size_in_bytes": 3697 + }, + { + "_path": "include/python3.10/internal/pycore_hashtable.h", + "path_type": "hardlink", + "sha256": "75e903486d6b6e0468770a6bc3895d8b9423c1b64614e38b29a1d65a1d5bfdf7", + "sha256_in_prefix": "75e903486d6b6e0468770a6bc3895d8b9423c1b64614e38b29a1d65a1d5bfdf7", + "size_in_bytes": 4197 + }, + { + "_path": "include/python3.10/internal/pycore_import.h", + "path_type": "hardlink", + "sha256": "1f84fef1c3137f2b122485cf2a5f7c53eb24795ce26631b63ebd239c239af60b", + "sha256_in_prefix": "1f84fef1c3137f2b122485cf2a5f7c53eb24795ce26631b63ebd239c239af60b", + "size_in_bytes": 346 + }, + { + "_path": "include/python3.10/internal/pycore_initconfig.h", + "path_type": "hardlink", + "sha256": "77f6cfec6d35a23180b0a5794893e49790f171e72d97c6d79c0579e4ea11155f", + "sha256_in_prefix": "77f6cfec6d35a23180b0a5794893e49790f171e72d97c6d79c0579e4ea11155f", + "size_in_bytes": 5625 + }, + { + "_path": "include/python3.10/internal/pycore_interp.h", + "path_type": "hardlink", + "sha256": "fa9edb1e1dea5b0536d132d0379d3ead6f43d5c1be8cf2105dbaad3ba4a67b04", + "sha256_in_prefix": "fa9edb1e1dea5b0536d132d0379d3ead6f43d5c1be8cf2105dbaad3ba4a67b04", + "size_in_bytes": 9289 + }, + { + "_path": "include/python3.10/internal/pycore_list.h", + "path_type": "hardlink", + "sha256": "f9531d6503db771166538ec53c69b265f0fe0a16e8f7ee1a90900d6bcd97e1e2", + "sha256_in_prefix": "f9531d6503db771166538ec53c69b265f0fe0a16e8f7ee1a90900d6bcd97e1e2", + "size_in_bytes": 350 + }, + { + "_path": "include/python3.10/internal/pycore_long.h", + "path_type": "hardlink", + "sha256": "b9d61c7e55ca7529f8e3e8825730acf2c1c9cc33ccfb973c1c440e9215aeb454", + "sha256_in_prefix": "b9d61c7e55ca7529f8e3e8825730acf2c1c9cc33ccfb973c1c440e9215aeb454", + "size_in_bytes": 2589 + }, + { + "_path": "include/python3.10/internal/pycore_moduleobject.h", + "path_type": "hardlink", + "sha256": "bfdc9d60f792c180fddc18e01906c442a89d4642e796db9788960d8639a82205", + "sha256_in_prefix": "bfdc9d60f792c180fddc18e01906c442a89d4642e796db9788960d8639a82205", + "size_in_bytes": 1047 + }, + { + "_path": "include/python3.10/internal/pycore_object.h", + "path_type": "hardlink", + "sha256": "55e7e9ae668c7d38cf6e7dceb4c641106b7af9868bbdcb5dcbc44ec6815fba2a", + "sha256_in_prefix": "55e7e9ae668c7d38cf6e7dceb4c641106b7af9868bbdcb5dcbc44ec6815fba2a", + "size_in_bytes": 5989 + }, + { + "_path": "include/python3.10/internal/pycore_parser.h", + "path_type": "hardlink", + "sha256": "05260556eb3974a843ef4528f0b2d287fe0271260d40a901139fca5840585409", + "sha256_in_prefix": "05260556eb3974a843ef4528f0b2d287fe0271260d40a901139fca5840585409", + "size_in_bytes": 626 + }, + { + "_path": "include/python3.10/internal/pycore_pathconfig.h", + "path_type": "hardlink", + "sha256": "b491e40de0c3c1b7b41890ee523de040a62b7114ae77660417aa8eccfc02203f", + "sha256_in_prefix": "b491e40de0c3c1b7b41890ee523de040a62b7114ae77660417aa8eccfc02203f", + "size_in_bytes": 1981 + }, + { + "_path": "include/python3.10/internal/pycore_pyarena.h", + "path_type": "hardlink", + "sha256": "d4f4e513bae78ff985f51ca48fb7d1a4d57055c59393a1eb661e55e6ec3ba61f", + "sha256_in_prefix": "d4f4e513bae78ff985f51ca48fb7d1a4d57055c59393a1eb661e55e6ec3ba61f", + "size_in_bytes": 2733 + }, + { + "_path": "include/python3.10/internal/pycore_pyerrors.h", + "path_type": "hardlink", + "sha256": "6b499fa85237aad6fd350b42a72ffff0870de23e5b1365113cab495381592df9", + "sha256_in_prefix": "6b499fa85237aad6fd350b42a72ffff0870de23e5b1365113cab495381592df9", + "size_in_bytes": 2314 + }, + { + "_path": "include/python3.10/internal/pycore_pyhash.h", + "path_type": "hardlink", + "sha256": "6e9db9d3e7d7245b10e33598b995fc9b51b3952ce17225830d0248c6fa62dd51", + "sha256_in_prefix": "6e9db9d3e7d7245b10e33598b995fc9b51b3952ce17225830d0248c6fa62dd51", + "size_in_bytes": 206 + }, + { + "_path": "include/python3.10/internal/pycore_pylifecycle.h", + "path_type": "hardlink", + "sha256": "6e0f877bd32fb93ef8826b56974c9e01b54463fb4f3a61c6887e3f94d20b5c74", + "sha256_in_prefix": "6e0f877bd32fb93ef8826b56974c9e01b54463fb4f3a61c6887e3f94d20b5c74", + "size_in_bytes": 4940 + }, + { + "_path": "include/python3.10/internal/pycore_pymem.h", + "path_type": "hardlink", + "sha256": "c5b5b4b8379b8fa6b7b9aaf938afc848d70e424f01eaef8fe0fcd493f806faeb", + "sha256_in_prefix": "c5b5b4b8379b8fa6b7b9aaf938afc848d70e424f01eaef8fe0fcd493f806faeb", + "size_in_bytes": 3211 + }, + { + "_path": "include/python3.10/internal/pycore_pystate.h", + "path_type": "hardlink", + "sha256": "32c1b74638a2809d3fdc1889b927a15d13f71c87e1428023b48f0dc684ef22be", + "sha256_in_prefix": "32c1b74638a2809d3fdc1889b927a15d13f71c87e1428023b48f0dc684ef22be", + "size_in_bytes": 3938 + }, + { + "_path": "include/python3.10/internal/pycore_runtime.h", + "path_type": "hardlink", + "sha256": "142ae39d5b7488ae8abf48036f9817914b5aff43924c70264054a7800d1335bc", + "sha256_in_prefix": "142ae39d5b7488ae8abf48036f9817914b5aff43924c70264054a7800d1335bc", + "size_in_bytes": 4902 + }, + { + "_path": "include/python3.10/internal/pycore_structseq.h", + "path_type": "hardlink", + "sha256": "2199afc79e137be35150f4e06fa2f8d9f42ccbea56bcd68d5f3ecc6a2a14660e", + "sha256_in_prefix": "2199afc79e137be35150f4e06fa2f8d9f42ccbea56bcd68d5f3ecc6a2a14660e", + "size_in_bytes": 386 + }, + { + "_path": "include/python3.10/internal/pycore_symtable.h", + "path_type": "hardlink", + "sha256": "514c300c5ce732bb68f7207e502a2726d470d4b7d5265aef0bcb23f69dda5b06", + "sha256_in_prefix": "514c300c5ce732bb68f7207e502a2726d470d4b7d5265aef0bcb23f69dda5b06", + "size_in_bytes": 5578 + }, + { + "_path": "include/python3.10/internal/pycore_sysmodule.h", + "path_type": "hardlink", + "sha256": "091730828d6b60293756f9ed5f700bb77e7f2419f6b05c9fc0f2e02708617fb5", + "sha256_in_prefix": "091730828d6b60293756f9ed5f700bb77e7f2419f6b05c9fc0f2e02708617fb5", + "size_in_bytes": 548 + }, + { + "_path": "include/python3.10/internal/pycore_traceback.h", + "path_type": "hardlink", + "sha256": "d5c76579b88470869ee5b6bf338c5dabb3f7cae8741fcf3f5c0e1e05eefd9e2a", + "sha256_in_prefix": "d5c76579b88470869ee5b6bf338c5dabb3f7cae8741fcf3f5c0e1e05eefd9e2a", + "size_in_bytes": 2970 + }, + { + "_path": "include/python3.10/internal/pycore_tuple.h", + "path_type": "hardlink", + "sha256": "7f44d17d0d9500284c7167c9455e597f3c5b7d712ba27ce8eb696d82fd5d8acd", + "sha256_in_prefix": "7f44d17d0d9500284c7167c9455e597f3c5b7d712ba27ce8eb696d82fd5d8acd", + "size_in_bytes": 425 + }, + { + "_path": "include/python3.10/internal/pycore_ucnhash.h", + "path_type": "hardlink", + "sha256": "6d9077e875703e5db7daf293a6c7ea3d43d1ee84dec137a950f17a26e9348eb5", + "sha256_in_prefix": "6d9077e875703e5db7daf293a6c7ea3d43d1ee84dec137a950f17a26e9348eb5", + "size_in_bytes": 898 + }, + { + "_path": "include/python3.10/internal/pycore_unionobject.h", + "path_type": "hardlink", + "sha256": "8ec5586a3ffac58c3006d227ae4e9868a5e8afd5cdbebcb84b26570ca0097dd6", + "sha256_in_prefix": "8ec5586a3ffac58c3006d227ae4e9868a5e8afd5cdbebcb84b26570ca0097dd6", + "size_in_bytes": 629 + }, + { + "_path": "include/python3.10/internal/pycore_warnings.h", + "path_type": "hardlink", + "sha256": "bb97717b23047f5788708aef722b3c8f761a8ff191a5147681dac18ef6604595", + "sha256_in_prefix": "bb97717b23047f5788708aef722b3c8f761a8ff191a5147681dac18ef6604595", + "size_in_bytes": 633 + }, + { + "_path": "include/python3.10/interpreteridobject.h", + "path_type": "hardlink", + "sha256": "62d060794f7488f365402db81ded3d588b6d7759eb0de9194329fd01a9374cf6", + "sha256_in_prefix": "62d060794f7488f365402db81ded3d588b6d7759eb0de9194329fd01a9374cf6", + "size_in_bytes": 334 + }, + { + "_path": "include/python3.10/intrcheck.h", + "path_type": "hardlink", + "sha256": "696fe17618c579a8cbaad9b86175f60d43ea0b9e8aaaa1d65ad256d53dc163c1", + "sha256_in_prefix": "696fe17618c579a8cbaad9b86175f60d43ea0b9e8aaaa1d65ad256d53dc163c1", + "size_in_bytes": 772 + }, + { + "_path": "include/python3.10/iterobject.h", + "path_type": "hardlink", + "sha256": "fab74e0f2a2cd185f846ade3247b1e348b9ed5b72f875cec7ff6f90e8f167dc3", + "sha256_in_prefix": "fab74e0f2a2cd185f846ade3247b1e348b9ed5b72f875cec7ff6f90e8f167dc3", + "size_in_bytes": 593 + }, + { + "_path": "include/python3.10/listobject.h", + "path_type": "hardlink", + "sha256": "fea25ac3a5d8f0b8678cd77eba73cf9c3797490a24c1e6585bf255982ab48c23", + "sha256_in_prefix": "fea25ac3a5d8f0b8678cd77eba73cf9c3797490a24c1e6585bf255982ab48c23", + "size_in_bytes": 1781 + }, + { + "_path": "include/python3.10/longintrepr.h", + "path_type": "hardlink", + "sha256": "28dddc9f2d5db3e383d1e921a7731bdff683ec394b8fd334f6cba14241d5d244", + "sha256_in_prefix": "28dddc9f2d5db3e383d1e921a7731bdff683ec394b8fd334f6cba14241d5d244", + "size_in_bytes": 3799 + }, + { + "_path": "include/python3.10/longobject.h", + "path_type": "hardlink", + "sha256": "7159278389a2a2bc9d27dd8def44800c6fbf966582d112021c19d5c4278b03aa", + "sha256_in_prefix": "7159278389a2a2bc9d27dd8def44800c6fbf966582d112021c19d5c4278b03aa", + "size_in_bytes": 8606 + }, + { + "_path": "include/python3.10/marshal.h", + "path_type": "hardlink", + "sha256": "06ba6a68154f85951794529465a07e07444fb852440059a398c98344004a27f5", + "sha256_in_prefix": "06ba6a68154f85951794529465a07e07444fb852440059a398c98344004a27f5", + "size_in_bytes": 803 + }, + { + "_path": "include/python3.10/memoryobject.h", + "path_type": "hardlink", + "sha256": "5a89491cd879fd90ba20525c710c74e278d2432da789ce6c608ee4c65920cd48", + "sha256_in_prefix": "5a89491cd879fd90ba20525c710c74e278d2432da789ce6c608ee4c65920cd48", + "size_in_bytes": 2764 + }, + { + "_path": "include/python3.10/methodobject.h", + "path_type": "hardlink", + "sha256": "f4b74f9970a1077df25b79349cae90ce26499736a7cae9612fe32615e3852c6f", + "sha256_in_prefix": "f4b74f9970a1077df25b79349cae90ce26499736a7cae9612fe32615e3852c6f", + "size_in_bytes": 4147 + }, + { + "_path": "include/python3.10/modsupport.h", + "path_type": "hardlink", + "sha256": "718c034912af87f742a587863f1cf384a3c6bc69a7d80288b324acc4cdfea901", + "sha256_in_prefix": "718c034912af87f742a587863f1cf384a3c6bc69a7d80288b324acc4cdfea901", + "size_in_bytes": 10333 + }, + { + "_path": "include/python3.10/moduleobject.h", + "path_type": "hardlink", + "sha256": "1c53bd662099c015242581a1c1c96784455a6f5be0e673f569a7734a9841a62e", + "sha256_in_prefix": "1c53bd662099c015242581a1c1c96784455a6f5be0e673f569a7734a9841a62e", + "size_in_bytes": 2458 + }, + { + "_path": "include/python3.10/namespaceobject.h", + "path_type": "hardlink", + "sha256": "d282d6d0c6493f56921c039bfa23fd38bc4a643ebb9ace07108d9b170900fbc8", + "sha256_in_prefix": "d282d6d0c6493f56921c039bfa23fd38bc4a643ebb9ace07108d9b170900fbc8", + "size_in_bytes": 349 + }, + { + "_path": "include/python3.10/object.h", + "path_type": "hardlink", + "sha256": "ccf9ce9261d28fbbbbcb5c365e10e467c3a9df0bdf408f9449d713389c71e0ab", + "sha256_in_prefix": "ccf9ce9261d28fbbbbcb5c365e10e467c3a9df0bdf408f9449d713389c71e0ab", + "size_in_bytes": 28344 + }, + { + "_path": "include/python3.10/objimpl.h", + "path_type": "hardlink", + "sha256": "235f2853c721bfa952a98452961ca1ad5200da10b2d76b026a27e45fb11593c2", + "sha256_in_prefix": "235f2853c721bfa952a98452961ca1ad5200da10b2d76b026a27e45fb11593c2", + "size_in_bytes": 8445 + }, + { + "_path": "include/python3.10/opcode.h", + "path_type": "hardlink", + "sha256": "831a78176f1e285a4f37bd11253ba7e28870956d8fc5df32d281f2dff88c5e07", + "sha256_in_prefix": "831a78176f1e285a4f37bd11253ba7e28870956d8fc5df32d281f2dff88c5e07", + "size_in_bytes": 5509 + }, + { + "_path": "include/python3.10/osdefs.h", + "path_type": "hardlink", + "sha256": "8372e9c507949a88ed3cad5fd0a830190d60a1655e9a3f59ef4d0832c06a041c", + "sha256_in_prefix": "8372e9c507949a88ed3cad5fd0a830190d60a1655e9a3f59ef4d0832c06a041c", + "size_in_bytes": 737 + }, + { + "_path": "include/python3.10/osmodule.h", + "path_type": "hardlink", + "sha256": "c013935b48f48ca8ce249a4d482c55e3fb6f1cfe786c5a32a57969bb74a779d9", + "sha256_in_prefix": "c013935b48f48ca8ce249a4d482c55e3fb6f1cfe786c5a32a57969bb74a779d9", + "size_in_bytes": 291 + }, + { + "_path": "include/python3.10/patchlevel.h", + "path_type": "hardlink", + "sha256": "59744a5030593533e3217dfea25dc08c23d130a5224ff6465ec33901e798decb", + "sha256_in_prefix": "59744a5030593533e3217dfea25dc08c23d130a5224ff6465ec33901e798decb", + "size_in_bytes": 1301 + }, + { + "_path": "include/python3.10/py_curses.h", + "path_type": "hardlink", + "sha256": "18498ae03ed5fb81815a98e1dde888c9e0ea1c38fead6c7b3698d2583538c7f6", + "sha256_in_prefix": "18498ae03ed5fb81815a98e1dde888c9e0ea1c38fead6c7b3698d2583538c7f6", + "size_in_bytes": 2474 + }, + { + "_path": "include/python3.10/pycapsule.h", + "path_type": "hardlink", + "sha256": "8fed74eb81e83720caae346011dd6deedb147fd462bf94e679eac5065dfa92aa", + "sha256_in_prefix": "8fed74eb81e83720caae346011dd6deedb147fd462bf94e679eac5065dfa92aa", + "size_in_bytes": 1725 + }, + { + "_path": "include/python3.10/pyconfig.h", + "path_type": "hardlink", + "sha256": "e135595826a0dfaef729fb12c47e9defd4eb78307b75e96703dfc19df1127fff", + "sha256_in_prefix": "e135595826a0dfaef729fb12c47e9defd4eb78307b75e96703dfc19df1127fff", + "size_in_bytes": 48898 + }, + { + "_path": "include/python3.10/pydtrace.h", + "path_type": "hardlink", + "sha256": "d342948372e46cb0124ba1311ce5ba9941837ac8a137a76b5a532bca03c696e8", + "sha256_in_prefix": "d342948372e46cb0124ba1311ce5ba9941837ac8a137a76b5a532bca03c696e8", + "size_in_bytes": 2413 + }, + { + "_path": "include/python3.10/pyerrors.h", + "path_type": "hardlink", + "sha256": "2ae64c563e6b020ef70dc29ad78dab7a32b6074ca5d324d60befc92b092730d5", + "sha256_in_prefix": "2ae64c563e6b020ef70dc29ad78dab7a32b6074ca5d324d60befc92b092730d5", + "size_in_bytes": 12426 + }, + { + "_path": "include/python3.10/pyexpat.h", + "path_type": "hardlink", + "sha256": "24eb6f486b4eec69bcd84ec6cc17833040095aabba7a0c4ebe491bb5de02879e", + "sha256_in_prefix": "24eb6f486b4eec69bcd84ec6cc17833040095aabba7a0c4ebe491bb5de02879e", + "size_in_bytes": 2572 + }, + { + "_path": "include/python3.10/pyframe.h", + "path_type": "hardlink", + "sha256": "92fa396239229cd523e37349f9ae6e8d990061698c5d7e0770a473ce15b39304", + "sha256_in_prefix": "92fa396239229cd523e37349f9ae6e8d990061698c5d7e0770a473ce15b39304", + "size_in_bytes": 466 + }, + { + "_path": "include/python3.10/pyhash.h", + "path_type": "hardlink", + "sha256": "f6746833402decba260d9d83f98111a0088de3f00bd44ee205b89140027f62e3", + "sha256_in_prefix": "f6746833402decba260d9d83f98111a0088de3f00bd44ee205b89140027f62e3", + "size_in_bytes": 4223 + }, + { + "_path": "include/python3.10/pylifecycle.h", + "path_type": "hardlink", + "sha256": "0b3b1923447d6e1224e88994fe00b63ee50786d253832bdeea3323db985fa99b", + "sha256_in_prefix": "0b3b1923447d6e1224e88994fe00b63ee50786d253832bdeea3323db985fa99b", + "size_in_bytes": 2080 + }, + { + "_path": "include/python3.10/pymacconfig.h", + "path_type": "hardlink", + "sha256": "06a284cd2ccccbac21c5aa2ce5ea1d05d04a4b5e5038e5d55c7fab260ab30e2c", + "sha256_in_prefix": "06a284cd2ccccbac21c5aa2ce5ea1d05d04a4b5e5038e5d55c7fab260ab30e2c", + "size_in_bytes": 2989 + }, + { + "_path": "include/python3.10/pymacro.h", + "path_type": "hardlink", + "sha256": "4bed498f025583031bf71f5fde5cb589e3af0744e73143b6b074845fff51f7ef", + "sha256_in_prefix": "4bed498f025583031bf71f5fde5cb589e3af0744e73143b6b074845fff51f7ef", + "size_in_bytes": 4920 + }, + { + "_path": "include/python3.10/pymath.h", + "path_type": "hardlink", + "sha256": "3942d5ed97fccb693d4b342ffe3dbf1ceb01927a4566fb54f3b748fb92e348aa", + "sha256_in_prefix": "3942d5ed97fccb693d4b342ffe3dbf1ceb01927a4566fb54f3b748fb92e348aa", + "size_in_bytes": 8313 + }, + { + "_path": "include/python3.10/pymem.h", + "path_type": "hardlink", + "sha256": "3e256cc189d68c3fc0a70496e22cf3cd9b34be925b157240699f9e397c9cbd3a", + "sha256_in_prefix": "3e256cc189d68c3fc0a70496e22cf3cd9b34be925b157240699f9e397c9cbd3a", + "size_in_bytes": 3891 + }, + { + "_path": "include/python3.10/pyport.h", + "path_type": "hardlink", + "sha256": "7f8668d75ea83e4cbb3c187383bc032abb99a585eed5f67791a418b9c7065377", + "sha256_in_prefix": "7f8668d75ea83e4cbb3c187383bc032abb99a585eed5f67791a418b9c7065377", + "size_in_bytes": 31684 + }, + { + "_path": "include/python3.10/pystate.h", + "path_type": "hardlink", + "sha256": "69aafe4b49dbcb969d56ad795aac8b97f4ed48ea233675d83e0ba93423254197", + "sha256_in_prefix": "69aafe4b49dbcb969d56ad795aac8b97f4ed48ea233675d83e0ba93423254197", + "size_in_bytes": 5250 + }, + { + "_path": "include/python3.10/pystrcmp.h", + "path_type": "hardlink", + "sha256": "f401d8338fb6ecf5f12768ee95cd09c262f880b2ee522ca344b890dbdcde4c88", + "sha256_in_prefix": "f401d8338fb6ecf5f12768ee95cd09c262f880b2ee522ca344b890dbdcde4c88", + "size_in_bytes": 436 + }, + { + "_path": "include/python3.10/pystrhex.h", + "path_type": "hardlink", + "sha256": "2242f90a9a2bf13a32f0016bb056869193df04230ace468b469b18008f56a0f9", + "sha256_in_prefix": "2242f90a9a2bf13a32f0016bb056869193df04230ace468b469b18008f56a0f9", + "size_in_bytes": 849 + }, + { + "_path": "include/python3.10/pystrtod.h", + "path_type": "hardlink", + "sha256": "df98a492044f55cf016c008fef3181d77d13f1828b84625b5cb1f460e5f5ed2f", + "sha256_in_prefix": "df98a492044f55cf016c008fef3181d77d13f1828b84625b5cb1f460e5f5ed2f", + "size_in_bytes": 1483 + }, + { + "_path": "include/python3.10/pythonrun.h", + "path_type": "hardlink", + "sha256": "0a4dbe8791dae43facabc29e8b298d95bd0d1da615d6ccf3158b5ab033f08fb4", + "sha256_in_prefix": "0a4dbe8791dae43facabc29e8b298d95bd0d1da615d6ccf3158b5ab033f08fb4", + "size_in_bytes": 1110 + }, + { + "_path": "include/python3.10/pythread.h", + "path_type": "hardlink", + "sha256": "f578d2d30051b9474f36916909308665d51d3e9653f62774a628e659b969f8d4", + "sha256_in_prefix": "f578d2d30051b9474f36916909308665d51d3e9653f62774a628e659b969f8d4", + "size_in_bytes": 5938 + }, + { + "_path": "include/python3.10/rangeobject.h", + "path_type": "hardlink", + "sha256": "eb9bbb31cf628ffa8c4452aa7d136941b3e93e43e04d44b51c68ba0b16d56381", + "sha256_in_prefix": "eb9bbb31cf628ffa8c4452aa7d136941b3e93e43e04d44b51c68ba0b16d56381", + "size_in_bytes": 628 + }, + { + "_path": "include/python3.10/setobject.h", + "path_type": "hardlink", + "sha256": "822f34d6214a838f9d15ffeb47b4bbae4b0726cb9aa28b1a92ab321175c26161", + "sha256_in_prefix": "822f34d6214a838f9d15ffeb47b4bbae4b0726cb9aa28b1a92ab321175c26161", + "size_in_bytes": 3381 + }, + { + "_path": "include/python3.10/sliceobject.h", + "path_type": "hardlink", + "sha256": "3215a02de59673a950b8941a0224474cf0bcb62f617d9afc402f1e17713f9c28", + "sha256_in_prefix": "3215a02de59673a950b8941a0224474cf0bcb62f617d9afc402f1e17713f9c28", + "size_in_bytes": 2516 + }, + { + "_path": "include/python3.10/structmember.h", + "path_type": "hardlink", + "sha256": "8a7666cbc440aefb0520615dd50a776c34b987bd6781dd4c2d40950ceb603950", + "sha256_in_prefix": "8a7666cbc440aefb0520615dd50a776c34b987bd6781dd4c2d40950ceb603950", + "size_in_bytes": 2074 + }, + { + "_path": "include/python3.10/structseq.h", + "path_type": "hardlink", + "sha256": "d08c84466646660599c2f6d03af90be06ee8f9f81380a891d9e2a8c8e27e4308", + "sha256_in_prefix": "d08c84466646660599c2f6d03af90be06ee8f9f81380a891d9e2a8c8e27e4308", + "size_in_bytes": 1390 + }, + { + "_path": "include/python3.10/sysmodule.h", + "path_type": "hardlink", + "sha256": "2c1c21db5c8704de23d1580250a30243ca3a924f14f11e4b54376a3fffd8d76f", + "sha256_in_prefix": "2c1c21db5c8704de23d1580250a30243ca3a924f14f11e4b54376a3fffd8d76f", + "size_in_bytes": 1242 + }, + { + "_path": "include/python3.10/token.h", + "path_type": "hardlink", + "sha256": "754b9f53780c030f72b1d0ac10f13b89d0da1ad955c07c4eb3bcbc3406347b02", + "sha256_in_prefix": "754b9f53780c030f72b1d0ac10f13b89d0da1ad955c07c4eb3bcbc3406347b02", + "size_in_bytes": 2669 + }, + { + "_path": "include/python3.10/traceback.h", + "path_type": "hardlink", + "sha256": "c6db281d9686cf1b6895f7574a05291263b81aaa3f35cd0ca9a2e3219a669b45", + "sha256_in_prefix": "c6db281d9686cf1b6895f7574a05291263b81aaa3f35cd0ca9a2e3219a669b45", + "size_in_bytes": 584 + }, + { + "_path": "include/python3.10/tracemalloc.h", + "path_type": "hardlink", + "sha256": "0e5e535fbb5e66400b4dcb3d404ff532971ae964b4a11ac4abb6d73991ad24fe", + "sha256_in_prefix": "0e5e535fbb5e66400b4dcb3d404ff532971ae964b4a11ac4abb6d73991ad24fe", + "size_in_bytes": 1114 + }, + { + "_path": "include/python3.10/tupleobject.h", + "path_type": "hardlink", + "sha256": "a0659adc9bdffd1980fca036b3b9eabc1a99540435b6e857f071711054ebb3ed", + "sha256_in_prefix": "a0659adc9bdffd1980fca036b3b9eabc1a99540435b6e857f071711054ebb3ed", + "size_in_bytes": 1614 + }, + { + "_path": "include/python3.10/typeslots.h", + "path_type": "hardlink", + "sha256": "a6387e3e14881e86e1b71433a76db9d0ed8ab3a67be3fafc79edbcc44dcc77e1", + "sha256_in_prefix": "a6387e3e14881e86e1b71433a76db9d0ed8ab3a67be3fafc79edbcc44dcc77e1", + "size_in_bytes": 2460 + }, + { + "_path": "include/python3.10/unicodeobject.h", + "path_type": "hardlink", + "sha256": "99a0694450678191c1105c5bfdd53caafd7a9bf96af0c894fac0b725194972e7", + "sha256_in_prefix": "99a0694450678191c1105c5bfdd53caafd7a9bf96af0c894fac0b725194972e7", + "size_in_bytes": 36148 + }, + { + "_path": "include/python3.10/warnings.h", + "path_type": "hardlink", + "sha256": "d07c5b3d4b5f3b0c651e1d4244cfe7494e312792ece3568a5134dd8169b61eb2", + "sha256_in_prefix": "d07c5b3d4b5f3b0c651e1d4244cfe7494e312792ece3568a5134dd8169b61eb2", + "size_in_bytes": 1776 + }, + { + "_path": "include/python3.10/weakrefobject.h", + "path_type": "hardlink", + "sha256": "d64920779d0bdf9b1620eb19afa837d0d74df2e076819b90aa95a3aa0a35c009", + "sha256_in_prefix": "d64920779d0bdf9b1620eb19afa837d0d74df2e076819b90aa95a3aa0a35c009", + "size_in_bytes": 2863 + }, + { + "_path": "lib/libpython3.10.dylib", + "file_mode": "binary", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_9afkyeq1z4/croot/python-split_1715024112201/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_p", + "sha256": "7b1f9570c42214c0e6e8635e8c63baa3595a775426eac7f124cff5335bd6cb40", + "sha256_in_prefix": "abb207b8c7d590a3ed8e104de52d6b7966dbc39fabe725a28c1bc11e61a21e58", + "size_in_bytes": 3864464 + }, + { + "_path": "lib/pkgconfig/python-3.10-embed.pc", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_9afkyeq1z4/croot/python-split_1715024112201/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_p", + "sha256": "680dfe09aa7c661be98e9efa4a887f980e6c5bb4d7e61f78fbb4ea270c9b09fa", + "sha256_in_prefix": "42b27adc731ee221dd2bc09d66470c6b61cf5a633f9a5bde68a27fcb35dd3ea7", + "size_in_bytes": 559 + }, + { + "_path": "lib/pkgconfig/python-3.10.pc", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_9afkyeq1z4/croot/python-split_1715024112201/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_p", + "sha256": "a5d91d009752e565bdf4af589608872508e12f763dd67665d3a0c49df8216c21", + "sha256_in_prefix": "a45dec0733455234729d7a8d0b17d5715cb8c9758f1b214ef4e1b1e9fff23580", + "size_in_bytes": 532 + }, + { + "_path": "lib/pkgconfig/python3-embed.pc", + "path_type": "softlink", + "sha256": "680dfe09aa7c661be98e9efa4a887f980e6c5bb4d7e61f78fbb4ea270c9b09fa", + "size_in_bytes": 559 + }, + { + "_path": "lib/pkgconfig/python3.pc", + "path_type": "softlink", + "sha256": "a5d91d009752e565bdf4af589608872508e12f763dd67665d3a0c49df8216c21", + "size_in_bytes": 532 + }, + { + "_path": "lib/python3.1", + "path_type": "softlink", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size_in_bytes": 0 + }, + { + "_path": "lib/python3.10/LICENSE.txt", + "path_type": "hardlink", + "sha256": "3b2f81fe21d181c499c59a256c8e1968455d6689d269aa85373bfb6af41da3bf", + "sha256_in_prefix": "3b2f81fe21d181c499c59a256c8e1968455d6689d269aa85373bfb6af41da3bf", + "size_in_bytes": 13936 + }, + { + "_path": "lib/python3.10/__future__.py", + "path_type": "hardlink", + "sha256": "7923cdce02f46d719df43663dcf5f5bf21e28ac5397c950ec7dc4e357881b33f", + "sha256_in_prefix": "7923cdce02f46d719df43663dcf5f5bf21e28ac5397c950ec7dc4e357881b33f", + "size_in_bytes": 5155 + }, + { + "_path": "lib/python3.10/__phello__.foo.py", + "path_type": "hardlink", + "sha256": "586d9bf9b42fadd32feb1fba80613bcbfb4180dbcd6f03af678b5a6deb9d6a7b", + "sha256_in_prefix": "586d9bf9b42fadd32feb1fba80613bcbfb4180dbcd6f03af678b5a6deb9d6a7b", + "size_in_bytes": 64 + }, + { + "_path": "lib/python3.10/__pycache__/__future__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "b4400240cb61bac95f1b30edddb9019299bcb7cdebc786645e7e393f3d044622", + "sha256_in_prefix": "b4400240cb61bac95f1b30edddb9019299bcb7cdebc786645e7e393f3d044622", + "size_in_bytes": 4385 + }, + { + "_path": "lib/python3.10/__pycache__/__phello__.foo.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "0d92003811f61096c30da9e786b25f6b7f7db272f2bc5b4ecc5b2aa26ce2d90e", + "sha256_in_prefix": "0d92003811f61096c30da9e786b25f6b7f7db272f2bc5b4ecc5b2aa26ce2d90e", + "size_in_bytes": 384 + }, + { + "_path": "lib/python3.10/__pycache__/_aix_support.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "74d84993a86c57fdccb1ff7b23b678b22668003f5861475d23a576f6f9c751ac", + "sha256_in_prefix": "74d84993a86c57fdccb1ff7b23b678b22668003f5861475d23a576f6f9c751ac", + "size_in_bytes": 3133 + }, + { + "_path": "lib/python3.10/__pycache__/_bootsubprocess.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "40afad151efd5325420b68e419e9bc7ca00860072d669d1b371a48244301f05a", + "sha256_in_prefix": "40afad151efd5325420b68e419e9bc7ca00860072d669d1b371a48244301f05a", + "size_in_bytes": 2548 + }, + { + "_path": "lib/python3.10/__pycache__/_collections_abc.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "3705adeeb0ddb5592775a9f427879a1eda2a77f2e2b15ab1aa56e0ef6f1ad39f", + "sha256_in_prefix": "3705adeeb0ddb5592775a9f427879a1eda2a77f2e2b15ab1aa56e0ef6f1ad39f", + "size_in_bytes": 33179 + }, + { + "_path": "lib/python3.10/__pycache__/_compat_pickle.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "448003ce38a928842f989516b480fa63fd7c1caa00c2e2155a4e20cf1c33882d", + "sha256_in_prefix": "448003ce38a928842f989516b480fa63fd7c1caa00c2e2155a4e20cf1c33882d", + "size_in_bytes": 6126 + }, + { + "_path": "lib/python3.10/__pycache__/_compression.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "efbfbc1a43f7219c5f211b24672bd2aeaa032a98721977c52adc5db4d38d94f8", + "sha256_in_prefix": "efbfbc1a43f7219c5f211b24672bd2aeaa032a98721977c52adc5db4d38d94f8", + "size_in_bytes": 4766 + }, + { + "_path": "lib/python3.10/__pycache__/_markupbase.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "4287cce456ca1be6e0cee9396233113517742a9d4f6f6cbfc03133e11a192c64", + "sha256_in_prefix": "4287cce456ca1be6e0cee9396233113517742a9d4f6f6cbfc03133e11a192c64", + "size_in_bytes": 7826 + }, + { + "_path": "lib/python3.10/__pycache__/_osx_support.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "403ea0eae3d1140d78ad6098ec8c1c4b46ed4a2ba929e36196fb5e1d08822072", + "sha256_in_prefix": "403ea0eae3d1140d78ad6098ec8c1c4b46ed4a2ba929e36196fb5e1d08822072", + "size_in_bytes": 11789 + }, + { + "_path": "lib/python3.10/__pycache__/_py_abc.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "ca109749193930066f511803fbeba6b784ae3e217d886f10da830e2aefc1ea33", + "sha256_in_prefix": "ca109749193930066f511803fbeba6b784ae3e217d886f10da830e2aefc1ea33", + "size_in_bytes": 4937 + }, + { + "_path": "lib/python3.10/__pycache__/_pydecimal.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c408bb10ac1eb72fb56f5a6a5280f816766c3d771c6019a55903f958230efe9a", + "sha256_in_prefix": "c408bb10ac1eb72fb56f5a6a5280f816766c3d771c6019a55903f958230efe9a", + "size_in_bytes": 157990 + }, + { + "_path": "lib/python3.10/__pycache__/_pyio.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "ff30382a92156104f756a2e02aacd68b40e22050eb0d9f09256a7c906a65b824", + "sha256_in_prefix": "ff30382a92156104f756a2e02aacd68b40e22050eb0d9f09256a7c906a65b824", + "size_in_bytes": 73649 + }, + { + "_path": "lib/python3.10/__pycache__/_sitebuiltins.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "5a1c5e7fd72c254268da36c9c6b8511967e77d139d9a684af7c17429617bb92e", + "sha256_in_prefix": "5a1c5e7fd72c254268da36c9c6b8511967e77d139d9a684af7c17429617bb92e", + "size_in_bytes": 3801 + }, + { + "_path": "lib/python3.10/__pycache__/_strptime.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "f9b89b256738b6103b7f6ccf083b0151062becd023fbf40054087c5201eef1eb", + "sha256_in_prefix": "f9b89b256738b6103b7f6ccf083b0151062becd023fbf40054087c5201eef1eb", + "size_in_bytes": 16199 + }, + { + "_path": "lib/python3.10/__pycache__/_sysconfigdata__darwin_darwin.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "eb806727aa1a98280b614d68278ba12e73ecc9bf781664108799a6ae12bfe882", + "sha256_in_prefix": "eb806727aa1a98280b614d68278ba12e73ecc9bf781664108799a6ae12bfe882", + "size_in_bytes": 57477 + }, + { + "_path": "lib/python3.10/__pycache__/_sysconfigdata_arm64_apple_darwin20_0_0.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "d6d51c552a9c2a1a2e21e72cb87818d42c8cfc3a070a936eec0791bb2ad9b1c4", + "sha256_in_prefix": "d6d51c552a9c2a1a2e21e72cb87818d42c8cfc3a070a936eec0791bb2ad9b1c4", + "size_in_bytes": 58720 + }, + { + "_path": "lib/python3.10/__pycache__/_threading_local.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "956a29319dfce726dbbda799bdf596fa7c3ddc455279aebc05c9d3f3226b475c", + "sha256_in_prefix": "956a29319dfce726dbbda799bdf596fa7c3ddc455279aebc05c9d3f3226b475c", + "size_in_bytes": 6793 + }, + { + "_path": "lib/python3.10/__pycache__/_weakrefset.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "89a206d3765095441f4f87b4e0de6363811e9c849e58fbc9fdb7b4253f6b5a18", + "sha256_in_prefix": "89a206d3765095441f4f87b4e0de6363811e9c849e58fbc9fdb7b4253f6b5a18", + "size_in_bytes": 7862 + }, + { + "_path": "lib/python3.10/__pycache__/abc.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "a52553d510dfc14f194ce4f05b1a074245caac9ee764c90ba1170c4d7703e084", + "sha256_in_prefix": "a52553d510dfc14f194ce4f05b1a074245caac9ee764c90ba1170c4d7703e084", + "size_in_bytes": 7005 + }, + { + "_path": "lib/python3.10/__pycache__/aifc.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "96fa531f6eaf2c655060de9de0b5a526b1926187b6725a7b5e1b3785bf793651", + "sha256_in_prefix": "96fa531f6eaf2c655060de9de0b5a526b1926187b6725a7b5e1b3785bf793651", + "size_in_bytes": 24939 + }, + { + "_path": "lib/python3.10/__pycache__/antigravity.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c15ba793e79f1c88709ff4ccf712d044c07d69ad754e5f4389ab52d996293d3d", + "sha256_in_prefix": "c15ba793e79f1c88709ff4ccf712d044c07d69ad754e5f4389ab52d996293d3d", + "size_in_bytes": 1076 + }, + { + "_path": "lib/python3.10/__pycache__/argparse.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "653261b6cefdd6b591630d7d73121050a3f4836b6be9472d7ba3592db591f91b", + "sha256_in_prefix": "653261b6cefdd6b591630d7d73121050a3f4836b6be9472d7ba3592db591f91b", + "size_in_bytes": 63480 + }, + { + "_path": "lib/python3.10/__pycache__/ast.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "4fdba66a5b5d6056c4f44735830a9c95e7263f715755e51878e08d57cc49573d", + "sha256_in_prefix": "4fdba66a5b5d6056c4f44735830a9c95e7263f715755e51878e08d57cc49573d", + "size_in_bytes": 55993 + }, + { + "_path": "lib/python3.10/__pycache__/asynchat.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "77bc80a0e9730883ff9deebe553a9bd04b90f996897fe2d6742ae9c5b2884f94", + "sha256_in_prefix": "77bc80a0e9730883ff9deebe553a9bd04b90f996897fe2d6742ae9c5b2884f94", + "size_in_bytes": 7279 + }, + { + "_path": "lib/python3.10/__pycache__/asyncore.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "20e719657d8f7fe419cf078ec820e7ee97926cb65144027e7372c3b9d7d00a00", + "sha256_in_prefix": "20e719657d8f7fe419cf078ec820e7ee97926cb65144027e7372c3b9d7d00a00", + "size_in_bytes": 16256 + }, + { + "_path": "lib/python3.10/__pycache__/base64.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "e65e4002d78cf7808e39529a69743bbc1fac426ce553099cab0c340586a9e146", + "sha256_in_prefix": "e65e4002d78cf7808e39529a69743bbc1fac426ce553099cab0c340586a9e146", + "size_in_bytes": 17416 + }, + { + "_path": "lib/python3.10/__pycache__/bdb.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "cff013ddad99a2161fca0ab9b3dffb383646f30508cb3025099a731887ec717b", + "sha256_in_prefix": "cff013ddad99a2161fca0ab9b3dffb383646f30508cb3025099a731887ec717b", + "size_in_bytes": 26086 + }, + { + "_path": "lib/python3.10/__pycache__/binhex.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "58d9d124d04814f5c2228496c5875b922084a5ae67b48891543f608297009f5e", + "sha256_in_prefix": "58d9d124d04814f5c2228496c5875b922084a5ae67b48891543f608297009f5e", + "size_in_bytes": 13124 + }, + { + "_path": "lib/python3.10/__pycache__/bisect.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "2fe405c57a646ff82872f60c542976b44cf80e8b82966f8d534481805d55aab7", + "sha256_in_prefix": "2fe405c57a646ff82872f60c542976b44cf80e8b82966f8d534481805d55aab7", + "size_in_bytes": 2583 + }, + { + "_path": "lib/python3.10/__pycache__/bz2.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "388c6983c5e23e30281cfa4b6087116ce943bfce46f51de2e06c4f2832e4da1e", + "sha256_in_prefix": "388c6983c5e23e30281cfa4b6087116ce943bfce46f51de2e06c4f2832e4da1e", + "size_in_bytes": 10865 + }, + { + "_path": "lib/python3.10/__pycache__/cProfile.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "6f4832fb40c8422631d84ee0b1984bb746cc3386d9f6d55bc8fa1a87c04941cc", + "sha256_in_prefix": "6f4832fb40c8422631d84ee0b1984bb746cc3386d9f6d55bc8fa1a87c04941cc", + "size_in_bytes": 5367 + }, + { + "_path": "lib/python3.10/__pycache__/calendar.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "41ab7e6289302ea49fe02bb5de66f2fcb4d603c896ec57f29923ac1878189e09", + "sha256_in_prefix": "41ab7e6289302ea49fe02bb5de66f2fcb4d603c896ec57f29923ac1878189e09", + "size_in_bytes": 26557 + }, + { + "_path": "lib/python3.10/__pycache__/cgi.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "21508b6a55607103314bf8c2a1e299f5e9a5418e1a8ee02c29ab35a540b7f84b", + "sha256_in_prefix": "21508b6a55607103314bf8c2a1e299f5e9a5418e1a8ee02c29ab35a540b7f84b", + "size_in_bytes": 26977 + }, + { + "_path": "lib/python3.10/__pycache__/cgitb.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "eb42ebda3782db9101ee60737b1eb8f876cac86bfd549740ca73d76c84428df0", + "sha256_in_prefix": "eb42ebda3782db9101ee60737b1eb8f876cac86bfd549740ca73d76c84428df0", + "size_in_bytes": 10252 + }, + { + "_path": "lib/python3.10/__pycache__/chunk.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "9526ed36ad8fdf2a461a0f3a8b87cf2d4ba9faf6598c1d5c23f947da328019d3", + "sha256_in_prefix": "9526ed36ad8fdf2a461a0f3a8b87cf2d4ba9faf6598c1d5c23f947da328019d3", + "size_in_bytes": 5114 + }, + { + "_path": "lib/python3.10/__pycache__/cmd.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "d9697c409d32169e1b487b83dc88dde0afcd41094971f5cdce19b89b4b4ee0d7", + "sha256_in_prefix": "d9697c409d32169e1b487b83dc88dde0afcd41094971f5cdce19b89b4b4ee0d7", + "size_in_bytes": 12961 + }, + { + "_path": "lib/python3.10/__pycache__/code.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "01f3f998ba446add1e80175913158d579b25bc768dccaa890436bfe14d018b0e", + "sha256_in_prefix": "01f3f998ba446add1e80175913158d579b25bc768dccaa890436bfe14d018b0e", + "size_in_bytes": 10211 + }, + { + "_path": "lib/python3.10/__pycache__/codecs.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "f6dd0eb1aed702c9bda5ce714f805b2f48d69784792239f924bf75946b777987", + "sha256_in_prefix": "f6dd0eb1aed702c9bda5ce714f805b2f48d69784792239f924bf75946b777987", + "size_in_bytes": 33473 + }, + { + "_path": "lib/python3.10/__pycache__/codeop.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "56e25f650344efd7be63464e769bb16710c4bf29f97f52160e308ea8fe026838", + "sha256_in_prefix": "56e25f650344efd7be63464e769bb16710c4bf29f97f52160e308ea8fe026838", + "size_in_bytes": 5849 + }, + { + "_path": "lib/python3.10/__pycache__/colorsys.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "8e9f1200e7755d7cb4e158268162de0790390fb217d946420878f9237d4d8ab7", + "sha256_in_prefix": "8e9f1200e7755d7cb4e158268162de0790390fb217d946420878f9237d4d8ab7", + "size_in_bytes": 3519 + }, + { + "_path": "lib/python3.10/__pycache__/compileall.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "6869c23c55badfdbd9b3f6d96034af82fe2f92eba5733f6d046e926d22b97d81", + "sha256_in_prefix": "6869c23c55badfdbd9b3f6d96034af82fe2f92eba5733f6d046e926d22b97d81", + "size_in_bytes": 12987 + }, + { + "_path": "lib/python3.10/__pycache__/configparser.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "83afca07c67a5f77d96a0ef151a4430b30523506204e9e8b45f6cf828ec5eeef", + "sha256_in_prefix": "83afca07c67a5f77d96a0ef151a4430b30523506204e9e8b45f6cf828ec5eeef", + "size_in_bytes": 45712 + }, + { + "_path": "lib/python3.10/__pycache__/contextlib.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "6b8bf7767070ae3c2c7b9d22bbc1120e1b8e544b01e72918f0afb446f7df9969", + "sha256_in_prefix": "6b8bf7767070ae3c2c7b9d22bbc1120e1b8e544b01e72918f0afb446f7df9969", + "size_in_bytes": 21149 + }, + { + "_path": "lib/python3.10/__pycache__/contextvars.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c2f57f37f3d9a12abfd7834f8db67e815624798366a4ceea2317e43a9d532221", + "sha256_in_prefix": "c2f57f37f3d9a12abfd7834f8db67e815624798366a4ceea2317e43a9d532221", + "size_in_bytes": 500 + }, + { + "_path": "lib/python3.10/__pycache__/copy.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "64decfc2d25d7ef0fb208694d90a76bca7b8cb05d7b628ae53e243c6b3bd581f", + "sha256_in_prefix": "64decfc2d25d7ef0fb208694d90a76bca7b8cb05d7b628ae53e243c6b3bd581f", + "size_in_bytes": 7250 + }, + { + "_path": "lib/python3.10/__pycache__/copyreg.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "61570021bcf4d6d70d7b6d204bb5187bc0b19b23d0a0ea81473e2af213c579d9", + "sha256_in_prefix": "61570021bcf4d6d70d7b6d204bb5187bc0b19b23d0a0ea81473e2af213c579d9", + "size_in_bytes": 4937 + }, + { + "_path": "lib/python3.10/__pycache__/crypt.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "585d7215b895f8a93acfec84b6164730df9a7ccfd68ee06de213fe0f73e39069", + "sha256_in_prefix": "585d7215b895f8a93acfec84b6164730df9a7ccfd68ee06de213fe0f73e39069", + "size_in_bytes": 3804 + }, + { + "_path": "lib/python3.10/__pycache__/csv.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "678bbcd238f510ce76e46def71ca4a13bee377445b0939cd4ef3d1715cf73e45", + "sha256_in_prefix": "678bbcd238f510ce76e46def71ca4a13bee377445b0939cd4ef3d1715cf73e45", + "size_in_bytes": 12052 + }, + { + "_path": "lib/python3.10/__pycache__/dataclasses.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "8492229bfdc0d841d19df272212952d3927b262a0cf2854e310512d59d9933b5", + "sha256_in_prefix": "8492229bfdc0d841d19df272212952d3927b262a0cf2854e310512d59d9933b5", + "size_in_bytes": 26832 + }, + { + "_path": "lib/python3.10/__pycache__/datetime.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "da688f0a3da65dd52aca379f681b813dbefbafaae69fc2f3c506c6ad35c2bf4d", + "sha256_in_prefix": "da688f0a3da65dd52aca379f681b813dbefbafaae69fc2f3c506c6ad35c2bf4d", + "size_in_bytes": 56528 + }, + { + "_path": "lib/python3.10/__pycache__/decimal.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "37745d1f434455d6bf8aa25c329a79914c3026a4fecec9a87ae784d3d6ac1523", + "sha256_in_prefix": "37745d1f434455d6bf8aa25c329a79914c3026a4fecec9a87ae784d3d6ac1523", + "size_in_bytes": 616 + }, + { + "_path": "lib/python3.10/__pycache__/difflib.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "40cb5d1019f34a0d8df8ef816a4df5ab5fcb28eb1a20f28361184e205d9ce0e6", + "sha256_in_prefix": "40cb5d1019f34a0d8df8ef816a4df5ab5fcb28eb1a20f28361184e205d9ce0e6", + "size_in_bytes": 58900 + }, + { + "_path": "lib/python3.10/__pycache__/dis.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "fbf9be612e9a1bd2f7121f4d4e5a1de5c27fef1c3eeb1da0a34bbb8b0d9db221", + "sha256_in_prefix": "fbf9be612e9a1bd2f7121f4d4e5a1de5c27fef1c3eeb1da0a34bbb8b0d9db221", + "size_in_bytes": 15910 + }, + { + "_path": "lib/python3.10/__pycache__/doctest.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c5feb35e4844e56346949e78c9f83a990c18e5efac0369c3962ff0af322550d0", + "sha256_in_prefix": "c5feb35e4844e56346949e78c9f83a990c18e5efac0369c3962ff0af322550d0", + "size_in_bytes": 76429 + }, + { + "_path": "lib/python3.10/__pycache__/enum.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "da66a5b03db5a124e7e37f33c164f928df4cce80d24c49a368b36f95f6fe6656", + "sha256_in_prefix": "da66a5b03db5a124e7e37f33c164f928df4cce80d24c49a368b36f95f6fe6656", + "size_in_bytes": 26317 + }, + { + "_path": "lib/python3.10/__pycache__/filecmp.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "f83ba44cc7adbbfee80d5fde25d175c458c6dab351df114ab394a98ce72ffb83", + "sha256_in_prefix": "f83ba44cc7adbbfee80d5fde25d175c458c6dab351df114ab394a98ce72ffb83", + "size_in_bytes": 9003 + }, + { + "_path": "lib/python3.10/__pycache__/fileinput.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "141d4e9264495c8bc48e0541e60224b0c781285929a32d8ed9bcfeacad5c5ed5", + "sha256_in_prefix": "141d4e9264495c8bc48e0541e60224b0c781285929a32d8ed9bcfeacad5c5ed5", + "size_in_bytes": 14326 + }, + { + "_path": "lib/python3.10/__pycache__/fnmatch.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "7fbf805d920be71ed49a34c098bacfc8cafb66ce03fc46ea9542ee964382be19", + "sha256_in_prefix": "7fbf805d920be71ed49a34c098bacfc8cafb66ce03fc46ea9542ee964382be19", + "size_in_bytes": 4498 + }, + { + "_path": "lib/python3.10/__pycache__/fractions.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "f3931e2ed31a74e52b1e7a8e2e028b3241156629e02b89d43e1e4ef5c1ffba11", + "sha256_in_prefix": "f3931e2ed31a74e52b1e7a8e2e028b3241156629e02b89d43e1e4ef5c1ffba11", + "size_in_bytes": 18854 + }, + { + "_path": "lib/python3.10/__pycache__/ftplib.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "7456d488070584f8e84e732edbbc97b975bfe386f974ee30c557cf4f0574a697", + "sha256_in_prefix": "7456d488070584f8e84e732edbbc97b975bfe386f974ee30c557cf4f0574a697", + "size_in_bytes": 29231 + }, + { + "_path": "lib/python3.10/__pycache__/functools.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c7fedc57d8e94cb481559418e42f30fa40665ff9644e30f089e0c2cc84a4bb0e", + "sha256_in_prefix": "c7fedc57d8e94cb481559418e42f30fa40665ff9644e30f089e0c2cc84a4bb0e", + "size_in_bytes": 28589 + }, + { + "_path": "lib/python3.10/__pycache__/genericpath.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "017725066fe80b38f6bdd8f3021db04a43a09e6b9f7517d4678c244ce7d00400", + "sha256_in_prefix": "017725066fe80b38f6bdd8f3021db04a43a09e6b9f7517d4678c244ce7d00400", + "size_in_bytes": 4161 + }, + { + "_path": "lib/python3.10/__pycache__/getopt.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "7c422760fb84531ddf234c61505d759ba75b2a2eb1ada137c74f89d47d07262f", + "sha256_in_prefix": "7c422760fb84531ddf234c61505d759ba75b2a2eb1ada137c74f89d47d07262f", + "size_in_bytes": 6593 + }, + { + "_path": "lib/python3.10/__pycache__/getpass.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "262fb20a9e63d82eb3db3aa101e3d61b4bbda9c8794508ebfc9a185933c33015", + "sha256_in_prefix": "262fb20a9e63d82eb3db3aa101e3d61b4bbda9c8794508ebfc9a185933c33015", + "size_in_bytes": 4464 + }, + { + "_path": "lib/python3.10/__pycache__/gettext.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "148373ca4225f840b889936102e105bda112526d8062e50c83a06d239b2d5130", + "sha256_in_prefix": "148373ca4225f840b889936102e105bda112526d8062e50c83a06d239b2d5130", + "size_in_bytes": 18364 + }, + { + "_path": "lib/python3.10/__pycache__/glob.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "dd205a5b8563456be3fb60b0e5198394a184a576260bf601f38b6b68abe38280", + "sha256_in_prefix": "dd205a5b8563456be3fb60b0e5198394a184a576260bf601f38b6b68abe38280", + "size_in_bytes": 6106 + }, + { + "_path": "lib/python3.10/__pycache__/graphlib.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "32645c5b773034100ce7693745a2a92439ce668796d1ac34c5b3bc8650623e20", + "sha256_in_prefix": "32645c5b773034100ce7693745a2a92439ce668796d1ac34c5b3bc8650623e20", + "size_in_bytes": 7870 + }, + { + "_path": "lib/python3.10/__pycache__/gzip.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "d0e07fd01a69fb3254902660a5df1ed4d6320d3917f607f5129ddf12881e5aab", + "sha256_in_prefix": "d0e07fd01a69fb3254902660a5df1ed4d6320d3917f607f5129ddf12881e5aab", + "size_in_bytes": 18800 + }, + { + "_path": "lib/python3.10/__pycache__/hashlib.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "e85264b58f48e05e3556aa2411d76d73e4ffaf8285a8e6c02c542ed3057d5e35", + "sha256_in_prefix": "e85264b58f48e05e3556aa2411d76d73e4ffaf8285a8e6c02c542ed3057d5e35", + "size_in_bytes": 7099 + }, + { + "_path": "lib/python3.10/__pycache__/heapq.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "e4a33cabee62636677a09b92b8e2311b850408d714aafc39a9c272f141a2c291", + "sha256_in_prefix": "e4a33cabee62636677a09b92b8e2311b850408d714aafc39a9c272f141a2c291", + "size_in_bytes": 14119 + }, + { + "_path": "lib/python3.10/__pycache__/hmac.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "b9b4d10afe14c33ea7fdc4ce50802eed2e95547e08fe8eef772a44971289e42c", + "sha256_in_prefix": "b9b4d10afe14c33ea7fdc4ce50802eed2e95547e08fe8eef772a44971289e42c", + "size_in_bytes": 7227 + }, + { + "_path": "lib/python3.10/__pycache__/imaplib.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "0317f26c00af5e25492c45762ed0cc6547258d53a9515b41485c11cbb7be72bb", + "sha256_in_prefix": "0317f26c00af5e25492c45762ed0cc6547258d53a9515b41485c11cbb7be72bb", + "size_in_bytes": 42566 + }, + { + "_path": "lib/python3.10/__pycache__/imghdr.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "838a47f3449dc0bf6f3c8beffee125fbe018ddb6bfc5868623bc61ee8ac130f7", + "sha256_in_prefix": "838a47f3449dc0bf6f3c8beffee125fbe018ddb6bfc5868623bc61ee8ac130f7", + "size_in_bytes": 4159 + }, + { + "_path": "lib/python3.10/__pycache__/imp.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "b46c580a561c2c58b8a094f5627e2f00f89f9e10e0f6a10c79766bb307d4dfc3", + "sha256_in_prefix": "b46c580a561c2c58b8a094f5627e2f00f89f9e10e0f6a10c79766bb307d4dfc3", + "size_in_bytes": 10040 + }, + { + "_path": "lib/python3.10/__pycache__/inspect.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "65f2cfd81a6e279e3240a05a5e0754ac2e61660d39d439b3d81ee4306b387cea", + "sha256_in_prefix": "65f2cfd81a6e279e3240a05a5e0754ac2e61660d39d439b3d81ee4306b387cea", + "size_in_bytes": 85407 + }, + { + "_path": "lib/python3.10/__pycache__/io.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "97de3de8e511637f4fe9307214190f10d0e9362b8e0a90b7c3aee8adbc1e0188", + "sha256_in_prefix": "97de3de8e511637f4fe9307214190f10d0e9362b8e0a90b7c3aee8adbc1e0188", + "size_in_bytes": 3917 + }, + { + "_path": "lib/python3.10/__pycache__/ipaddress.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "3bdd8557eda0056c4c9d2f074aec1d665150389e3be4ec4c2b1dee276ecad5fa", + "sha256_in_prefix": "3bdd8557eda0056c4c9d2f074aec1d665150389e3be4ec4c2b1dee276ecad5fa", + "size_in_bytes": 61705 + }, + { + "_path": "lib/python3.10/__pycache__/keyword.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "6bb53d8d8f40997214e7aa1adbb1ef3982149b1e7278b26a877c66519f010c9a", + "sha256_in_prefix": "6bb53d8d8f40997214e7aa1adbb1ef3982149b1e7278b26a877c66519f010c9a", + "size_in_bytes": 1181 + }, + { + "_path": "lib/python3.10/__pycache__/linecache.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "3a8b060a5ef79be319694b8aa84f683048bd3e6134b75bd4ecc72cc9b0d52cc7", + "sha256_in_prefix": "3a8b060a5ef79be319694b8aa84f683048bd3e6134b75bd4ecc72cc9b0d52cc7", + "size_in_bytes": 4396 + }, + { + "_path": "lib/python3.10/__pycache__/locale.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "e2eb02d08c094d29c2eeb0f2b4f39d151512d920032f122beec1c335e45f552d", + "sha256_in_prefix": "e2eb02d08c094d29c2eeb0f2b4f39d151512d920032f122beec1c335e45f552d", + "size_in_bytes": 46419 + }, + { + "_path": "lib/python3.10/__pycache__/lzma.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "ef0fb42b275c937c15ca5bbc9e348ea11d68241edd750f877c3a98e8867ceaf7", + "sha256_in_prefix": "ef0fb42b275c937c15ca5bbc9e348ea11d68241edd750f877c3a98e8867ceaf7", + "size_in_bytes": 12095 + }, + { + "_path": "lib/python3.10/__pycache__/mailbox.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "26ee985ff97911fac27a3753c3f7f53e1b8f51a75cebca586ed58bd763a7d4f0", + "sha256_in_prefix": "26ee985ff97911fac27a3753c3f7f53e1b8f51a75cebca586ed58bd763a7d4f0", + "size_in_bytes": 60345 + }, + { + "_path": "lib/python3.10/__pycache__/mailcap.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "eb78b7326bab97d8404c7ca04a37dc0b395a750f99fe568ea7c7f870fd31a289", + "sha256_in_prefix": "eb78b7326bab97d8404c7ca04a37dc0b395a750f99fe568ea7c7f870fd31a289", + "size_in_bytes": 7315 + }, + { + "_path": "lib/python3.10/__pycache__/mimetypes.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "41aa6242d996d005a37cc99cc9f66371cbf717a0c55adabd59a79a0e7100f291", + "sha256_in_prefix": "41aa6242d996d005a37cc99cc9f66371cbf717a0c55adabd59a79a0e7100f291", + "size_in_bytes": 17873 + }, + { + "_path": "lib/python3.10/__pycache__/modulefinder.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "329c08f04075d30537ee703668778b759bfb90a865a31c27ed1c60b73df01aec", + "sha256_in_prefix": "329c08f04075d30537ee703668778b759bfb90a865a31c27ed1c60b73df01aec", + "size_in_bytes": 16420 + }, + { + "_path": "lib/python3.10/__pycache__/netrc.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "9d1c97a947c74d169ced52ecaaec755bc97f7ddffe884cea69b459dae11ef768", + "sha256_in_prefix": "9d1c97a947c74d169ced52ecaaec755bc97f7ddffe884cea69b459dae11ef768", + "size_in_bytes": 4187 + }, + { + "_path": "lib/python3.10/__pycache__/nntplib.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "12b86f6b84eb639725c05ea07b23c8c333befff47b36d91a2f4164b39976e880", + "sha256_in_prefix": "12b86f6b84eb639725c05ea07b23c8c333befff47b36d91a2f4164b39976e880", + "size_in_bytes": 31618 + }, + { + "_path": "lib/python3.10/__pycache__/ntpath.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "afb3d2071aa6e66e3ad57d0ae6f3ed72f5204f1e8a48c870b25ae617d5f26dc6", + "sha256_in_prefix": "afb3d2071aa6e66e3ad57d0ae6f3ed72f5204f1e8a48c870b25ae617d5f26dc6", + "size_in_bytes": 15557 + }, + { + "_path": "lib/python3.10/__pycache__/nturl2path.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "4553299c008527b278c6267b2fdb24abca4e83c737c12d2f41fda199be56830a", + "sha256_in_prefix": "4553299c008527b278c6267b2fdb24abca4e83c737c12d2f41fda199be56830a", + "size_in_bytes": 2001 + }, + { + "_path": "lib/python3.10/__pycache__/numbers.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "7b8f9165e3fe1fe5eb792ed562bf9ae91cde73c678b5183fe01ac6a8ee9c96a2", + "sha256_in_prefix": "7b8f9165e3fe1fe5eb792ed562bf9ae91cde73c678b5183fe01ac6a8ee9c96a2", + "size_in_bytes": 12120 + }, + { + "_path": "lib/python3.10/__pycache__/opcode.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "7e3f11d2639a0ca368994591f750f0dda1c40bf61e50f98926a8bcf0d5f92781", + "sha256_in_prefix": "7e3f11d2639a0ca368994591f750f0dda1c40bf61e50f98926a8bcf0d5f92781", + "size_in_bytes": 5701 + }, + { + "_path": "lib/python3.10/__pycache__/operator.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "e33d469c1ef19afb226be604d443c0632c0cfdf371b0b2be1ca88201eb7d05ba", + "sha256_in_prefix": "e33d469c1ef19afb226be604d443c0632c0cfdf371b0b2be1ca88201eb7d05ba", + "size_in_bytes": 13762 + }, + { + "_path": "lib/python3.10/__pycache__/optparse.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "12e45c066b939489305438da8cdb99d089ad5976eb9509c3ee44abd68558da1d", + "sha256_in_prefix": "12e45c066b939489305438da8cdb99d089ad5976eb9509c3ee44abd68558da1d", + "size_in_bytes": 48008 + }, + { + "_path": "lib/python3.10/__pycache__/os.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "ee8c8334085a36a276a2a7588d37325b22096657763c38d77a65d87a16167fe6", + "sha256_in_prefix": "ee8c8334085a36a276a2a7588d37325b22096657763c38d77a65d87a16167fe6", + "size_in_bytes": 31853 + }, + { + "_path": "lib/python3.10/__pycache__/pathlib.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "8b3907a9e51f8960d8ed9f90a80313cfb77d06879ca49a337ef5b3a425c34c89", + "sha256_in_prefix": "8b3907a9e51f8960d8ed9f90a80313cfb77d06879ca49a337ef5b3a425c34c89", + "size_in_bytes": 42306 + }, + { + "_path": "lib/python3.10/__pycache__/pdb.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "76ab63e94834951bb52b48ac2f697d97e32b8906bf1e5d8a398b46fe251558c7", + "sha256_in_prefix": "76ab63e94834951bb52b48ac2f697d97e32b8906bf1e5d8a398b46fe251558c7", + "size_in_bytes": 47435 + }, + { + "_path": "lib/python3.10/__pycache__/pickle.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "332a98837f8ef0e0462ca05369fc595d5ddfdb9ef8329f23b8a2e8c2e1571276", + "sha256_in_prefix": "332a98837f8ef0e0462ca05369fc595d5ddfdb9ef8329f23b8a2e8c2e1571276", + "size_in_bytes": 47136 + }, + { + "_path": "lib/python3.10/__pycache__/pickletools.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "e5e32ef4cf4b58be1ec348b20bb215426d509feae0ccdd12879adba6454959a3", + "sha256_in_prefix": "e5e32ef4cf4b58be1ec348b20bb215426d509feae0ccdd12879adba6454959a3", + "size_in_bytes": 68014 + }, + { + "_path": "lib/python3.10/__pycache__/pipes.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "7db85cd541010725873b10dd5d2ce937f644318240666747b97cadf802a2e42e", + "sha256_in_prefix": "7db85cd541010725873b10dd5d2ce937f644318240666747b97cadf802a2e42e", + "size_in_bytes": 8023 + }, + { + "_path": "lib/python3.10/__pycache__/pkgutil.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "2b86671ff03bd2e9057fbd5163be4ba97608ea2aa23b2a78040aa548bc8f794d", + "sha256_in_prefix": "2b86671ff03bd2e9057fbd5163be4ba97608ea2aa23b2a78040aa548bc8f794d", + "size_in_bytes": 18615 + }, + { + "_path": "lib/python3.10/__pycache__/platform.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "f0e3ae39791484fb075953aecf85613b5a5cee114a497bad349f3fe5b199edd4", + "sha256_in_prefix": "f0e3ae39791484fb075953aecf85613b5a5cee114a497bad349f3fe5b199edd4", + "size_in_bytes": 27749 + }, + { + "_path": "lib/python3.10/__pycache__/plistlib.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "e23305830d8f895b514a0c9c1a0c818385052d561d3735a792296e7c053909d6", + "sha256_in_prefix": "e23305830d8f895b514a0c9c1a0c818385052d561d3735a792296e7c053909d6", + "size_in_bytes": 23810 + }, + { + "_path": "lib/python3.10/__pycache__/poplib.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "79f55fdcc7e417f3b095aa72c5abcce72e3e05a14dafc27314ddffa9833c21f4", + "sha256_in_prefix": "79f55fdcc7e417f3b095aa72c5abcce72e3e05a14dafc27314ddffa9833c21f4", + "size_in_bytes": 13827 + }, + { + "_path": "lib/python3.10/__pycache__/posixpath.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "af5ad547cebb7e6d7a555aac88f073dfcee2e2793987ae19a220d6bfc4ac1549", + "sha256_in_prefix": "af5ad547cebb7e6d7a555aac88f073dfcee2e2793987ae19a220d6bfc4ac1549", + "size_in_bytes": 10784 + }, + { + "_path": "lib/python3.10/__pycache__/pprint.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "480b453266bfc47328f5c59673975d0cc684bbcd18130ff79e195700fb13ffab", + "sha256_in_prefix": "480b453266bfc47328f5c59673975d0cc684bbcd18130ff79e195700fb13ffab", + "size_in_bytes": 18129 + }, + { + "_path": "lib/python3.10/__pycache__/profile.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "b5d6a24048a288c977fb7760bef5a75c081599ccc1ee4d74e5ffe3652d9ec7e1", + "sha256_in_prefix": "b5d6a24048a288c977fb7760bef5a75c081599ccc1ee4d74e5ffe3652d9ec7e1", + "size_in_bytes": 14645 + }, + { + "_path": "lib/python3.10/__pycache__/pstats.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "74a105a817909e809dc4f03f6f5455a51b2abbcdf2eddefcae4f52712756cbff", + "sha256_in_prefix": "74a105a817909e809dc4f03f6f5455a51b2abbcdf2eddefcae4f52712756cbff", + "size_in_bytes": 23616 + }, + { + "_path": "lib/python3.10/__pycache__/pty.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "7764d7bf1369e06195f94464b10bf1841f872b0a3b658a4bfc3e61c04d1a62db", + "sha256_in_prefix": "7764d7bf1369e06195f94464b10bf1841f872b0a3b658a4bfc3e61c04d1a62db", + "size_in_bytes": 4397 + }, + { + "_path": "lib/python3.10/__pycache__/py_compile.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "8c51520e06892c5c9c8643b2ae596f44a87e8e00f90878ffba38fae8d6715f01", + "sha256_in_prefix": "8c51520e06892c5c9c8643b2ae596f44a87e8e00f90878ffba38fae8d6715f01", + "size_in_bytes": 7571 + }, + { + "_path": "lib/python3.10/__pycache__/pyclbr.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "eea28e22a5cb5e2f72f8d0502a38ac8603bb39d143706b56304c0f0a66f05d4e", + "sha256_in_prefix": "eea28e22a5cb5e2f72f8d0502a38ac8603bb39d143706b56304c0f0a66f05d4e", + "size_in_bytes": 10029 + }, + { + "_path": "lib/python3.10/__pycache__/pydoc.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "853cefb6de255c4375b360519b9d21cc9f3c7c1b7d1077bb912fef01ec95d728", + "sha256_in_prefix": "853cefb6de255c4375b360519b9d21cc9f3c7c1b7d1077bb912fef01ec95d728", + "size_in_bytes": 85634 + }, + { + "_path": "lib/python3.10/__pycache__/queue.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "3f977a43029a4742801bc954076cc5740834ece129dd704a5adff6157e9159d8", + "sha256_in_prefix": "3f977a43029a4742801bc954076cc5740834ece129dd704a5adff6157e9159d8", + "size_in_bytes": 11046 + }, + { + "_path": "lib/python3.10/__pycache__/quopri.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "ad041b7a6d53f7320fa5d3493ba76084a324e6801a7dcf6d3b401f708ca9e74c", + "sha256_in_prefix": "ad041b7a6d53f7320fa5d3493ba76084a324e6801a7dcf6d3b401f708ca9e74c", + "size_in_bytes": 6048 + }, + { + "_path": "lib/python3.10/__pycache__/random.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "7f799e9a6a4efef1df5aa0bdf3cf0baff9821cd86b89122e84a0dbc73bce221f", + "sha256_in_prefix": "7f799e9a6a4efef1df5aa0bdf3cf0baff9821cd86b89122e84a0dbc73bce221f", + "size_in_bytes": 23002 + }, + { + "_path": "lib/python3.10/__pycache__/re.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "de6f6b6b8e587a60ceef34f7e232eeb60d4fba1b41852b278d62a55b709e7f3a", + "sha256_in_prefix": "de6f6b6b8e587a60ceef34f7e232eeb60d4fba1b41852b278d62a55b709e7f3a", + "size_in_bytes": 14481 + }, + { + "_path": "lib/python3.10/__pycache__/reprlib.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "05634e96492039fb43041a3bcc3ce453027ac674e874430d93e49a7188495332", + "sha256_in_prefix": "05634e96492039fb43041a3bcc3ce453027ac674e874430d93e49a7188495332", + "size_in_bytes": 5504 + }, + { + "_path": "lib/python3.10/__pycache__/rlcompleter.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "9a12abe6afa01bfb5ff1dff5c65596e82c9e0b9696a4bed623c5b0ad30f35fbd", + "sha256_in_prefix": "9a12abe6afa01bfb5ff1dff5c65596e82c9e0b9696a4bed623c5b0ad30f35fbd", + "size_in_bytes": 6208 + }, + { + "_path": "lib/python3.10/__pycache__/runpy.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "2f7f23f41bd3053299446cd47182c63d0d37d4e571d71fd27cf3168bdb4278d8", + "sha256_in_prefix": "2f7f23f41bd3053299446cd47182c63d0d37d4e571d71fd27cf3168bdb4278d8", + "size_in_bytes": 9665 + }, + { + "_path": "lib/python3.10/__pycache__/sched.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "8b87370133b11f0cecd85162b9eff6acf12eff0d92c76e9b60aaeae7479067dd", + "sha256_in_prefix": "8b87370133b11f0cecd85162b9eff6acf12eff0d92c76e9b60aaeae7479067dd", + "size_in_bytes": 6369 + }, + { + "_path": "lib/python3.10/__pycache__/secrets.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "e54f26116de28db76fac51d9fe2ad7db94b740c8f30cdd1de1a795d854a52f37", + "sha256_in_prefix": "e54f26116de28db76fac51d9fe2ad7db94b740c8f30cdd1de1a795d854a52f37", + "size_in_bytes": 2429 + }, + { + "_path": "lib/python3.10/__pycache__/selectors.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "466b56ea319722116fd2daed9a9356698cee4b614c8a357f51833c2642247e11", + "sha256_in_prefix": "466b56ea319722116fd2daed9a9356698cee4b614c8a357f51833c2642247e11", + "size_in_bytes": 17359 + }, + { + "_path": "lib/python3.10/__pycache__/shelve.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "fb0c9f0543143667d2864540755a44d9a4f85e58f3bee6534b6b325f159f32c9", + "sha256_in_prefix": "fb0c9f0543143667d2864540755a44d9a4f85e58f3bee6534b6b325f159f32c9", + "size_in_bytes": 9746 + }, + { + "_path": "lib/python3.10/__pycache__/shlex.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c12946081162ca3a5bac322701d059d441bd7ef7c291ce0daab57ecf61117a68", + "sha256_in_prefix": "c12946081162ca3a5bac322701d059d441bd7ef7c291ce0daab57ecf61117a68", + "size_in_bytes": 8036 + }, + { + "_path": "lib/python3.10/__pycache__/shutil.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "7a5fa7157229da3fd94f4d39c5086c13dcbaf842b4a7bf4baf7376d4b151b05e", + "sha256_in_prefix": "7a5fa7157229da3fd94f4d39c5086c13dcbaf842b4a7bf4baf7376d4b151b05e", + "size_in_bytes": 38790 + }, + { + "_path": "lib/python3.10/__pycache__/signal.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "9269615b7bfaedb29c59c989bcdbea06bfbc4b24bd5b799d4e58c1093f455f60", + "sha256_in_prefix": "9269615b7bfaedb29c59c989bcdbea06bfbc4b24bd5b799d4e58c1093f455f60", + "size_in_bytes": 3189 + }, + { + "_path": "lib/python3.10/__pycache__/site.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "cd0d6790f041a3b661e66f00676431f93e857dd49580ee5d01e36bb04e4a6e08", + "sha256_in_prefix": "cd0d6790f041a3b661e66f00676431f93e857dd49580ee5d01e36bb04e4a6e08", + "size_in_bytes": 17902 + }, + { + "_path": "lib/python3.10/__pycache__/smtpd.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "7399c09f937bb69c75f57b3aba64d15009498ac4d21fc9a35bd2668ae65cf390", + "sha256_in_prefix": "7399c09f937bb69c75f57b3aba64d15009498ac4d21fc9a35bd2668ae65cf390", + "size_in_bytes": 26401 + }, + { + "_path": "lib/python3.10/__pycache__/smtplib.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "38efe1268c57a7bd00e721cd87aac916d7391a352b99292ebf0baf797e47b283", + "sha256_in_prefix": "38efe1268c57a7bd00e721cd87aac916d7391a352b99292ebf0baf797e47b283", + "size_in_bytes": 36020 + }, + { + "_path": "lib/python3.10/__pycache__/sndhdr.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "36d3d17304b43a2bd66bf4e0fdabb997fa500ae2778053fcf38df49a24f22f8d", + "sha256_in_prefix": "36d3d17304b43a2bd66bf4e0fdabb997fa500ae2778053fcf38df49a24f22f8d", + "size_in_bytes": 7216 + }, + { + "_path": "lib/python3.10/__pycache__/socket.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "73631c65590777b0e07f303619b090eeacf6c47b758ddaacd194f9544323627a", + "sha256_in_prefix": "73631c65590777b0e07f303619b090eeacf6c47b758ddaacd194f9544323627a", + "size_in_bytes": 29217 + }, + { + "_path": "lib/python3.10/__pycache__/socketserver.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "9896c3117ef237e5ae913794cba70879599eb075c31477f24940a1101fdfa6df", + "sha256_in_prefix": "9896c3117ef237e5ae913794cba70879599eb075c31477f24940a1101fdfa6df", + "size_in_bytes": 25601 + }, + { + "_path": "lib/python3.10/__pycache__/sre_compile.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "5ff24ece8dfe2ec6cdd2aa3ef738ba3a22da25e73d88adc6df983f8f6ddb8c7f", + "sha256_in_prefix": "5ff24ece8dfe2ec6cdd2aa3ef738ba3a22da25e73d88adc6df983f8f6ddb8c7f", + "size_in_bytes": 15448 + }, + { + "_path": "lib/python3.10/__pycache__/sre_constants.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "7458a0443a5c3528e72bb5234e08a559bd093369823a60c8702e26f25b942e12", + "sha256_in_prefix": "7458a0443a5c3528e72bb5234e08a559bd093369823a60c8702e26f25b942e12", + "size_in_bytes": 6611 + }, + { + "_path": "lib/python3.10/__pycache__/sre_parse.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "cdf0130c3260d61c4ae02cebb348a2a7124311f5a0a905b5316dbd21b9ea96d7", + "sha256_in_prefix": "cdf0130c3260d61c4ae02cebb348a2a7124311f5a0a905b5316dbd21b9ea96d7", + "size_in_bytes": 22009 + }, + { + "_path": "lib/python3.10/__pycache__/ssl.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "90ee6432f019288a23f4decb84a718114cb98b4f7344be67e83cf45303fa08a0", + "sha256_in_prefix": "90ee6432f019288a23f4decb84a718114cb98b4f7344be67e83cf45303fa08a0", + "size_in_bytes": 45535 + }, + { + "_path": "lib/python3.10/__pycache__/stat.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "1976574aa065b1ac292f8d713d37f02e97c4342696464e5e71e98b1b2026f265", + "sha256_in_prefix": "1976574aa065b1ac292f8d713d37f02e97c4342696464e5e71e98b1b2026f265", + "size_in_bytes": 4527 + }, + { + "_path": "lib/python3.10/__pycache__/statistics.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "564529e2d5c9bf9af57231465c03bf4cd1eaa04f144c77814ea641d64d6065c9", + "sha256_in_prefix": "564529e2d5c9bf9af57231465c03bf4cd1eaa04f144c77814ea641d64d6065c9", + "size_in_bytes": 37305 + }, + { + "_path": "lib/python3.10/__pycache__/string.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "2db1d247799b8173ca3a75a928c5e41e4dbe1b76b1e2730e99b7d827f5c635d2", + "sha256_in_prefix": "2db1d247799b8173ca3a75a928c5e41e4dbe1b76b1e2730e99b7d827f5c635d2", + "size_in_bytes": 7356 + }, + { + "_path": "lib/python3.10/__pycache__/stringprep.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "23d1f3f79af1f13e97129248afb3514b5519157b33838d0799b0f56467aa9104", + "sha256_in_prefix": "23d1f3f79af1f13e97129248afb3514b5519157b33838d0799b0f56467aa9104", + "size_in_bytes": 17329 + }, + { + "_path": "lib/python3.10/__pycache__/struct.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "3688a1f0af065700ea01e94a97465309550daa3567e50027a508a48161f5b198", + "sha256_in_prefix": "3688a1f0af065700ea01e94a97465309550daa3567e50027a508a48161f5b198", + "size_in_bytes": 561 + }, + { + "_path": "lib/python3.10/__pycache__/subprocess.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "ee4dfd25ca82d435506dbd280ff00788ac18f714ba4ac01dd48eac68c448b084", + "sha256_in_prefix": "ee4dfd25ca82d435506dbd280ff00788ac18f714ba4ac01dd48eac68c448b084", + "size_in_bytes": 44995 + }, + { + "_path": "lib/python3.10/__pycache__/sunau.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "930531ad687c85cf8044ce5a2e07e1ac79845496da8c0da9cc76d5f08a5d9ccf", + "sha256_in_prefix": "930531ad687c85cf8044ce5a2e07e1ac79845496da8c0da9cc76d5f08a5d9ccf", + "size_in_bytes": 16736 + }, + { + "_path": "lib/python3.10/__pycache__/symtable.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "879e5a33e2280a19bafcc09fe58c528daec95b04693c768e89c3bb9064805362", + "sha256_in_prefix": "879e5a33e2280a19bafcc09fe58c528daec95b04693c768e89c3bb9064805362", + "size_in_bytes": 13089 + }, + { + "_path": "lib/python3.10/__pycache__/sysconfig.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "937aa0ab417e860a11b07ad3037d8ebea4a2fd186c91107dd82b41ea04853d06", + "sha256_in_prefix": "937aa0ab417e860a11b07ad3037d8ebea4a2fd186c91107dd82b41ea04853d06", + "size_in_bytes": 17767 + }, + { + "_path": "lib/python3.10/__pycache__/tabnanny.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "bd7c8620d89ea31ac448b09163aeb174ab57115a7ed2b1c19637ebf5cb908345", + "sha256_in_prefix": "bd7c8620d89ea31ac448b09163aeb174ab57115a7ed2b1c19637ebf5cb908345", + "size_in_bytes": 7204 + }, + { + "_path": "lib/python3.10/__pycache__/tarfile.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "22565e029d33406c53a4557e7ad6706f75427fb61e5aaf9cefb4f182fe6b0ca0", + "sha256_in_prefix": "22565e029d33406c53a4557e7ad6706f75427fb61e5aaf9cefb4f182fe6b0ca0", + "size_in_bytes": 70607 + }, + { + "_path": "lib/python3.10/__pycache__/telnetlib.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c65f7a03d11380870ce335d60339f7781f3f8b5f2426f3f7af8d477120fdc3c6", + "sha256_in_prefix": "c65f7a03d11380870ce335d60339f7781f3f8b5f2426f3f7af8d477120fdc3c6", + "size_in_bytes": 18760 + }, + { + "_path": "lib/python3.10/__pycache__/tempfile.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "71810ee6e0f42968750c7f2819c3ccc4928aab9f5cc243ff20449dc225c0352f", + "sha256_in_prefix": "71810ee6e0f42968750c7f2819c3ccc4928aab9f5cc243ff20449dc225c0352f", + "size_in_bytes": 24567 + }, + { + "_path": "lib/python3.10/__pycache__/textwrap.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "a60bd591aab34db92c21e066e0d04c11758d76f73471425d70d928bf3d7a899a", + "sha256_in_prefix": "a60bd591aab34db92c21e066e0d04c11758d76f73471425d70d928bf3d7a899a", + "size_in_bytes": 14066 + }, + { + "_path": "lib/python3.10/__pycache__/this.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "186ae09446db64aad0268cba0c6b7314b24b4b28d9695fb53b87918fe5a3f106", + "sha256_in_prefix": "186ae09446db64aad0268cba0c6b7314b24b4b28d9695fb53b87918fe5a3f106", + "size_in_bytes": 1518 + }, + { + "_path": "lib/python3.10/__pycache__/threading.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "4cb74848eba1f5f0b508d775b25437a7bbcbe0aeb9850305880f25e8fa7ad4a0", + "sha256_in_prefix": "4cb74848eba1f5f0b508d775b25437a7bbcbe0aeb9850305880f25e8fa7ad4a0", + "size_in_bytes": 45223 + }, + { + "_path": "lib/python3.10/__pycache__/timeit.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "348e2518d965ad9b0c841aecfd311424aa458519f4eb768693366a5baa0dd118", + "sha256_in_prefix": "348e2518d965ad9b0c841aecfd311424aa458519f4eb768693366a5baa0dd118", + "size_in_bytes": 12023 + }, + { + "_path": "lib/python3.10/__pycache__/token.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "556f792ef1326a52dd4f87c19a58057c66c5bef16d34173377de61636f570b0d", + "sha256_in_prefix": "556f792ef1326a52dd4f87c19a58057c66c5bef16d34173377de61636f570b0d", + "size_in_bytes": 2992 + }, + { + "_path": "lib/python3.10/__pycache__/tokenize.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "1f8741f734bed8e44c0d6933a54e4722242de32470de8bcd83340a35ac0ad352", + "sha256_in_prefix": "1f8741f734bed8e44c0d6933a54e4722242de32470de8bcd83340a35ac0ad352", + "size_in_bytes": 17448 + }, + { + "_path": "lib/python3.10/__pycache__/trace.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "10c5591c3e75634587f9265a5a014cf2e141475b9ea4391b981ee0bbc5124b57", + "sha256_in_prefix": "10c5591c3e75634587f9265a5a014cf2e141475b9ea4391b981ee0bbc5124b57", + "size_in_bytes": 20124 + }, + { + "_path": "lib/python3.10/__pycache__/traceback.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "31d0b30ac4c29ef2f2d2dd5bafacf21c4d34c1e4bea8b8dc31c5f3180bd6d79f", + "sha256_in_prefix": "31d0b30ac4c29ef2f2d2dd5bafacf21c4d34c1e4bea8b8dc31c5f3180bd6d79f", + "size_in_bytes": 21966 + }, + { + "_path": "lib/python3.10/__pycache__/tracemalloc.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "e65a53d0f3a39940d639591cc6a0e5a9a87f5a2a78ce56894214fc281328cda3", + "sha256_in_prefix": "e65a53d0f3a39940d639591cc6a0e5a9a87f5a2a78ce56894214fc281328cda3", + "size_in_bytes": 17779 + }, + { + "_path": "lib/python3.10/__pycache__/tty.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "4c00d776ed42339b847c45e5eaccd510355c3d8e0cdf001aefbcd2f1fffe0386", + "sha256_in_prefix": "4c00d776ed42339b847c45e5eaccd510355c3d8e0cdf001aefbcd2f1fffe0386", + "size_in_bytes": 1333 + }, + { + "_path": "lib/python3.10/__pycache__/turtle.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c119e518158b121dd5df9b364a2145a3df571cbc1fef5f2cb9239b554906c8b4", + "sha256_in_prefix": "c119e518158b121dd5df9b364a2145a3df571cbc1fef5f2cb9239b554906c8b4", + "size_in_bytes": 129111 + }, + { + "_path": "lib/python3.10/__pycache__/types.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "2ff80802d1c1453ac9c8033bc96e74bf4f350d285c30d4b6ea66aaab3ef0acf1", + "sha256_in_prefix": "2ff80802d1c1453ac9c8033bc96e74bf4f350d285c30d4b6ea66aaab3ef0acf1", + "size_in_bytes": 9779 + }, + { + "_path": "lib/python3.10/__pycache__/typing.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "1a09ec028e150b35e8b06fb50262a4f59b20ac3f87663d42e425665e789fe5f1", + "sha256_in_prefix": "1a09ec028e150b35e8b06fb50262a4f59b20ac3f87663d42e425665e789fe5f1", + "size_in_bytes": 85531 + }, + { + "_path": "lib/python3.10/__pycache__/uu.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "5f4d6534c252e38259be605486ec87073c87d41c54dead227f1ad03d5301f600", + "sha256_in_prefix": "5f4d6534c252e38259be605486ec87073c87d41c54dead227f1ad03d5301f600", + "size_in_bytes": 4121 + }, + { + "_path": "lib/python3.10/__pycache__/uuid.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "bd49bf96527b25593232faa59fb504b5b834a9fb879c29299f29d908df2737bc", + "sha256_in_prefix": "bd49bf96527b25593232faa59fb504b5b834a9fb879c29299f29d908df2737bc", + "size_in_bytes": 22752 + }, + { + "_path": "lib/python3.10/__pycache__/warnings.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "1a8aa179d694195741780fcdc616932b7f5d75ddc9242d1929815a2fbd7cd616", + "sha256_in_prefix": "1a8aa179d694195741780fcdc616932b7f5d75ddc9242d1929815a2fbd7cd616", + "size_in_bytes": 13900 + }, + { + "_path": "lib/python3.10/__pycache__/wave.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "f7520ce2f972e65426ab67eef413334d6c13eaf323468172547aec6053929726", + "sha256_in_prefix": "f7520ce2f972e65426ab67eef413334d6c13eaf323468172547aec6053929726", + "size_in_bytes": 17848 + }, + { + "_path": "lib/python3.10/__pycache__/weakref.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "50aa992f0c9441147f76dbfb92233623c175f0931b86eb6ff51ac68e898c517d", + "sha256_in_prefix": "50aa992f0c9441147f76dbfb92233623c175f0931b86eb6ff51ac68e898c517d", + "size_in_bytes": 20597 + }, + { + "_path": "lib/python3.10/__pycache__/webbrowser.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "ca40167c6382225a6116dc352a57d7c3a75be9ff6ec557dc362dbdd594cf236a", + "sha256_in_prefix": "ca40167c6382225a6116dc352a57d7c3a75be9ff6ec557dc362dbdd594cf236a", + "size_in_bytes": 17254 + }, + { + "_path": "lib/python3.10/__pycache__/xdrlib.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "754402e4d3e1ac5c54f112562d9796e18db17f2ff92c6b4f6ffb7c0eccc12455", + "sha256_in_prefix": "754402e4d3e1ac5c54f112562d9796e18db17f2ff92c6b4f6ffb7c0eccc12455", + "size_in_bytes": 8134 + }, + { + "_path": "lib/python3.10/__pycache__/zipapp.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "fdf3b5ea4eec59e1026596e984b42621ce0f56c2fea6a09713982bd31d1b7335", + "sha256_in_prefix": "fdf3b5ea4eec59e1026596e984b42621ce0f56c2fea6a09713982bd31d1b7335", + "size_in_bytes": 6267 + }, + { + "_path": "lib/python3.10/__pycache__/zipfile.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "3c8e5b920291055f1b015372d9c430977f6680f48186aa7a4480dfc34afa374e", + "sha256_in_prefix": "3c8e5b920291055f1b015372d9c430977f6680f48186aa7a4480dfc34afa374e", + "size_in_bytes": 61658 + }, + { + "_path": "lib/python3.10/__pycache__/zipimport.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c9b6b37a1c99d3c3dd80218cdbb8c1bd7075a463da4041e9103eca7cdb9e49a1", + "sha256_in_prefix": "c9b6b37a1c99d3c3dd80218cdbb8c1bd7075a463da4041e9103eca7cdb9e49a1", + "size_in_bytes": 17287 + }, + { + "_path": "lib/python3.10/_aix_support.py", + "path_type": "hardlink", + "sha256": "d46a626c4160dcfde1f8e83f10f014524f0c1faf793432e5f322cd97a403a010", + "sha256_in_prefix": "d46a626c4160dcfde1f8e83f10f014524f0c1faf793432e5f322cd97a403a010", + "size_in_bytes": 3270 + }, + { + "_path": "lib/python3.10/_bootsubprocess.py", + "path_type": "hardlink", + "sha256": "dd8afc4a86131491a4f05078b307aae5eef19d6a26e7d9ffbfe2ebabbd6b5b6a", + "sha256_in_prefix": "dd8afc4a86131491a4f05078b307aae5eef19d6a26e7d9ffbfe2ebabbd6b5b6a", + "size_in_bytes": 2675 + }, + { + "_path": "lib/python3.10/_collections_abc.py", + "path_type": "hardlink", + "sha256": "48560945f0f48a364ceff93de6e4cd2e2779b5effce505e70258506be4c67dba", + "sha256_in_prefix": "48560945f0f48a364ceff93de6e4cd2e2779b5effce505e70258506be4c67dba", + "size_in_bytes": 32284 + }, + { + "_path": "lib/python3.10/_compat_pickle.py", + "path_type": "hardlink", + "sha256": "71248216fb1cc2b9a0a1faa305daa8c680d9c637141cb2db283e407684209cab", + "sha256_in_prefix": "71248216fb1cc2b9a0a1faa305daa8c680d9c637141cb2db283e407684209cab", + "size_in_bytes": 8749 + }, + { + "_path": "lib/python3.10/_compression.py", + "path_type": "hardlink", + "sha256": "3ad5d60627477a60939ee44fc1bb3a05dbe8fb52f0f75039b8f5d8f1a278b981", + "sha256_in_prefix": "3ad5d60627477a60939ee44fc1bb3a05dbe8fb52f0f75039b8f5d8f1a278b981", + "size_in_bytes": 5681 + }, + { + "_path": "lib/python3.10/_markupbase.py", + "path_type": "hardlink", + "sha256": "cb14dd6f2e2439eb70b806cd49d19911363d424c2b6b9f4b73c9c08022d47030", + "sha256_in_prefix": "cb14dd6f2e2439eb70b806cd49d19911363d424c2b6b9f4b73c9c08022d47030", + "size_in_bytes": 14653 + }, + { + "_path": "lib/python3.10/_osx_support.py", + "path_type": "hardlink", + "sha256": "6a99e8c9ff67c891a3c4c19e449fe2ee7b9d8e4b71f8741c3ce4469ce315dd95", + "sha256_in_prefix": "6a99e8c9ff67c891a3c4c19e449fe2ee7b9d8e4b71f8741c3ce4469ce315dd95", + "size_in_bytes": 21787 + }, + { + "_path": "lib/python3.10/_py_abc.py", + "path_type": "hardlink", + "sha256": "f9c6fe3dd9b51bd7d93f867356e9d362600c924febfd903ee1c6e298860dca92", + "sha256_in_prefix": "f9c6fe3dd9b51bd7d93f867356e9d362600c924febfd903ee1c6e298860dca92", + "size_in_bytes": 6189 + }, + { + "_path": "lib/python3.10/_pydecimal.py", + "path_type": "hardlink", + "sha256": "8b8d83314c282428810d5111dc76fad3b4f773ab535f425c1cd951483f735c50", + "sha256_in_prefix": "8b8d83314c282428810d5111dc76fad3b4f773ab535f425c1cd951483f735c50", + "size_in_bytes": 228676 + }, + { + "_path": "lib/python3.10/_pyio.py", + "path_type": "hardlink", + "sha256": "6c059e6f9800fc08bd0998251c66c16066c9bd3e0413424f252e16e5b48d3dee", + "sha256_in_prefix": "6c059e6f9800fc08bd0998251c66c16066c9bd3e0413424f252e16e5b48d3dee", + "size_in_bytes": 94467 + }, + { + "_path": "lib/python3.10/_sitebuiltins.py", + "path_type": "hardlink", + "sha256": "b9388bc1d6d12ed6be12da420ab1feca40f99c0e33ec315d92b1e01cb69b25bc", + "sha256_in_prefix": "b9388bc1d6d12ed6be12da420ab1feca40f99c0e33ec315d92b1e01cb69b25bc", + "size_in_bytes": 3128 + }, + { + "_path": "lib/python3.10/_strptime.py", + "path_type": "hardlink", + "sha256": "065e6597af214f795d16c018fdfe60ec93ab1d2703bdb159e0576173a19a72f8", + "sha256_in_prefix": "065e6597af214f795d16c018fdfe60ec93ab1d2703bdb159e0576173a19a72f8", + "size_in_bytes": 25277 + }, + { + "_path": "lib/python3.10/_sysconfigdata__darwin_darwin.py", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_9afkyeq1z4/croot/python-split_1715024112201/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_p", + "sha256": "e6d60c63eb8c01b4fde7d61f5e9245ac32662db7b499b1a7c96053dfaeff3297", + "sha256_in_prefix": "4bcdc88d749f3550ce70c4331043e0c43e4aeb47272324c079d1f186c1a1b3ba", + "size_in_bytes": 57548 + }, + { + "_path": "lib/python3.10/_sysconfigdata__darwin_darwin.py.orig", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_9afkyeq1z4/croot/python-split_1715024112201/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_p", + "sha256": "b7856badf58d94dffc6bf0f8a4abb7dabea7e25cc0742b5be5f597e5713670c3", + "sha256_in_prefix": "dd629c56ec211ee7c5082535a812cf13bd1f61e6a2787f74593d549781c6e47d", + "size_in_bytes": 66674 + }, + { + "_path": "lib/python3.10/_sysconfigdata_arm64_apple_darwin20_0_0.py", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_9afkyeq1z4/croot/python-split_1715024112201/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_p", + "sha256": "f271a2d611a7f9de1e0085415618a611469dffa8f754368f1f955f4f5d59b3f2", + "sha256_in_prefix": "24b06995ef1dc0c5c1929b6d436241857f9c79a75af15a850076b67e42c1f931", + "size_in_bytes": 59223 + }, + { + "_path": "lib/python3.10/_threading_local.py", + "path_type": "hardlink", + "sha256": "e1bf3dae66d0bfa63c8bb8a1d10c611203c35c636f7f5191fd56105788ef29cb", + "sha256_in_prefix": "e1bf3dae66d0bfa63c8bb8a1d10c611203c35c636f7f5191fd56105788ef29cb", + "size_in_bytes": 7220 + }, + { + "_path": "lib/python3.10/_weakrefset.py", + "path_type": "hardlink", + "sha256": "49fb432325ef836f89caa60e50b152eb6f32b700ed71fedcd4d56815723f77ba", + "sha256_in_prefix": "49fb432325ef836f89caa60e50b152eb6f32b700ed71fedcd4d56815723f77ba", + "size_in_bytes": 5923 + }, + { + "_path": "lib/python3.10/abc.py", + "path_type": "hardlink", + "sha256": "c702f783a7e81f9c37a1d22095c05360b11916d144d2730ff735c36f879523c5", + "sha256_in_prefix": "c702f783a7e81f9c37a1d22095c05360b11916d144d2730ff735c36f879523c5", + "size_in_bytes": 6522 + }, + { + "_path": "lib/python3.10/aifc.py", + "path_type": "hardlink", + "sha256": "bb1a32c21c6ce68e9858cd5ec983643afa586a4f6d613210e49ea7346ba02833", + "sha256_in_prefix": "bb1a32c21c6ce68e9858cd5ec983643afa586a4f6d613210e49ea7346ba02833", + "size_in_bytes": 32605 + }, + { + "_path": "lib/python3.10/antigravity.py", + "path_type": "hardlink", + "sha256": "8a5ee63e1b79ba2733e7ff4290b6eefea60e7f3a1ccb6bb519535aaf92b44967", + "sha256_in_prefix": "8a5ee63e1b79ba2733e7ff4290b6eefea60e7f3a1ccb6bb519535aaf92b44967", + "size_in_bytes": 500 + }, + { + "_path": "lib/python3.10/argparse.py", + "path_type": "hardlink", + "sha256": "a238b700513237e10d26056e42c5b4e42d4961ea70e15ebeef4c61c76615f004", + "sha256_in_prefix": "a238b700513237e10d26056e42c5b4e42d4961ea70e15ebeef4c61c76615f004", + "size_in_bytes": 98543 + }, + { + "_path": "lib/python3.10/ast.py", + "path_type": "hardlink", + "sha256": "2bacf018a141dd55b5ab20e4e2cc39ca7390b26f06948f8a8cb6edbedc292829", + "sha256_in_prefix": "2bacf018a141dd55b5ab20e4e2cc39ca7390b26f06948f8a8cb6edbedc292829", + "size_in_bytes": 59900 + }, + { + "_path": "lib/python3.10/asynchat.py", + "path_type": "hardlink", + "sha256": "375c501c0dc3138c5f75fa80ce624c8f1a5bfd388c7855c3b03982751faf30e5", + "sha256_in_prefix": "375c501c0dc3138c5f75fa80ce624c8f1a5bfd388c7855c3b03982751faf30e5", + "size_in_bytes": 11520 + }, + { + "_path": "lib/python3.10/asyncio/__init__.py", + "path_type": "hardlink", + "sha256": "3930c26c8274f38a7f5bf6cc323f313b8ed922a8c0fc1fb50aab4beccca25d02", + "sha256_in_prefix": "3930c26c8274f38a7f5bf6cc323f313b8ed922a8c0fc1fb50aab4beccca25d02", + "size_in_bytes": 1108 + }, + { + "_path": "lib/python3.10/asyncio/__main__.py", + "path_type": "hardlink", + "sha256": "eb22d0fa0c480025270feb1e7f962510666287fe2ccaeb7f309d32637507d061", + "sha256_in_prefix": "eb22d0fa0c480025270feb1e7f962510666287fe2ccaeb7f309d32637507d061", + "size_in_bytes": 3343 + }, + { + "_path": "lib/python3.10/asyncio/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c50fd6ca76b312bb7d5fa6e961302e625075e9f02758245e9a2076419312be1c", + "sha256_in_prefix": "c50fd6ca76b312bb7d5fa6e961302e625075e9f02758245e9a2076419312be1c", + "size_in_bytes": 998 + }, + { + "_path": "lib/python3.10/asyncio/__pycache__/__main__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c49dd7d96c2a2a86ae1dda3c2f49c19173c64b60f380d4c0fe7889893c4ad21c", + "sha256_in_prefix": "c49dd7d96c2a2a86ae1dda3c2f49c19173c64b60f380d4c0fe7889893c4ad21c", + "size_in_bytes": 3166 + }, + { + "_path": "lib/python3.10/asyncio/__pycache__/base_events.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "107e0a1924a2a20765415ecdd6f95485f250a8b446d65bd8dc4edb3f762869fe", + "sha256_in_prefix": "107e0a1924a2a20765415ecdd6f95485f250a8b446d65bd8dc4edb3f762869fe", + "size_in_bytes": 52106 + }, + { + "_path": "lib/python3.10/asyncio/__pycache__/base_futures.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "773f23a3f46e15b3fa2a6bda6945de6244864cf610428e7a6e249e85c17420eb", + "sha256_in_prefix": "773f23a3f46e15b3fa2a6bda6945de6244864cf610428e7a6e249e85c17420eb", + "size_in_bytes": 2165 + }, + { + "_path": "lib/python3.10/asyncio/__pycache__/base_subprocess.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "200ccaf2461bb48f0c0d7dbb6959e21dd457ef87eb830a43dc772ab906857137", + "sha256_in_prefix": "200ccaf2461bb48f0c0d7dbb6959e21dd457ef87eb830a43dc772ab906857137", + "size_in_bytes": 9640 + }, + { + "_path": "lib/python3.10/asyncio/__pycache__/base_tasks.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "88b198a64c78e2e2eac9912b087ed6e3186fdb643b6d260180f83f7299bfdfc0", + "sha256_in_prefix": "88b198a64c78e2e2eac9912b087ed6e3186fdb643b6d260180f83f7299bfdfc0", + "size_in_bytes": 2235 + }, + { + "_path": "lib/python3.10/asyncio/__pycache__/constants.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "7f25f4ac10ea7c0a2ddb0f63b46d2838177b4f3abdf6ed3dc4da794489e852b3", + "sha256_in_prefix": "7f25f4ac10ea7c0a2ddb0f63b46d2838177b4f3abdf6ed3dc4da794489e852b3", + "size_in_bytes": 840 + }, + { + "_path": "lib/python3.10/asyncio/__pycache__/coroutines.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "22747090a427fc5e389510308d66c16521d84101ef54055540a94398197b335d", + "sha256_in_prefix": "22747090a427fc5e389510308d66c16521d84101ef54055540a94398197b335d", + "size_in_bytes": 6875 + }, + { + "_path": "lib/python3.10/asyncio/__pycache__/events.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "6150778bbf8d133c1370537e4f5a16eac066c6f533e8c3322c01e8bb4df60157", + "sha256_in_prefix": "6150778bbf8d133c1370537e4f5a16eac066c6f533e8c3322c01e8bb4df60157", + "size_in_bytes": 28560 + }, + { + "_path": "lib/python3.10/asyncio/__pycache__/exceptions.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "408b845a92a10abba02e4dbd7dd5f7f67a8cc44d66eb2086b0cd34e0fd965c08", + "sha256_in_prefix": "408b845a92a10abba02e4dbd7dd5f7f67a8cc44d66eb2086b0cd34e0fd965c08", + "size_in_bytes": 2722 + }, + { + "_path": "lib/python3.10/asyncio/__pycache__/format_helpers.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "742b31f71b8f9e780d228d0d99e708b7424ca3f2f025240fc3dffdf40adc72b1", + "sha256_in_prefix": "742b31f71b8f9e780d228d0d99e708b7424ca3f2f025240fc3dffdf40adc72b1", + "size_in_bytes": 2593 + }, + { + "_path": "lib/python3.10/asyncio/__pycache__/futures.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "487922582f9a2511359bef27edf9d58eb92672b9381f57ab990e022e5893d778", + "sha256_in_prefix": "487922582f9a2511359bef27edf9d58eb92672b9381f57ab990e022e5893d778", + "size_in_bytes": 12141 + }, + { + "_path": "lib/python3.10/asyncio/__pycache__/locks.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "02758800fd9fac72ff67b913bc8ae8e14e795d5578851d2755575f21bc72e669", + "sha256_in_prefix": "02758800fd9fac72ff67b913bc8ae8e14e795d5578851d2755575f21bc72e669", + "size_in_bytes": 14427 + }, + { + "_path": "lib/python3.10/asyncio/__pycache__/log.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "555c7d91172b204424dea6a5c06016ce09db370e6851245b5de88e239f9d0c67", + "sha256_in_prefix": "555c7d91172b204424dea6a5c06016ce09db370e6851245b5de88e239f9d0c67", + "size_in_bytes": 483 + }, + { + "_path": "lib/python3.10/asyncio/__pycache__/mixins.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "0caf4cb884242dd4f5f5108a7a7d23899e9b094957337899005ec5d762e20328", + "sha256_in_prefix": "0caf4cb884242dd4f5f5108a7a7d23899e9b094957337899005ec5d762e20328", + "size_in_bytes": 1331 + }, + { + "_path": "lib/python3.10/asyncio/__pycache__/proactor_events.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "28200218ef05692e6b7d6adb50578f2563bc4ae37841f81ef904eed51bebb198", + "sha256_in_prefix": "28200218ef05692e6b7d6adb50578f2563bc4ae37841f81ef904eed51bebb198", + "size_in_bytes": 24952 + }, + { + "_path": "lib/python3.10/asyncio/__pycache__/protocols.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "9910d32f4131be86845b0e899a0bae115a67be62b17818f24564eff9e6d5bf5e", + "sha256_in_prefix": "9910d32f4131be86845b0e899a0bae115a67be62b17818f24564eff9e6d5bf5e", + "size_in_bytes": 8552 + }, + { + "_path": "lib/python3.10/asyncio/__pycache__/queues.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "eb5024cf7181427dc4b3661c191aeff1df3a52269f8dea0c89e18f31e2aae00a", + "sha256_in_prefix": "eb5024cf7181427dc4b3661c191aeff1df3a52269f8dea0c89e18f31e2aae00a", + "size_in_bytes": 8295 + }, + { + "_path": "lib/python3.10/asyncio/__pycache__/runners.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "2ad8b783b39fc485bb6da55175a7cfc8124801b0a1e5f94d84a3c7dbcca24c4f", + "sha256_in_prefix": "2ad8b783b39fc485bb6da55175a7cfc8124801b0a1e5f94d84a3c7dbcca24c4f", + "size_in_bytes": 2346 + }, + { + "_path": "lib/python3.10/asyncio/__pycache__/selector_events.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "bda68f3f9da026d31e7a7a3fde3b6ec53887500e9638f5a06c2dc4287f7f6c3a", + "sha256_in_prefix": "bda68f3f9da026d31e7a7a3fde3b6ec53887500e9638f5a06c2dc4287f7f6c3a", + "size_in_bytes": 29832 + }, + { + "_path": "lib/python3.10/asyncio/__pycache__/sslproto.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "217b114b4ee62c01a5155e2b2a56dca065cdb127fc8e9b952ea8ef373f8acf3f", + "sha256_in_prefix": "217b114b4ee62c01a5155e2b2a56dca065cdb127fc8e9b952ea8ef373f8acf3f", + "size_in_bytes": 21949 + }, + { + "_path": "lib/python3.10/asyncio/__pycache__/staggered.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "028d579920950564efc1030b0718fc23c88680dc30c0e01da1d015283f621169", + "sha256_in_prefix": "028d579920950564efc1030b0718fc23c88680dc30c0e01da1d015283f621169", + "size_in_bytes": 4437 + }, + { + "_path": "lib/python3.10/asyncio/__pycache__/streams.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "96f11f2fca9ec097d0092d5e68894a68d076f4df6f342b6fabfbfbdc9e656ffd", + "sha256_in_prefix": "96f11f2fca9ec097d0092d5e68894a68d076f4df6f342b6fabfbfbdc9e656ffd", + "size_in_bytes": 20637 + }, + { + "_path": "lib/python3.10/asyncio/__pycache__/subprocess.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "291c7851b3ca2a1cdf71860f4966f727d3bdee269d428dcc4c3a758fb36761d9", + "sha256_in_prefix": "291c7851b3ca2a1cdf71860f4966f727d3bdee269d428dcc4c3a758fb36761d9", + "size_in_bytes": 7316 + }, + { + "_path": "lib/python3.10/asyncio/__pycache__/tasks.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "ad32f1f9d7fe895c5e5ca97791ba33078f9961c0c18f3fdd4c3490a762bb1933", + "sha256_in_prefix": "ad32f1f9d7fe895c5e5ca97791ba33078f9961c0c18f3fdd4c3490a762bb1933", + "size_in_bytes": 24227 + }, + { + "_path": "lib/python3.10/asyncio/__pycache__/threads.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "97c4d7237aae8e0d7a6e31d81fcf10f58e87d5b7cc391083c1b85a2001510643", + "sha256_in_prefix": "97c4d7237aae8e0d7a6e31d81fcf10f58e87d5b7cc391083c1b85a2001510643", + "size_in_bytes": 1239 + }, + { + "_path": "lib/python3.10/asyncio/__pycache__/transports.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "6e06ffb819a318472508584eadd5049d8dcb46f35aeb02df665c5398a3cb1fd0", + "sha256_in_prefix": "6e06ffb819a318472508584eadd5049d8dcb46f35aeb02df665c5398a3cb1fd0", + "size_in_bytes": 12586 + }, + { + "_path": "lib/python3.10/asyncio/__pycache__/trsock.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "e4fe086286a84cb1a62cf798eb303cc2ff472efaa417d9dccaa4312e14866946", + "sha256_in_prefix": "e4fe086286a84cb1a62cf798eb303cc2ff472efaa417d9dccaa4312e14866946", + "size_in_bytes": 8096 + }, + { + "_path": "lib/python3.10/asyncio/__pycache__/unix_events.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "6698b97c82d84f083d89655bd19dffd01c9939f791c77218955c26fc3b24511e", + "sha256_in_prefix": "6698b97c82d84f083d89655bd19dffd01c9939f791c77218955c26fc3b24511e", + "size_in_bytes": 41686 + }, + { + "_path": "lib/python3.10/asyncio/__pycache__/windows_events.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "91ab16177ca8a6cca36e8c5f98cbe4ebd1b0731e51e0e15693a2051d0a9703df", + "sha256_in_prefix": "91ab16177ca8a6cca36e8c5f98cbe4ebd1b0731e51e0e15693a2051d0a9703df", + "size_in_bytes": 24401 + }, + { + "_path": "lib/python3.10/asyncio/__pycache__/windows_utils.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "70c3a25e8a8b9e7a6b2da431f921232ffc79807eeaafc7d21c77db081b8c7a3a", + "sha256_in_prefix": "70c3a25e8a8b9e7a6b2da431f921232ffc79807eeaafc7d21c77db081b8c7a3a", + "size_in_bytes": 4750 + }, + { + "_path": "lib/python3.10/asyncio/base_events.py", + "path_type": "hardlink", + "sha256": "c6eae278db516bb7330204f7117ba4f80f200879c53d04a5e1e9c1131413c4f7", + "sha256_in_prefix": "c6eae278db516bb7330204f7117ba4f80f200879c53d04a5e1e9c1131413c4f7", + "size_in_bytes": 74341 + }, + { + "_path": "lib/python3.10/asyncio/base_futures.py", + "path_type": "hardlink", + "sha256": "6305968656c74facd06240e0a5352a8cb6db569c1c91f4908277d2723bae411d", + "sha256_in_prefix": "6305968656c74facd06240e0a5352a8cb6db569c1c91f4908277d2723bae411d", + "size_in_bytes": 2574 + }, + { + "_path": "lib/python3.10/asyncio/base_subprocess.py", + "path_type": "hardlink", + "sha256": "877cd264f49b3fbeaf0de6d7f0369e007a5e02f601d7ab72f3117a056aaa3cea", + "sha256_in_prefix": "877cd264f49b3fbeaf0de6d7f0369e007a5e02f601d7ab72f3117a056aaa3cea", + "size_in_bytes": 8843 + }, + { + "_path": "lib/python3.10/asyncio/base_tasks.py", + "path_type": "hardlink", + "sha256": "fb8c4508749d9ff286eeea60a9cc179b21480467f93d3b440ddc5caf908ec3bd", + "sha256_in_prefix": "fb8c4508749d9ff286eeea60a9cc179b21480467f93d3b440ddc5caf908ec3bd", + "size_in_bytes": 2467 + }, + { + "_path": "lib/python3.10/asyncio/constants.py", + "path_type": "hardlink", + "sha256": "e3bb7404a839c2ba512def9ef8ce206ff4ae3499eeec840c3d08d633d5e72d5d", + "sha256_in_prefix": "e3bb7404a839c2ba512def9ef8ce206ff4ae3499eeec840c3d08d633d5e72d5d", + "size_in_bytes": 888 + }, + { + "_path": "lib/python3.10/asyncio/coroutines.py", + "path_type": "hardlink", + "sha256": "55132b9bd716b607d231f97098d5c74484b4317f97877d7fcc9256ee56e0e154", + "sha256_in_prefix": "55132b9bd716b607d231f97098d5c74484b4317f97877d7fcc9256ee56e0e154", + "size_in_bytes": 8797 + }, + { + "_path": "lib/python3.10/asyncio/events.py", + "path_type": "hardlink", + "sha256": "29b89287c42d78cc8ef426e791cc36e5ecdf172bd04b3ceb77889f2e37661dc7", + "sha256_in_prefix": "29b89287c42d78cc8ef426e791cc36e5ecdf172bd04b3ceb77889f2e37661dc7", + "size_in_bytes": 27346 + }, + { + "_path": "lib/python3.10/asyncio/exceptions.py", + "path_type": "hardlink", + "sha256": "026283dbf8f6ab28f1aede20d07f13ec60653293e7da495eac2fd13aa3f6e289", + "sha256_in_prefix": "026283dbf8f6ab28f1aede20d07f13ec60653293e7da495eac2fd13aa3f6e289", + "size_in_bytes": 1633 + }, + { + "_path": "lib/python3.10/asyncio/format_helpers.py", + "path_type": "hardlink", + "sha256": "6377b672b3f4ba8b6f0f7a5f0ea00cde24c8cddc0ca764e3329f302763477f59", + "sha256_in_prefix": "6377b672b3f4ba8b6f0f7a5f0ea00cde24c8cddc0ca764e3329f302763477f59", + "size_in_bytes": 2404 + }, + { + "_path": "lib/python3.10/asyncio/futures.py", + "path_type": "hardlink", + "sha256": "5bc3d79ef36d9253beb8fb636acbbba061cd6b1c6a82a3100b9a31d4321ea097", + "sha256_in_prefix": "5bc3d79ef36d9253beb8fb636acbbba061cd6b1c6a82a3100b9a31d4321ea097", + "size_in_bytes": 14187 + }, + { + "_path": "lib/python3.10/asyncio/locks.py", + "path_type": "hardlink", + "sha256": "46a3a6a634d65900a1bc1567fa778146e5cb37a0d1b208bc0f29ee6b5703a0f1", + "sha256_in_prefix": "46a3a6a634d65900a1bc1567fa778146e5cb37a0d1b208bc0f29ee6b5703a0f1", + "size_in_bytes": 14122 + }, + { + "_path": "lib/python3.10/asyncio/log.py", + "path_type": "hardlink", + "sha256": "80e4cc3ded4b138baba486519e7444801a23d6ac35f229d336a407a96af7e8d2", + "sha256_in_prefix": "80e4cc3ded4b138baba486519e7444801a23d6ac35f229d336a407a96af7e8d2", + "size_in_bytes": 124 + }, + { + "_path": "lib/python3.10/asyncio/mixins.py", + "path_type": "hardlink", + "sha256": "830ed2ee56d90258cb29d0042b321e8076f7fac34c66b5f265f93aceb7159d25", + "sha256_in_prefix": "830ed2ee56d90258cb29d0042b321e8076f7fac34c66b5f265f93aceb7159d25", + "size_in_bytes": 803 + }, + { + "_path": "lib/python3.10/asyncio/proactor_events.py", + "path_type": "hardlink", + "sha256": "0ff50f71c24339339319c82d987b13541b625a1d6357ff3aea04d817857a7bbf", + "sha256_in_prefix": "0ff50f71c24339339319c82d987b13541b625a1d6357ff3aea04d817857a7bbf", + "size_in_bytes": 32541 + }, + { + "_path": "lib/python3.10/asyncio/protocols.py", + "path_type": "hardlink", + "sha256": "1d1b49988c338b4ef06e30f9e92d9db2e00080c341f0a3f573bb8312deb8aff6", + "sha256_in_prefix": "1d1b49988c338b4ef06e30f9e92d9db2e00080c341f0a3f573bb8312deb8aff6", + "size_in_bytes": 6957 + }, + { + "_path": "lib/python3.10/asyncio/queues.py", + "path_type": "hardlink", + "sha256": "b8f53efbc9fe57d4fb7df0bcc95f17c1eb63b1917f4fb7cd7906f382e3ed1ca3", + "sha256_in_prefix": "b8f53efbc9fe57d4fb7df0bcc95f17c1eb63b1917f4fb7cd7906f382e3ed1ca3", + "size_in_bytes": 8034 + }, + { + "_path": "lib/python3.10/asyncio/runners.py", + "path_type": "hardlink", + "sha256": "ab0247599989c8c8ff0e083eebb54e63312c32a207f28a47f5f22390a89364db", + "sha256_in_prefix": "ab0247599989c8c8ff0e083eebb54e63312c32a207f28a47f5f22390a89364db", + "size_in_bytes": 2104 + }, + { + "_path": "lib/python3.10/asyncio/selector_events.py", + "path_type": "hardlink", + "sha256": "964874b8b676dffadc934e131977d68b5d3df5372f5d8e476117dc8ae8a3a078", + "sha256_in_prefix": "964874b8b676dffadc934e131977d68b5d3df5372f5d8e476117dc8ae8a3a078", + "size_in_bytes": 39700 + }, + { + "_path": "lib/python3.10/asyncio/sslproto.py", + "path_type": "hardlink", + "sha256": "8da7cf9187e6e99cfc4331fb273673a2a7968c4323680add7b3c3e3e669cddde", + "sha256_in_prefix": "8da7cf9187e6e99cfc4331fb273673a2a7968c4323680add7b3c3e3e669cddde", + "size_in_bytes": 27459 + }, + { + "_path": "lib/python3.10/asyncio/staggered.py", + "path_type": "hardlink", + "sha256": "ff289bdc20a50ad9620393479d785bc653e71c2e3298f53ab27907cd136498e9", + "sha256_in_prefix": "ff289bdc20a50ad9620393479d785bc653e71c2e3298f53ab27907cd136498e9", + "size_in_bytes": 5992 + }, + { + "_path": "lib/python3.10/asyncio/streams.py", + "path_type": "hardlink", + "sha256": "48139784fe1e262ebea7ff72effd32c228f031399a12e0fbe27c0e770bc598e2", + "sha256_in_prefix": "48139784fe1e262ebea7ff72effd32c228f031399a12e0fbe27c0e770bc598e2", + "size_in_bytes": 25749 + }, + { + "_path": "lib/python3.10/asyncio/subprocess.py", + "path_type": "hardlink", + "sha256": "bfe0359e5fcf7a41554c47c94479014fb8873debac5d7f39869e17f82266e555", + "sha256_in_prefix": "bfe0359e5fcf7a41554c47c94479014fb8873debac5d7f39869e17f82266e555", + "size_in_bytes": 7405 + }, + { + "_path": "lib/python3.10/asyncio/tasks.py", + "path_type": "hardlink", + "sha256": "b3bccb5346d370059d20191cfec96e15bb07442c3aae9ce9c717190a8d8920c7", + "sha256_in_prefix": "b3bccb5346d370059d20191cfec96e15bb07442c3aae9ce9c717190a8d8920c7", + "size_in_bytes": 32458 + }, + { + "_path": "lib/python3.10/asyncio/threads.py", + "path_type": "hardlink", + "sha256": "39d37295383641565f0c08bd992e2f661dc8051eb17e890b834fce96bde0910e", + "sha256_in_prefix": "39d37295383641565f0c08bd992e2f661dc8051eb17e890b834fce96bde0910e", + "size_in_bytes": 790 + }, + { + "_path": "lib/python3.10/asyncio/transports.py", + "path_type": "hardlink", + "sha256": "986703cea28769307f7cdffc58a09ef78ea292e74d3b8d4f926e4452558998ce", + "sha256_in_prefix": "986703cea28769307f7cdffc58a09ef78ea292e74d3b8d4f926e4452558998ce", + "size_in_bytes": 10724 + }, + { + "_path": "lib/python3.10/asyncio/trsock.py", + "path_type": "hardlink", + "sha256": "435acc190d018d9421baa224d25b8d893967af5c5737a1e42f1bbf614c8e2bf3", + "sha256_in_prefix": "435acc190d018d9421baa224d25b8d893967af5c5737a1e42f1bbf614c8e2bf3", + "size_in_bytes": 5876 + }, + { + "_path": "lib/python3.10/asyncio/unix_events.py", + "path_type": "hardlink", + "sha256": "5db9c0ef744faa38c3429261473a3c894ba2108ac85b1f6d8a15317abfacb23e", + "sha256_in_prefix": "5db9c0ef744faa38c3429261473a3c894ba2108ac85b1f6d8a15317abfacb23e", + "size_in_bytes": 51624 + }, + { + "_path": "lib/python3.10/asyncio/windows_events.py", + "path_type": "hardlink", + "sha256": "95e80fb8245aa6de6435a70fdb7b8dd1f3189ce16d746addd0037e055384ced4", + "sha256_in_prefix": "95e80fb8245aa6de6435a70fdb7b8dd1f3189ce16d746addd0037e055384ced4", + "size_in_bytes": 33394 + }, + { + "_path": "lib/python3.10/asyncio/windows_utils.py", + "path_type": "hardlink", + "sha256": "e6fcffefa2521666bc2aed0f5caf8e862c1c1014ad12d2ab5fbce09c2df9c6f0", + "sha256_in_prefix": "e6fcffefa2521666bc2aed0f5caf8e862c1c1014ad12d2ab5fbce09c2df9c6f0", + "size_in_bytes": 5060 + }, + { + "_path": "lib/python3.10/asyncore.py", + "path_type": "hardlink", + "sha256": "a16d3244eb6d29870811bf9bf28227f005200e1498405f0adfac972f55220110", + "sha256_in_prefix": "a16d3244eb6d29870811bf9bf28227f005200e1498405f0adfac972f55220110", + "size_in_bytes": 20268 + }, + { + "_path": "lib/python3.10/base64.py", + "path_type": "hardlink", + "sha256": "108aaee81d7b9d1ceeb5d64d299ad8b9f78b6358c14a34d29ea11389f676cc91", + "sha256_in_prefix": "108aaee81d7b9d1ceeb5d64d299ad8b9f78b6358c14a34d29ea11389f676cc91", + "size_in_bytes": 20847 + }, + { + "_path": "lib/python3.10/bdb.py", + "path_type": "hardlink", + "sha256": "fe2841e182a4bc8561278102bdbd73c99c8345b4a8d2b2540af6a95f0b7f7734", + "sha256_in_prefix": "fe2841e182a4bc8561278102bdbd73c99c8345b4a8d2b2540af6a95f0b7f7734", + "size_in_bytes": 32396 + }, + { + "_path": "lib/python3.10/binhex.py", + "path_type": "hardlink", + "sha256": "347151ad93436cac32265eb255b07c75ddb89055ee8aca2c59eebff9df5d5d73", + "sha256_in_prefix": "347151ad93436cac32265eb255b07c75ddb89055ee8aca2c59eebff9df5d5d73", + "size_in_bytes": 14784 + }, + { + "_path": "lib/python3.10/bisect.py", + "path_type": "hardlink", + "sha256": "e5b2ff166f48a06e70ae831d8c9b47283fcd0c254306eee12d3dae9c55e11526", + "sha256_in_prefix": "e5b2ff166f48a06e70ae831d8c9b47283fcd0c254306eee12d3dae9c55e11526", + "size_in_bytes": 3135 + }, + { + "_path": "lib/python3.10/bz2.py", + "path_type": "hardlink", + "sha256": "76ab3252924e71e859d7d90e8d3db13b6554975cfcac0fdadced4de7f8779330", + "sha256_in_prefix": "76ab3252924e71e859d7d90e8d3db13b6554975cfcac0fdadced4de7f8779330", + "size_in_bytes": 11847 + }, + { + "_path": "lib/python3.10/cProfile.py", + "path_type": "hardlink", + "sha256": "60421977dca84f29b6c3be7229b39c5ec1ebbc724852b947ca779be8f84e7a4f", + "sha256_in_prefix": "60421977dca84f29b6c3be7229b39c5ec1ebbc724852b947ca779be8f84e7a4f", + "size_in_bytes": 6347 + }, + { + "_path": "lib/python3.10/calendar.py", + "path_type": "hardlink", + "sha256": "69bce110ecb19bf03d90fceddeb4f6704091c6f615ed6e8870fce5116ea2130e", + "sha256_in_prefix": "69bce110ecb19bf03d90fceddeb4f6704091c6f615ed6e8870fce5116ea2130e", + "size_in_bytes": 24575 + }, + { + "_path": "lib/python3.10/cgi.py", + "path_type": "hardlink", + "sha256": "ecd78445816fcd84c3c6fbcbb42f171a76cbad74c685a2ab241ca5c49ec5c297", + "sha256_in_prefix": "ecd78445816fcd84c3c6fbcbb42f171a76cbad74c685a2ab241ca5c49ec5c297", + "size_in_bytes": 34099 + }, + { + "_path": "lib/python3.10/cgitb.py", + "path_type": "hardlink", + "sha256": "8fbd49c0c9fad05e5036258e3749516f4e0c8a61cf7c9720574f5e20cb94beab", + "sha256_in_prefix": "8fbd49c0c9fad05e5036258e3749516f4e0c8a61cf7c9720574f5e20cb94beab", + "size_in_bytes": 12096 + }, + { + "_path": "lib/python3.10/chunk.py", + "path_type": "hardlink", + "sha256": "34a5d2cde2e00a03acd84768ccd352ebdc3ac008a8f41ab1caee698e4a474ca0", + "sha256_in_prefix": "34a5d2cde2e00a03acd84768ccd352ebdc3ac008a8f41ab1caee698e4a474ca0", + "size_in_bytes": 5435 + }, + { + "_path": "lib/python3.10/cmd.py", + "path_type": "hardlink", + "sha256": "1b18b978b7f2e2a587aa77f0bc7a6130718c4b680dd19cc749eb2ee7eb8b9590", + "sha256_in_prefix": "1b18b978b7f2e2a587aa77f0bc7a6130718c4b680dd19cc749eb2ee7eb8b9590", + "size_in_bytes": 14860 + }, + { + "_path": "lib/python3.10/code.py", + "path_type": "hardlink", + "sha256": "266841655656d5b2370e80addcdb959f5173142d5e3778b489e734802447c5e8", + "sha256_in_prefix": "266841655656d5b2370e80addcdb959f5173142d5e3778b489e734802447c5e8", + "size_in_bytes": 10622 + }, + { + "_path": "lib/python3.10/codecs.py", + "path_type": "hardlink", + "sha256": "166ffd0f0fe40631bb7adef898ebfe59c7fb9efeb25f635b0fd50b68e9353b6a", + "sha256_in_prefix": "166ffd0f0fe40631bb7adef898ebfe59c7fb9efeb25f635b0fd50b68e9353b6a", + "size_in_bytes": 36714 + }, + { + "_path": "lib/python3.10/codeop.py", + "path_type": "hardlink", + "sha256": "32799ec2d30e2792f8ddbd4b33ac83d5d410142c71199078c2036c6503ef29d2", + "sha256_in_prefix": "32799ec2d30e2792f8ddbd4b33ac83d5d410142c71199078c2036c6503ef29d2", + "size_in_bytes": 5609 + }, + { + "_path": "lib/python3.10/collections/__init__.py", + "path_type": "hardlink", + "sha256": "5d7b9d899fb1407a614cb2ade46b6d2400ba797634e9fed7d770fc4b7e372760", + "sha256_in_prefix": "5d7b9d899fb1407a614cb2ade46b6d2400ba797634e9fed7d770fc4b7e372760", + "size_in_bytes": 51398 + }, + { + "_path": "lib/python3.10/collections/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c91339a01dc68d45c09a82dc8d04b9387770b34b0b8a7b8592fbcaa2128c4b5f", + "sha256_in_prefix": "c91339a01dc68d45c09a82dc8d04b9387770b34b0b8a7b8592fbcaa2128c4b5f", + "size_in_bytes": 48707 + }, + { + "_path": "lib/python3.10/collections/__pycache__/abc.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "005d8c614fd5d98dc1941e080f9b7befaaa4d34ddce54b649db33848ea0ff1b7", + "sha256_in_prefix": "005d8c614fd5d98dc1941e080f9b7befaaa4d34ddce54b649db33848ea0ff1b7", + "size_in_bytes": 233 + }, + { + "_path": "lib/python3.10/collections/abc.py", + "path_type": "hardlink", + "sha256": "9cb4208f99128a0489b6c8e6c61637617dd7d4250c59e065491957eda084dd10", + "sha256_in_prefix": "9cb4208f99128a0489b6c8e6c61637617dd7d4250c59e065491957eda084dd10", + "size_in_bytes": 119 + }, + { + "_path": "lib/python3.10/colorsys.py", + "path_type": "hardlink", + "sha256": "ab78926242b393e09aeb37854f11cce2160cafce02ef713e4aac341abed9b040", + "sha256_in_prefix": "ab78926242b393e09aeb37854f11cce2160cafce02ef713e4aac341abed9b040", + "size_in_bytes": 4017 + }, + { + "_path": "lib/python3.10/compileall.py", + "path_type": "hardlink", + "sha256": "6ab668e2660cc54aafa2621751302da637f27c2484bf4783e559e68dbb0e05e5", + "sha256_in_prefix": "6ab668e2660cc54aafa2621751302da637f27c2484bf4783e559e68dbb0e05e5", + "size_in_bytes": 20252 + }, + { + "_path": "lib/python3.10/concurrent/__init__.py", + "path_type": "hardlink", + "sha256": "87ad5c8954dd56fbbca04517bf87477ff4dce575170c7dd1281d7ef1f4214ac8", + "sha256_in_prefix": "87ad5c8954dd56fbbca04517bf87477ff4dce575170c7dd1281d7ef1f4214ac8", + "size_in_bytes": 38 + }, + { + "_path": "lib/python3.10/concurrent/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "6f0e54471503635b75e1358ea6f79a28324d893d15acb2809e883500f8cd3064", + "sha256_in_prefix": "6f0e54471503635b75e1358ea6f79a28324d893d15acb2809e883500f8cd3064", + "size_in_bytes": 389 + }, + { + "_path": "lib/python3.10/concurrent/futures/__init__.py", + "path_type": "hardlink", + "sha256": "ff1f05fa12bc54681fa90da6197d7b2aaa09545e92b2a407769412b99b8966f9", + "sha256_in_prefix": "ff1f05fa12bc54681fa90da6197d7b2aaa09545e92b2a407769412b99b8966f9", + "size_in_bytes": 1554 + }, + { + "_path": "lib/python3.10/concurrent/futures/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c8cabba8d5be8f720bbc3bf69a3c4a61c6cfc889a9ebe3bf780fc56cdd40c1bc", + "sha256_in_prefix": "c8cabba8d5be8f720bbc3bf69a3c4a61c6cfc889a9ebe3bf780fc56cdd40c1bc", + "size_in_bytes": 1361 + }, + { + "_path": "lib/python3.10/concurrent/futures/__pycache__/_base.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "0bee2bd0cdfa306a6d54e7d227da0fafd4a98ed0cbdd859c80744958548a2484", + "sha256_in_prefix": "0bee2bd0cdfa306a6d54e7d227da0fafd4a98ed0cbdd859c80744958548a2484", + "size_in_bytes": 22487 + }, + { + "_path": "lib/python3.10/concurrent/futures/__pycache__/process.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "6e23026b7d5c8e78e26fd5feb66fc0399be47c06de6534239f1cd7556aad8ccf", + "sha256_in_prefix": "6e23026b7d5c8e78e26fd5feb66fc0399be47c06de6534239f1cd7556aad8ccf", + "size_in_bytes": 22011 + }, + { + "_path": "lib/python3.10/concurrent/futures/__pycache__/thread.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "d8c7f4edb878ec2060ba520318b465a049068837edb814c1bcc0a7fafe1178e8", + "sha256_in_prefix": "d8c7f4edb878ec2060ba520318b465a049068837edb814c1bcc0a7fafe1178e8", + "size_in_bytes": 6219 + }, + { + "_path": "lib/python3.10/concurrent/futures/_base.py", + "path_type": "hardlink", + "sha256": "6fc621cca6d246a19d3474f0e8b33cf24aecd0d89c649e92e2786709b9e24408", + "sha256_in_prefix": "6fc621cca6d246a19d3474f0e8b33cf24aecd0d89c649e92e2786709b9e24408", + "size_in_bytes": 22848 + }, + { + "_path": "lib/python3.10/concurrent/futures/process.py", + "path_type": "hardlink", + "sha256": "b02bb0c6158a31bc2e7ffc8fb6d049f4af64d6830b8b0c5aefc56e308cf53676", + "sha256_in_prefix": "b02bb0c6158a31bc2e7ffc8fb6d049f4af64d6830b8b0c5aefc56e308cf53676", + "size_in_bytes": 31995 + }, + { + "_path": "lib/python3.10/concurrent/futures/thread.py", + "path_type": "hardlink", + "sha256": "b06f8899881193efc72cfc3ebf2836dce4e668b3856ad35f4016616d643a519e", + "sha256_in_prefix": "b06f8899881193efc72cfc3ebf2836dce4e668b3856ad35f4016616d643a519e", + "size_in_bytes": 8771 + }, + { + "_path": "lib/python3.10/config-3.10-darwin/Makefile", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_9afkyeq1z4/croot/python-split_1715024112201/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_p", + "sha256": "519fc7d7e5bf92f06c8676ceb3c4f1f42cc96ca2d4b65aab2052c7d9aedf1ff5", + "sha256_in_prefix": "066a2492b8f464bb57e0d0e8b547faa49f138714f8c72fc8988d448a3ee3a519", + "size_in_bytes": 92204 + }, + { + "_path": "lib/python3.10/config-3.10-darwin/Setup", + "path_type": "hardlink", + "sha256": "4e919ed7f7fc274d9ea400fe0f56ff0e2942635bf1d878034db9d12b342425f0", + "sha256_in_prefix": "4e919ed7f7fc274d9ea400fe0f56ff0e2942635bf1d878034db9d12b342425f0", + "size_in_bytes": 15518 + }, + { + "_path": "lib/python3.10/config-3.10-darwin/Setup.local", + "path_type": "hardlink", + "sha256": "d29e734b34f3f8cb4a8c2b9305b6e7f378214ecd13928f2671db2c7ee0f7b378", + "sha256_in_prefix": "d29e734b34f3f8cb4a8c2b9305b6e7f378214ecd13928f2671db2c7ee0f7b378", + "size_in_bytes": 41 + }, + { + "_path": "lib/python3.10/config-3.10-darwin/__pycache__/python-config.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "9eee063ca3b38c7066d1585e752104a57ef0667669e8ea1489acf96331bcdf5f", + "sha256_in_prefix": "9eee063ca3b38c7066d1585e752104a57ef0667669e8ea1489acf96331bcdf5f", + "size_in_bytes": 2130 + }, + { + "_path": "lib/python3.10/config-3.10-darwin/config.c", + "path_type": "hardlink", + "sha256": "a33b17b491bd8d9817c74beae5bd4e64ce6df754e161ff2813c83e661baa734a", + "sha256_in_prefix": "a33b17b491bd8d9817c74beae5bd4e64ce6df754e161ff2813c83e661baa734a", + "size_in_bytes": 3389 + }, + { + "_path": "lib/python3.10/config-3.10-darwin/config.c.in", + "path_type": "hardlink", + "sha256": "7a31cbf2498d03219c431cb13a22eb868c4fc0f5f45f369fc3acb317edd5e1c1", + "sha256_in_prefix": "7a31cbf2498d03219c431cb13a22eb868c4fc0f5f45f369fc3acb317edd5e1c1", + "size_in_bytes": 1623 + }, + { + "_path": "lib/python3.10/config-3.10-darwin/install-sh", + "path_type": "hardlink", + "sha256": "618b9afe95659e12966f090232b2e713946f1c162915c8385dfff71f34eacd58", + "sha256_in_prefix": "618b9afe95659e12966f090232b2e713946f1c162915c8385dfff71f34eacd58", + "size_in_bytes": 15368 + }, + { + "_path": "lib/python3.10/config-3.10-darwin/makesetup", + "path_type": "hardlink", + "sha256": "b4db4d0be1ba1bcd82ccd9d9b5ed41281d2a9f7b7245d3e5459537a117c05fd4", + "sha256_in_prefix": "b4db4d0be1ba1bcd82ccd9d9b5ed41281d2a9f7b7245d3e5459537a117c05fd4", + "size_in_bytes": 7855 + }, + { + "_path": "lib/python3.10/config-3.10-darwin/python-config.py", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_9afkyeq1z4/croot/python-split_1715024112201/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_p", + "sha256": "c707b82a8c5cc53054769d40dc72386fd3d7ac3cf1719e5721b85e680eecb6ba", + "sha256_in_prefix": "bf233aab74afc434e8cbbe86c64a58e9124b3cd2ed328404db9fd808b9f4155a", + "size_in_bytes": 2289 + }, + { + "_path": "lib/python3.10/config-3.10-darwin/python.o", + "path_type": "hardlink", + "sha256": "eb79c860cdeba773902b5fd0ad42712bd47147a3be1a056a8d1371b8d3941c4c", + "sha256_in_prefix": "eb79c860cdeba773902b5fd0ad42712bd47147a3be1a056a8d1371b8d3941c4c", + "size_in_bytes": 3808 + }, + { + "_path": "lib/python3.10/configparser.py", + "path_type": "hardlink", + "sha256": "df56496e25906c42f7599e7237b1c8e33eb6e9a9a5590cad55e2907492bba88a", + "sha256_in_prefix": "df56496e25906c42f7599e7237b1c8e33eb6e9a9a5590cad55e2907492bba88a", + "size_in_bytes": 54612 + }, + { + "_path": "lib/python3.10/contextlib.py", + "path_type": "hardlink", + "sha256": "2e17d45cf3da698c9752c58a668c8a03d0ce2280fdffd6e352794a38a94d9f07", + "sha256_in_prefix": "2e17d45cf3da698c9752c58a668c8a03d0ce2280fdffd6e352794a38a94d9f07", + "size_in_bytes": 25882 + }, + { + "_path": "lib/python3.10/contextvars.py", + "path_type": "hardlink", + "sha256": "5ed260be8d1f4fe92261b7810b4bb1e8539c42093d7493f677d076e1a87f459a", + "sha256_in_prefix": "5ed260be8d1f4fe92261b7810b4bb1e8539c42093d7493f677d076e1a87f459a", + "size_in_bytes": 129 + }, + { + "_path": "lib/python3.10/copy.py", + "path_type": "hardlink", + "sha256": "27dcfc53a4b9d4fbc3d90c74e549eb6eca9301524d6d2fbff9a6589cf51b6fd5", + "sha256_in_prefix": "27dcfc53a4b9d4fbc3d90c74e549eb6eca9301524d6d2fbff9a6589cf51b6fd5", + "size_in_bytes": 8681 + }, + { + "_path": "lib/python3.10/copyreg.py", + "path_type": "hardlink", + "sha256": "65cc0a30e07e9768ff97c78391985459a237083dce0c9086abfb879dc517420b", + "sha256_in_prefix": "65cc0a30e07e9768ff97c78391985459a237083dce0c9086abfb879dc517420b", + "size_in_bytes": 7426 + }, + { + "_path": "lib/python3.10/crypt.py", + "path_type": "hardlink", + "sha256": "5905d010f274b8935e12e7536fe25ec44877e04ad7633ffe21db855718ada8d5", + "sha256_in_prefix": "5905d010f274b8935e12e7536fe25ec44877e04ad7633ffe21db855718ada8d5", + "size_in_bytes": 3848 + }, + { + "_path": "lib/python3.10/csv.py", + "path_type": "hardlink", + "sha256": "6c68a5186e3b85e6e267a7ef96479327a45ae2b40bf5e9f2017e4b2282b3f5b1", + "sha256_in_prefix": "6c68a5186e3b85e6e267a7ef96479327a45ae2b40bf5e9f2017e4b2282b3f5b1", + "size_in_bytes": 16030 + }, + { + "_path": "lib/python3.10/ctypes/__init__.py", + "path_type": "hardlink", + "sha256": "9b99fa34cb2c454490337a62a9d91f5828c1a4f1ac22d94d94fffea34a2d612e", + "sha256_in_prefix": "9b99fa34cb2c454490337a62a9d91f5828c1a4f1ac22d94d94fffea34a2d612e", + "size_in_bytes": 17988 + }, + { + "_path": "lib/python3.10/ctypes/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "fb5bc3570132c634bf175f5c3d3ac899e4d22f97e991e00b6754ae3807801070", + "sha256_in_prefix": "fb5bc3570132c634bf175f5c3d3ac899e4d22f97e991e00b6754ae3807801070", + "size_in_bytes": 16136 + }, + { + "_path": "lib/python3.10/ctypes/__pycache__/_aix.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "1ef00e5239f3abe2259e548fc9286aa1f8abbb6d6e5289b998af3a4f76553d0c", + "sha256_in_prefix": "1ef00e5239f3abe2259e548fc9286aa1f8abbb6d6e5289b998af3a4f76553d0c", + "size_in_bytes": 10124 + }, + { + "_path": "lib/python3.10/ctypes/__pycache__/_endian.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "2efc0b0a7e4ff6eae4a44981d0ede3c5d0d25f305f1c03abac9aed9c1495cd14", + "sha256_in_prefix": "2efc0b0a7e4ff6eae4a44981d0ede3c5d0d25f305f1c03abac9aed9c1495cd14", + "size_in_bytes": 2155 + }, + { + "_path": "lib/python3.10/ctypes/__pycache__/util.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "04b1da955952e522b1cbb606193193398f08f895d1683a3eddb18b8464c40c75", + "sha256_in_prefix": "04b1da955952e522b1cbb606193193398f08f895d1683a3eddb18b8464c40c75", + "size_in_bytes": 8973 + }, + { + "_path": "lib/python3.10/ctypes/__pycache__/wintypes.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "233a2cd6f2882fa7359e34f45e428cb87b74b2c4cae3670cbbc91204d30924f9", + "sha256_in_prefix": "233a2cd6f2882fa7359e34f45e428cb87b74b2c4cae3670cbbc91204d30924f9", + "size_in_bytes": 5112 + }, + { + "_path": "lib/python3.10/ctypes/_aix.py", + "path_type": "hardlink", + "sha256": "3aaaa326d9c45e115d87e9e52874b1acd766cb4c578cecad667177d50849034c", + "sha256_in_prefix": "3aaaa326d9c45e115d87e9e52874b1acd766cb4c578cecad667177d50849034c", + "size_in_bytes": 12575 + }, + { + "_path": "lib/python3.10/ctypes/_endian.py", + "path_type": "hardlink", + "sha256": "4c9944875236d4227e8fd80ca0439417870ef387a532403393da91bf7ff67e16", + "sha256_in_prefix": "4c9944875236d4227e8fd80ca0439417870ef387a532403393da91bf7ff67e16", + "size_in_bytes": 2000 + }, + { + "_path": "lib/python3.10/ctypes/macholib/README.ctypes", + "path_type": "hardlink", + "sha256": "dc29d1da83b6a0a09a41647e4111eee878ed079c2d6b54a98fd6d8b88dd581f2", + "sha256_in_prefix": "dc29d1da83b6a0a09a41647e4111eee878ed079c2d6b54a98fd6d8b88dd581f2", + "size_in_bytes": 296 + }, + { + "_path": "lib/python3.10/ctypes/macholib/__init__.py", + "path_type": "hardlink", + "sha256": "1e77c01eec8f167ed10b754f153c0c743c8e5196ae9c81dffc08f129ab56dbfd", + "sha256_in_prefix": "1e77c01eec8f167ed10b754f153c0c743c8e5196ae9c81dffc08f129ab56dbfd", + "size_in_bytes": 154 + }, + { + "_path": "lib/python3.10/ctypes/macholib/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "361a9a71511781187498d4fed371f90aa3e7de30bb5ff394510f80038da3c9d1", + "sha256_in_prefix": "361a9a71511781187498d4fed371f90aa3e7de30bb5ff394510f80038da3c9d1", + "size_in_bytes": 556 + }, + { + "_path": "lib/python3.10/ctypes/macholib/__pycache__/dyld.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "1e713afb833efce544ef5fa682594c693424aff08817ec550f343169b8eb9a64", + "sha256_in_prefix": "1e713afb833efce544ef5fa682594c693424aff08817ec550f343169b8eb9a64", + "size_in_bytes": 4946 + }, + { + "_path": "lib/python3.10/ctypes/macholib/__pycache__/dylib.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "0c5d12fd48d2ce660a68902552fc6e2986048342ad01c4ce15b0736bd9a8223c", + "sha256_in_prefix": "0c5d12fd48d2ce660a68902552fc6e2986048342ad01c4ce15b0736bd9a8223c", + "size_in_bytes": 2163 + }, + { + "_path": "lib/python3.10/ctypes/macholib/__pycache__/framework.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "867c297f7ccb9265f964af093ff52c5b9826bf0d06e82ef19f462599caa9eac6", + "sha256_in_prefix": "867c297f7ccb9265f964af093ff52c5b9826bf0d06e82ef19f462599caa9eac6", + "size_in_bytes": 2443 + }, + { + "_path": "lib/python3.10/ctypes/macholib/dyld.py", + "path_type": "hardlink", + "sha256": "d0c8d4fd2b41360c513f49aa0bbfe2dfb79b7543bb78534aeeea9abfd18c57b7", + "sha256_in_prefix": "d0c8d4fd2b41360c513f49aa0bbfe2dfb79b7543bb78534aeeea9abfd18c57b7", + "size_in_bytes": 5415 + }, + { + "_path": "lib/python3.10/ctypes/macholib/dylib.py", + "path_type": "hardlink", + "sha256": "17de9f3d36c6ccbd97ed4ca15a908ad06663a84aa5d485714b202db7fe8e171a", + "sha256_in_prefix": "17de9f3d36c6ccbd97ed4ca15a908ad06663a84aa5d485714b202db7fe8e171a", + "size_in_bytes": 1828 + }, + { + "_path": "lib/python3.10/ctypes/macholib/fetch_macholib", + "path_type": "hardlink", + "sha256": "a9f6faacdb1aa00ac2f68043cd445171de9639a732b861bd5e64090a2865ab23", + "sha256_in_prefix": "a9f6faacdb1aa00ac2f68043cd445171de9639a732b861bd5e64090a2865ab23", + "size_in_bytes": 84 + }, + { + "_path": "lib/python3.10/ctypes/macholib/fetch_macholib.bat", + "path_type": "hardlink", + "sha256": "7497fbdbb98afca4ac455e3a057c59bcdebaf1280e25c94741dc301f05cb53e5", + "sha256_in_prefix": "7497fbdbb98afca4ac455e3a057c59bcdebaf1280e25c94741dc301f05cb53e5", + "size_in_bytes": 75 + }, + { + "_path": "lib/python3.10/ctypes/macholib/framework.py", + "path_type": "hardlink", + "sha256": "bf15187b7ea40c0255f14095e1091c13953c2efd98d96b409debc67669defc56", + "sha256_in_prefix": "bf15187b7ea40c0255f14095e1091c13953c2efd98d96b409debc67669defc56", + "size_in_bytes": 2201 + }, + { + "_path": "lib/python3.10/ctypes/util.py", + "path_type": "hardlink", + "sha256": "2c256f4c754f9e085b3a86d22a307ceb8ec455a1d351b88fca517e6ffbfa13f6", + "sha256_in_prefix": "2c256f4c754f9e085b3a86d22a307ceb8ec455a1d351b88fca517e6ffbfa13f6", + "size_in_bytes": 14856 + }, + { + "_path": "lib/python3.10/ctypes/wintypes.py", + "path_type": "hardlink", + "sha256": "c8f29e6cb1b05223e423391242f671381546130acae1fd7baafb65ba849f2a00", + "sha256_in_prefix": "c8f29e6cb1b05223e423391242f671381546130acae1fd7baafb65ba849f2a00", + "size_in_bytes": 5628 + }, + { + "_path": "lib/python3.10/curses/__init__.py", + "path_type": "hardlink", + "sha256": "d8730e360dd00ec046bdd85cae41fe83c907c6ae3716a964158fce8f31ab28b0", + "sha256_in_prefix": "d8730e360dd00ec046bdd85cae41fe83c907c6ae3716a964158fce8f31ab28b0", + "size_in_bytes": 3369 + }, + { + "_path": "lib/python3.10/curses/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "8f27cc2cae6d0e52b8fb9a8037187cbe4bdce2a739c043b7bc0ba548e69fe9eb", + "sha256_in_prefix": "8f27cc2cae6d0e52b8fb9a8037187cbe4bdce2a739c043b7bc0ba548e69fe9eb", + "size_in_bytes": 2103 + }, + { + "_path": "lib/python3.10/curses/__pycache__/ascii.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "6dc378240369b0424ddc01c0cfb8bcc3330d0202b9fe8dd7ead8ea52e50a103f", + "sha256_in_prefix": "6dc378240369b0424ddc01c0cfb8bcc3330d0202b9fe8dd7ead8ea52e50a103f", + "size_in_bytes": 3864 + }, + { + "_path": "lib/python3.10/curses/__pycache__/has_key.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "3894717809e7c7a16e54f39425c278c9f9e35155df0ea76d5d64dd759a1d302b", + "sha256_in_prefix": "3894717809e7c7a16e54f39425c278c9f9e35155df0ea76d5d64dd759a1d302b", + "size_in_bytes": 4905 + }, + { + "_path": "lib/python3.10/curses/__pycache__/panel.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "34471d16d56a0dedeed733ea6d5e451e986ab496159b52e99d5ceef453bfc7e6", + "sha256_in_prefix": "34471d16d56a0dedeed733ea6d5e451e986ab496159b52e99d5ceef453bfc7e6", + "size_in_bytes": 480 + }, + { + "_path": "lib/python3.10/curses/__pycache__/textpad.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "2de2bb28f4d2d6e610d3c1b226e9102fd689b25991a1c6812d152b35365e6ddc", + "sha256_in_prefix": "2de2bb28f4d2d6e610d3c1b226e9102fd689b25991a1c6812d152b35365e6ddc", + "size_in_bytes": 6243 + }, + { + "_path": "lib/python3.10/curses/ascii.py", + "path_type": "hardlink", + "sha256": "cf0137c2143c5e5bea2ccd25bfc61f3a274c5d8fdab3bc4c2c7329412ce7b656", + "sha256_in_prefix": "cf0137c2143c5e5bea2ccd25bfc61f3a274c5d8fdab3bc4c2c7329412ce7b656", + "size_in_bytes": 2547 + }, + { + "_path": "lib/python3.10/curses/has_key.py", + "path_type": "hardlink", + "sha256": "15a052812d9ae80124bb25b3f5b9ffae38e2b03073774e163abf3d773140cfb3", + "sha256_in_prefix": "15a052812d9ae80124bb25b3f5b9ffae38e2b03073774e163abf3d773140cfb3", + "size_in_bytes": 5634 + }, + { + "_path": "lib/python3.10/curses/panel.py", + "path_type": "hardlink", + "sha256": "13ef404a30da1825a612ca3e453db88c305d45deef4441c4c9e2ef7ee0ef50c7", + "sha256_in_prefix": "13ef404a30da1825a612ca3e453db88c305d45deef4441c4c9e2ef7ee0ef50c7", + "size_in_bytes": 87 + }, + { + "_path": "lib/python3.10/curses/textpad.py", + "path_type": "hardlink", + "sha256": "bbc4634b3396bb6aa89f186206b9e236047e443ffd727116f45b537f4dce0759", + "sha256_in_prefix": "bbc4634b3396bb6aa89f186206b9e236047e443ffd727116f45b537f4dce0759", + "size_in_bytes": 7657 + }, + { + "_path": "lib/python3.10/dataclasses.py", + "path_type": "hardlink", + "sha256": "fa2e3728d8184954479c6fcd17015a5e0c176850f18f119f5c548fca49019441", + "sha256_in_prefix": "fa2e3728d8184954479c6fcd17015a5e0c176850f18f119f5c548fca49019441", + "size_in_bytes": 56390 + }, + { + "_path": "lib/python3.10/datetime.py", + "path_type": "hardlink", + "sha256": "92cdb4ad1ed394924cf3b7eaa601541e38aef1df98b3841f5eca733b2c5097b8", + "sha256_in_prefix": "92cdb4ad1ed394924cf3b7eaa601541e38aef1df98b3841f5eca733b2c5097b8", + "size_in_bytes": 88086 + }, + { + "_path": "lib/python3.10/dbm/__init__.py", + "path_type": "hardlink", + "sha256": "930cdedcd5887bdf70477c541d73b54797c232d90dce149ab5b135331f04ec16", + "sha256_in_prefix": "930cdedcd5887bdf70477c541d73b54797c232d90dce149ab5b135331f04ec16", + "size_in_bytes": 5839 + }, + { + "_path": "lib/python3.10/dbm/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "a75a5e4d20fdad661ea5401d63a0706dbc2f6cf79e7ae5c45545076cdf45e773", + "sha256_in_prefix": "a75a5e4d20fdad661ea5401d63a0706dbc2f6cf79e7ae5c45545076cdf45e773", + "size_in_bytes": 4235 + }, + { + "_path": "lib/python3.10/dbm/__pycache__/dumb.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "9b80ec6267bd76fbb06a06d62567c3f5241fd076b47cd5ee1aed17280921c9ba", + "sha256_in_prefix": "9b80ec6267bd76fbb06a06d62567c3f5241fd076b47cd5ee1aed17280921c9ba", + "size_in_bytes": 8104 + }, + { + "_path": "lib/python3.10/dbm/__pycache__/gnu.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "ebffc1c4b03b444286f2e5350269299329c257e3dcb4f49abf368681261c5a39", + "sha256_in_prefix": "ebffc1c4b03b444286f2e5350269299329c257e3dcb4f49abf368681261c5a39", + "size_in_bytes": 460 + }, + { + "_path": "lib/python3.10/dbm/__pycache__/ndbm.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "051a71d7b598af84c691d4f0da22a8f5bb615ceedd9bcebaba8b4b4eab0ddef3", + "sha256_in_prefix": "051a71d7b598af84c691d4f0da22a8f5bb615ceedd9bcebaba8b4b4eab0ddef3", + "size_in_bytes": 459 + }, + { + "_path": "lib/python3.10/dbm/dumb.py", + "path_type": "hardlink", + "sha256": "eec69824f4a1cfa02e23766eecc48339b09c5a08b0099063d3f0311c252e9700", + "sha256_in_prefix": "eec69824f4a1cfa02e23766eecc48339b09c5a08b0099063d3f0311c252e9700", + "size_in_bytes": 11536 + }, + { + "_path": "lib/python3.10/dbm/gnu.py", + "path_type": "hardlink", + "sha256": "36cd4904f50e00c4df4ad9d450b3970e150957425f47c00cf979ba73eff49778", + "sha256_in_prefix": "36cd4904f50e00c4df4ad9d450b3970e150957425f47c00cf979ba73eff49778", + "size_in_bytes": 72 + }, + { + "_path": "lib/python3.10/dbm/ndbm.py", + "path_type": "hardlink", + "sha256": "1bcc2d9b2fad1901f3421a174eeecb5b8ccc6763283b87bbe0705b404c71904b", + "sha256_in_prefix": "1bcc2d9b2fad1901f3421a174eeecb5b8ccc6763283b87bbe0705b404c71904b", + "size_in_bytes": 70 + }, + { + "_path": "lib/python3.10/decimal.py", + "path_type": "hardlink", + "sha256": "000c00bad31d126b054c6ec7f3e02b27c0f9a4d579f987d3c4f879cee1bacb81", + "sha256_in_prefix": "000c00bad31d126b054c6ec7f3e02b27c0f9a4d579f987d3c4f879cee1bacb81", + "size_in_bytes": 320 + }, + { + "_path": "lib/python3.10/difflib.py", + "path_type": "hardlink", + "sha256": "0c6afc23568d55b3e9ac914f9c5361e3033e778aa5b58d3cc82835fc5c638679", + "sha256_in_prefix": "0c6afc23568d55b3e9ac914f9c5361e3033e778aa5b58d3cc82835fc5c638679", + "size_in_bytes": 83308 + }, + { + "_path": "lib/python3.10/dis.py", + "path_type": "hardlink", + "sha256": "67075458fb59ec9e0d6206440df6b2f31944fcb4c480b9f6fe202094bc455d1d", + "sha256_in_prefix": "67075458fb59ec9e0d6206440df6b2f31944fcb4c480b9f6fe202094bc455d1d", + "size_in_bytes": 20020 + }, + { + "_path": "lib/python3.10/distutils/README", + "path_type": "hardlink", + "sha256": "8d19071886238eda514e96a7ab1c17d6d8c26ae628c4ddbc8ecc5329fd9d8000", + "sha256_in_prefix": "8d19071886238eda514e96a7ab1c17d6d8c26ae628c4ddbc8ecc5329fd9d8000", + "size_in_bytes": 244 + }, + { + "_path": "lib/python3.10/distutils/__init__.py", + "path_type": "hardlink", + "sha256": "50c33f1d73f224a50a07f64e29a5e71b86b105a2e61873e7f47dc28a6baa7680", + "sha256_in_prefix": "50c33f1d73f224a50a07f64e29a5e71b86b105a2e61873e7f47dc28a6baa7680", + "size_in_bytes": 541 + }, + { + "_path": "lib/python3.10/distutils/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "78081e735ece7a0ed014e84634d7fae140b6467a1fa4ee05512eb5dfae87d15a", + "sha256_in_prefix": "78081e735ece7a0ed014e84634d7fae140b6467a1fa4ee05512eb5dfae87d15a", + "size_in_bytes": 875 + }, + { + "_path": "lib/python3.10/distutils/__pycache__/_msvccompiler.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "dc9cfd7fb7c535279c089713035d5cfe7bc54769eaef3cf2fc5cad1a22f63545", + "sha256_in_prefix": "dc9cfd7fb7c535279c089713035d5cfe7bc54769eaef3cf2fc5cad1a22f63545", + "size_in_bytes": 13198 + }, + { + "_path": "lib/python3.10/distutils/__pycache__/archive_util.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "b842a109cccb4b315bd49e93db83d77b227e8ba3e877d60a0f9f764aa0f8e860", + "sha256_in_prefix": "b842a109cccb4b315bd49e93db83d77b227e8ba3e877d60a0f9f764aa0f8e860", + "size_in_bytes": 6762 + }, + { + "_path": "lib/python3.10/distutils/__pycache__/bcppcompiler.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "00731c7662c1bbfd65dd1a14e354a22885c98cf73417d202e01f93113fa0d0cc", + "sha256_in_prefix": "00731c7662c1bbfd65dd1a14e354a22885c98cf73417d202e01f93113fa0d0cc", + "size_in_bytes": 6749 + }, + { + "_path": "lib/python3.10/distutils/__pycache__/ccompiler.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "e3fd619a0f07286308f36e84a8b6ab6680dd471d5299ff348104f7ee3b829486", + "sha256_in_prefix": "e3fd619a0f07286308f36e84a8b6ab6680dd471d5299ff348104f7ee3b829486", + "size_in_bytes": 33039 + }, + { + "_path": "lib/python3.10/distutils/__pycache__/cmd.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "5cb1cc89b3a2ee171eefca71b0e8c70dbc62960c5fc9b10ededa58b80d9f4b01", + "sha256_in_prefix": "5cb1cc89b3a2ee171eefca71b0e8c70dbc62960c5fc9b10ededa58b80d9f4b01", + "size_in_bytes": 14149 + }, + { + "_path": "lib/python3.10/distutils/__pycache__/config.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c0ec082d60c3cd488850245ec6207c4a229aa434fbf2938ee811f2e167482e5c", + "sha256_in_prefix": "c0ec082d60c3cd488850245ec6207c4a229aa434fbf2938ee811f2e167482e5c", + "size_in_bytes": 3788 + }, + { + "_path": "lib/python3.10/distutils/__pycache__/core.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "755a9b635c7edca2e4f8b8ef433c1bf1b35ed4e8adb0421912b64d2a2598cfad", + "sha256_in_prefix": "755a9b635c7edca2e4f8b8ef433c1bf1b35ed4e8adb0421912b64d2a2598cfad", + "size_in_bytes": 6857 + }, + { + "_path": "lib/python3.10/distutils/__pycache__/cygwinccompiler.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "23b0cca35695adf473b923ca2f67df4389e842242bcd0afdad5e96ff66d1b7bd", + "sha256_in_prefix": "23b0cca35695adf473b923ca2f67df4389e842242bcd0afdad5e96ff66d1b7bd", + "size_in_bytes": 8752 + }, + { + "_path": "lib/python3.10/distutils/__pycache__/debug.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "a66c62448e6375b80478ba0de20d8954ea55979df862549a4b2dca371d738201", + "sha256_in_prefix": "a66c62448e6375b80478ba0de20d8954ea55979df862549a4b2dca371d738201", + "size_in_bytes": 451 + }, + { + "_path": "lib/python3.10/distutils/__pycache__/dep_util.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "a134fa99a024a7fbe7681c01bdbf57d9602090c98988abeb6437dcd2e97a6547", + "sha256_in_prefix": "a134fa99a024a7fbe7681c01bdbf57d9602090c98988abeb6437dcd2e97a6547", + "size_in_bytes": 2972 + }, + { + "_path": "lib/python3.10/distutils/__pycache__/dir_util.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "a096f0220d121863dd13801048f1dcf9378f7a2cc43e595f3c32c5e7c5848265", + "sha256_in_prefix": "a096f0220d121863dd13801048f1dcf9378f7a2cc43e595f3c32c5e7c5848265", + "size_in_bytes": 5824 + }, + { + "_path": "lib/python3.10/distutils/__pycache__/dist.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "ab8b0c1af8ca4b65257917c4356c0f5588bc2798fe989d0640dcc91cc22ad7ca", + "sha256_in_prefix": "ab8b0c1af8ca4b65257917c4356c0f5588bc2798fe989d0640dcc91cc22ad7ca", + "size_in_bytes": 34204 + }, + { + "_path": "lib/python3.10/distutils/__pycache__/errors.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "6416a7bad79de74a93ce577e29b1c35fa01c89d6e39f867d6699bc1c929e47f2", + "sha256_in_prefix": "6416a7bad79de74a93ce577e29b1c35fa01c89d6e39f867d6699bc1c929e47f2", + "size_in_bytes": 5193 + }, + { + "_path": "lib/python3.10/distutils/__pycache__/extension.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "104263a1686869c9d6e948f380ee891e199a06c5cd625514eda3a8454de27b83", + "sha256_in_prefix": "104263a1686869c9d6e948f380ee891e199a06c5cd625514eda3a8454de27b83", + "size_in_bytes": 7228 + }, + { + "_path": "lib/python3.10/distutils/__pycache__/fancy_getopt.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "4f6238092f1209dd1e1def93cf659d1ffa38382fb447d57fb57b3b91b76e4e8d", + "sha256_in_prefix": "4f6238092f1209dd1e1def93cf659d1ffa38382fb447d57fb57b3b91b76e4e8d", + "size_in_bytes": 10831 + }, + { + "_path": "lib/python3.10/distutils/__pycache__/file_util.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "228914526ec211b9c0e6c4104ace7a859794fbbfd68cee3f2eef6822add7f039", + "sha256_in_prefix": "228914526ec211b9c0e6c4104ace7a859794fbbfd68cee3f2eef6822add7f039", + "size_in_bytes": 6177 + }, + { + "_path": "lib/python3.10/distutils/__pycache__/filelist.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "50ceac85ba57c2ff825719a5826679122fa1521e5a04c0f5459f834c7f9796ad", + "sha256_in_prefix": "50ceac85ba57c2ff825719a5826679122fa1521e5a04c0f5459f834c7f9796ad", + "size_in_bytes": 10081 + }, + { + "_path": "lib/python3.10/distutils/__pycache__/log.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "975274e9ece0f0d0fd7dfa5cee9df2dddd3dba40d344f4a3dec9519c4d7c61f3", + "sha256_in_prefix": "975274e9ece0f0d0fd7dfa5cee9df2dddd3dba40d344f4a3dec9519c4d7c61f3", + "size_in_bytes": 2508 + }, + { + "_path": "lib/python3.10/distutils/__pycache__/msvc9compiler.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "2608e5037f7a9e28f4cab2229d49e36051f059939b433e2a31fbe89a53c6ffdd", + "sha256_in_prefix": "2608e5037f7a9e28f4cab2229d49e36051f059939b433e2a31fbe89a53c6ffdd", + "size_in_bytes": 17763 + }, + { + "_path": "lib/python3.10/distutils/__pycache__/msvccompiler.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "d1745b220d2a78e32fce06fd6c4d4b5b4800d44130a5fed6aae4bccc162435fb", + "sha256_in_prefix": "d1745b220d2a78e32fce06fd6c4d4b5b4800d44130a5fed6aae4bccc162435fb", + "size_in_bytes": 14982 + }, + { + "_path": "lib/python3.10/distutils/__pycache__/spawn.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "b0bf66e3259ee923c1e05d28a0e2065d4b4c529224dd289e1af243194df10bc1", + "sha256_in_prefix": "b0bf66e3259ee923c1e05d28a0e2065d4b4c529224dd289e1af243194df10bc1", + "size_in_bytes": 3668 + }, + { + "_path": "lib/python3.10/distutils/__pycache__/sysconfig.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "cb83c63aa8b3c78ebadb08030a69694c6a9d84435fbd86b5c371ef7b6ba62fd5", + "sha256_in_prefix": "cb83c63aa8b3c78ebadb08030a69694c6a9d84435fbd86b5c371ef7b6ba62fd5", + "size_in_bytes": 7322 + }, + { + "_path": "lib/python3.10/distutils/__pycache__/text_file.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "ae831c74025813e2eda218a19becae0a46a6870f239e2d3bdda64bfbf20d46c5", + "sha256_in_prefix": "ae831c74025813e2eda218a19becae0a46a6870f239e2d3bdda64bfbf20d46c5", + "size_in_bytes": 8670 + }, + { + "_path": "lib/python3.10/distutils/__pycache__/unixccompiler.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "d65206fdc7aec173e8ccebb1b7ed1032ceac3081555a015f5ed90d656829d842", + "sha256_in_prefix": "d65206fdc7aec173e8ccebb1b7ed1032ceac3081555a015f5ed90d656829d842", + "size_in_bytes": 7070 + }, + { + "_path": "lib/python3.10/distutils/__pycache__/util.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "d27f5ce699de319deac40f2ff5482daf1ac2d99f29d9e9b7113a0cb43bc1b7b0", + "sha256_in_prefix": "d27f5ce699de319deac40f2ff5482daf1ac2d99f29d9e9b7113a0cb43bc1b7b0", + "size_in_bytes": 15890 + }, + { + "_path": "lib/python3.10/distutils/__pycache__/version.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "f29e6373d9e1746421279bb4b7fa389988bb134f47f4a0352628f022f7541e72", + "sha256_in_prefix": "f29e6373d9e1746421279bb4b7fa389988bb134f47f4a0352628f022f7541e72", + "size_in_bytes": 7560 + }, + { + "_path": "lib/python3.10/distutils/__pycache__/versionpredicate.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "d388e2dd942fea3f0e504399fe0e541676b572527784c2d2b1d8f9cab57905ff", + "sha256_in_prefix": "d388e2dd942fea3f0e504399fe0e541676b572527784c2d2b1d8f9cab57905ff", + "size_in_bytes": 5388 + }, + { + "_path": "lib/python3.10/distutils/_msvccompiler.py", + "path_type": "hardlink", + "sha256": "21c14c94e6015f56b8c28abd8c8f628f33efbdb808a4a26b0deeb31f2d4ca17a", + "sha256_in_prefix": "21c14c94e6015f56b8c28abd8c8f628f33efbdb808a4a26b0deeb31f2d4ca17a", + "size_in_bytes": 20404 + }, + { + "_path": "lib/python3.10/distutils/archive_util.py", + "path_type": "hardlink", + "sha256": "a96fae886c187b14ef2b97be8927a5ff7d43b21c7e0aa4da9cd3caeac9f07fdf", + "sha256_in_prefix": "a96fae886c187b14ef2b97be8927a5ff7d43b21c7e0aa4da9cd3caeac9f07fdf", + "size_in_bytes": 8572 + }, + { + "_path": "lib/python3.10/distutils/bcppcompiler.py", + "path_type": "hardlink", + "sha256": "3890d5a425265fa1fcbffee5575ce27d5d5f731f760abd9d862521ebdf3d5092", + "sha256_in_prefix": "3890d5a425265fa1fcbffee5575ce27d5d5f731f760abd9d862521ebdf3d5092", + "size_in_bytes": 14894 + }, + { + "_path": "lib/python3.10/distutils/ccompiler.py", + "path_type": "hardlink", + "sha256": "194146bc2645bafe0d34d90d6837958779de804b21178b3e1a3da651bbbccffb", + "sha256_in_prefix": "194146bc2645bafe0d34d90d6837958779de804b21178b3e1a3da651bbbccffb", + "size_in_bytes": 47418 + }, + { + "_path": "lib/python3.10/distutils/cmd.py", + "path_type": "hardlink", + "sha256": "79ca3a2c0194b686cbb8f69fba19a02a09304512ff598f0a27861e0c21e9725b", + "sha256_in_prefix": "79ca3a2c0194b686cbb8f69fba19a02a09304512ff598f0a27861e0c21e9725b", + "size_in_bytes": 18079 + }, + { + "_path": "lib/python3.10/distutils/command/__init__.py", + "path_type": "hardlink", + "sha256": "f0bcde9801fad1d064fee42c8ccbe36eb121cba7b6e4415c40c3ec144217ee37", + "sha256_in_prefix": "f0bcde9801fad1d064fee42c8ccbe36eb121cba7b6e4415c40c3ec144217ee37", + "size_in_bytes": 771 + }, + { + "_path": "lib/python3.10/distutils/command/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "10b25e5e1bd542eb4ecc8e024e5aca5a94e9fbc7a14a593364846f32d2951b2c", + "sha256_in_prefix": "10b25e5e1bd542eb4ecc8e024e5aca5a94e9fbc7a14a593364846f32d2951b2c", + "size_in_bytes": 456 + }, + { + "_path": "lib/python3.10/distutils/command/__pycache__/bdist.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "fb7b429c74113dbba6ec305783195139cac7f96c4958cb1ad3c95ebce5820d01", + "sha256_in_prefix": "fb7b429c74113dbba6ec305783195139cac7f96c4958cb1ad3c95ebce5820d01", + "size_in_bytes": 3804 + }, + { + "_path": "lib/python3.10/distutils/command/__pycache__/bdist_dumb.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "7be8b4f25ceb0860ebe1f26badcc9cf30dc6fc6ce23fcd5b6c88c5312eabe32c", + "sha256_in_prefix": "7be8b4f25ceb0860ebe1f26badcc9cf30dc6fc6ce23fcd5b6c88c5312eabe32c", + "size_in_bytes": 3584 + }, + { + "_path": "lib/python3.10/distutils/command/__pycache__/bdist_msi.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "547d13fa3a865e57dea68f9ca7605ba0e3a38fa4674ed26fdd58415816278fb5", + "sha256_in_prefix": "547d13fa3a865e57dea68f9ca7605ba0e3a38fa4674ed26fdd58415816278fb5", + "size_in_bytes": 19919 + }, + { + "_path": "lib/python3.10/distutils/command/__pycache__/bdist_rpm.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "ac617772f23fbdb3443958c48c607d5c375d77e275fbc5392a83e57311a2b6b3", + "sha256_in_prefix": "ac617772f23fbdb3443958c48c607d5c375d77e275fbc5392a83e57311a2b6b3", + "size_in_bytes": 12487 + }, + { + "_path": "lib/python3.10/distutils/command/__pycache__/build.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "2a46c498ed15d60d1686184f27bc8144456bea06c2a2a5f32ac9a2c92071ca19", + "sha256_in_prefix": "2a46c498ed15d60d1686184f27bc8144456bea06c2a2a5f32ac9a2c92071ca19", + "size_in_bytes": 4098 + }, + { + "_path": "lib/python3.10/distutils/command/__pycache__/build_clib.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "2f9fa67bd251f3dee4482aef0a15d56963b00da7d9612cf243b26f0e1bc86377", + "sha256_in_prefix": "2f9fa67bd251f3dee4482aef0a15d56963b00da7d9612cf243b26f0e1bc86377", + "size_in_bytes": 5069 + }, + { + "_path": "lib/python3.10/distutils/command/__pycache__/build_ext.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "72f4160dbcad7c47a0f5fdd2abd61edd288100b322b6ded0b41766420b5ff493", + "sha256_in_prefix": "72f4160dbcad7c47a0f5fdd2abd61edd288100b322b6ded0b41766420b5ff493", + "size_in_bytes": 16447 + }, + { + "_path": "lib/python3.10/distutils/command/__pycache__/build_py.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "a7029857b60fcccbda350d63a8d0705d5af8c001aecdaec3858e70b19995e5fc", + "sha256_in_prefix": "a7029857b60fcccbda350d63a8d0705d5af8c001aecdaec3858e70b19995e5fc", + "size_in_bytes": 10728 + }, + { + "_path": "lib/python3.10/distutils/command/__pycache__/build_scripts.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "2759e5382d4ed80c14a6a804bea554e2bf94b1bd0f58ad8e6469cd1815936ccb", + "sha256_in_prefix": "2759e5382d4ed80c14a6a804bea554e2bf94b1bd0f58ad8e6469cd1815936ccb", + "size_in_bytes": 4583 + }, + { + "_path": "lib/python3.10/distutils/command/__pycache__/check.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "07d4dfdfe92b872f221f1a10dc7ca086ba0e3470d0fb56ba78824151e59157f9", + "sha256_in_prefix": "07d4dfdfe92b872f221f1a10dc7ca086ba0e3470d0fb56ba78824151e59157f9", + "size_in_bytes": 5207 + }, + { + "_path": "lib/python3.10/distutils/command/__pycache__/clean.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "f9d91d8666c6c44048d30ac6ab92cc62e47e1b33d0c07a36ea0fc4aa78dc7624", + "sha256_in_prefix": "f9d91d8666c6c44048d30ac6ab92cc62e47e1b33d0c07a36ea0fc4aa78dc7624", + "size_in_bytes": 2347 + }, + { + "_path": "lib/python3.10/distutils/command/__pycache__/config.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "beb9a927ceff8878ecec302b83da887dc2288918cec3743ebf6124fa728f7fb3", + "sha256_in_prefix": "beb9a927ceff8878ecec302b83da887dc2288918cec3743ebf6124fa728f7fb3", + "size_in_bytes": 10529 + }, + { + "_path": "lib/python3.10/distutils/command/__pycache__/install.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "d756dcd486c53b9434edcd223df80fc25ca6bcb865760cf4f3355816d101dc77", + "sha256_in_prefix": "d756dcd486c53b9434edcd223df80fc25ca6bcb865760cf4f3355816d101dc77", + "size_in_bytes": 14064 + }, + { + "_path": "lib/python3.10/distutils/command/__pycache__/install_data.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "81656cfac75c9261f82ceb3ab6f3d27f4838839e579e6b3b63fd18e96f1960f9", + "sha256_in_prefix": "81656cfac75c9261f82ceb3ab6f3d27f4838839e579e6b3b63fd18e96f1960f9", + "size_in_bytes": 2546 + }, + { + "_path": "lib/python3.10/distutils/command/__pycache__/install_egg_info.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "b40a8d73dc439806754c419a24bd70e4a19313cce74b285ced2acac7f17e05b0", + "sha256_in_prefix": "b40a8d73dc439806754c419a24bd70e4a19313cce74b285ced2acac7f17e05b0", + "size_in_bytes": 3287 + }, + { + "_path": "lib/python3.10/distutils/command/__pycache__/install_headers.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "beff819b95120aa837d71a7e47a03dc9f17bb4f8dee10d59de7ac2cc2f66269b", + "sha256_in_prefix": "beff819b95120aa837d71a7e47a03dc9f17bb4f8dee10d59de7ac2cc2f66269b", + "size_in_bytes": 1969 + }, + { + "_path": "lib/python3.10/distutils/command/__pycache__/install_lib.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "7b9a3abc80ce16a528c53a4a56b1eccf11db187b65bd5f0f9bdc747cae975561", + "sha256_in_prefix": "7b9a3abc80ce16a528c53a4a56b1eccf11db187b65bd5f0f9bdc747cae975561", + "size_in_bytes": 5371 + }, + { + "_path": "lib/python3.10/distutils/command/__pycache__/install_scripts.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "90b1513898786c2320fae478dbf1b5c7509ca4b14c2f6ef1ea03f851773a6d34", + "sha256_in_prefix": "90b1513898786c2320fae478dbf1b5c7509ca4b14c2f6ef1ea03f851773a6d34", + "size_in_bytes": 2398 + }, + { + "_path": "lib/python3.10/distutils/command/__pycache__/register.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "0ac09691ec79999bd489e80bdb9c974712107183ac51e06df97a4314c19d2f1a", + "sha256_in_prefix": "0ac09691ec79999bd489e80bdb9c974712107183ac51e06df97a4314c19d2f1a", + "size_in_bytes": 8882 + }, + { + "_path": "lib/python3.10/distutils/command/__pycache__/sdist.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "b81453bd424a6e682d9c0c0ec2dd0f0b13e8d30376c86faa2ae07753bdbed242", + "sha256_in_prefix": "b81453bd424a6e682d9c0c0ec2dd0f0b13e8d30376c86faa2ae07753bdbed242", + "size_in_bytes": 14698 + }, + { + "_path": "lib/python3.10/distutils/command/__pycache__/upload.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "d261a24782f2b679129db667a3f758c0aa1e4f2dc6db7a57496b4cf7cc8fb1c8", + "sha256_in_prefix": "d261a24782f2b679129db667a3f758c0aa1e4f2dc6db7a57496b4cf7cc8fb1c8", + "size_in_bytes": 5341 + }, + { + "_path": "lib/python3.10/distutils/command/bdist.py", + "path_type": "hardlink", + "sha256": "b8fa0cb381931c6d51e13da553a7d91a3e9841324d9ba4496862f2fdac990459", + "sha256_in_prefix": "b8fa0cb381931c6d51e13da553a7d91a3e9841324d9ba4496862f2fdac990459", + "size_in_bytes": 5433 + }, + { + "_path": "lib/python3.10/distutils/command/bdist_dumb.py", + "path_type": "hardlink", + "sha256": "053babf63708a69c8fecf89abe37ec93b623125aafc5e60eda7a54c8f3ce7a47", + "sha256_in_prefix": "053babf63708a69c8fecf89abe37ec93b623125aafc5e60eda7a54c8f3ce7a47", + "size_in_bytes": 4913 + }, + { + "_path": "lib/python3.10/distutils/command/bdist_msi.py", + "path_type": "hardlink", + "sha256": "f9a6c1fdcbaead2f17ea343b2645d5fae6e6fa5b6bbd84aa92d715a013caa968", + "sha256_in_prefix": "f9a6c1fdcbaead2f17ea343b2645d5fae6e6fa5b6bbd84aa92d715a013caa968", + "size_in_bytes": 35519 + }, + { + "_path": "lib/python3.10/distutils/command/bdist_rpm.py", + "path_type": "hardlink", + "sha256": "8233b0db61a10d26dcab46ddab6e5c4dbfa7e875969b46d284b41a77f9a42789", + "sha256_in_prefix": "8233b0db61a10d26dcab46ddab6e5c4dbfa7e875969b46d284b41a77f9a42789", + "size_in_bytes": 21537 + }, + { + "_path": "lib/python3.10/distutils/command/build.py", + "path_type": "hardlink", + "sha256": "d753724765005336a5ae44d9da98740401c55850b68ed4ac37b808685f8d0b4f", + "sha256_in_prefix": "d753724765005336a5ae44d9da98740401c55850b68ed4ac37b808685f8d0b4f", + "size_in_bytes": 5767 + }, + { + "_path": "lib/python3.10/distutils/command/build_clib.py", + "path_type": "hardlink", + "sha256": "6e05531e1dbc78b400d86930ebc6a602977f8fba90057e0c4c8fb34ef00afc9e", + "sha256_in_prefix": "6e05531e1dbc78b400d86930ebc6a602977f8fba90057e0c4c8fb34ef00afc9e", + "size_in_bytes": 8022 + }, + { + "_path": "lib/python3.10/distutils/command/build_ext.py", + "path_type": "hardlink", + "sha256": "30c24f0b11e57fdae05248b39f82a3abdbd878011fc72a9fabc5ec4c4f84a563", + "sha256_in_prefix": "30c24f0b11e57fdae05248b39f82a3abdbd878011fc72a9fabc5ec4c4f84a563", + "size_in_bytes": 31635 + }, + { + "_path": "lib/python3.10/distutils/command/build_py.py", + "path_type": "hardlink", + "sha256": "4bf365c3885913c3e7220a97e4e14c766b7e19298e84f410e1fda3af5b819e85", + "sha256_in_prefix": "4bf365c3885913c3e7220a97e4e14c766b7e19298e84f410e1fda3af5b819e85", + "size_in_bytes": 17190 + }, + { + "_path": "lib/python3.10/distutils/command/build_scripts.py", + "path_type": "hardlink", + "sha256": "68ac9c2493f1dcb7d9d5cbd981225ac670f62e7bd1339589fbcc64a5d81c2ec2", + "sha256_in_prefix": "68ac9c2493f1dcb7d9d5cbd981225ac670f62e7bd1339589fbcc64a5d81c2ec2", + "size_in_bytes": 6232 + }, + { + "_path": "lib/python3.10/distutils/command/check.py", + "path_type": "hardlink", + "sha256": "9927e429a3a9e968e41ae0bd5fa5ce2d691dfc1aa5e84b532b8089a8d3e87c0f", + "sha256_in_prefix": "9927e429a3a9e968e41ae0bd5fa5ce2d691dfc1aa5e84b532b8089a8d3e87c0f", + "size_in_bytes": 5636 + }, + { + "_path": "lib/python3.10/distutils/command/clean.py", + "path_type": "hardlink", + "sha256": "d930ade3baeee2165933445f55f5188f96dba6272918b3f8421c398c1b6fa7d9", + "sha256_in_prefix": "d930ade3baeee2165933445f55f5188f96dba6272918b3f8421c398c1b6fa7d9", + "size_in_bytes": 2776 + }, + { + "_path": "lib/python3.10/distutils/command/command_template", + "path_type": "hardlink", + "sha256": "7c1c707cd6ad3872515cf3fc9d8dd1a3f7cc08e3eb71813ed427499b256a8751", + "sha256_in_prefix": "7c1c707cd6ad3872515cf3fc9d8dd1a3f7cc08e3eb71813ed427499b256a8751", + "size_in_bytes": 633 + }, + { + "_path": "lib/python3.10/distutils/command/config.py", + "path_type": "hardlink", + "sha256": "d9a4e3c30dcfc23301f3e6626c27b83fb07ea86d61335827feb257632c51cfa7", + "sha256_in_prefix": "d9a4e3c30dcfc23301f3e6626c27b83fb07ea86d61335827feb257632c51cfa7", + "size_in_bytes": 13117 + }, + { + "_path": "lib/python3.10/distutils/command/install.py", + "path_type": "hardlink", + "sha256": "32b5cd24c6aafcdd73a2835e99f3bdf8c4f53d04de0011b3cb04f786ae60b994", + "sha256_in_prefix": "32b5cd24c6aafcdd73a2835e99f3bdf8c4f53d04de0011b3cb04f786ae60b994", + "size_in_bytes": 28242 + }, + { + "_path": "lib/python3.10/distutils/command/install_data.py", + "path_type": "hardlink", + "sha256": "62118e0308778093ea17b7a6e57034ae6a51e36cf56cb87cd28a049730f252f9", + "sha256_in_prefix": "62118e0308778093ea17b7a6e57034ae6a51e36cf56cb87cd28a049730f252f9", + "size_in_bytes": 2822 + }, + { + "_path": "lib/python3.10/distutils/command/install_egg_info.py", + "path_type": "hardlink", + "sha256": "d245b496254c79a7648d7d197117cca6d2857a7d3b1b0ea0cb0d551d3e4a2307", + "sha256_in_prefix": "d245b496254c79a7648d7d197117cca6d2857a7d3b1b0ea0cb0d551d3e4a2307", + "size_in_bytes": 2603 + }, + { + "_path": "lib/python3.10/distutils/command/install_headers.py", + "path_type": "hardlink", + "sha256": "5d0ea27646c80dfaf59635c23b39ee55432f385a47067e9c2b45b3f6020cd9be", + "sha256_in_prefix": "5d0ea27646c80dfaf59635c23b39ee55432f385a47067e9c2b45b3f6020cd9be", + "size_in_bytes": 1298 + }, + { + "_path": "lib/python3.10/distutils/command/install_lib.py", + "path_type": "hardlink", + "sha256": "f40a1f47e30ef6502d8f0c2eba40a9b5ea4e68910a3195b65478b2479854ec70", + "sha256_in_prefix": "f40a1f47e30ef6502d8f0c2eba40a9b5ea4e68910a3195b65478b2479854ec70", + "size_in_bytes": 8397 + }, + { + "_path": "lib/python3.10/distutils/command/install_scripts.py", + "path_type": "hardlink", + "sha256": "fc22d4790c06251718da48a4edaccf327e4876d0c2ae359d52f675921946e9c9", + "sha256_in_prefix": "fc22d4790c06251718da48a4edaccf327e4876d0c2ae359d52f675921946e9c9", + "size_in_bytes": 2017 + }, + { + "_path": "lib/python3.10/distutils/command/register.py", + "path_type": "hardlink", + "sha256": "da36aaf7debcaedda9b91543071d476cd897bf6eee3a4f22744ff894f7ffdd53", + "sha256_in_prefix": "da36aaf7debcaedda9b91543071d476cd897bf6eee3a4f22744ff894f7ffdd53", + "size_in_bytes": 11712 + }, + { + "_path": "lib/python3.10/distutils/command/sdist.py", + "path_type": "hardlink", + "sha256": "aa8b498c03b3ca1263ab6fa80c89a3345aceb5a4a778414325307eb04935c275", + "sha256_in_prefix": "aa8b498c03b3ca1263ab6fa80c89a3345aceb5a4a778414325307eb04935c275", + "size_in_bytes": 19005 + }, + { + "_path": "lib/python3.10/distutils/command/upload.py", + "path_type": "hardlink", + "sha256": "ed9475fb90f3ef73d98f8f1f40b8637de2767c9c4fca95975b0a2c55164e5b8c", + "sha256_in_prefix": "ed9475fb90f3ef73d98f8f1f40b8637de2767c9c4fca95975b0a2c55164e5b8c", + "size_in_bytes": 7621 + }, + { + "_path": "lib/python3.10/distutils/config.py", + "path_type": "hardlink", + "sha256": "76d1e06e5c7d2617f2acac75f89ec9971c3f7fbb3c65b3c54228b65163136696", + "sha256_in_prefix": "76d1e06e5c7d2617f2acac75f89ec9971c3f7fbb3c65b3c54228b65163136696", + "size_in_bytes": 4827 + }, + { + "_path": "lib/python3.10/distutils/core.py", + "path_type": "hardlink", + "sha256": "8db74e92938ad3dc62fb9eaf861c2f9f77d87612dbe4324ef2adcad5f9d0cf44", + "sha256_in_prefix": "8db74e92938ad3dc62fb9eaf861c2f9f77d87612dbe4324ef2adcad5f9d0cf44", + "size_in_bytes": 8876 + }, + { + "_path": "lib/python3.10/distutils/cygwinccompiler.py", + "path_type": "hardlink", + "sha256": "b75a16168b3210efd52a6b79b47f386da4ea3d86644caaa929a31a1bc25d1f0c", + "sha256_in_prefix": "b75a16168b3210efd52a6b79b47f386da4ea3d86644caaa929a31a1bc25d1f0c", + "size_in_bytes": 16480 + }, + { + "_path": "lib/python3.10/distutils/debug.py", + "path_type": "hardlink", + "sha256": "37a32b4c0a8aea5f52564ead5b0791d74f0f33c3a5eea3657f257e9c770b86c6", + "sha256_in_prefix": "37a32b4c0a8aea5f52564ead5b0791d74f0f33c3a5eea3657f257e9c770b86c6", + "size_in_bytes": 139 + }, + { + "_path": "lib/python3.10/distutils/dep_util.py", + "path_type": "hardlink", + "sha256": "1ae47d230fe3cd9464c9e989e475fcac1ff0446c642017019b5aa1e78afbce19", + "sha256_in_prefix": "1ae47d230fe3cd9464c9e989e475fcac1ff0446c642017019b5aa1e78afbce19", + "size_in_bytes": 3491 + }, + { + "_path": "lib/python3.10/distutils/dir_util.py", + "path_type": "hardlink", + "sha256": "5308413944dc57ae464f071ee123ee4d747c67cab72d811c9adb6a7066f46d8a", + "sha256_in_prefix": "5308413944dc57ae464f071ee123ee4d747c67cab72d811c9adb6a7066f46d8a", + "size_in_bytes": 7778 + }, + { + "_path": "lib/python3.10/distutils/dist.py", + "path_type": "hardlink", + "sha256": "1e797f81633e34c7993030ac4047b0cd43e49739d40dd03ef262d5c7dd7b17d2", + "sha256_in_prefix": "1e797f81633e34c7993030ac4047b0cd43e49739d40dd03ef262d5c7dd7b17d2", + "size_in_bytes": 50385 + }, + { + "_path": "lib/python3.10/distutils/errors.py", + "path_type": "hardlink", + "sha256": "62bead29919dcc1a0d8b9def06d8aad1427ffd7d390a6c5275026a3966b0e926", + "sha256_in_prefix": "62bead29919dcc1a0d8b9def06d8aad1427ffd7d390a6c5275026a3966b0e926", + "size_in_bytes": 3577 + }, + { + "_path": "lib/python3.10/distutils/extension.py", + "path_type": "hardlink", + "sha256": "cfb99f8b891f9e933544d4b0d25a59569e71bbd79320d61ba64e953e6a6f5a58", + "sha256_in_prefix": "cfb99f8b891f9e933544d4b0d25a59569e71bbd79320d61ba64e953e6a6f5a58", + "size_in_bytes": 10529 + }, + { + "_path": "lib/python3.10/distutils/fancy_getopt.py", + "path_type": "hardlink", + "sha256": "38fc69d82c478b5629fddd43f09c56e147aaf5f0bbd6d7a040569a7e1e7c1865", + "sha256_in_prefix": "38fc69d82c478b5629fddd43f09c56e147aaf5f0bbd6d7a040569a7e1e7c1865", + "size_in_bytes": 17784 + }, + { + "_path": "lib/python3.10/distutils/file_util.py", + "path_type": "hardlink", + "sha256": "d2152a7c8b4dff1d83562851d0c1dd03828231508e3bc568072685a7f6ba3038", + "sha256_in_prefix": "d2152a7c8b4dff1d83562851d0c1dd03828231508e3bc568072685a7f6ba3038", + "size_in_bytes": 8148 + }, + { + "_path": "lib/python3.10/distutils/filelist.py", + "path_type": "hardlink", + "sha256": "f1b471873a7616c6a81d3ed3b8a0f842372e87f07d3b0ff14edfe1b5926f3764", + "sha256_in_prefix": "f1b471873a7616c6a81d3ed3b8a0f842372e87f07d3b0ff14edfe1b5926f3764", + "size_in_bytes": 12832 + }, + { + "_path": "lib/python3.10/distutils/log.py", + "path_type": "hardlink", + "sha256": "8560667540b62bddbb41c56fdd110c5b71cc3dc97171c3d09e0c4b4ae517425d", + "sha256_in_prefix": "8560667540b62bddbb41c56fdd110c5b71cc3dc97171c3d09e0c4b4ae517425d", + "size_in_bytes": 1969 + }, + { + "_path": "lib/python3.10/distutils/msvc9compiler.py", + "path_type": "hardlink", + "sha256": "33d3edc009158d1bf1353165440929e8403935776c16bfaa775f97466f8a8ac3", + "sha256_in_prefix": "33d3edc009158d1bf1353165440929e8403935776c16bfaa775f97466f8a8ac3", + "size_in_bytes": 30453 + }, + { + "_path": "lib/python3.10/distutils/msvccompiler.py", + "path_type": "hardlink", + "sha256": "658b27520202e2d653d969096d39135325520807369c533d0d5288b887cf054d", + "sha256_in_prefix": "658b27520202e2d653d969096d39135325520807369c533d0d5288b887cf054d", + "size_in_bytes": 23540 + }, + { + "_path": "lib/python3.10/distutils/spawn.py", + "path_type": "hardlink", + "sha256": "87336cdb85c2f6ecf2c67cd8a43903bf2cf884c218b1661dcc63a52ad96343e7", + "sha256_in_prefix": "87336cdb85c2f6ecf2c67cd8a43903bf2cf884c218b1661dcc63a52ad96343e7", + "size_in_bytes": 4660 + }, + { + "_path": "lib/python3.10/distutils/sysconfig.py", + "path_type": "hardlink", + "sha256": "d256473d977d81f47eaf2f639672f70ca155635a13ef0ea156b0a94d94fc9a49", + "sha256_in_prefix": "d256473d977d81f47eaf2f639672f70ca155635a13ef0ea156b0a94d94fc9a49", + "size_in_bytes": 12631 + }, + { + "_path": "lib/python3.10/distutils/tests/Setup.sample", + "path_type": "hardlink", + "sha256": "ff839230cf999711c05b9ee030a7e843376aa51190971fd597643508cea7dc74", + "sha256_in_prefix": "ff839230cf999711c05b9ee030a7e843376aa51190971fd597643508cea7dc74", + "size_in_bytes": 2249 + }, + { + "_path": "lib/python3.10/distutils/tests/__init__.py", + "path_type": "hardlink", + "sha256": "07af8a5bf78195cef635a75fa3433feb88e8e33565eefeb66d330ac02260fd45", + "sha256_in_prefix": "07af8a5bf78195cef635a75fa3433feb88e8e33565eefeb66d330ac02260fd45", + "size_in_bytes": 1384 + }, + { + "_path": "lib/python3.10/distutils/tests/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "cf719d176699396df733fdad686e825e5f63af9da147f1e9573cddb2571e1146", + "sha256_in_prefix": "cf719d176699396df733fdad686e825e5f63af9da147f1e9573cddb2571e1146", + "size_in_bytes": 1652 + }, + { + "_path": "lib/python3.10/distutils/tests/__pycache__/support.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "ddf254ab6bb81160a20d7fe08ae6ae6edb914145e855ef36abdc6650e6198ee6", + "sha256_in_prefix": "ddf254ab6bb81160a20d7fe08ae6ae6edb914145e855ef36abdc6650e6198ee6", + "size_in_bytes": 7727 + }, + { + "_path": "lib/python3.10/distutils/tests/__pycache__/test_archive_util.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "1595fad4bbc8d924900fdac67de5da92e85733cded1ea409b6e8948f7dc15420", + "sha256_in_prefix": "1595fad4bbc8d924900fdac67de5da92e85733cded1ea409b6e8948f7dc15420", + "size_in_bytes": 11852 + }, + { + "_path": "lib/python3.10/distutils/tests/__pycache__/test_bdist.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "1880061caf9d88101712704433a15c0ba68b047d723c62ea102817a62c09ceb9", + "sha256_in_prefix": "1880061caf9d88101712704433a15c0ba68b047d723c62ea102817a62c09ceb9", + "size_in_bytes": 2038 + }, + { + "_path": "lib/python3.10/distutils/tests/__pycache__/test_bdist_dumb.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "a33a38b193c09f63972c480f0f12554eb7ee93c893afc17dd73c77fbd7947cf3", + "sha256_in_prefix": "a33a38b193c09f63972c480f0f12554eb7ee93c893afc17dd73c77fbd7947cf3", + "size_in_bytes": 3119 + }, + { + "_path": "lib/python3.10/distutils/tests/__pycache__/test_bdist_msi.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "d7a7f8c809a91b4bdc69e1523d2b3ca209be50b101700135d60b75dc1a800a6d", + "sha256_in_prefix": "d7a7f8c809a91b4bdc69e1523d2b3ca209be50b101700135d60b75dc1a800a6d", + "size_in_bytes": 1493 + }, + { + "_path": "lib/python3.10/distutils/tests/__pycache__/test_bdist_rpm.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "357cfe54d84fb283e05c774c1468e889d33db5e3645071bb18e7231ebe0b834d", + "sha256_in_prefix": "357cfe54d84fb283e05c774c1468e889d33db5e3645071bb18e7231ebe0b834d", + "size_in_bytes": 3883 + }, + { + "_path": "lib/python3.10/distutils/tests/__pycache__/test_build.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "57774a904908fc0c828e0e95409a7bc9d4a4396e0090dfb668640d96af77725b", + "sha256_in_prefix": "57774a904908fc0c828e0e95409a7bc9d4a4396e0090dfb668640d96af77725b", + "size_in_bytes": 1903 + }, + { + "_path": "lib/python3.10/distutils/tests/__pycache__/test_build_clib.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c833d713317f92e98d23e4dbdf0ffc66ffa502a72ecf790b574f03ca2103e917", + "sha256_in_prefix": "c833d713317f92e98d23e4dbdf0ffc66ffa502a72ecf790b574f03ca2103e917", + "size_in_bytes": 4428 + }, + { + "_path": "lib/python3.10/distutils/tests/__pycache__/test_build_ext.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "ab657617b1e212361ec1fbb19572b87d1bd6d0f24869b9766665c08dc2463c94", + "sha256_in_prefix": "ab657617b1e212361ec1fbb19572b87d1bd6d0f24869b9766665c08dc2463c94", + "size_in_bytes": 13995 + }, + { + "_path": "lib/python3.10/distutils/tests/__pycache__/test_build_py.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "d07a6b54562000d2eecd01878841e7b745ea4e326e8e186ece7c3742052ecb6c", + "sha256_in_prefix": "d07a6b54562000d2eecd01878841e7b745ea4e326e8e186ece7c3742052ecb6c", + "size_in_bytes": 5283 + }, + { + "_path": "lib/python3.10/distutils/tests/__pycache__/test_build_scripts.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "2dbb66e5713d431a0cc169228a6d0ddd53a45fed5856190c64344d677e8dd25b", + "sha256_in_prefix": "2dbb66e5713d431a0cc169228a6d0ddd53a45fed5856190c64344d677e8dd25b", + "size_in_bytes": 3726 + }, + { + "_path": "lib/python3.10/distutils/tests/__pycache__/test_check.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "162b5fa962be0aad7cc8246bb51e9b07ed1d89d51120580b2c17971256c2475e", + "sha256_in_prefix": "162b5fa962be0aad7cc8246bb51e9b07ed1d89d51120580b2c17971256c2475e", + "size_in_bytes": 4452 + }, + { + "_path": "lib/python3.10/distutils/tests/__pycache__/test_clean.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "9ab2d7af81564381a810c0a8fecb2ba7d1596e3f8c0f54eed18edfed2429a08d", + "sha256_in_prefix": "9ab2d7af81564381a810c0a8fecb2ba7d1596e3f8c0f54eed18edfed2429a08d", + "size_in_bytes": 1586 + }, + { + "_path": "lib/python3.10/distutils/tests/__pycache__/test_cmd.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "87e930df455682003ded46941d637d9b459e9ee726f0d8f164767a29bbe6f760", + "sha256_in_prefix": "87e930df455682003ded46941d637d9b459e9ee726f0d8f164767a29bbe6f760", + "size_in_bytes": 4576 + }, + { + "_path": "lib/python3.10/distutils/tests/__pycache__/test_config.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "8bca21b9e13eaacbf2c2c1a60bfa51ad961c626cc524aee99f39aa0cf7e78c99", + "sha256_in_prefix": "8bca21b9e13eaacbf2c2c1a60bfa51ad961c626cc524aee99f39aa0cf7e78c99", + "size_in_bytes": 4372 + }, + { + "_path": "lib/python3.10/distutils/tests/__pycache__/test_config_cmd.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "967dded47363bd52c80b44c15a0a60579b8d546960dc8ebaa354eb9b4504314a", + "sha256_in_prefix": "967dded47363bd52c80b44c15a0a60579b8d546960dc8ebaa354eb9b4504314a", + "size_in_bytes": 3849 + }, + { + "_path": "lib/python3.10/distutils/tests/__pycache__/test_core.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "9f3e50deba21a36fcb8e6718a278afe58135993719325b2f3c68d6dd6ec2884a", + "sha256_in_prefix": "9f3e50deba21a36fcb8e6718a278afe58135993719325b2f3c68d6dd6ec2884a", + "size_in_bytes": 4473 + }, + { + "_path": "lib/python3.10/distutils/tests/__pycache__/test_cygwinccompiler.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "aa230e4f394194019c10697d46b4214c73677b5060c7529e7a7b09e0fa58a397", + "sha256_in_prefix": "aa230e4f394194019c10697d46b4214c73677b5060c7529e7a7b09e0fa58a397", + "size_in_bytes": 4741 + }, + { + "_path": "lib/python3.10/distutils/tests/__pycache__/test_dep_util.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "5b7062d687e3624bf5e01e2f5b223102ab227f8caec494cd07a9734489a34b52", + "sha256_in_prefix": "5b7062d687e3624bf5e01e2f5b223102ab227f8caec494cd07a9734489a34b52", + "size_in_bytes": 2550 + }, + { + "_path": "lib/python3.10/distutils/tests/__pycache__/test_dir_util.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "cd06b2e2bd3aa27de8de9e6199a3387489e681e63934190d547934ab6cbd7b03", + "sha256_in_prefix": "cd06b2e2bd3aa27de8de9e6199a3387489e681e63934190d547934ab6cbd7b03", + "size_in_bytes": 5174 + }, + { + "_path": "lib/python3.10/distutils/tests/__pycache__/test_dist.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "db4b0b262d2591d9eb30f7911b8bf21abd850e43438958fe040427aa7786e1ad", + "sha256_in_prefix": "db4b0b262d2591d9eb30f7911b8bf21abd850e43438958fe040427aa7786e1ad", + "size_in_bytes": 16026 + }, + { + "_path": "lib/python3.10/distutils/tests/__pycache__/test_extension.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "ac61f202cfa70bf9b62eeabf31ac4529a534a6d5394d422644e030c221ca2041", + "sha256_in_prefix": "ac61f202cfa70bf9b62eeabf31ac4529a534a6d5394d422644e030c221ca2041", + "size_in_bytes": 2727 + }, + { + "_path": "lib/python3.10/distutils/tests/__pycache__/test_file_util.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "59717b4288932f5801a7cdce2bb987c7c7567d6e274fd879d9e7dee8b96f03c5", + "sha256_in_prefix": "59717b4288932f5801a7cdce2bb987c7c7567d6e274fd879d9e7dee8b96f03c5", + "size_in_bytes": 4934 + }, + { + "_path": "lib/python3.10/distutils/tests/__pycache__/test_filelist.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "f80f6c9561bcc354e08571cdce5641ec5383b5ff11ae5776120b6a5cf5a9e46c", + "sha256_in_prefix": "f80f6c9561bcc354e08571cdce5641ec5383b5ff11ae5776120b6a5cf5a9e46c", + "size_in_bytes": 8683 + }, + { + "_path": "lib/python3.10/distutils/tests/__pycache__/test_install.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "bb9db112386da6fa93362e7fc1a9f7d9d159cc65ea4f40731fcd1d51e949ee2f", + "sha256_in_prefix": "bb9db112386da6fa93362e7fc1a9f7d9d159cc65ea4f40731fcd1d51e949ee2f", + "size_in_bytes": 7892 + }, + { + "_path": "lib/python3.10/distutils/tests/__pycache__/test_install_data.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "d1147df7293d2f5073fa3e3aae95066c3be1dff73558137dce640c55060185da", + "sha256_in_prefix": "d1147df7293d2f5073fa3e3aae95066c3be1dff73558137dce640c55060185da", + "size_in_bytes": 2209 + }, + { + "_path": "lib/python3.10/distutils/tests/__pycache__/test_install_headers.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "35599d1afacab51bd8710d2a6d9989cd7cb3adcb6cf75af430c33e27d832c022", + "sha256_in_prefix": "35599d1afacab51bd8710d2a6d9989cd7cb3adcb6cf75af430c33e27d832c022", + "size_in_bytes": 1640 + }, + { + "_path": "lib/python3.10/distutils/tests/__pycache__/test_install_lib.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "d39e45d243fd756f145cbd7b5ea03ad2e0be093deb2295b80d79a49eaf9d2577", + "sha256_in_prefix": "d39e45d243fd756f145cbd7b5ea03ad2e0be093deb2295b80d79a49eaf9d2577", + "size_in_bytes": 3569 + }, + { + "_path": "lib/python3.10/distutils/tests/__pycache__/test_install_scripts.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "8663a0c1b853f73c9355e77f81db04eb416a6d1eff26c727157df565dcda54f9", + "sha256_in_prefix": "8663a0c1b853f73c9355e77f81db04eb416a6d1eff26c727157df565dcda54f9", + "size_in_bytes": 2710 + }, + { + "_path": "lib/python3.10/distutils/tests/__pycache__/test_log.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "3bcf71b651d1904f6cd90ccfc1aed3fc67a291733d10994eee6f8d829065061d", + "sha256_in_prefix": "3bcf71b651d1904f6cd90ccfc1aed3fc67a291733d10994eee6f8d829065061d", + "size_in_bytes": 1914 + }, + { + "_path": "lib/python3.10/distutils/tests/__pycache__/test_msvc9compiler.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "8270a6edba52e98ec2b83be70ce7487860ff15524f891a9d6afc5aa74e177a38", + "sha256_in_prefix": "8270a6edba52e98ec2b83be70ce7487860ff15524f891a9d6afc5aa74e177a38", + "size_in_bytes": 5927 + }, + { + "_path": "lib/python3.10/distutils/tests/__pycache__/test_msvccompiler.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "a701a71398ac0d2aef9ff1136431811864888b75be20ba76805c168c9e6961c2", + "sha256_in_prefix": "a701a71398ac0d2aef9ff1136431811864888b75be20ba76805c168c9e6961c2", + "size_in_bytes": 2552 + }, + { + "_path": "lib/python3.10/distutils/tests/__pycache__/test_register.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "67aef4bf00a422b56beb5ef36462295c3cea9b3d3d9ef048cf3daacd32163eeb", + "sha256_in_prefix": "67aef4bf00a422b56beb5ef36462295c3cea9b3d3d9ef048cf3daacd32163eeb", + "size_in_bytes": 8440 + }, + { + "_path": "lib/python3.10/distutils/tests/__pycache__/test_sdist.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "a8ad8f6185d0987f9443ef1e775675262b6f3b9f2fa10da600be22457a5820b0", + "sha256_in_prefix": "a8ad8f6185d0987f9443ef1e775675262b6f3b9f2fa10da600be22457a5820b0", + "size_in_bytes": 12764 + }, + { + "_path": "lib/python3.10/distutils/tests/__pycache__/test_spawn.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "1e264821a8be72979b4736d57d32dd7365195fd12dfb18aff86b9988e9723d58", + "sha256_in_prefix": "1e264821a8be72979b4736d57d32dd7365195fd12dfb18aff86b9988e9723d58", + "size_in_bytes": 3907 + }, + { + "_path": "lib/python3.10/distutils/tests/__pycache__/test_sysconfig.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "3a99e2279a5012ea2e2eb08fc9219d0559b748f9795541cdc137d71750a04920", + "sha256_in_prefix": "3a99e2279a5012ea2e2eb08fc9219d0559b748f9795541cdc137d71750a04920", + "size_in_bytes": 9103 + }, + { + "_path": "lib/python3.10/distutils/tests/__pycache__/test_text_file.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "98e32dc5fc12e8e2b0f00ce7b7b745aceb50a4900f5ba4eb509b2afb5c6c81d8", + "sha256_in_prefix": "98e32dc5fc12e8e2b0f00ce7b7b745aceb50a4900f5ba4eb509b2afb5c6c81d8", + "size_in_bytes": 2651 + }, + { + "_path": "lib/python3.10/distutils/tests/__pycache__/test_unixccompiler.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "348f8da1fe4ef52bc53b4010ba7ceda1ffbcd427f49905c71a31c79b08650038", + "sha256_in_prefix": "348f8da1fe4ef52bc53b4010ba7ceda1ffbcd427f49905c71a31c79b08650038", + "size_in_bytes": 4748 + }, + { + "_path": "lib/python3.10/distutils/tests/__pycache__/test_upload.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "d3d3cfe30827c198d948351b98c5776d2c2a7e02e39826987c974d1d3343226c", + "sha256_in_prefix": "d3d3cfe30827c198d948351b98c5776d2c2a7e02e39826987c974d1d3343226c", + "size_in_bytes": 7099 + }, + { + "_path": "lib/python3.10/distutils/tests/__pycache__/test_util.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "a03dcd9ec81680a61f70d084742e488256fbe9f54b7d3c1efff2a536422b4c14", + "sha256_in_prefix": "a03dcd9ec81680a61f70d084742e488256fbe9f54b7d3c1efff2a536422b4c14", + "size_in_bytes": 9305 + }, + { + "_path": "lib/python3.10/distutils/tests/__pycache__/test_version.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "d9fd4f8635e16137e9118d50bbad3418b2a21d51610cc57a1a3b67ef4ade99ad", + "sha256_in_prefix": "d9fd4f8635e16137e9118d50bbad3418b2a21d51610cc57a1a3b67ef4ade99ad", + "size_in_bytes": 2702 + }, + { + "_path": "lib/python3.10/distutils/tests/__pycache__/test_versionpredicate.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "ca952fcbad2f0e03e733628734a9bd02556fdcbbc4660b4e9cd69f7ee8bf7658", + "sha256_in_prefix": "ca952fcbad2f0e03e733628734a9bd02556fdcbbc4660b4e9cd69f7ee8bf7658", + "size_in_bytes": 788 + }, + { + "_path": "lib/python3.10/distutils/tests/includetest.rst", + "path_type": "hardlink", + "sha256": "1a766ccac6850b0424118733e2b086803921e0829f98ad0719be671a5da4263c", + "sha256_in_prefix": "1a766ccac6850b0424118733e2b086803921e0829f98ad0719be671a5da4263c", + "size_in_bytes": 25 + }, + { + "_path": "lib/python3.10/distutils/tests/support.py", + "path_type": "hardlink", + "sha256": "f7649fe69f9eae66781747a72550c3743a197608ca6b37d5607930570a804384", + "sha256_in_prefix": "f7649fe69f9eae66781747a72550c3743a197608ca6b37d5607930570a804384", + "size_in_bytes": 6490 + }, + { + "_path": "lib/python3.10/distutils/tests/test_archive_util.py", + "path_type": "hardlink", + "sha256": "83bf2ee3296935e9a7cc528e903c5bd4632501f5a659453da9576f95b5ee133a", + "sha256_in_prefix": "83bf2ee3296935e9a7cc528e903c5bd4632501f5a659453da9576f95b5ee133a", + "size_in_bytes": 14375 + }, + { + "_path": "lib/python3.10/distutils/tests/test_bdist.py", + "path_type": "hardlink", + "sha256": "48ceba7378dd0d0ed0e3983d120c4fbc3793a35d8bf47cb32f13f18f61a1f854", + "sha256_in_prefix": "48ceba7378dd0d0ed0e3983d120c4fbc3793a35d8bf47cb32f13f18f61a1f854", + "size_in_bytes": 1764 + }, + { + "_path": "lib/python3.10/distutils/tests/test_bdist_dumb.py", + "path_type": "hardlink", + "sha256": "fbe9884e5e1a28ff1d01c087bae2aff7fce7f80884f16b7e3941945e977f3ec2", + "sha256_in_prefix": "fbe9884e5e1a28ff1d01c087bae2aff7fce7f80884f16b7e3941945e977f3ec2", + "size_in_bytes": 2905 + }, + { + "_path": "lib/python3.10/distutils/tests/test_bdist_msi.py", + "path_type": "hardlink", + "sha256": "85385f211bc84e188d73acec80e5023db03cccd4dea606c02c2d52ee2d42f55f", + "sha256_in_prefix": "85385f211bc84e188d73acec80e5023db03cccd4dea606c02c2d52ee2d42f55f", + "size_in_bytes": 843 + }, + { + "_path": "lib/python3.10/distutils/tests/test_bdist_rpm.py", + "path_type": "hardlink", + "sha256": "e40ec9e60ee10385af078bf41b8a2fa126fc4f0919547e0a68f0b1aa2517f046", + "sha256_in_prefix": "e40ec9e60ee10385af078bf41b8a2fa126fc4f0919547e0a68f0b1aa2517f046", + "size_in_bytes": 5012 + }, + { + "_path": "lib/python3.10/distutils/tests/test_build.py", + "path_type": "hardlink", + "sha256": "c21e2ce5937429a9aeb92686b192e4751eb28399dd7af44bf524b5706c2237e8", + "sha256_in_prefix": "c21e2ce5937429a9aeb92686b192e4751eb28399dd7af44bf524b5706c2237e8", + "size_in_bytes": 1965 + }, + { + "_path": "lib/python3.10/distutils/tests/test_build_clib.py", + "path_type": "hardlink", + "sha256": "c13bcc9b849ba70fa7e49baffc922fb2ad03671cbd989e28217220a65fc5bad1", + "sha256_in_prefix": "c13bcc9b849ba70fa7e49baffc922fb2ad03671cbd989e28217220a65fc5bad1", + "size_in_bytes": 4913 + }, + { + "_path": "lib/python3.10/distutils/tests/test_build_ext.py", + "path_type": "hardlink", + "sha256": "e79ebbde7cb44634761b906c45315cf054c360184844bb7274dfeb010088c9a8", + "sha256_in_prefix": "e79ebbde7cb44634761b906c45315cf054c360184844bb7274dfeb010088c9a8", + "size_in_bytes": 20829 + }, + { + "_path": "lib/python3.10/distutils/tests/test_build_py.py", + "path_type": "hardlink", + "sha256": "1eeea30b412c1f9375c86965528f0fcea92cb59a9f6f7f827ad639f6d50d5432", + "sha256_in_prefix": "1eeea30b412c1f9375c86965528f0fcea92cb59a9f6f7f827ad639f6d50d5432", + "size_in_bytes": 6335 + }, + { + "_path": "lib/python3.10/distutils/tests/test_build_scripts.py", + "path_type": "hardlink", + "sha256": "046407fe31a1b3416acbd34df0c4622c7f7e6fecf9859bcebd4214b6b62c505f", + "sha256_in_prefix": "046407fe31a1b3416acbd34df0c4622c7f7e6fecf9859bcebd4214b6b62c505f", + "size_in_bytes": 3593 + }, + { + "_path": "lib/python3.10/distutils/tests/test_check.py", + "path_type": "hardlink", + "sha256": "03950ad7681549157802d8c38005c59ed3c5df5d9f328636701bf24c9953984f", + "sha256_in_prefix": "03950ad7681549157802d8c38005c59ed3c5df5d9f328636701bf24c9953984f", + "size_in_bytes": 5711 + }, + { + "_path": "lib/python3.10/distutils/tests/test_clean.py", + "path_type": "hardlink", + "sha256": "af860768e940633cd0dda9bdb10d3faa9f018e4e94bcb29975cbfa8fcb7fe424", + "sha256_in_prefix": "af860768e940633cd0dda9bdb10d3faa9f018e4e94bcb29975cbfa8fcb7fe424", + "size_in_bytes": 1441 + }, + { + "_path": "lib/python3.10/distutils/tests/test_cmd.py", + "path_type": "hardlink", + "sha256": "f0e86363c03e17fcf28d44938d2d064d3de8419705acfa6f6f7a286a66e4b7ba", + "sha256_in_prefix": "f0e86363c03e17fcf28d44938d2d064d3de8419705acfa6f6f7a286a66e4b7ba", + "size_in_bytes": 3835 + }, + { + "_path": "lib/python3.10/distutils/tests/test_config.py", + "path_type": "hardlink", + "sha256": "1c0e82ceed789b3bd1c1de73d40a79c623b8698f07aad0299921bb4ab9f758ea", + "sha256_in_prefix": "1c0e82ceed789b3bd1c1de73d40a79c623b8698f07aad0299921bb4ab9f758ea", + "size_in_bytes": 3892 + }, + { + "_path": "lib/python3.10/distutils/tests/test_config_cmd.py", + "path_type": "hardlink", + "sha256": "792a8948fd5d79a77bad54d65b92f4a8bbfa2d54211ecb93a8884066f56427e8", + "sha256_in_prefix": "792a8948fd5d79a77bad54d65b92f4a8bbfa2d54211ecb93a8884066f56427e8", + "size_in_bytes": 3199 + }, + { + "_path": "lib/python3.10/distutils/tests/test_core.py", + "path_type": "hardlink", + "sha256": "f05ece1f6896864213519c9ebd6dcc3b68afe35769aff55de9d5c1a37e354908", + "sha256_in_prefix": "f05ece1f6896864213519c9ebd6dcc3b68afe35769aff55de9d5c1a37e354908", + "size_in_bytes": 4080 + }, + { + "_path": "lib/python3.10/distutils/tests/test_cygwinccompiler.py", + "path_type": "hardlink", + "sha256": "ab94a3e3cc02359e455af7fed69ab8dc2266bf58a3b10d4153ace9a776b28fb6", + "sha256_in_prefix": "ab94a3e3cc02359e455af7fed69ab8dc2266bf58a3b10d4153ace9a776b28fb6", + "size_in_bytes": 5636 + }, + { + "_path": "lib/python3.10/distutils/tests/test_dep_util.py", + "path_type": "hardlink", + "sha256": "6dc13cad79303d04b81a83a9d556775a442e1369d45121a0e0ab8f13242328c1", + "sha256_in_prefix": "6dc13cad79303d04b81a83a9d556775a442e1369d45121a0e0ab8f13242328c1", + "size_in_bytes": 2820 + }, + { + "_path": "lib/python3.10/distutils/tests/test_dir_util.py", + "path_type": "hardlink", + "sha256": "44a92518311e69ba5e32529650673c6ac61b300b97800f8cd5423b429ca2abf1", + "sha256_in_prefix": "44a92518311e69ba5e32529650673c6ac61b300b97800f8cd5423b429ca2abf1", + "size_in_bytes": 4654 + }, + { + "_path": "lib/python3.10/distutils/tests/test_dist.py", + "path_type": "hardlink", + "sha256": "71ea4a132597be2891b931d7f1ccb5ff7811aa6353bc13bd9490df7ef18feabc", + "sha256_in_prefix": "71ea4a132597be2891b931d7f1ccb5ff7811aa6353bc13bd9490df7ef18feabc", + "size_in_bytes": 19114 + }, + { + "_path": "lib/python3.10/distutils/tests/test_extension.py", + "path_type": "hardlink", + "sha256": "01eed22047545deacb1b4448b55589a9941df362a28570dd225606776d47c225", + "sha256_in_prefix": "01eed22047545deacb1b4448b55589a9941df362a28570dd225606776d47c225", + "size_in_bytes": 2808 + }, + { + "_path": "lib/python3.10/distutils/tests/test_file_util.py", + "path_type": "hardlink", + "sha256": "43f8091f014358761d806c4f7a69347afec116f37093c0a01991a9d58cf59b5d", + "sha256_in_prefix": "43f8091f014358761d806c4f7a69347afec116f37093c0a01991a9d58cf59b5d", + "size_in_bytes": 4448 + }, + { + "_path": "lib/python3.10/distutils/tests/test_filelist.py", + "path_type": "hardlink", + "sha256": "a15e902307d415403251a223f52fb90345030025b133231188b2bfa1b1ca725b", + "sha256_in_prefix": "a15e902307d415403251a223f52fb90345030025b133231188b2bfa1b1ca725b", + "size_in_bytes": 11469 + }, + { + "_path": "lib/python3.10/distutils/tests/test_install.py", + "path_type": "hardlink", + "sha256": "2e45219abaa569087b5f0a0c0c930ec92538672c79e4034e368f324ddef02110", + "sha256_in_prefix": "2e45219abaa569087b5f0a0c0c930ec92538672c79e4034e368f324ddef02110", + "size_in_bytes": 8984 + }, + { + "_path": "lib/python3.10/distutils/tests/test_install_data.py", + "path_type": "hardlink", + "sha256": "e0a29d16cffd3997def9179353eb6ae020644c2e59a5d4dc5ec1583da51eab7e", + "sha256_in_prefix": "e0a29d16cffd3997def9179353eb6ae020644c2e59a5d4dc5ec1583da51eab7e", + "size_in_bytes": 2577 + }, + { + "_path": "lib/python3.10/distutils/tests/test_install_headers.py", + "path_type": "hardlink", + "sha256": "abbddc109ef35ed9aca855ca57629ff38f775f7a972da5771df9654e0bcdf8aa", + "sha256_in_prefix": "abbddc109ef35ed9aca855ca57629ff38f775f7a972da5771df9654e0bcdf8aa", + "size_in_bytes": 1238 + }, + { + "_path": "lib/python3.10/distutils/tests/test_install_lib.py", + "path_type": "hardlink", + "sha256": "b7bb725739e88f1529897190c26c969689735852da29b39f1fa962a7875dd531", + "sha256_in_prefix": "b7bb725739e88f1529897190c26c969689735852da29b39f1fa962a7875dd531", + "size_in_bytes": 3974 + }, + { + "_path": "lib/python3.10/distutils/tests/test_install_scripts.py", + "path_type": "hardlink", + "sha256": "0a7e1d6f6befd7aa20f4acc0b9154f3206565a2ea5c81b71ad7b255d2b9195f8", + "sha256_in_prefix": "0a7e1d6f6befd7aa20f4acc0b9154f3206565a2ea5c81b71ad7b255d2b9195f8", + "size_in_bytes": 2625 + }, + { + "_path": "lib/python3.10/distutils/tests/test_log.py", + "path_type": "hardlink", + "sha256": "e79dada8f4e68c15b1ceb61f1f35354106972a6e3f29b69f351d701ad1ff3690", + "sha256_in_prefix": "e79dada8f4e68c15b1ceb61f1f35354106972a6e3f29b69f351d701ad1ff3690", + "size_in_bytes": 1864 + }, + { + "_path": "lib/python3.10/distutils/tests/test_msvc9compiler.py", + "path_type": "hardlink", + "sha256": "284acd052027b622bc696be5fd2068fb149cb82a10e6dd15537175604c1a212e", + "sha256_in_prefix": "284acd052027b622bc696be5fd2068fb149cb82a10e6dd15537175604c1a212e", + "size_in_bytes": 6038 + }, + { + "_path": "lib/python3.10/distutils/tests/test_msvccompiler.py", + "path_type": "hardlink", + "sha256": "0d1dde41db44732b7bb09f00ecb0359d6c9434ddbe3065ea0ee3a93a9035543b", + "sha256_in_prefix": "0d1dde41db44732b7bb09f00ecb0359d6c9434ddbe3065ea0ee3a93a9035543b", + "size_in_bytes": 2845 + }, + { + "_path": "lib/python3.10/distutils/tests/test_register.py", + "path_type": "hardlink", + "sha256": "0250ba18275c1b7b4d54a7e5e5b2353d0408b938baae10783661d24123dc31d0", + "sha256_in_prefix": "0250ba18275c1b7b4d54a7e5e5b2353d0408b938baae10783661d24123dc31d0", + "size_in_bytes": 9805 + }, + { + "_path": "lib/python3.10/distutils/tests/test_sdist.py", + "path_type": "hardlink", + "sha256": "7b14aa02788e3ec8f3f68aa73120bdfdb9771aba3c4f0db6af2482707322fcb5", + "sha256_in_prefix": "7b14aa02788e3ec8f3f68aa73120bdfdb9771aba3c4f0db6af2482707322fcb5", + "size_in_bytes": 17087 + }, + { + "_path": "lib/python3.10/distutils/tests/test_spawn.py", + "path_type": "hardlink", + "sha256": "94ac8098d4663d41cbfb8893d3af3b633c06bb40dfe898a0f76a96bf10bcafe7", + "sha256_in_prefix": "94ac8098d4663d41cbfb8893d3af3b633c06bb40dfe898a0f76a96bf10bcafe7", + "size_in_bytes": 5430 + }, + { + "_path": "lib/python3.10/distutils/tests/test_sysconfig.py", + "path_type": "hardlink", + "sha256": "a5398489113f8b7a878b6bcccccba5a1a8bbea3857a285c3c3d3ffde8903e0b2", + "sha256_in_prefix": "a5398489113f8b7a878b6bcccccba5a1a8bbea3857a285c3c3d3ffde8903e0b2", + "size_in_bytes": 11120 + }, + { + "_path": "lib/python3.10/distutils/tests/test_text_file.py", + "path_type": "hardlink", + "sha256": "dbf3f1b388f55a2ac4c13336f2814fdc862ad52e88a93c7eca7cb3e68d2d8d9a", + "sha256_in_prefix": "dbf3f1b388f55a2ac4c13336f2814fdc862ad52e88a93c7eca7cb3e68d2d8d9a", + "size_in_bytes": 3436 + }, + { + "_path": "lib/python3.10/distutils/tests/test_unixccompiler.py", + "path_type": "hardlink", + "sha256": "afdec9265cc15f2dd52e11128ff9ea6fc75a47c39d3d079ef9953c0a14108eae", + "sha256_in_prefix": "afdec9265cc15f2dd52e11128ff9ea6fc75a47c39d3d079ef9953c0a14108eae", + "size_in_bytes": 4829 + }, + { + "_path": "lib/python3.10/distutils/tests/test_upload.py", + "path_type": "hardlink", + "sha256": "5acabcbf6ad46d7c6cd0a3ab45796872944e8ddf21fa89c0cca6f1ecbb1cc733", + "sha256_in_prefix": "5acabcbf6ad46d7c6cd0a3ab45796872944e8ddf21fa89c0cca6f1ecbb1cc733", + "size_in_bytes": 7137 + }, + { + "_path": "lib/python3.10/distutils/tests/test_util.py", + "path_type": "hardlink", + "sha256": "9a795b1ede038ac9c2ab16e1f852c17bd5c00e29d22c0c9e2d02ce8224fb74f9", + "sha256_in_prefix": "9a795b1ede038ac9c2ab16e1f852c17bd5c00e29d22c0c9e2d02ce8224fb74f9", + "size_in_bytes": 11611 + }, + { + "_path": "lib/python3.10/distutils/tests/test_version.py", + "path_type": "hardlink", + "sha256": "9fad90df09845d5dd4b654f375c929f5532e2e243f77ab102aaeabf39a71e7e5", + "sha256_in_prefix": "9fad90df09845d5dd4b654f375c929f5532e2e243f77ab102aaeabf39a71e7e5", + "size_in_bytes": 3450 + }, + { + "_path": "lib/python3.10/distutils/tests/test_versionpredicate.py", + "path_type": "hardlink", + "sha256": "690003c23752f77c7ea1108cd51dd7e9b0ca7021ad925aa982bae5bcd2f988b0", + "sha256_in_prefix": "690003c23752f77c7ea1108cd51dd7e9b0ca7021ad925aa982bae5bcd2f988b0", + "size_in_bytes": 280 + }, + { + "_path": "lib/python3.10/distutils/tests/xxmodule.c", + "path_type": "hardlink", + "sha256": "0a3bcc0446de7d7092d3b36b4b908c2aa7278c91188d399faa6e511df87daee8", + "sha256_in_prefix": "0a3bcc0446de7d7092d3b36b4b908c2aa7278c91188d399faa6e511df87daee8", + "size_in_bytes": 12862 + }, + { + "_path": "lib/python3.10/distutils/text_file.py", + "path_type": "hardlink", + "sha256": "3ecb8025e59d289a0b495ffa37a229079fb43daf382b32d4b9c24c1516b3c372", + "sha256_in_prefix": "3ecb8025e59d289a0b495ffa37a229079fb43daf382b32d4b9c24c1516b3c372", + "size_in_bytes": 12483 + }, + { + "_path": "lib/python3.10/distutils/unixccompiler.py", + "path_type": "hardlink", + "sha256": "d712f8538752bbc8cf7c76e30b3e69c0a409d94fbf004732f6f6ea5c24f26780", + "sha256_in_prefix": "d712f8538752bbc8cf7c76e30b3e69c0a409d94fbf004732f6f6ea5c24f26780", + "size_in_bytes": 14855 + }, + { + "_path": "lib/python3.10/distutils/util.py", + "path_type": "hardlink", + "sha256": "5a759d80dc2bebdda1bc4461ddc9a335c378e3a25e4da20218cdce07686824ae", + "sha256_in_prefix": "5a759d80dc2bebdda1bc4461ddc9a335c378e3a25e4da20218cdce07686824ae", + "size_in_bytes": 21032 + }, + { + "_path": "lib/python3.10/distutils/version.py", + "path_type": "hardlink", + "sha256": "f0da203fa34f3d0a69dc450c65c4fd73310789af9e86a3e8f2ca68fdeec08145", + "sha256_in_prefix": "f0da203fa34f3d0a69dc450c65c4fd73310789af9e86a3e8f2ca68fdeec08145", + "size_in_bytes": 12514 + }, + { + "_path": "lib/python3.10/distutils/versionpredicate.py", + "path_type": "hardlink", + "sha256": "671a4403e4d0bfcf2651673a85eb543b8a92a80dac6bb8a98d9dd010ae5ebc39", + "sha256_in_prefix": "671a4403e4d0bfcf2651673a85eb543b8a92a80dac6bb8a98d9dd010ae5ebc39", + "size_in_bytes": 5133 + }, + { + "_path": "lib/python3.10/doctest.py", + "path_type": "hardlink", + "sha256": "e6cb29d6207195f566d69aea56c2c2036c311b8188b89ee3e9264116a60b82e1", + "sha256_in_prefix": "e6cb29d6207195f566d69aea56c2c2036c311b8188b89ee3e9264116a60b82e1", + "size_in_bytes": 105143 + }, + { + "_path": "lib/python3.10/email/__init__.py", + "path_type": "hardlink", + "sha256": "14eeb17ae40c6cc19b48a9bd5e2a0340ee3dd86a8d64bd1d5c4df8fcfa726c8a", + "sha256_in_prefix": "14eeb17ae40c6cc19b48a9bd5e2a0340ee3dd86a8d64bd1d5c4df8fcfa726c8a", + "size_in_bytes": 1766 + }, + { + "_path": "lib/python3.10/email/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "d96c88b809756384b1299a1bfc52a7ce7cd6712c4261cb9b335b056b74f9ad4e", + "sha256_in_prefix": "d96c88b809756384b1299a1bfc52a7ce7cd6712c4261cb9b335b056b74f9ad4e", + "size_in_bytes": 1814 + }, + { + "_path": "lib/python3.10/email/__pycache__/_encoded_words.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "9c3634b01d72d0db5cab6a0c928eb5f8e15126718d768679c36a0055201c2070", + "sha256_in_prefix": "9c3634b01d72d0db5cab6a0c928eb5f8e15126718d768679c36a0055201c2070", + "size_in_bytes": 5994 + }, + { + "_path": "lib/python3.10/email/__pycache__/_header_value_parser.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "48fe91697cb36586ba0fdb8b65fab59d3fff94d5e0771a9ae6de661d5c9fdb6d", + "sha256_in_prefix": "48fe91697cb36586ba0fdb8b65fab59d3fff94d5e0771a9ae6de661d5c9fdb6d", + "size_in_bytes": 78049 + }, + { + "_path": "lib/python3.10/email/__pycache__/_parseaddr.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "71ffe0ea0421cdc7d6e992be3edf59a6254e7cac36a32a955d931597c28910bb", + "sha256_in_prefix": "71ffe0ea0421cdc7d6e992be3edf59a6254e7cac36a32a955d931597c28910bb", + "size_in_bytes": 12766 + }, + { + "_path": "lib/python3.10/email/__pycache__/_policybase.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "b34fb92f9e766beb2a83718a701dbb4389f1eb7d2807502657390ffb194a4bc0", + "sha256_in_prefix": "b34fb92f9e766beb2a83718a701dbb4389f1eb7d2807502657390ffb194a4bc0", + "size_in_bytes": 15036 + }, + { + "_path": "lib/python3.10/email/__pycache__/base64mime.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "179c7013edadf9d44451f9eceed7c1585d206e0dfa06e6283a5a32dc55032298", + "sha256_in_prefix": "179c7013edadf9d44451f9eceed7c1585d206e0dfa06e6283a5a32dc55032298", + "size_in_bytes": 3494 + }, + { + "_path": "lib/python3.10/email/__pycache__/charset.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c5129bb2184682c17e63da022643dfd0ecd4219b7cf292070e936e050b8340d8", + "sha256_in_prefix": "c5129bb2184682c17e63da022643dfd0ecd4219b7cf292070e936e050b8340d8", + "size_in_bytes": 11829 + }, + { + "_path": "lib/python3.10/email/__pycache__/contentmanager.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "53e4704110f0791440fa403cc3cfa5287dcf5f4eced99340c4c949ae77e780e7", + "sha256_in_prefix": "53e4704110f0791440fa403cc3cfa5287dcf5f4eced99340c4c949ae77e780e7", + "size_in_bytes": 7643 + }, + { + "_path": "lib/python3.10/email/__pycache__/encoders.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "4d47e49f24ca18a31a64615e7fa81f3bfab75ced5bf74775a5d60a180edbbabc", + "sha256_in_prefix": "4d47e49f24ca18a31a64615e7fa81f3bfab75ced5bf74775a5d60a180edbbabc", + "size_in_bytes": 1881 + }, + { + "_path": "lib/python3.10/email/__pycache__/errors.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "1e15917bbb070ebb3aab99c418982b42b03156bb49c850fc0f9b39db21dfd344", + "sha256_in_prefix": "1e15917bbb070ebb3aab99c418982b42b03156bb49c850fc0f9b39db21dfd344", + "size_in_bytes": 5956 + }, + { + "_path": "lib/python3.10/email/__pycache__/feedparser.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c9b3a3cc2561072c988a595108623035a7aca12d1160d4bcfefff639e4bd4300", + "sha256_in_prefix": "c9b3a3cc2561072c988a595108623035a7aca12d1160d4bcfefff639e4bd4300", + "size_in_bytes": 10832 + }, + { + "_path": "lib/python3.10/email/__pycache__/generator.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "e56cc2363b7bc48bcda9791529adc23c687ffd3e9dee42de38ba2976839dc97f", + "sha256_in_prefix": "e56cc2363b7bc48bcda9791529adc23c687ffd3e9dee42de38ba2976839dc97f", + "size_in_bytes": 12855 + }, + { + "_path": "lib/python3.10/email/__pycache__/header.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "da6b85822bc5cd8d502fc6e382959f4427e492dad89eeb5ffbbee6937bf545ff", + "sha256_in_prefix": "da6b85822bc5cd8d502fc6e382959f4427e492dad89eeb5ffbbee6937bf545ff", + "size_in_bytes": 16716 + }, + { + "_path": "lib/python3.10/email/__pycache__/headerregistry.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "1c9cc79997b7753d6dc0538b07c5cb1d91661b7f9ad23b31ccb0f4070f6e38bc", + "sha256_in_prefix": "1c9cc79997b7753d6dc0538b07c5cb1d91661b7f9ad23b31ccb0f4070f6e38bc", + "size_in_bytes": 22159 + }, + { + "_path": "lib/python3.10/email/__pycache__/iterators.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "9c4c45eb0b3585c8e7eb40d695d86489fb50536d3d7102f5b0467bb1939d5db7", + "sha256_in_prefix": "9c4c45eb0b3585c8e7eb40d695d86489fb50536d3d7102f5b0467bb1939d5db7", + "size_in_bytes": 2222 + }, + { + "_path": "lib/python3.10/email/__pycache__/message.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c07e625a935251ec3ad1549206db5e0a8509650961789219b69d05b84fb2d20b", + "sha256_in_prefix": "c07e625a935251ec3ad1549206db5e0a8509650961789219b69d05b84fb2d20b", + "size_in_bytes": 38058 + }, + { + "_path": "lib/python3.10/email/__pycache__/parser.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "0fa7eb30940ba95080fe64a992a681c16e2d0a50e264c877e31266634d4238b2", + "sha256_in_prefix": "0fa7eb30940ba95080fe64a992a681c16e2d0a50e264c877e31266634d4238b2", + "size_in_bytes": 5927 + }, + { + "_path": "lib/python3.10/email/__pycache__/policy.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c06eca141280f578addde40dd75094b69356d574e913b50e3d5b60a39c36004d", + "sha256_in_prefix": "c06eca141280f578addde40dd75094b69356d574e913b50e3d5b60a39c36004d", + "size_in_bytes": 9907 + }, + { + "_path": "lib/python3.10/email/__pycache__/quoprimime.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c5c44b096807d45b8a2aecdc8602c7e79482bdba4ac901e4b082fa15077196c4", + "sha256_in_prefix": "c5c44b096807d45b8a2aecdc8602c7e79482bdba4ac901e4b082fa15077196c4", + "size_in_bytes": 7877 + }, + { + "_path": "lib/python3.10/email/__pycache__/utils.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "46bed577933fc8d2e4963c1775e988c2f10a8891fd72b52165e8d858365e7fdc", + "sha256_in_prefix": "46bed577933fc8d2e4963c1775e988c2f10a8891fd72b52165e8d858365e7fdc", + "size_in_bytes": 9940 + }, + { + "_path": "lib/python3.10/email/_encoded_words.py", + "path_type": "hardlink", + "sha256": "4178321600c0a19ca04cfe8542ce44487f339d15d89a473b58cea63c0b230217", + "sha256_in_prefix": "4178321600c0a19ca04cfe8542ce44487f339d15d89a473b58cea63c0b230217", + "size_in_bytes": 8541 + }, + { + "_path": "lib/python3.10/email/_header_value_parser.py", + "path_type": "hardlink", + "sha256": "f4fe84dcd279f58ef04a9763cde87947fc6358a112ef2953f40b04b5a9058c9c", + "sha256_in_prefix": "f4fe84dcd279f58ef04a9763cde87947fc6358a112ef2953f40b04b5a9058c9c", + "size_in_bytes": 106982 + }, + { + "_path": "lib/python3.10/email/_parseaddr.py", + "path_type": "hardlink", + "sha256": "4308932872acbf4a674312a45a49b870e48026e3dfedc878ee2f512ddf2f30ba", + "sha256_in_prefix": "4308932872acbf4a674312a45a49b870e48026e3dfedc878ee2f512ddf2f30ba", + "size_in_bytes": 17821 + }, + { + "_path": "lib/python3.10/email/_policybase.py", + "path_type": "hardlink", + "sha256": "967a41672b54f3443eac096968ad189d75c77be7eb42611b4d81d12a41605be9", + "sha256_in_prefix": "967a41672b54f3443eac096968ad189d75c77be7eb42611b4d81d12a41605be9", + "size_in_bytes": 15073 + }, + { + "_path": "lib/python3.10/email/architecture.rst", + "path_type": "hardlink", + "sha256": "f2b2ba7497fd02d13abcfc2a98099283a94b09e8b4f2c1c822ecacde3bec3eae", + "sha256_in_prefix": "f2b2ba7497fd02d13abcfc2a98099283a94b09e8b4f2c1c822ecacde3bec3eae", + "size_in_bytes": 9561 + }, + { + "_path": "lib/python3.10/email/base64mime.py", + "path_type": "hardlink", + "sha256": "508aa55b77f042a8da60ce79ed66715818049d5061677be6d02fe89269d8a3dd", + "sha256_in_prefix": "508aa55b77f042a8da60ce79ed66715818049d5061677be6d02fe89269d8a3dd", + "size_in_bytes": 3559 + }, + { + "_path": "lib/python3.10/email/charset.py", + "path_type": "hardlink", + "sha256": "115cc9aad570643b91897a19c71f7a27028bc11b4ee4374e11a32643c1b12d25", + "sha256_in_prefix": "115cc9aad570643b91897a19c71f7a27028bc11b4ee4374e11a32643c1b12d25", + "size_in_bytes": 17128 + }, + { + "_path": "lib/python3.10/email/contentmanager.py", + "path_type": "hardlink", + "sha256": "2b3adab3d945d156bf8a22762590278bbf177d95545e5fc3c1d6c73b5d041ddf", + "sha256_in_prefix": "2b3adab3d945d156bf8a22762590278bbf177d95545e5fc3c1d6c73b5d041ddf", + "size_in_bytes": 10555 + }, + { + "_path": "lib/python3.10/email/encoders.py", + "path_type": "hardlink", + "sha256": "1e05b3ee30c62c605077e7770b5b3249f5060d968b0fee8d5cf9cad9450b89cd", + "sha256_in_prefix": "1e05b3ee30c62c605077e7770b5b3249f5060d968b0fee8d5cf9cad9450b89cd", + "size_in_bytes": 1786 + }, + { + "_path": "lib/python3.10/email/errors.py", + "path_type": "hardlink", + "sha256": "33fc889cbff57bb78c913bb6c24c5d52bd02f3cba0f4b1cb2913340294a6ec1a", + "sha256_in_prefix": "33fc889cbff57bb78c913bb6c24c5d52bd02f3cba0f4b1cb2913340294a6ec1a", + "size_in_bytes": 3735 + }, + { + "_path": "lib/python3.10/email/feedparser.py", + "path_type": "hardlink", + "sha256": "6f8faf3d77fbdc2096f8bbedfd58c3d58e7937a11f0d652b43a2b842a5597625", + "sha256_in_prefix": "6f8faf3d77fbdc2096f8bbedfd58c3d58e7937a11f0d652b43a2b842a5597625", + "size_in_bytes": 22780 + }, + { + "_path": "lib/python3.10/email/generator.py", + "path_type": "hardlink", + "sha256": "696404ca67a6d917a6801221cd6f5c9f0f88eaf3a3d0c7bae426ba573ab34d5e", + "sha256_in_prefix": "696404ca67a6d917a6801221cd6f5c9f0f88eaf3a3d0c7bae426ba573ab34d5e", + "size_in_bytes": 20196 + }, + { + "_path": "lib/python3.10/email/header.py", + "path_type": "hardlink", + "sha256": "99921e2aa7ae5ae1433a0e3f92c732026677417c39923996c11931589ff8a361", + "sha256_in_prefix": "99921e2aa7ae5ae1433a0e3f92c732026677417c39923996c11931589ff8a361", + "size_in_bytes": 24102 + }, + { + "_path": "lib/python3.10/email/headerregistry.py", + "path_type": "hardlink", + "sha256": "c6732dcb9473c45c8999c318d6281e549e842174bd9da13f39d9bfd45324d283", + "sha256_in_prefix": "c6732dcb9473c45c8999c318d6281e549e842174bd9da13f39d9bfd45324d283", + "size_in_bytes": 20813 + }, + { + "_path": "lib/python3.10/email/iterators.py", + "path_type": "hardlink", + "sha256": "7ebca15c9f5889b9551727303666a7bd80c5e4ebdf6bc7ec4d0c46938a1378e1", + "sha256_in_prefix": "7ebca15c9f5889b9551727303666a7bd80c5e4ebdf6bc7ec4d0c46938a1378e1", + "size_in_bytes": 2135 + }, + { + "_path": "lib/python3.10/email/message.py", + "path_type": "hardlink", + "sha256": "1b125a3f94289c3ff62f4dee59bcc46ded67aa4f759d3dbc035d84ce92d85d1e", + "sha256_in_prefix": "1b125a3f94289c3ff62f4dee59bcc46ded67aa4f759d3dbc035d84ce92d85d1e", + "size_in_bytes": 47060 + }, + { + "_path": "lib/python3.10/email/mime/__init__.py", + "path_type": "hardlink", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size_in_bytes": 0 + }, + { + "_path": "lib/python3.10/email/mime/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "4262672278c29465df589e8576e13ec3c2c0be6f99ca98aed673a372b2ae4129", + "sha256_in_prefix": "4262672278c29465df589e8576e13ec3c2c0be6f99ca98aed673a372b2ae4129", + "size_in_bytes": 389 + }, + { + "_path": "lib/python3.10/email/mime/__pycache__/application.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "b3d72bd96a897c9c642a96f29cf2c973c0c4aede07f279a86833e57aebe6db8e", + "sha256_in_prefix": "b3d72bd96a897c9c642a96f29cf2c973c0c4aede07f279a86833e57aebe6db8e", + "size_in_bytes": 1718 + }, + { + "_path": "lib/python3.10/email/mime/__pycache__/audio.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "cb3f53c6beb588d98633c502d4e3a9942dfb1a64c08adf35a49c4c7d14d3cec4", + "sha256_in_prefix": "cb3f53c6beb588d98633c502d4e3a9942dfb1a64c08adf35a49c4c7d14d3cec4", + "size_in_bytes": 2885 + }, + { + "_path": "lib/python3.10/email/mime/__pycache__/base.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "40afd4523b13e99b916dfd663e73da2e97a0fac12f99bdf0ebd0b82da56619c0", + "sha256_in_prefix": "40afd4523b13e99b916dfd663e73da2e97a0fac12f99bdf0ebd0b82da56619c0", + "size_in_bytes": 1304 + }, + { + "_path": "lib/python3.10/email/mime/__pycache__/image.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "f847ed79360b698743c0a9a628448961cf60d76d44acf78708a2477ef93aff2c", + "sha256_in_prefix": "f847ed79360b698743c0a9a628448961cf60d76d44acf78708a2477ef93aff2c", + "size_in_bytes": 2162 + }, + { + "_path": "lib/python3.10/email/mime/__pycache__/message.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "4859d12e5edfcbddeb858b93f4f60e503f4ce08e8b2394c06e6e21545f018100", + "sha256_in_prefix": "4859d12e5edfcbddeb858b93f4f60e503f4ce08e8b2394c06e6e21545f018100", + "size_in_bytes": 1541 + }, + { + "_path": "lib/python3.10/email/mime/__pycache__/multipart.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "759118ca75976cda6a054ba910ab5eae4a1bafe7c6b2d598a4bb999e4dad188e", + "sha256_in_prefix": "759118ca75976cda6a054ba910ab5eae4a1bafe7c6b2d598a4bb999e4dad188e", + "size_in_bytes": 1767 + }, + { + "_path": "lib/python3.10/email/mime/__pycache__/nonmultipart.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "956e1cee596fe50409ca1c0147f1c9391e099c7aaba1511e41d754e0952f3015", + "sha256_in_prefix": "956e1cee596fe50409ca1c0147f1c9391e099c7aaba1511e41d754e0952f3015", + "size_in_bytes": 1019 + }, + { + "_path": "lib/python3.10/email/mime/__pycache__/text.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "eed1d756a181ce7141f57c26904359784d410ee04842a16783a5d74df8c841e7", + "sha256_in_prefix": "eed1d756a181ce7141f57c26904359784d410ee04842a16783a5d74df8c841e7", + "size_in_bytes": 1570 + }, + { + "_path": "lib/python3.10/email/mime/application.py", + "path_type": "hardlink", + "sha256": "b82a944ccba03e7e7eec46232e50ffe4ce2c32f4b0e26662e6bde30d533584ae", + "sha256_in_prefix": "b82a944ccba03e7e7eec46232e50ffe4ce2c32f4b0e26662e6bde30d533584ae", + "size_in_bytes": 1321 + }, + { + "_path": "lib/python3.10/email/mime/audio.py", + "path_type": "hardlink", + "sha256": "5c1566e6fbf12bb963489ee71df43b60cba8a2bed640a0387d9b3e27fc521e85", + "sha256_in_prefix": "5c1566e6fbf12bb963489ee71df43b60cba8a2bed640a0387d9b3e27fc521e85", + "size_in_bytes": 2739 + }, + { + "_path": "lib/python3.10/email/mime/base.py", + "path_type": "hardlink", + "sha256": "8e1014770d0d5e9fe6207ae0919b572033e4acc75e961ea0a3f760547716e3ee", + "sha256_in_prefix": "8e1014770d0d5e9fe6207ae0919b572033e4acc75e961ea0a3f760547716e3ee", + "size_in_bytes": 916 + }, + { + "_path": "lib/python3.10/email/mime/image.py", + "path_type": "hardlink", + "sha256": "9346e718eac589fc711bd1549a216466850eb1ed7e05cce0ecc73d280c368e6e", + "sha256_in_prefix": "9346e718eac589fc711bd1549a216466850eb1ed7e05cce0ecc73d280c368e6e", + "size_in_bytes": 1828 + }, + { + "_path": "lib/python3.10/email/mime/message.py", + "path_type": "hardlink", + "sha256": "0553e0365eb7e58ba8dcd5f4d416af8ab331b5d6d920b6fb16481ed172fa7d79", + "sha256_in_prefix": "0553e0365eb7e58ba8dcd5f4d416af8ab331b5d6d920b6fb16481ed172fa7d79", + "size_in_bytes": 1317 + }, + { + "_path": "lib/python3.10/email/mime/multipart.py", + "path_type": "hardlink", + "sha256": "53730a1a7807d8af12b88665d8f474f48bf39ed1ef4c47433267a44ef54b0ba7", + "sha256_in_prefix": "53730a1a7807d8af12b88665d8f474f48bf39ed1ef4c47433267a44ef54b0ba7", + "size_in_bytes": 1621 + }, + { + "_path": "lib/python3.10/email/mime/nonmultipart.py", + "path_type": "hardlink", + "sha256": "1f6fdedb5ba3e0a698bf33d77e329fc4cf2ab4305474b6ae23c1bc0f99daaf7a", + "sha256_in_prefix": "1f6fdedb5ba3e0a698bf33d77e329fc4cf2ab4305474b6ae23c1bc0f99daaf7a", + "size_in_bytes": 691 + }, + { + "_path": "lib/python3.10/email/mime/text.py", + "path_type": "hardlink", + "sha256": "aa903b8248020e9211e88f2c3a5e3a05f6969b6aab2b6f01ea1ddff776b870de", + "sha256_in_prefix": "aa903b8248020e9211e88f2c3a5e3a05f6969b6aab2b6f01ea1ddff776b870de", + "size_in_bytes": 1437 + }, + { + "_path": "lib/python3.10/email/parser.py", + "path_type": "hardlink", + "sha256": "eab481ca55902fae679fa2f794c8a81f913723d5029a79d9eb806d4b0c6b6b49", + "sha256_in_prefix": "eab481ca55902fae679fa2f794c8a81f913723d5029a79d9eb806d4b0c6b6b49", + "size_in_bytes": 5041 + }, + { + "_path": "lib/python3.10/email/policy.py", + "path_type": "hardlink", + "sha256": "ca1b94f27db711094e9ba3ec4419313c3e660d1016f4bf01d467e5a174bb6302", + "sha256_in_prefix": "ca1b94f27db711094e9ba3ec4419313c3e660d1016f4bf01d467e5a174bb6302", + "size_in_bytes": 10383 + }, + { + "_path": "lib/python3.10/email/quoprimime.py", + "path_type": "hardlink", + "sha256": "3b892900fd55b57d3be22f7bc9696feb905545adb81d37f4b77166753473a4b4", + "sha256_in_prefix": "3b892900fd55b57d3be22f7bc9696feb905545adb81d37f4b77166753473a4b4", + "size_in_bytes": 9858 + }, + { + "_path": "lib/python3.10/email/utils.py", + "path_type": "hardlink", + "sha256": "151a5736d6be70f9e397f3578c8d59a95d92e6490482d21287f6a5506d332fe8", + "sha256_in_prefix": "151a5736d6be70f9e397f3578c8d59a95d92e6490482d21287f6a5506d332fe8", + "size_in_bytes": 13422 + }, + { + "_path": "lib/python3.10/encodings/__init__.py", + "path_type": "hardlink", + "sha256": "05f07fc2a0fbd9a9cc92aa7567df84f343ebbb17fc676432e108e127d81913df", + "sha256_in_prefix": "05f07fc2a0fbd9a9cc92aa7567df84f343ebbb17fc676432e108e127d81913df", + "size_in_bytes": 5620 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "44ebff2b329edca585e553e9093df4e796430b3f351ecde019320f9a4579f93d", + "sha256_in_prefix": "44ebff2b329edca585e553e9093df4e796430b3f351ecde019320f9a4579f93d", + "size_in_bytes": 4129 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/aliases.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "39237892b7f84aacde50bbb1e08931a43d00f30129a201c02b355e3ea718a1e1", + "sha256_in_prefix": "39237892b7f84aacde50bbb1e08931a43d00f30129a201c02b355e3ea718a1e1", + "size_in_bytes": 11175 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/ascii.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "9789383f7a1a8a6bf4d9a54bc965f625cbea67e5e9d193ebf256c0808c5e1705", + "sha256_in_prefix": "9789383f7a1a8a6bf4d9a54bc965f625cbea67e5e9d193ebf256c0808c5e1705", + "size_in_bytes": 2066 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/base64_codec.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "d427b4aa532d9daea96a880273a4d66a84ecbdb8ddf9c4890adb83b83dbd7824", + "sha256_in_prefix": "d427b4aa532d9daea96a880273a4d66a84ecbdb8ddf9c4890adb83b83dbd7824", + "size_in_bytes": 2501 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/big5.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "11970f0e431436a6fa553642dd38b6b1850eb9b5910d8c507935c9858a578b6a", + "sha256_in_prefix": "11970f0e431436a6fa553642dd38b6b1850eb9b5910d8c507935c9858a578b6a", + "size_in_bytes": 1620 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/big5hkscs.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "3932bd845ee66311f5fabfc8b0143753e2a5b87c251bedfb65ea4daadee8a627", + "sha256_in_prefix": "3932bd845ee66311f5fabfc8b0143753e2a5b87c251bedfb65ea4daadee8a627", + "size_in_bytes": 1630 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/bz2_codec.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "856964b3ecf4f5e9a3a8692fc280332919a6e629d623e75e52c2967369a7417b", + "sha256_in_prefix": "856964b3ecf4f5e9a3a8692fc280332919a6e629d623e75e52c2967369a7417b", + "size_in_bytes": 3340 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/charmap.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "e67e588a78c94b40ab42dab009f729276c5de082f389d98ad9ddd0d399da4c58", + "sha256_in_prefix": "e67e588a78c94b40ab42dab009f729276c5de082f389d98ad9ddd0d399da4c58", + "size_in_bytes": 2714 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/cp037.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "85dd1139f008633c3a62e0a8fde45d19e5021299d064f64986bc0edf3d01e6b2", + "sha256_in_prefix": "85dd1139f008633c3a62e0a8fde45d19e5021299d064f64986bc0edf3d01e6b2", + "size_in_bytes": 2604 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/cp1006.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "7f684e3d0f114df7cb79a0f047ebf1f2a430af3b9fffdacf55b93a9d30c7fa12", + "sha256_in_prefix": "7f684e3d0f114df7cb79a0f047ebf1f2a430af3b9fffdacf55b93a9d30c7fa12", + "size_in_bytes": 2680 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/cp1026.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "0b4708876397296fb06caae80e7c77582e4555e95ae9956bffb20cab680c034c", + "sha256_in_prefix": "0b4708876397296fb06caae80e7c77582e4555e95ae9956bffb20cab680c034c", + "size_in_bytes": 2608 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/cp1125.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "eee00712821e6ba9828d11690ccadc3f9fd88ceb77fcd643a467331766ba4230", + "sha256_in_prefix": "eee00712821e6ba9828d11690ccadc3f9fd88ceb77fcd643a467331766ba4230", + "size_in_bytes": 9545 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/cp1140.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "65fdfe7c0416b4f7c88e4ba791085643f304b475e12f633a87dadf6033ee0b8b", + "sha256_in_prefix": "65fdfe7c0416b4f7c88e4ba791085643f304b475e12f633a87dadf6033ee0b8b", + "size_in_bytes": 2594 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/cp1250.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "ea5a69aa2399ea5ee85f88c83ef47eb56a569bc5fcb9b766e757935506cde7ea", + "sha256_in_prefix": "ea5a69aa2399ea5ee85f88c83ef47eb56a569bc5fcb9b766e757935506cde7ea", + "size_in_bytes": 2631 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/cp1251.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "03a843b0e54e07c0c2d05b3fdcea0a939fda179b8cb3162b7b189903bd7bde5c", + "sha256_in_prefix": "03a843b0e54e07c0c2d05b3fdcea0a939fda179b8cb3162b7b189903bd7bde5c", + "size_in_bytes": 2628 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/cp1252.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "eba53eb031aeb03b9f9d3d0ae110d466a9c93e8235201252f8b804250b5e700a", + "sha256_in_prefix": "eba53eb031aeb03b9f9d3d0ae110d466a9c93e8235201252f8b804250b5e700a", + "size_in_bytes": 2631 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/cp1253.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "ceae90acd6505c874de2c57e434cbdff5323c1890bb49ef6a4bd76ad4180bb27", + "sha256_in_prefix": "ceae90acd6505c874de2c57e434cbdff5323c1890bb49ef6a4bd76ad4180bb27", + "size_in_bytes": 2644 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/cp1254.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "bd775e7c07bc1b5e31556bb36b47b30be4b1669c97af345bc74b12ad59598b56", + "sha256_in_prefix": "bd775e7c07bc1b5e31556bb36b47b30be4b1669c97af345bc74b12ad59598b56", + "size_in_bytes": 2633 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/cp1255.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "f23e3d82ef1a3bf38b2d62097dcc2685ed8dea1eee3ce218d0fa02fde7c4fbf1", + "sha256_in_prefix": "f23e3d82ef1a3bf38b2d62097dcc2685ed8dea1eee3ce218d0fa02fde7c4fbf1", + "size_in_bytes": 2652 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/cp1256.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "a04054368aa259ef991d29cf73b3d99d38be513b5fb56c78905ed63577dfe753", + "sha256_in_prefix": "a04054368aa259ef991d29cf73b3d99d38be513b5fb56c78905ed63577dfe753", + "size_in_bytes": 2630 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/cp1257.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "367aed5ba60979754a0850b41dcc184da34c2158b26849a1ade8e14353682bdf", + "sha256_in_prefix": "367aed5ba60979754a0850b41dcc184da34c2158b26849a1ade8e14353682bdf", + "size_in_bytes": 2638 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/cp1258.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "8641e0243abb93ab5808c43615b1eae3a510ea7f7c2fb42700c8b05f7cb74768", + "sha256_in_prefix": "8641e0243abb93ab5808c43615b1eae3a510ea7f7c2fb42700c8b05f7cb74768", + "size_in_bytes": 2636 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/cp273.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "bb11a7200fce6a13a6d1ee3cc7fb79c814c200cdb3e5627981a885a144f8e2ae", + "sha256_in_prefix": "bb11a7200fce6a13a6d1ee3cc7fb79c814c200cdb3e5627981a885a144f8e2ae", + "size_in_bytes": 2590 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/cp424.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "98188f963e0403a359a6cacaf878c1354b173c5aac137c70f8122a696b0e56b2", + "sha256_in_prefix": "98188f963e0403a359a6cacaf878c1354b173c5aac137c70f8122a696b0e56b2", + "size_in_bytes": 2375 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/cp437.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "696f079e6fcfde7b23b217c12fc0ab7aa19b7f157b8c91493e4b6dcaa286ec32", + "sha256_in_prefix": "696f079e6fcfde7b23b217c12fc0ab7aa19b7f157b8c91493e4b6dcaa286ec32", + "size_in_bytes": 9178 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/cp500.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "f43dbe392cc114c089cfce5f174b3bbf19f87d7489f9a0e145019f0fe0139109", + "sha256_in_prefix": "f43dbe392cc114c089cfce5f174b3bbf19f87d7489f9a0e145019f0fe0139109", + "size_in_bytes": 2604 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/cp720.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "0442fda704669d6b3bb34a5bc5fe787d8af1020423fe3512164c23f7d88a1c90", + "sha256_in_prefix": "0442fda704669d6b3bb34a5bc5fe787d8af1020423fe3512164c23f7d88a1c90", + "size_in_bytes": 2701 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/cp737.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "b14cd5fac5ac626d5d93bdc349c31948cd4274d7c6608975713d87db22076979", + "sha256_in_prefix": "b14cd5fac5ac626d5d93bdc349c31948cd4274d7c6608975713d87db22076979", + "size_in_bytes": 9580 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/cp775.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "a3343c5938a7b0cbf3d448d35900f4d178867b309467aa11f168fb46b9b4c2eb", + "sha256_in_prefix": "a3343c5938a7b0cbf3d448d35900f4d178867b309467aa11f168fb46b9b4c2eb", + "size_in_bytes": 9218 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/cp850.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "a0c685ff9ea76c2d43f93c4bcf9e373c47aae5f84eeccd8c7f53edd01523a418", + "sha256_in_prefix": "a0c685ff9ea76c2d43f93c4bcf9e373c47aae5f84eeccd8c7f53edd01523a418", + "size_in_bytes": 8759 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/cp852.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "6f2fafe3a109ac40ce0d2698e66c185a45459bd176c1596beb0182671cd7a403", + "sha256_in_prefix": "6f2fafe3a109ac40ce0d2698e66c185a45459bd176c1596beb0182671cd7a403", + "size_in_bytes": 9234 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/cp855.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "649c427996c6e16cfa8f81dbe70d765928a4d10bdafaa9955ac82459a9beec25", + "sha256_in_prefix": "649c427996c6e16cfa8f81dbe70d765928a4d10bdafaa9955ac82459a9beec25", + "size_in_bytes": 9547 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/cp856.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "7fe48f8054080de23252810db2093052a6d5a48f850734f44d082da8e6491c7f", + "sha256_in_prefix": "7fe48f8054080de23252810db2093052a6d5a48f850734f44d082da8e6491c7f", + "size_in_bytes": 2666 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/cp857.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "1f2a296ebbab6301fb3fc8150fff46757ea0ba2407c47de7f5fd3c5ad85936ba", + "sha256_in_prefix": "1f2a296ebbab6301fb3fc8150fff46757ea0ba2407c47de7f5fd3c5ad85936ba", + "size_in_bytes": 8658 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/cp858.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "8298561a4f40299532ad832f875f88708891d565fe63ce8be09de98f41d3695d", + "sha256_in_prefix": "8298561a4f40299532ad832f875f88708891d565fe63ce8be09de98f41d3695d", + "size_in_bytes": 8729 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/cp860.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "efc45700dcecb70065c4e6302a1409541c19061071ec413e620406b803a13cec", + "sha256_in_prefix": "efc45700dcecb70065c4e6302a1409541c19061071ec413e620406b803a13cec", + "size_in_bytes": 9149 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/cp861.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "f6687a187e755fb7c15957445a9a70870a860d8402cfa08713b8a963bce11c26", + "sha256_in_prefix": "f6687a187e755fb7c15957445a9a70870a860d8402cfa08713b8a963bce11c26", + "size_in_bytes": 9174 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/cp862.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "0b42c8bb7048d68d88f4f7503d3cbce25b3c74906c9dfd7047bb12edf4eb6170", + "sha256_in_prefix": "0b42c8bb7048d68d88f4f7503d3cbce25b3c74906c9dfd7047bb12edf4eb6170", + "size_in_bytes": 9407 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/cp863.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "7068f22a9f1c83cdcfb2bba099ae1be5fdb82b1bd89c854eea867389b8a39c81", + "sha256_in_prefix": "7068f22a9f1c83cdcfb2bba099ae1be5fdb82b1bd89c854eea867389b8a39c81", + "size_in_bytes": 9170 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/cp864.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "19fa66c93ed988eb475ec48cb2d73db8808f0b29ca9d1e3901a5ab7960771917", + "sha256_in_prefix": "19fa66c93ed988eb475ec48cb2d73db8808f0b29ca9d1e3901a5ab7960771917", + "size_in_bytes": 9317 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/cp865.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "0bd10f50c2f896994379c0d64a955314e7ba0323f1e9e20612befd64d44a2693", + "sha256_in_prefix": "0bd10f50c2f896994379c0d64a955314e7ba0323f1e9e20612befd64d44a2693", + "size_in_bytes": 9174 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/cp866.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "6ff95b6774a539d65401bbec080d5943b2f6d66fd064a455f3badfcc084bc0e0", + "sha256_in_prefix": "6ff95b6774a539d65401bbec080d5943b2f6d66fd064a455f3badfcc084bc0e0", + "size_in_bytes": 9587 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/cp869.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "8e9668fad0f07b4c1055c2ec1def67f0de002c086986f8cba55d40eea07d0c9b", + "sha256_in_prefix": "8e9668fad0f07b4c1055c2ec1def67f0de002c086986f8cba55d40eea07d0c9b", + "size_in_bytes": 9222 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/cp874.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c1b1ca3f2faac23a7c7e53f0ad54dede6c3ee70f387b6b516da9b9734bd50d8e", + "sha256_in_prefix": "c1b1ca3f2faac23a7c7e53f0ad54dede6c3ee70f387b6b516da9b9734bd50d8e", + "size_in_bytes": 2473 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/cp875.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "85124f68e894a82c10e1887137125ff489111f2afd5f6478b39f8534cf72be26", + "sha256_in_prefix": "85124f68e894a82c10e1887137125ff489111f2afd5f6478b39f8534cf72be26", + "size_in_bytes": 2601 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/cp932.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "6bcdaabadf1e126c8506bc24bad4239d4cca704cc8642091d4059b2bfec29297", + "sha256_in_prefix": "6bcdaabadf1e126c8506bc24bad4239d4cca704cc8642091d4059b2bfec29297", + "size_in_bytes": 1622 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/cp949.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "415e4e3074b3a884305fd38cfab6892bd2c209626135ea9c7f2c966667cd8b5c", + "sha256_in_prefix": "415e4e3074b3a884305fd38cfab6892bd2c209626135ea9c7f2c966667cd8b5c", + "size_in_bytes": 1622 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/cp950.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c09edd5c1b4d65dd56352337b53650bc2e5b6b61c539317f7caa1c011673410b", + "sha256_in_prefix": "c09edd5c1b4d65dd56352337b53650bc2e5b6b61c539317f7caa1c011673410b", + "size_in_bytes": 1622 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/euc_jis_2004.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "f1989b4dba7639455bd401adc4f44dd8206f5a22f503282acc1613646c0f22ef", + "sha256_in_prefix": "f1989b4dba7639455bd401adc4f44dd8206f5a22f503282acc1613646c0f22ef", + "size_in_bytes": 1636 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/euc_jisx0213.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "29800b3557a7bd99bb16eaea428fb71fedd275f59d8c6cc0ca24a716d2ac0eb8", + "sha256_in_prefix": "29800b3557a7bd99bb16eaea428fb71fedd275f59d8c6cc0ca24a716d2ac0eb8", + "size_in_bytes": 1636 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/euc_jp.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "07e8984898f50aaf8824845ea5869b7eba80ca34ff87034eabecba5d0f49acc7", + "sha256_in_prefix": "07e8984898f50aaf8824845ea5869b7eba80ca34ff87034eabecba5d0f49acc7", + "size_in_bytes": 1624 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/euc_kr.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "88a370fdda7fdc203eb8f36ca5420884121cdf54ff9ed62a02ab85918d0781cc", + "sha256_in_prefix": "88a370fdda7fdc203eb8f36ca5420884121cdf54ff9ed62a02ab85918d0781cc", + "size_in_bytes": 1624 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/gb18030.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "e437534e5d15d69755e0f2e4df60c997a7a620bfb0891294157793ccccc347a4", + "sha256_in_prefix": "e437534e5d15d69755e0f2e4df60c997a7a620bfb0891294157793ccccc347a4", + "size_in_bytes": 1626 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/gb2312.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "aad9b564a771366adadde69b31faba6d9f8f5b1d95a9a3bba013e8a3fdba2770", + "sha256_in_prefix": "aad9b564a771366adadde69b31faba6d9f8f5b1d95a9a3bba013e8a3fdba2770", + "size_in_bytes": 1624 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/gbk.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "449efe3da61b96376b50c6a27b1daad18f32bffcbc432cc968d3281b808f0362", + "sha256_in_prefix": "449efe3da61b96376b50c6a27b1daad18f32bffcbc432cc968d3281b808f0362", + "size_in_bytes": 1618 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/hex_codec.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "4a2802006401637cf5bd15696f7cfb35d60ce5a9d8665778dbee1f2a9ab8d307", + "sha256_in_prefix": "4a2802006401637cf5bd15696f7cfb35d60ce5a9d8665778dbee1f2a9ab8d307", + "size_in_bytes": 2488 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/hp_roman8.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "a368d2a3661f6a2b52de6ce6959b100465dd9f56ecc73acfc3a7b643193acdc5", + "sha256_in_prefix": "a368d2a3661f6a2b52de6ce6959b100465dd9f56ecc73acfc3a7b643193acdc5", + "size_in_bytes": 2805 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/hz.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "4f49593b6b7cff2fb5ec9b07d68b99ff9f0b9bb246a81d5bcba7a2739abd3678", + "sha256_in_prefix": "4f49593b6b7cff2fb5ec9b07d68b99ff9f0b9bb246a81d5bcba7a2739abd3678", + "size_in_bytes": 1616 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/idna.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "a6649d58fea99d8b06fe5c07e415684e46b3ad1658cd740feaf0b0b758c23f25", + "sha256_in_prefix": "a6649d58fea99d8b06fe5c07e415684e46b3ad1658cd740feaf0b0b758c23f25", + "size_in_bytes": 5853 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/iso2022_jp.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "398e4fefe3f1aff3ff316ab4a0ddefe0fa4660c91afb504dc1b5cb9696307474", + "sha256_in_prefix": "398e4fefe3f1aff3ff316ab4a0ddefe0fa4660c91afb504dc1b5cb9696307474", + "size_in_bytes": 1637 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/iso2022_jp_1.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "e671736b5d9a5249cedaee7038996431d8291e48cb38b8501afc21d132939e44", + "sha256_in_prefix": "e671736b5d9a5249cedaee7038996431d8291e48cb38b8501afc21d132939e44", + "size_in_bytes": 1641 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/iso2022_jp_2.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "5fb826cafb01116b61577aa1484dcd92ca5cd7c21f639b057a0cb8245c05e2c8", + "sha256_in_prefix": "5fb826cafb01116b61577aa1484dcd92ca5cd7c21f639b057a0cb8245c05e2c8", + "size_in_bytes": 1641 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/iso2022_jp_2004.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "a02fd1d0ea23cd76db0002b41a2dc00191dbe14ab1e09bac245adec55e1463bf", + "sha256_in_prefix": "a02fd1d0ea23cd76db0002b41a2dc00191dbe14ab1e09bac245adec55e1463bf", + "size_in_bytes": 1647 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/iso2022_jp_3.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "411734f00c018ba30468e7a9499a4160c4fb2853fe469cef46e9daabbb443045", + "sha256_in_prefix": "411734f00c018ba30468e7a9499a4160c4fb2853fe469cef46e9daabbb443045", + "size_in_bytes": 1641 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/iso2022_jp_ext.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "3708ac0a5dbd2506a25ddeb9c8a6b1d0bde78ba073e39d5d8798f50f17edef0b", + "sha256_in_prefix": "3708ac0a5dbd2506a25ddeb9c8a6b1d0bde78ba073e39d5d8798f50f17edef0b", + "size_in_bytes": 1645 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/iso2022_kr.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "649c7bb387ff5afdc41276ab69c6dc08d9429ba6169c3c78324676f7baf4dabb", + "sha256_in_prefix": "649c7bb387ff5afdc41276ab69c6dc08d9429ba6169c3c78324676f7baf4dabb", + "size_in_bytes": 1637 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/iso8859_1.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "aa9274cbac4ff16a8ff0b39e76c4dae1ff5792c48fcc51a7d697df58ae9dc08e", + "sha256_in_prefix": "aa9274cbac4ff16a8ff0b39e76c4dae1ff5792c48fcc51a7d697df58ae9dc08e", + "size_in_bytes": 2603 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/iso8859_10.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "fdd0c8d0c93b0cdfce96b571930320a0fdf421d98fec0563d8bbdd4fd99ce2ad", + "sha256_in_prefix": "fdd0c8d0c93b0cdfce96b571930320a0fdf421d98fec0563d8bbdd4fd99ce2ad", + "size_in_bytes": 2608 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/iso8859_11.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "3fdbc2b61dab3b9583147a7c75b8701babc64dd59e02e78e8100de201e34a0e8", + "sha256_in_prefix": "3fdbc2b61dab3b9583147a7c75b8701babc64dd59e02e78e8100de201e34a0e8", + "size_in_bytes": 2443 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/iso8859_13.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "a19752eafb2eaa6409ee424377afc786f0c1af494d7e64f62e7edd991a39a659", + "sha256_in_prefix": "a19752eafb2eaa6409ee424377afc786f0c1af494d7e64f62e7edd991a39a659", + "size_in_bytes": 2611 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/iso8859_14.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "8eff13271dea3425c20d5ff4b854065b8a8fc84ac646252a4312d8bdf4d353bb", + "sha256_in_prefix": "8eff13271dea3425c20d5ff4b854065b8a8fc84ac646252a4312d8bdf4d353bb", + "size_in_bytes": 2370 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/iso8859_15.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "a85b1cd0400337b192f79c151b490fe9e693cdafe570c4e61cd5703df049aa09", + "sha256_in_prefix": "a85b1cd0400337b192f79c151b490fe9e693cdafe570c4e61cd5703df049aa09", + "size_in_bytes": 2608 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/iso8859_16.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "dad9fc91c80cfaac9f23d30d85513cb76284b340f0e4e6d9160132270d5c6dbf", + "sha256_in_prefix": "dad9fc91c80cfaac9f23d30d85513cb76284b340f0e4e6d9160132270d5c6dbf", + "size_in_bytes": 2610 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/iso8859_2.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "fbafed16dac54624c729d17b2d2b62e90b5fac1f3a20c826ddeb6a3d94e13186", + "sha256_in_prefix": "fbafed16dac54624c729d17b2d2b62e90b5fac1f3a20c826ddeb6a3d94e13186", + "size_in_bytes": 2603 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/iso8859_3.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "8de7f818836c003393601b68093b6d0ef1fc5ca472851a648b243a6076e562e8", + "sha256_in_prefix": "8de7f818836c003393601b68093b6d0ef1fc5ca472851a648b243a6076e562e8", + "size_in_bytes": 2610 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/iso8859_4.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "aa309f0cfdf8079849d60514ca5d88d68db5d7627a1805f85fb8dd5e72452b38", + "sha256_in_prefix": "aa309f0cfdf8079849d60514ca5d88d68db5d7627a1805f85fb8dd5e72452b38", + "size_in_bytes": 2603 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/iso8859_5.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "2afb9fc97c126f5def7d9a906ebc41800c83572f9703896886ca52fa342dee32", + "sha256_in_prefix": "2afb9fc97c126f5def7d9a906ebc41800c83572f9703896886ca52fa342dee32", + "size_in_bytes": 2604 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/iso8859_6.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "a554b59bbab0919fd994673db6a343c7c85d9cf81ec7b7fd6ce406467889d997", + "sha256_in_prefix": "a554b59bbab0919fd994673db6a343c7c85d9cf81ec7b7fd6ce406467889d997", + "size_in_bytes": 2389 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/iso8859_7.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "b5f345b6b23291b2529350160aee275556bdb33f6824ea2e68d26f3fcfc9d834", + "sha256_in_prefix": "b5f345b6b23291b2529350160aee275556bdb33f6824ea2e68d26f3fcfc9d834", + "size_in_bytes": 2611 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/iso8859_8.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "a15037e4e7deb5ed8e4998f682bd9b734292f94fa37d40849a4bc1b378b3e7bb", + "sha256_in_prefix": "a15037e4e7deb5ed8e4998f682bd9b734292f94fa37d40849a4bc1b378b3e7bb", + "size_in_bytes": 2642 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/iso8859_9.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "67a2123d0dfc3d04192b9bf1a5adc6f0950b53e462d88cea9a976e42b3a82c68", + "sha256_in_prefix": "67a2123d0dfc3d04192b9bf1a5adc6f0950b53e462d88cea9a976e42b3a82c68", + "size_in_bytes": 2603 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/johab.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "770627660c2134652aa6aec64bcfc9bd59cbeeba45116a0bee95439e8ccee6c1", + "sha256_in_prefix": "770627660c2134652aa6aec64bcfc9bd59cbeeba45116a0bee95439e8ccee6c1", + "size_in_bytes": 1622 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/koi8_r.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "b5c33523e5f229bf3052c0f5cfd65e7d388008358a5de277099a896064ca03aa", + "sha256_in_prefix": "b5c33523e5f229bf3052c0f5cfd65e7d388008358a5de277099a896064ca03aa", + "size_in_bytes": 2655 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/koi8_t.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "72b4d45b4121809bc62db21af1e6c07b4f852641be6a052558145057de6ee5f0", + "sha256_in_prefix": "72b4d45b4121809bc62db21af1e6c07b4f852641be6a052558145057de6ee5f0", + "size_in_bytes": 2566 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/koi8_u.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "250de0622506619b103e95e93fbbdb3832fc31d5cd96c908556e30c7a45afb74", + "sha256_in_prefix": "250de0622506619b103e95e93fbbdb3832fc31d5cd96c908556e30c7a45afb74", + "size_in_bytes": 2641 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/kz1048.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "91d04b669035195cf7f7ac078c98807948923447f1a423d54f305aacbe8aa641", + "sha256_in_prefix": "91d04b669035195cf7f7ac078c98807948923447f1a423d54f305aacbe8aa641", + "size_in_bytes": 2618 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/latin_1.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "82960a45d19bca668b2a059322d0fa6ff2da071ef36e8b347e597e92320e8839", + "sha256_in_prefix": "82960a45d19bca668b2a059322d0fa6ff2da071ef36e8b347e597e92320e8839", + "size_in_bytes": 2078 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/mac_arabic.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "d0368142c72309a39d58542ea4da95cbc483d484f0d2c210c8b0a22d23a44a82", + "sha256_in_prefix": "d0368142c72309a39d58542ea4da95cbc483d484f0d2c210c8b0a22d23a44a82", + "size_in_bytes": 9064 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/mac_croatian.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c94226fa3bd25e2e358043b2eaba6440f6727c21e9c4f3b00daa96eb89a8cca9", + "sha256_in_prefix": "c94226fa3bd25e2e358043b2eaba6440f6727c21e9c4f3b00daa96eb89a8cca9", + "size_in_bytes": 2650 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/mac_cyrillic.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "38c5e0f4b69ddaaddeef584bd92d29529d8b696b3ce27dbb431bb0822db3297d", + "sha256_in_prefix": "38c5e0f4b69ddaaddeef584bd92d29529d8b696b3ce27dbb431bb0822db3297d", + "size_in_bytes": 2640 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/mac_farsi.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "3e3bbf65d5a7ac56f75eb01c0155b247a2145ec76a4ab81fd9d36a8b8ed16de9", + "sha256_in_prefix": "3e3bbf65d5a7ac56f75eb01c0155b247a2145ec76a4ab81fd9d36a8b8ed16de9", + "size_in_bytes": 2584 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/mac_greek.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "b84a3336b147f3a22be627b674e6d18bb035bb3c799d8214b69655c4e9e39ec3", + "sha256_in_prefix": "b84a3336b147f3a22be627b674e6d18bb035bb3c799d8214b69655c4e9e39ec3", + "size_in_bytes": 2624 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/mac_iceland.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "5c4c04b4b92ac383e7c0c6360c2bd37a5909a964fe3e9595e0163f26a0367764", + "sha256_in_prefix": "5c4c04b4b92ac383e7c0c6360c2bd37a5909a964fe3e9595e0163f26a0367764", + "size_in_bytes": 2643 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/mac_latin2.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "7dd625a7e5762109a1735bf570807a6dc704c40675c4e91e8cadbfeb866f1714", + "sha256_in_prefix": "7dd625a7e5762109a1735bf570807a6dc704c40675c4e91e8cadbfeb866f1714", + "size_in_bytes": 2784 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/mac_roman.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "bfb2aa785f43bdea50edc5a9c87d962630eb24aa2e30d5f4eddec6f64ba46fac", + "sha256_in_prefix": "bfb2aa785f43bdea50edc5a9c87d962630eb24aa2e30d5f4eddec6f64ba46fac", + "size_in_bytes": 2641 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/mac_romanian.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "9bd51c26824322b69e3a81ed101709daff973aeb9517d60d9dcdf0086048cad2", + "sha256_in_prefix": "9bd51c26824322b69e3a81ed101709daff973aeb9517d60d9dcdf0086048cad2", + "size_in_bytes": 2651 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/mac_turkish.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "f490a68db5254e2034d24c782fc2d1856e13bf943b986059d2ff50593e7cd949", + "sha256_in_prefix": "f490a68db5254e2034d24c782fc2d1856e13bf943b986059d2ff50593e7cd949", + "size_in_bytes": 2385 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/mbcs.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "bb6edb6ab6f3f365c3d04f5580e4a1f41ae041655ba0cfd3bcfe3f9023abfbf5", + "sha256_in_prefix": "bb6edb6ab6f3f365c3d04f5580e4a1f41ae041655ba0cfd3bcfe3f9023abfbf5", + "size_in_bytes": 1936 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/oem.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c3c973cf13432176802d65c6b8fd1dc67a38e60b0634d7723cc535c44d530d97", + "sha256_in_prefix": "c3c973cf13432176802d65c6b8fd1dc67a38e60b0634d7723cc535c44d530d97", + "size_in_bytes": 1749 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/palmos.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "16918797f259b272180c9c512e50f9681d4cb54c9c6a94d20f578153047d1fbd", + "sha256_in_prefix": "16918797f259b272180c9c512e50f9681d4cb54c9c6a94d20f578153047d1fbd", + "size_in_bytes": 2631 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/ptcp154.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c9fc0fa81df5424a2646f14070d09c3e094c080afe6b6ea3ab2fa05759f89421", + "sha256_in_prefix": "c9fc0fa81df5424a2646f14070d09c3e094c080afe6b6ea3ab2fa05759f89421", + "size_in_bytes": 2725 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/punycode.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "d913ad9200eb306803ee99afcf00c4d161bd7fd74f221d1d8d7b2cd2e6c38890", + "sha256_in_prefix": "d913ad9200eb306803ee99afcf00c4d161bd7fd74f221d1d8d7b2cd2e6c38890", + "size_in_bytes": 6559 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/quopri_codec.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "a2fa14114fc51fe5bb7ca0290e2da8670b09b85a85fb42e7acd065803136492a", + "sha256_in_prefix": "a2fa14114fc51fe5bb7ca0290e2da8670b09b85a85fb42e7acd065803136492a", + "size_in_bytes": 2571 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/raw_unicode_escape.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "a5e453d4074b891c0805fec335115915203e2a60b587b0f495ff4af494d0faab", + "sha256_in_prefix": "a5e453d4074b891c0805fec335115915203e2a60b587b0f495ff4af494d0faab", + "size_in_bytes": 2212 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/rot_13.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c243427f4aa2bd5b8fbb810bd7f3eaa3c56e029b47ea7b1b2124763635c586ed", + "sha256_in_prefix": "c243427f4aa2bd5b8fbb810bd7f3eaa3c56e029b47ea7b1b2124763635c586ed", + "size_in_bytes": 3245 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/shift_jis.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "d06fa5da2bbc1a03da638ce3e38c2c13f07dac50c3838909644c5b022215825b", + "sha256_in_prefix": "d06fa5da2bbc1a03da638ce3e38c2c13f07dac50c3838909644c5b022215825b", + "size_in_bytes": 1630 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/shift_jis_2004.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c377d5bb4767d761f776b234931d3d7bd8cdc136fd8f546851bcfad9f063534a", + "sha256_in_prefix": "c377d5bb4767d761f776b234931d3d7bd8cdc136fd8f546851bcfad9f063534a", + "size_in_bytes": 1381 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/shift_jisx0213.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "61b39dfb695ffd349e4509d50147f96f734f59a8934790d0c2242fc7e8ea76a1", + "sha256_in_prefix": "61b39dfb695ffd349e4509d50147f96f734f59a8934790d0c2242fc7e8ea76a1", + "size_in_bytes": 1381 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/tis_620.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "6d0f8aa18bb7edafb2c24aae3e4d4442922f55d3fc9f2eaa51f9761d50e4d072", + "sha256_in_prefix": "6d0f8aa18bb7edafb2c24aae3e4d4442922f55d3fc9f2eaa51f9761d50e4d072", + "size_in_bytes": 2693 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/undefined.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "b1a8ac117fcbbbf742e6ae817201734fd1cf0b2eaa601f31a250f73d39b8c713", + "sha256_in_prefix": "b1a8ac117fcbbbf742e6ae817201734fd1cf0b2eaa601f31a250f73d39b8c713", + "size_in_bytes": 2269 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/unicode_escape.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "b7926ba86c4261dd4f2cd18137a15e9debdc04fa0cd2e01b4ce28f89f136acbb", + "sha256_in_prefix": "b7926ba86c4261dd4f2cd18137a15e9debdc04fa0cd2e01b4ce28f89f136acbb", + "size_in_bytes": 2192 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/utf_16.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "2ecc3a89b933c81504ff3a94f6616b2ddc88e315136760e4b49bad637f48cd16", + "sha256_in_prefix": "2ecc3a89b933c81504ff3a94f6616b2ddc88e315136760e4b49bad637f48cd16", + "size_in_bytes": 5098 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/utf_16_be.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "ca9c3a136da48e2166adacc2d4b61e43e5bd404da83efd0d27d7f465708b1726", + "sha256_in_prefix": "ca9c3a136da48e2166adacc2d4b61e43e5bd404da83efd0d27d7f465708b1726", + "size_in_bytes": 1871 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/utf_16_le.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "7f5f6e18eb213fdbd0689889f7d2c4503b1298a67b47d00ffbc65f84c18a642c", + "sha256_in_prefix": "7f5f6e18eb213fdbd0689889f7d2c4503b1298a67b47d00ffbc65f84c18a642c", + "size_in_bytes": 1871 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/utf_32.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "9d6aa48388c3ee9a0b0f0eac65718fabb6b7714e031f0dead8645cc104c0f558", + "sha256_in_prefix": "9d6aa48388c3ee9a0b0f0eac65718fabb6b7714e031f0dead8645cc104c0f558", + "size_in_bytes": 4991 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/utf_32_be.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "a04c8c5eaf1ad08b4e0e42e53609de257b3904cdb6b632166315ef179f05d8d7", + "sha256_in_prefix": "a04c8c5eaf1ad08b4e0e42e53609de257b3904cdb6b632166315ef179f05d8d7", + "size_in_bytes": 1764 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/utf_32_le.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "ca6d63a6e05745d36fa1ffa2746aa0b0cd36ce66cec03de51dc9dfddc1ffc97f", + "sha256_in_prefix": "ca6d63a6e05745d36fa1ffa2746aa0b0cd36ce66cec03de51dc9dfddc1ffc97f", + "size_in_bytes": 1764 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/utf_7.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "1927f5d5600ac5852c9ec3890dc6ee727433bc810986572ccdd2b484ac89b483", + "sha256_in_prefix": "1927f5d5600ac5852c9ec3890dc6ee727433bc810986572ccdd2b484ac89b483", + "size_in_bytes": 1792 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/utf_8.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "545c1e5b3381cbbfa07f97cb1016bd12812edbc3452be75866c6f672373a562d", + "sha256_in_prefix": "545c1e5b3381cbbfa07f97cb1016bd12812edbc3452be75866c6f672373a562d", + "size_in_bytes": 1851 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/utf_8_sig.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "40f9100325ca2bf28bbc0568738fb9481c1ff6b0d542b7e1e271b6375f07c7aa", + "sha256_in_prefix": "40f9100325ca2bf28bbc0568738fb9481c1ff6b0d542b7e1e271b6375f07c7aa", + "size_in_bytes": 4648 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/uu_codec.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "023468dd04207acf35186502354210fcc7b22dcf0c1699d0033518a30f7afade", + "sha256_in_prefix": "023468dd04207acf35186502354210fcc7b22dcf0c1699d0033518a30f7afade", + "size_in_bytes": 3440 + }, + { + "_path": "lib/python3.10/encodings/__pycache__/zlib_codec.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "9583eaa05864365fe955f87da7de1fac7d1d8e10860f41cc54e92b101064ec74", + "sha256_in_prefix": "9583eaa05864365fe955f87da7de1fac7d1d8e10860f41cc54e92b101064ec74", + "size_in_bytes": 2842 + }, + { + "_path": "lib/python3.10/encodings/aliases.py", + "path_type": "hardlink", + "sha256": "6fdcc49ba23a0203ae6cf28e608f8e6297d7c4d77d52e651db3cb49b9564c6d2", + "sha256_in_prefix": "6fdcc49ba23a0203ae6cf28e608f8e6297d7c4d77d52e651db3cb49b9564c6d2", + "size_in_bytes": 15677 + }, + { + "_path": "lib/python3.10/encodings/ascii.py", + "path_type": "hardlink", + "sha256": "578aa1173f7cc60dad2895071287fe6182bd14787b3fbf47a6c7983dfe3675e3", + "sha256_in_prefix": "578aa1173f7cc60dad2895071287fe6182bd14787b3fbf47a6c7983dfe3675e3", + "size_in_bytes": 1248 + }, + { + "_path": "lib/python3.10/encodings/base64_codec.py", + "path_type": "hardlink", + "sha256": "cf9ac7a464f541492486241d1b4bf33e37b45c6499275cc4d69c5a8e564e5976", + "sha256_in_prefix": "cf9ac7a464f541492486241d1b4bf33e37b45c6499275cc4d69c5a8e564e5976", + "size_in_bytes": 1533 + }, + { + "_path": "lib/python3.10/encodings/big5.py", + "path_type": "hardlink", + "sha256": "98fac6f86a20dd05da197e2058176ebfd47edee7074c3248f5f48fe0fb672d7c", + "sha256_in_prefix": "98fac6f86a20dd05da197e2058176ebfd47edee7074c3248f5f48fe0fb672d7c", + "size_in_bytes": 1019 + }, + { + "_path": "lib/python3.10/encodings/big5hkscs.py", + "path_type": "hardlink", + "sha256": "21d051a00fb5c6a86ba187e0c50e811d659ce00991fd5f5b408f71ebb2ef0f16", + "sha256_in_prefix": "21d051a00fb5c6a86ba187e0c50e811d659ce00991fd5f5b408f71ebb2ef0f16", + "size_in_bytes": 1039 + }, + { + "_path": "lib/python3.10/encodings/bz2_codec.py", + "path_type": "hardlink", + "sha256": "1181a2a89102a2b1d2b2f1f4473236d5d1ececdd0be8fdaa498a3dbe21a185ab", + "sha256_in_prefix": "1181a2a89102a2b1d2b2f1f4473236d5d1ececdd0be8fdaa498a3dbe21a185ab", + "size_in_bytes": 2249 + }, + { + "_path": "lib/python3.10/encodings/charmap.py", + "path_type": "hardlink", + "sha256": "1b8b5fdb36ce3becc62a6115ed904a17083949ec8aaef5a80f7078cec232f43b", + "sha256_in_prefix": "1b8b5fdb36ce3becc62a6115ed904a17083949ec8aaef5a80f7078cec232f43b", + "size_in_bytes": 2084 + }, + { + "_path": "lib/python3.10/encodings/cp037.py", + "path_type": "hardlink", + "sha256": "fda6ca994d710e4e0c760e0204c29a4273fc0f14ebe3169306d2eb54c9953f58", + "sha256_in_prefix": "fda6ca994d710e4e0c760e0204c29a4273fc0f14ebe3169306d2eb54c9953f58", + "size_in_bytes": 13121 + }, + { + "_path": "lib/python3.10/encodings/cp1006.py", + "path_type": "hardlink", + "sha256": "eaded38b427841bdf280e878f1e26da506e743eaa9429075332af60cce429473", + "sha256_in_prefix": "eaded38b427841bdf280e878f1e26da506e743eaa9429075332af60cce429473", + "size_in_bytes": 13568 + }, + { + "_path": "lib/python3.10/encodings/cp1026.py", + "path_type": "hardlink", + "sha256": "f5227237dd7ce5005b16a8e4d8342f0d193193c878e3cf35b9305d22b3b1aaf9", + "sha256_in_prefix": "f5227237dd7ce5005b16a8e4d8342f0d193193c878e3cf35b9305d22b3b1aaf9", + "size_in_bytes": 13113 + }, + { + "_path": "lib/python3.10/encodings/cp1125.py", + "path_type": "hardlink", + "sha256": "f84c7d30ce222e6a50cff1a4c9737173411da108cbd2c9bb57c854480103c470", + "sha256_in_prefix": "f84c7d30ce222e6a50cff1a4c9737173411da108cbd2c9bb57c854480103c470", + "size_in_bytes": 34597 + }, + { + "_path": "lib/python3.10/encodings/cp1140.py", + "path_type": "hardlink", + "sha256": "3379d78b244aa905ffe1171a968caaf41b9a0154d1ddc76c05a2abaca2b289fd", + "sha256_in_prefix": "3379d78b244aa905ffe1171a968caaf41b9a0154d1ddc76c05a2abaca2b289fd", + "size_in_bytes": 13105 + }, + { + "_path": "lib/python3.10/encodings/cp1250.py", + "path_type": "hardlink", + "sha256": "ebcec1adf9167863fb0bab29708c546300c80a77ef07838c9e0437a59e265970", + "sha256_in_prefix": "ebcec1adf9167863fb0bab29708c546300c80a77ef07838c9e0437a59e265970", + "size_in_bytes": 13686 + }, + { + "_path": "lib/python3.10/encodings/cp1251.py", + "path_type": "hardlink", + "sha256": "d57f8cfa34494c5acb6692ddb31f616ae2dd89a075d2af6d36b0b7ec2ffe7af1", + "sha256_in_prefix": "d57f8cfa34494c5acb6692ddb31f616ae2dd89a075d2af6d36b0b7ec2ffe7af1", + "size_in_bytes": 13361 + }, + { + "_path": "lib/python3.10/encodings/cp1252.py", + "path_type": "hardlink", + "sha256": "19aa5bee667f5fb387924a813aec9fa1dda47769d09e8483a748bdb202be6a84", + "sha256_in_prefix": "19aa5bee667f5fb387924a813aec9fa1dda47769d09e8483a748bdb202be6a84", + "size_in_bytes": 13511 + }, + { + "_path": "lib/python3.10/encodings/cp1253.py", + "path_type": "hardlink", + "sha256": "8c27696dcfb6894b378869bc89f113703fbd1e9b13a83934463d5999b055d1e8", + "sha256_in_prefix": "8c27696dcfb6894b378869bc89f113703fbd1e9b13a83934463d5999b055d1e8", + "size_in_bytes": 13094 + }, + { + "_path": "lib/python3.10/encodings/cp1254.py", + "path_type": "hardlink", + "sha256": "06517ec2f74f1c6562d0a1a500c48ba43f2e6e9d0c3d28356d747f274f1a4c8d", + "sha256_in_prefix": "06517ec2f74f1c6562d0a1a500c48ba43f2e6e9d0c3d28356d747f274f1a4c8d", + "size_in_bytes": 13502 + }, + { + "_path": "lib/python3.10/encodings/cp1255.py", + "path_type": "hardlink", + "sha256": "54a1b5087578fa78e5bdd0afa6a9e80e8c5467c1e4226cf6e586cfe7a674a653", + "sha256_in_prefix": "54a1b5087578fa78e5bdd0afa6a9e80e8c5467c1e4226cf6e586cfe7a674a653", + "size_in_bytes": 12466 + }, + { + "_path": "lib/python3.10/encodings/cp1256.py", + "path_type": "hardlink", + "sha256": "ad3768ac2fef2a646b3301c20af705f4d4a1544f22fa8a84241bada27ab84133", + "sha256_in_prefix": "ad3768ac2fef2a646b3301c20af705f4d4a1544f22fa8a84241bada27ab84133", + "size_in_bytes": 12814 + }, + { + "_path": "lib/python3.10/encodings/cp1257.py", + "path_type": "hardlink", + "sha256": "d9149d2925b3f719809ef2297e541461079f15c658af207a3e498be314ab2c6b", + "sha256_in_prefix": "d9149d2925b3f719809ef2297e541461079f15c658af207a3e498be314ab2c6b", + "size_in_bytes": 13374 + }, + { + "_path": "lib/python3.10/encodings/cp1258.py", + "path_type": "hardlink", + "sha256": "672e05b51952a82c8dbd5603769195fcedf565e457bb86c0d5bae04955d04630", + "sha256_in_prefix": "672e05b51952a82c8dbd5603769195fcedf565e457bb86c0d5bae04955d04630", + "size_in_bytes": 13364 + }, + { + "_path": "lib/python3.10/encodings/cp273.py", + "path_type": "hardlink", + "sha256": "6c6aec3b213ea3aebc2c526dd4d121c95d4a25a2fc928a87cd80f8448988185f", + "sha256_in_prefix": "6c6aec3b213ea3aebc2c526dd4d121c95d4a25a2fc928a87cd80f8448988185f", + "size_in_bytes": 14132 + }, + { + "_path": "lib/python3.10/encodings/cp424.py", + "path_type": "hardlink", + "sha256": "30414c2186ea0802bbf3db034122ddec1f8a10061b97c50871e14b74ee36d0ca", + "sha256_in_prefix": "30414c2186ea0802bbf3db034122ddec1f8a10061b97c50871e14b74ee36d0ca", + "size_in_bytes": 12055 + }, + { + "_path": "lib/python3.10/encodings/cp437.py", + "path_type": "hardlink", + "sha256": "5c2a5015cd36cf7f561269f33dec4c323093d3d88b0673969accdabdcb9ce2cb", + "sha256_in_prefix": "5c2a5015cd36cf7f561269f33dec4c323093d3d88b0673969accdabdcb9ce2cb", + "size_in_bytes": 34564 + }, + { + "_path": "lib/python3.10/encodings/cp500.py", + "path_type": "hardlink", + "sha256": "630f503f9110d98ea3e1529f2f965ebc275a2f78d3de47f8e9b69d35589d764b", + "sha256_in_prefix": "630f503f9110d98ea3e1529f2f965ebc275a2f78d3de47f8e9b69d35589d764b", + "size_in_bytes": 13121 + }, + { + "_path": "lib/python3.10/encodings/cp720.py", + "path_type": "hardlink", + "sha256": "395496001271b92efe5df07fc0ae7c3410d1dd2bdfebbd3e4d8e806c8166beb0", + "sha256_in_prefix": "395496001271b92efe5df07fc0ae7c3410d1dd2bdfebbd3e4d8e806c8166beb0", + "size_in_bytes": 13686 + }, + { + "_path": "lib/python3.10/encodings/cp737.py", + "path_type": "hardlink", + "sha256": "be3ca1785a3970ec62310710eaf7de82932181b04d06fe4528f8adaba9fb8c4b", + "sha256_in_prefix": "be3ca1785a3970ec62310710eaf7de82932181b04d06fe4528f8adaba9fb8c4b", + "size_in_bytes": 34681 + }, + { + "_path": "lib/python3.10/encodings/cp775.py", + "path_type": "hardlink", + "sha256": "e0dba85b99329d7f16907e620adada06be5216abcb964406c827b569b2cf1aeb", + "sha256_in_prefix": "e0dba85b99329d7f16907e620adada06be5216abcb964406c827b569b2cf1aeb", + "size_in_bytes": 34476 + }, + { + "_path": "lib/python3.10/encodings/cp850.py", + "path_type": "hardlink", + "sha256": "257e29f235e2a8790dd68cee45668776648bab809ce8584f893cdd8fd007993c", + "sha256_in_prefix": "257e29f235e2a8790dd68cee45668776648bab809ce8584f893cdd8fd007993c", + "size_in_bytes": 34105 + }, + { + "_path": "lib/python3.10/encodings/cp852.py", + "path_type": "hardlink", + "sha256": "cc6faaa9dc4a933127da0aaacd1dc7a44c09266051af56bfe3215ff228636b6b", + "sha256_in_prefix": "cc6faaa9dc4a933127da0aaacd1dc7a44c09266051af56bfe3215ff228636b6b", + "size_in_bytes": 35002 + }, + { + "_path": "lib/python3.10/encodings/cp855.py", + "path_type": "hardlink", + "sha256": "7b25c61c9e8c47b218d3fbb801541a2861926ac712843d2113fff90e2074f5ba", + "sha256_in_prefix": "7b25c61c9e8c47b218d3fbb801541a2861926ac712843d2113fff90e2074f5ba", + "size_in_bytes": 33850 + }, + { + "_path": "lib/python3.10/encodings/cp856.py", + "path_type": "hardlink", + "sha256": "2e52ec5cb1eafa6739b5569b0b98ee89df5f7358b84ccdc8da64e86f017d359f", + "sha256_in_prefix": "2e52ec5cb1eafa6739b5569b0b98ee89df5f7358b84ccdc8da64e86f017d359f", + "size_in_bytes": 12423 + }, + { + "_path": "lib/python3.10/encodings/cp857.py", + "path_type": "hardlink", + "sha256": "8d1b769058bfccdb3c6c70c49a104f5081a2fcc9fad68f7b5eb3e4f67f0b33da", + "sha256_in_prefix": "8d1b769058bfccdb3c6c70c49a104f5081a2fcc9fad68f7b5eb3e4f67f0b33da", + "size_in_bytes": 33908 + }, + { + "_path": "lib/python3.10/encodings/cp858.py", + "path_type": "hardlink", + "sha256": "a24930c4a6ad0ff66dde9a69f2027e4b92c2c9c61dcda2992e940654c606577b", + "sha256_in_prefix": "a24930c4a6ad0ff66dde9a69f2027e4b92c2c9c61dcda2992e940654c606577b", + "size_in_bytes": 34015 + }, + { + "_path": "lib/python3.10/encodings/cp860.py", + "path_type": "hardlink", + "sha256": "2dfae7e31d3d9aa3013cff44a4d7ad842f257ac63765a9998436701b629cd86a", + "sha256_in_prefix": "2dfae7e31d3d9aa3013cff44a4d7ad842f257ac63765a9998436701b629cd86a", + "size_in_bytes": 34681 + }, + { + "_path": "lib/python3.10/encodings/cp861.py", + "path_type": "hardlink", + "sha256": "701930d77a2177497586e99bc3fe60f2d4beffb645608f167c76874a72ff405e", + "sha256_in_prefix": "701930d77a2177497586e99bc3fe60f2d4beffb645608f167c76874a72ff405e", + "size_in_bytes": 34633 + }, + { + "_path": "lib/python3.10/encodings/cp862.py", + "path_type": "hardlink", + "sha256": "15a2844b6ed9544c6400cf7299b42d0c2bef93c9bee70a9e89f66b8610ad6d6d", + "sha256_in_prefix": "15a2844b6ed9544c6400cf7299b42d0c2bef93c9bee70a9e89f66b8610ad6d6d", + "size_in_bytes": 33370 + }, + { + "_path": "lib/python3.10/encodings/cp863.py", + "path_type": "hardlink", + "sha256": "a3d57f61fce1b98fc81ea8e4ebebaf402fae40bbcdd35d4b8297b9bb49a79aa2", + "sha256_in_prefix": "a3d57f61fce1b98fc81ea8e4ebebaf402fae40bbcdd35d4b8297b9bb49a79aa2", + "size_in_bytes": 34252 + }, + { + "_path": "lib/python3.10/encodings/cp864.py", + "path_type": "hardlink", + "sha256": "15ad8f1fdfdd842c7522241372e7eddda7df687e815692a89157c5f256f21a08", + "sha256_in_prefix": "15ad8f1fdfdd842c7522241372e7eddda7df687e815692a89157c5f256f21a08", + "size_in_bytes": 33663 + }, + { + "_path": "lib/python3.10/encodings/cp865.py", + "path_type": "hardlink", + "sha256": "bdbaded987242ed2a8de7133ec2f61ddcc1c2e9de27816ab7cd0a4c678a3a907", + "sha256_in_prefix": "bdbaded987242ed2a8de7133ec2f61ddcc1c2e9de27816ab7cd0a4c678a3a907", + "size_in_bytes": 34618 + }, + { + "_path": "lib/python3.10/encodings/cp866.py", + "path_type": "hardlink", + "sha256": "9efcc8e85bbd1687272a0991f6d0429a4c06679db2d114b2ac95db27a70f9d13", + "sha256_in_prefix": "9efcc8e85bbd1687272a0991f6d0429a4c06679db2d114b2ac95db27a70f9d13", + "size_in_bytes": 34396 + }, + { + "_path": "lib/python3.10/encodings/cp869.py", + "path_type": "hardlink", + "sha256": "52582d9fb769b24eac7154f18d7dae856588297d6da98f37fb5efd8da883826d", + "sha256_in_prefix": "52582d9fb769b24eac7154f18d7dae856588297d6da98f37fb5efd8da883826d", + "size_in_bytes": 32965 + }, + { + "_path": "lib/python3.10/encodings/cp874.py", + "path_type": "hardlink", + "sha256": "fe4752fa2e65741e08a563a31ff914fe71068942ce9c6f4070b1dfd7b25e5e7f", + "sha256_in_prefix": "fe4752fa2e65741e08a563a31ff914fe71068942ce9c6f4070b1dfd7b25e5e7f", + "size_in_bytes": 12595 + }, + { + "_path": "lib/python3.10/encodings/cp875.py", + "path_type": "hardlink", + "sha256": "2fe72632015db2cba2bb4367055551da6fe22051b96d170c7b96fa271c46b257", + "sha256_in_prefix": "2fe72632015db2cba2bb4367055551da6fe22051b96d170c7b96fa271c46b257", + "size_in_bytes": 12854 + }, + { + "_path": "lib/python3.10/encodings/cp932.py", + "path_type": "hardlink", + "sha256": "99748e28113d2d49f5d666b49b78accd2c6e10a7852f7dd6dece9b5b71aa83c4", + "sha256_in_prefix": "99748e28113d2d49f5d666b49b78accd2c6e10a7852f7dd6dece9b5b71aa83c4", + "size_in_bytes": 1023 + }, + { + "_path": "lib/python3.10/encodings/cp949.py", + "path_type": "hardlink", + "sha256": "950a7d29467ce0590b4a1137830d43d88d8f20e4035dcaaa8b2a5c3c3f1de962", + "sha256_in_prefix": "950a7d29467ce0590b4a1137830d43d88d8f20e4035dcaaa8b2a5c3c3f1de962", + "size_in_bytes": 1023 + }, + { + "_path": "lib/python3.10/encodings/cp950.py", + "path_type": "hardlink", + "sha256": "27811178b450731fc955b1247656a605d04e5ee98e0d585e4596b94b703a27f6", + "sha256_in_prefix": "27811178b450731fc955b1247656a605d04e5ee98e0d585e4596b94b703a27f6", + "size_in_bytes": 1023 + }, + { + "_path": "lib/python3.10/encodings/euc_jis_2004.py", + "path_type": "hardlink", + "sha256": "9fa426cd9f17629f6320700ed18baa94839304cf1bcabbee7edb501747dc055d", + "sha256_in_prefix": "9fa426cd9f17629f6320700ed18baa94839304cf1bcabbee7edb501747dc055d", + "size_in_bytes": 1051 + }, + { + "_path": "lib/python3.10/encodings/euc_jisx0213.py", + "path_type": "hardlink", + "sha256": "e28315910da20218dae8b7d5becd81de1e283dfd8b0415a4980d67065de73a0b", + "sha256_in_prefix": "e28315910da20218dae8b7d5becd81de1e283dfd8b0415a4980d67065de73a0b", + "size_in_bytes": 1051 + }, + { + "_path": "lib/python3.10/encodings/euc_jp.py", + "path_type": "hardlink", + "sha256": "b453a439787b0efa031e43416a7d852a6be705c985e1200693eb96d87ea79cdc", + "sha256_in_prefix": "b453a439787b0efa031e43416a7d852a6be705c985e1200693eb96d87ea79cdc", + "size_in_bytes": 1027 + }, + { + "_path": "lib/python3.10/encodings/euc_kr.py", + "path_type": "hardlink", + "sha256": "633a1a5504bfad04b1ec9c96d44d4ebb3bb99066a218318e7d67d866e20887a6", + "sha256_in_prefix": "633a1a5504bfad04b1ec9c96d44d4ebb3bb99066a218318e7d67d866e20887a6", + "size_in_bytes": 1027 + }, + { + "_path": "lib/python3.10/encodings/gb18030.py", + "path_type": "hardlink", + "sha256": "6c10b4dc49bc63724e539137ede6936304fcca1c97c28d16d89f381e10849521", + "sha256_in_prefix": "6c10b4dc49bc63724e539137ede6936304fcca1c97c28d16d89f381e10849521", + "size_in_bytes": 1031 + }, + { + "_path": "lib/python3.10/encodings/gb2312.py", + "path_type": "hardlink", + "sha256": "3d2d567d8d079b78f3f3b566ed52ad2f38af61bf832b7dc28858b0039a032d6b", + "sha256_in_prefix": "3d2d567d8d079b78f3f3b566ed52ad2f38af61bf832b7dc28858b0039a032d6b", + "size_in_bytes": 1027 + }, + { + "_path": "lib/python3.10/encodings/gbk.py", + "path_type": "hardlink", + "sha256": "eff9b8cbc9ad2ef2e10e96afa83d3db1f775ea044aed275b7a35574ae0d8645b", + "sha256_in_prefix": "eff9b8cbc9ad2ef2e10e96afa83d3db1f775ea044aed275b7a35574ae0d8645b", + "size_in_bytes": 1015 + }, + { + "_path": "lib/python3.10/encodings/hex_codec.py", + "path_type": "hardlink", + "sha256": "fc5f0a31b59efe990b86efb98936769f33dd91d912ce55b49a5a4cfc516cd047", + "sha256_in_prefix": "fc5f0a31b59efe990b86efb98936769f33dd91d912ce55b49a5a4cfc516cd047", + "size_in_bytes": 1508 + }, + { + "_path": "lib/python3.10/encodings/hp_roman8.py", + "path_type": "hardlink", + "sha256": "c43cce763d12e8f71a63dbc16641bd87147eaf5f9d9054ea856864b216b2735b", + "sha256_in_prefix": "c43cce763d12e8f71a63dbc16641bd87147eaf5f9d9054ea856864b216b2735b", + "size_in_bytes": 13475 + }, + { + "_path": "lib/python3.10/encodings/hz.py", + "path_type": "hardlink", + "sha256": "025a9531e3046e52d3e039c0be04f9a5a74651d7683a13c7c7ebd4c7dfb5996a", + "sha256_in_prefix": "025a9531e3046e52d3e039c0be04f9a5a74651d7683a13c7c7ebd4c7dfb5996a", + "size_in_bytes": 1011 + }, + { + "_path": "lib/python3.10/encodings/idna.py", + "path_type": "hardlink", + "sha256": "4fc5a79f53d60fd0576f94dfe8aa7677357d9ad95315ea220ba523f53c89229b", + "sha256_in_prefix": "4fc5a79f53d60fd0576f94dfe8aa7677357d9ad95315ea220ba523f53c89229b", + "size_in_bytes": 9098 + }, + { + "_path": "lib/python3.10/encodings/iso2022_jp.py", + "path_type": "hardlink", + "sha256": "461a0e7f72eccb8b29f351c4e7926cfbda58e0edd6d0770bd82e0b36c5febe77", + "sha256_in_prefix": "461a0e7f72eccb8b29f351c4e7926cfbda58e0edd6d0770bd82e0b36c5febe77", + "size_in_bytes": 1053 + }, + { + "_path": "lib/python3.10/encodings/iso2022_jp_1.py", + "path_type": "hardlink", + "sha256": "63bacad13a979a5519fcaa4f1e1e07b2c7415005167fac3a689408c7d886fabd", + "sha256_in_prefix": "63bacad13a979a5519fcaa4f1e1e07b2c7415005167fac3a689408c7d886fabd", + "size_in_bytes": 1061 + }, + { + "_path": "lib/python3.10/encodings/iso2022_jp_2.py", + "path_type": "hardlink", + "sha256": "5d4248181548b0fc89a9f5ee9cf52ebecb235708ba87d47896ad14130884ef9f", + "sha256_in_prefix": "5d4248181548b0fc89a9f5ee9cf52ebecb235708ba87d47896ad14130884ef9f", + "size_in_bytes": 1061 + }, + { + "_path": "lib/python3.10/encodings/iso2022_jp_2004.py", + "path_type": "hardlink", + "sha256": "b4d1468bcd608b46f38cb0c6ef115510dcf9aa0f71e590792f407efc6e165164", + "sha256_in_prefix": "b4d1468bcd608b46f38cb0c6ef115510dcf9aa0f71e590792f407efc6e165164", + "size_in_bytes": 1073 + }, + { + "_path": "lib/python3.10/encodings/iso2022_jp_3.py", + "path_type": "hardlink", + "sha256": "3aceaa5661909de14e2861d864443b8472460ce39b99cce5c6965346d47aa5ac", + "sha256_in_prefix": "3aceaa5661909de14e2861d864443b8472460ce39b99cce5c6965346d47aa5ac", + "size_in_bytes": 1061 + }, + { + "_path": "lib/python3.10/encodings/iso2022_jp_ext.py", + "path_type": "hardlink", + "sha256": "f4c9ed8f3031995faa224bcb10153d2b6144944477d1f27d1a6cc4a879fac34c", + "sha256_in_prefix": "f4c9ed8f3031995faa224bcb10153d2b6144944477d1f27d1a6cc4a879fac34c", + "size_in_bytes": 1069 + }, + { + "_path": "lib/python3.10/encodings/iso2022_kr.py", + "path_type": "hardlink", + "sha256": "1c86362e17944f0bcf68db02f4995bdeea605867795fff7ab4079073f96705e4", + "sha256_in_prefix": "1c86362e17944f0bcf68db02f4995bdeea605867795fff7ab4079073f96705e4", + "size_in_bytes": 1053 + }, + { + "_path": "lib/python3.10/encodings/iso8859_1.py", + "path_type": "hardlink", + "sha256": "b5cebd515e057d670bf54e10b8a6f162ef3daa7f21b146aee3249160caf3c32d", + "sha256_in_prefix": "b5cebd515e057d670bf54e10b8a6f162ef3daa7f21b146aee3249160caf3c32d", + "size_in_bytes": 13176 + }, + { + "_path": "lib/python3.10/encodings/iso8859_10.py", + "path_type": "hardlink", + "sha256": "54c886b41819ebb7f4fb34b8dbae1c45f4fc0864f019ecd772676ccfac5fae7b", + "sha256_in_prefix": "54c886b41819ebb7f4fb34b8dbae1c45f4fc0864f019ecd772676ccfac5fae7b", + "size_in_bytes": 13589 + }, + { + "_path": "lib/python3.10/encodings/iso8859_11.py", + "path_type": "hardlink", + "sha256": "ed5a964470a241b4da7a6cfb718e4149d09644933af38f0497602baab6e563ef", + "sha256_in_prefix": "ed5a964470a241b4da7a6cfb718e4149d09644933af38f0497602baab6e563ef", + "size_in_bytes": 12335 + }, + { + "_path": "lib/python3.10/encodings/iso8859_13.py", + "path_type": "hardlink", + "sha256": "7312237e8e5d201d920b4130f057cfdf1b0be9baafaa246826e6d93204fcc206", + "sha256_in_prefix": "7312237e8e5d201d920b4130f057cfdf1b0be9baafaa246826e6d93204fcc206", + "size_in_bytes": 13271 + }, + { + "_path": "lib/python3.10/encodings/iso8859_14.py", + "path_type": "hardlink", + "sha256": "82778b995a0ee87c5f1180fcc52900359eee15bd9a6e3a0e25f0d963e0b2a343", + "sha256_in_prefix": "82778b995a0ee87c5f1180fcc52900359eee15bd9a6e3a0e25f0d963e0b2a343", + "size_in_bytes": 13652 + }, + { + "_path": "lib/python3.10/encodings/iso8859_15.py", + "path_type": "hardlink", + "sha256": "01976a81811873dc9a0c79db9fc00d1c30103487f3c6bc3a6d81b4043cd48e02", + "sha256_in_prefix": "01976a81811873dc9a0c79db9fc00d1c30103487f3c6bc3a6d81b4043cd48e02", + "size_in_bytes": 13212 + }, + { + "_path": "lib/python3.10/encodings/iso8859_16.py", + "path_type": "hardlink", + "sha256": "b5ac8f5a5d8f84c0f903b2b7c342184758d590d8bcf810d561f942fe5b372d66", + "sha256_in_prefix": "b5ac8f5a5d8f84c0f903b2b7c342184758d590d8bcf810d561f942fe5b372d66", + "size_in_bytes": 13557 + }, + { + "_path": "lib/python3.10/encodings/iso8859_2.py", + "path_type": "hardlink", + "sha256": "2b57cab6111cae9021505e3ae1b2adbbfc344ec48165fda322f6b069fbb18adc", + "sha256_in_prefix": "2b57cab6111cae9021505e3ae1b2adbbfc344ec48165fda322f6b069fbb18adc", + "size_in_bytes": 13404 + }, + { + "_path": "lib/python3.10/encodings/iso8859_3.py", + "path_type": "hardlink", + "sha256": "4ffdf89004bf0c5230caa7079f7ca3142fc112f8b923ddb2c7358369d2d3c242", + "sha256_in_prefix": "4ffdf89004bf0c5230caa7079f7ca3142fc112f8b923ddb2c7358369d2d3c242", + "size_in_bytes": 13089 + }, + { + "_path": "lib/python3.10/encodings/iso8859_4.py", + "path_type": "hardlink", + "sha256": "87bd130daa0eaef3e4cb465e10cffb2bcd194ff74097e0c186b4b8eb7be41ac5", + "sha256_in_prefix": "87bd130daa0eaef3e4cb465e10cffb2bcd194ff74097e0c186b4b8eb7be41ac5", + "size_in_bytes": 13376 + }, + { + "_path": "lib/python3.10/encodings/iso8859_5.py", + "path_type": "hardlink", + "sha256": "9961d96cc7b9fdf011ebcaaeaeca7b50b8670fadbd7b75fde66192f8c1f68f30", + "sha256_in_prefix": "9961d96cc7b9fdf011ebcaaeaeca7b50b8670fadbd7b75fde66192f8c1f68f30", + "size_in_bytes": 13015 + }, + { + "_path": "lib/python3.10/encodings/iso8859_6.py", + "path_type": "hardlink", + "sha256": "4840e68014346517680f593ca22f67133c39ba7e46f34b9be62c980a728448c6", + "sha256_in_prefix": "4840e68014346517680f593ca22f67133c39ba7e46f34b9be62c980a728448c6", + "size_in_bytes": 10833 + }, + { + "_path": "lib/python3.10/encodings/iso8859_7.py", + "path_type": "hardlink", + "sha256": "b352eca3b819488f64fb3338fd93f39c1e30f32bb13f2f9c577925e58f2960e4", + "sha256_in_prefix": "b352eca3b819488f64fb3338fd93f39c1e30f32bb13f2f9c577925e58f2960e4", + "size_in_bytes": 12844 + }, + { + "_path": "lib/python3.10/encodings/iso8859_8.py", + "path_type": "hardlink", + "sha256": "4cf9e8a8bbe04accb1c1a80853efb19ae0772d18f81e270adefc1b2386cb368e", + "sha256_in_prefix": "4cf9e8a8bbe04accb1c1a80853efb19ae0772d18f81e270adefc1b2386cb368e", + "size_in_bytes": 11036 + }, + { + "_path": "lib/python3.10/encodings/iso8859_9.py", + "path_type": "hardlink", + "sha256": "84d9b15263e81685f7513c5ab45caf80b2f73c301c68e659f7162c1b1882d359", + "sha256_in_prefix": "84d9b15263e81685f7513c5ab45caf80b2f73c301c68e659f7162c1b1882d359", + "size_in_bytes": 13156 + }, + { + "_path": "lib/python3.10/encodings/johab.py", + "path_type": "hardlink", + "sha256": "9586615917afd3d848c1c4328656603b2834af6115f2aec932fccc935e1a60fb", + "sha256_in_prefix": "9586615917afd3d848c1c4328656603b2834af6115f2aec932fccc935e1a60fb", + "size_in_bytes": 1023 + }, + { + "_path": "lib/python3.10/encodings/koi8_r.py", + "path_type": "hardlink", + "sha256": "4d4e353aee8039bb71e2145a6e68fe1e6833a1b4250b70ee0ac5ec70bbb8c51d", + "sha256_in_prefix": "4d4e353aee8039bb71e2145a6e68fe1e6833a1b4250b70ee0ac5ec70bbb8c51d", + "size_in_bytes": 13779 + }, + { + "_path": "lib/python3.10/encodings/koi8_t.py", + "path_type": "hardlink", + "sha256": "9c9043814abdbe7dc39ff98f3857d5d110a84c978ad2304158d810a4e9eacef1", + "sha256_in_prefix": "9c9043814abdbe7dc39ff98f3857d5d110a84c978ad2304158d810a4e9eacef1", + "size_in_bytes": 13193 + }, + { + "_path": "lib/python3.10/encodings/koi8_u.py", + "path_type": "hardlink", + "sha256": "d449f9858e357fa8c2edbd4b9fe739337e9f201cac3ded20f99bfcecd4970ff7", + "sha256_in_prefix": "d449f9858e357fa8c2edbd4b9fe739337e9f201cac3ded20f99bfcecd4970ff7", + "size_in_bytes": 13762 + }, + { + "_path": "lib/python3.10/encodings/kz1048.py", + "path_type": "hardlink", + "sha256": "76beb30e98a911f72f97609a2373782573c17c88a5fb3537db338aa382979ffc", + "sha256_in_prefix": "76beb30e98a911f72f97609a2373782573c17c88a5fb3537db338aa382979ffc", + "size_in_bytes": 13723 + }, + { + "_path": "lib/python3.10/encodings/latin_1.py", + "path_type": "hardlink", + "sha256": "b75503e532a27c636477396c855209ff5f3036536d2a4bede0a576c89382b60c", + "sha256_in_prefix": "b75503e532a27c636477396c855209ff5f3036536d2a4bede0a576c89382b60c", + "size_in_bytes": 1264 + }, + { + "_path": "lib/python3.10/encodings/mac_arabic.py", + "path_type": "hardlink", + "sha256": "5eafd9a3136abfbd8ed52df9c90203c7a283e7429ed60502a87a02511e0fb777", + "sha256_in_prefix": "5eafd9a3136abfbd8ed52df9c90203c7a283e7429ed60502a87a02511e0fb777", + "size_in_bytes": 36467 + }, + { + "_path": "lib/python3.10/encodings/mac_croatian.py", + "path_type": "hardlink", + "sha256": "a880cd05c82a8d11a29c65ee86a396def3344465dd71441b0bb4a73826024953", + "sha256_in_prefix": "a880cd05c82a8d11a29c65ee86a396def3344465dd71441b0bb4a73826024953", + "size_in_bytes": 13633 + }, + { + "_path": "lib/python3.10/encodings/mac_cyrillic.py", + "path_type": "hardlink", + "sha256": "83616786a1c6308b03a0dc82536908d24d0974b2248d67393d613fe558cea4bd", + "sha256_in_prefix": "83616786a1c6308b03a0dc82536908d24d0974b2248d67393d613fe558cea4bd", + "size_in_bytes": 13454 + }, + { + "_path": "lib/python3.10/encodings/mac_farsi.py", + "path_type": "hardlink", + "sha256": "f5763c38fb4ab0423fafe2fdca34d6f9932ac7f1a74c0cd8109d60234c7dc624", + "sha256_in_prefix": "f5763c38fb4ab0423fafe2fdca34d6f9932ac7f1a74c0cd8109d60234c7dc624", + "size_in_bytes": 15170 + }, + { + "_path": "lib/python3.10/encodings/mac_greek.py", + "path_type": "hardlink", + "sha256": "63016a323ddf98cb3aa9cfa78f3bab4768bedbfe9a5262a36a5aecb13d291f6e", + "sha256_in_prefix": "63016a323ddf98cb3aa9cfa78f3bab4768bedbfe9a5262a36a5aecb13d291f6e", + "size_in_bytes": 13721 + }, + { + "_path": "lib/python3.10/encodings/mac_iceland.py", + "path_type": "hardlink", + "sha256": "753cc1ac635caa7e1b4630fbcebef8db8db332c098154a5b11f652912bf64f37", + "sha256_in_prefix": "753cc1ac635caa7e1b4630fbcebef8db8db332c098154a5b11f652912bf64f37", + "size_in_bytes": 13498 + }, + { + "_path": "lib/python3.10/encodings/mac_latin2.py", + "path_type": "hardlink", + "sha256": "31670da18ce8b5394cd53fe6bf216268e7e8eae4c0247532e420e2e103727d50", + "sha256_in_prefix": "31670da18ce8b5394cd53fe6bf216268e7e8eae4c0247532e420e2e103727d50", + "size_in_bytes": 14118 + }, + { + "_path": "lib/python3.10/encodings/mac_roman.py", + "path_type": "hardlink", + "sha256": "230367d96aef8e8d7f185b4acfb84923714f39ddbcbf9cf38a06bf6f5d621c22", + "sha256_in_prefix": "230367d96aef8e8d7f185b4acfb84923714f39ddbcbf9cf38a06bf6f5d621c22", + "size_in_bytes": 13480 + }, + { + "_path": "lib/python3.10/encodings/mac_romanian.py", + "path_type": "hardlink", + "sha256": "49630cf035c19e896a123ed6e5fee18b5e485123daf2f15da38bf727ff387bee", + "sha256_in_prefix": "49630cf035c19e896a123ed6e5fee18b5e485123daf2f15da38bf727ff387bee", + "size_in_bytes": 13661 + }, + { + "_path": "lib/python3.10/encodings/mac_turkish.py", + "path_type": "hardlink", + "sha256": "99758a5cad2825cb3be3fa5d031e0821e4eba910a46f417fd890207b9b6be77b", + "sha256_in_prefix": "99758a5cad2825cb3be3fa5d031e0821e4eba910a46f417fd890207b9b6be77b", + "size_in_bytes": 13513 + }, + { + "_path": "lib/python3.10/encodings/mbcs.py", + "path_type": "hardlink", + "sha256": "f6ed445ed537c9f856d8defe8b56505727737d0dc9348d0a877abedab4bdd864", + "sha256_in_prefix": "f6ed445ed537c9f856d8defe8b56505727737d0dc9348d0a877abedab4bdd864", + "size_in_bytes": 1211 + }, + { + "_path": "lib/python3.10/encodings/oem.py", + "path_type": "hardlink", + "sha256": "481656d3a35f792d0e5109e3f821e6dbfcf097163a19b0cdfcbff3b3db99292f", + "sha256_in_prefix": "481656d3a35f792d0e5109e3f821e6dbfcf097163a19b0cdfcbff3b3db99292f", + "size_in_bytes": 1019 + }, + { + "_path": "lib/python3.10/encodings/palmos.py", + "path_type": "hardlink", + "sha256": "eccf7418adefcc2a59e9a07fc4e34363bd62f7e878d48c8a02730a8ed1c584c8", + "sha256_in_prefix": "eccf7418adefcc2a59e9a07fc4e34363bd62f7e878d48c8a02730a8ed1c584c8", + "size_in_bytes": 13519 + }, + { + "_path": "lib/python3.10/encodings/ptcp154.py", + "path_type": "hardlink", + "sha256": "0eabcb2c287d335e86b71b0abe5718bd6ddc9aaee234f0f0f2363845d2926d8d", + "sha256_in_prefix": "0eabcb2c287d335e86b71b0abe5718bd6ddc9aaee234f0f0f2363845d2926d8d", + "size_in_bytes": 14015 + }, + { + "_path": "lib/python3.10/encodings/punycode.py", + "path_type": "hardlink", + "sha256": "34edc8fb1c50e4d1cbaa1e008bb491cd7c12116c316e51974f333fe7b628eb7c", + "sha256_in_prefix": "34edc8fb1c50e4d1cbaa1e008bb491cd7c12116c316e51974f333fe7b628eb7c", + "size_in_bytes": 6883 + }, + { + "_path": "lib/python3.10/encodings/quopri_codec.py", + "path_type": "hardlink", + "sha256": "502a213c34c05a94ed063ee03f47680bd6efbb35036e06fb4dc809bf398cfa64", + "sha256_in_prefix": "502a213c34c05a94ed063ee03f47680bd6efbb35036e06fb4dc809bf398cfa64", + "size_in_bytes": 1525 + }, + { + "_path": "lib/python3.10/encodings/raw_unicode_escape.py", + "path_type": "hardlink", + "sha256": "fa6328486b8f5a5cbd10e377e80adb8cf94acbbe19c38b4e1bf708d831a80a3a", + "sha256_in_prefix": "fa6328486b8f5a5cbd10e377e80adb8cf94acbbe19c38b4e1bf708d831a80a3a", + "size_in_bytes": 1332 + }, + { + "_path": "lib/python3.10/encodings/rot_13.py", + "path_type": "hardlink", + "sha256": "14767f475acdc0bf48e6272280dd15b80efaecafb93c06be21136f83dd1ee7e4", + "sha256_in_prefix": "14767f475acdc0bf48e6272280dd15b80efaecafb93c06be21136f83dd1ee7e4", + "size_in_bytes": 2448 + }, + { + "_path": "lib/python3.10/encodings/shift_jis.py", + "path_type": "hardlink", + "sha256": "ad4ac50ebf58294304e412cc0f1b12980988dd6edc414e4110029c0a1abbe966", + "sha256_in_prefix": "ad4ac50ebf58294304e412cc0f1b12980988dd6edc414e4110029c0a1abbe966", + "size_in_bytes": 1039 + }, + { + "_path": "lib/python3.10/encodings/shift_jis_2004.py", + "path_type": "hardlink", + "sha256": "d21c5930f21063ea78fea3b0f76dfb8fd92858d2a4a200064a52126a43dd1a99", + "sha256_in_prefix": "d21c5930f21063ea78fea3b0f76dfb8fd92858d2a4a200064a52126a43dd1a99", + "size_in_bytes": 1059 + }, + { + "_path": "lib/python3.10/encodings/shift_jisx0213.py", + "path_type": "hardlink", + "sha256": "2c8d0b93bb36edf31c1236b1b4d1c0008553868bd2fc9137570115b96b834f2e", + "sha256_in_prefix": "2c8d0b93bb36edf31c1236b1b4d1c0008553868bd2fc9137570115b96b834f2e", + "size_in_bytes": 1059 + }, + { + "_path": "lib/python3.10/encodings/tis_620.py", + "path_type": "hardlink", + "sha256": "647c4719e2c1a7375105e15a89b377c66f6b699977dcabbb71d923a4607b7902", + "sha256_in_prefix": "647c4719e2c1a7375105e15a89b377c66f6b699977dcabbb71d923a4607b7902", + "size_in_bytes": 12300 + }, + { + "_path": "lib/python3.10/encodings/undefined.py", + "path_type": "hardlink", + "sha256": "85bba5c5e1007cd8c1ade5c0214bcc825396d2bbd02054e62a9f162104748b64", + "sha256_in_prefix": "85bba5c5e1007cd8c1ade5c0214bcc825396d2bbd02054e62a9f162104748b64", + "size_in_bytes": 1299 + }, + { + "_path": "lib/python3.10/encodings/unicode_escape.py", + "path_type": "hardlink", + "sha256": "507e7ca8f18df639fd823d7cc23ce4028a3550ceefdfa40b3c76f81d1a94531d", + "sha256_in_prefix": "507e7ca8f18df639fd823d7cc23ce4028a3550ceefdfa40b3c76f81d1a94531d", + "size_in_bytes": 1304 + }, + { + "_path": "lib/python3.10/encodings/utf_16.py", + "path_type": "hardlink", + "sha256": "6c36257f7b8d214473560d195e71bccef0c69a53e1e52d2800b7a7890aad7e58", + "sha256_in_prefix": "6c36257f7b8d214473560d195e71bccef0c69a53e1e52d2800b7a7890aad7e58", + "size_in_bytes": 5236 + }, + { + "_path": "lib/python3.10/encodings/utf_16_be.py", + "path_type": "hardlink", + "sha256": "3357196f3fa52433326a6626880e34964e00c5570aee50e9a0a0a7c6d86f6e4f", + "sha256_in_prefix": "3357196f3fa52433326a6626880e34964e00c5570aee50e9a0a0a7c6d86f6e4f", + "size_in_bytes": 1037 + }, + { + "_path": "lib/python3.10/encodings/utf_16_le.py", + "path_type": "hardlink", + "sha256": "3aedaf3eb49769282daef1eaedfd4fa1c31fe5eebeff67fe2307c89dc2e2fd80", + "sha256_in_prefix": "3aedaf3eb49769282daef1eaedfd4fa1c31fe5eebeff67fe2307c89dc2e2fd80", + "size_in_bytes": 1037 + }, + { + "_path": "lib/python3.10/encodings/utf_32.py", + "path_type": "hardlink", + "sha256": "2072eece5f6026ad2d3549ab193a9e38894ea15ca9d5b3cd408fd6b116acc0c2", + "sha256_in_prefix": "2072eece5f6026ad2d3549ab193a9e38894ea15ca9d5b3cd408fd6b116acc0c2", + "size_in_bytes": 5129 + }, + { + "_path": "lib/python3.10/encodings/utf_32_be.py", + "path_type": "hardlink", + "sha256": "cbba20e1f6d0879c7c4293446c371a9f79e7c90bf3c78a77a9b8fc72b18915dd", + "sha256_in_prefix": "cbba20e1f6d0879c7c4293446c371a9f79e7c90bf3c78a77a9b8fc72b18915dd", + "size_in_bytes": 930 + }, + { + "_path": "lib/python3.10/encodings/utf_32_le.py", + "path_type": "hardlink", + "sha256": "9134b91047d85b442898d59effe23e7e0cf4167ca341ae31119a731dbf880a7b", + "sha256_in_prefix": "9134b91047d85b442898d59effe23e7e0cf4167ca341ae31119a731dbf880a7b", + "size_in_bytes": 930 + }, + { + "_path": "lib/python3.10/encodings/utf_7.py", + "path_type": "hardlink", + "sha256": "9ff32314f4f1fa074f206bbf7fdb851504e5313128636d73b4bf75b886e4a87d", + "sha256_in_prefix": "9ff32314f4f1fa074f206bbf7fdb851504e5313128636d73b4bf75b886e4a87d", + "size_in_bytes": 946 + }, + { + "_path": "lib/python3.10/encodings/utf_8.py", + "path_type": "hardlink", + "sha256": "ba0cac060269583523ca9506473a755203037c57d466a11aa89a30a5f6756f3d", + "sha256_in_prefix": "ba0cac060269583523ca9506473a755203037c57d466a11aa89a30a5f6756f3d", + "size_in_bytes": 1005 + }, + { + "_path": "lib/python3.10/encodings/utf_8_sig.py", + "path_type": "hardlink", + "sha256": "1ef3da8d8aa08149e7f274dc64dbfce2155da812e5258ca8e8f832428d3b5c2d", + "sha256_in_prefix": "1ef3da8d8aa08149e7f274dc64dbfce2155da812e5258ca8e8f832428d3b5c2d", + "size_in_bytes": 4133 + }, + { + "_path": "lib/python3.10/encodings/uu_codec.py", + "path_type": "hardlink", + "sha256": "45ba92000718abf85f158563c755205e100356ce1b4ab9444b4d0a3d21f061a3", + "sha256_in_prefix": "45ba92000718abf85f158563c755205e100356ce1b4ab9444b4d0a3d21f061a3", + "size_in_bytes": 2851 + }, + { + "_path": "lib/python3.10/encodings/zlib_codec.py", + "path_type": "hardlink", + "sha256": "6ef01e8d3a5fe1cc52f7b5ae008df12f1dbce7304111bf8d4758f1bfc0115759", + "sha256_in_prefix": "6ef01e8d3a5fe1cc52f7b5ae008df12f1dbce7304111bf8d4758f1bfc0115759", + "size_in_bytes": 2204 + }, + { + "_path": "lib/python3.10/ensurepip/__init__.py", + "path_type": "hardlink", + "sha256": "cdaba5afb1a8028fe882f5c7604b1e03b1162efb45a79156eee9e98c69d9be34", + "sha256_in_prefix": "cdaba5afb1a8028fe882f5c7604b1e03b1162efb45a79156eee9e98c69d9be34", + "size_in_bytes": 9635 + }, + { + "_path": "lib/python3.10/ensurepip/__main__.py", + "path_type": "hardlink", + "sha256": "ee735f518d0fc4dfec81f7aa3da1e052372ed4202c0da4eddd2587840beaecd7", + "sha256_in_prefix": "ee735f518d0fc4dfec81f7aa3da1e052372ed4202c0da4eddd2587840beaecd7", + "size_in_bytes": 88 + }, + { + "_path": "lib/python3.10/ensurepip/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "e18bb5b77ba2d9f57c02e738c161b9ba963bfd27f15887300a4cb2f67a4f663c", + "sha256_in_prefix": "e18bb5b77ba2d9f57c02e738c161b9ba963bfd27f15887300a4cb2f67a4f663c", + "size_in_bytes": 6567 + }, + { + "_path": "lib/python3.10/ensurepip/__pycache__/__main__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "0c2219866c12a2dd2c8567a1622c1653449bda943351c8baced7f20c3f91a2d6", + "sha256_in_prefix": "0c2219866c12a2dd2c8567a1622c1653449bda943351c8baced7f20c3f91a2d6", + "size_in_bytes": 489 + }, + { + "_path": "lib/python3.10/ensurepip/__pycache__/_uninstall.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c7bbba725dfdd7738ea7fb2647c1a7bb6a50cd0d33bde83bf2329b144efcba23", + "sha256_in_prefix": "c7bbba725dfdd7738ea7fb2647c1a7bb6a50cd0d33bde83bf2329b144efcba23", + "size_in_bytes": 1195 + }, + { + "_path": "lib/python3.10/ensurepip/_bundled/__init__.py", + "path_type": "hardlink", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size_in_bytes": 0 + }, + { + "_path": "lib/python3.10/ensurepip/_bundled/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "5a1654a95b7c05d66da9d5176257d40db8e3975f37af9746d58814b666d3ce01", + "sha256_in_prefix": "5a1654a95b7c05d66da9d5176257d40db8e3975f37af9746d58814b666d3ce01", + "size_in_bytes": 397 + }, + { + "_path": "lib/python3.10/ensurepip/_bundled/pip-23.0.1-py3-none-any.whl", + "path_type": "hardlink", + "sha256": "236bcb61156d76c4b8a05821b988c7b8c35bf0da28a4b614e8d6ab5212c25c6f", + "sha256_in_prefix": "236bcb61156d76c4b8a05821b988c7b8c35bf0da28a4b614e8d6ab5212c25c6f", + "size_in_bytes": 2055563 + }, + { + "_path": "lib/python3.10/ensurepip/_bundled/setuptools-65.5.0-py3-none-any.whl", + "path_type": "hardlink", + "sha256": "f62ea9da9ed6289bfe868cd6845968a2c854d1427f8548d52cae02a42b4f0356", + "sha256_in_prefix": "f62ea9da9ed6289bfe868cd6845968a2c854d1427f8548d52cae02a42b4f0356", + "size_in_bytes": 1232695 + }, + { + "_path": "lib/python3.10/ensurepip/_uninstall.py", + "path_type": "hardlink", + "sha256": "3a6e95d01c45e2e47c05df3c81073b895c97c1eb0e5b90ab175d6d9263fc81f2", + "sha256_in_prefix": "3a6e95d01c45e2e47c05df3c81073b895c97c1eb0e5b90ab175d6d9263fc81f2", + "size_in_bytes": 808 + }, + { + "_path": "lib/python3.10/enum.py", + "path_type": "hardlink", + "sha256": "59a62af0e129ae688f5549d6a273c51c5db80b534521f98dae2e4ceb485d9f75", + "sha256_in_prefix": "59a62af0e129ae688f5549d6a273c51c5db80b534521f98dae2e4ceb485d9f75", + "size_in_bytes": 39831 + }, + { + "_path": "lib/python3.10/filecmp.py", + "path_type": "hardlink", + "sha256": "178f19895fdd43d5d3865b2bfe9ae7b665611a30d29cfc23d44f01417774851c", + "sha256_in_prefix": "178f19895fdd43d5d3865b2bfe9ae7b665611a30d29cfc23d44f01417774851c", + "size_in_bytes": 10178 + }, + { + "_path": "lib/python3.10/fileinput.py", + "path_type": "hardlink", + "sha256": "82aaa7e7f62fca7af709e2d80461a37e1c0b2015e9d6b1145bd646bf0983712b", + "sha256_in_prefix": "82aaa7e7f62fca7af709e2d80461a37e1c0b2015e9d6b1145bd646bf0983712b", + "size_in_bytes": 16442 + }, + { + "_path": "lib/python3.10/fnmatch.py", + "path_type": "hardlink", + "sha256": "8a47ad23c243c6af0314bca4fc59b077035b6074f1915b6fc2b7c00864a7c16d", + "sha256_in_prefix": "8a47ad23c243c6af0314bca4fc59b077035b6074f1915b6fc2b7c00864a7c16d", + "size_in_bytes": 6713 + }, + { + "_path": "lib/python3.10/fractions.py", + "path_type": "hardlink", + "sha256": "c98b837e35c0ed2dd71d1d3551490553e5490ce954233f48e63e756c5f15938e", + "sha256_in_prefix": "c98b837e35c0ed2dd71d1d3551490553e5490ce954233f48e63e756c5f15938e", + "size_in_bytes": 28242 + }, + { + "_path": "lib/python3.10/ftplib.py", + "path_type": "hardlink", + "sha256": "672300f448249dfd7825369e47111c37b8aa5355ef0a10df3226bd5f849e538e", + "sha256_in_prefix": "672300f448249dfd7825369e47111c37b8aa5355ef0a10df3226bd5f849e538e", + "size_in_bytes": 35496 + }, + { + "_path": "lib/python3.10/functools.py", + "path_type": "hardlink", + "sha256": "1604a69d2d60921502b375a8af0d662702abe625987b773637a34c09c76a8a25", + "sha256_in_prefix": "1604a69d2d60921502b375a8af0d662702abe625987b773637a34c09c76a8a25", + "size_in_bytes": 38076 + }, + { + "_path": "lib/python3.10/genericpath.py", + "path_type": "hardlink", + "sha256": "9d58ad64056a89f12258a62596c2073cd9e52b459dde152f710edc0cffcd865b", + "sha256_in_prefix": "9d58ad64056a89f12258a62596c2073cd9e52b459dde152f710edc0cffcd865b", + "size_in_bytes": 4975 + }, + { + "_path": "lib/python3.10/getopt.py", + "path_type": "hardlink", + "sha256": "efafb88c7c978e96bd6c232b7fa10bf50cef5e7fb0fb7dc8e5bce44e19f8c92f", + "sha256_in_prefix": "efafb88c7c978e96bd6c232b7fa10bf50cef5e7fb0fb7dc8e5bce44e19f8c92f", + "size_in_bytes": 7489 + }, + { + "_path": "lib/python3.10/getpass.py", + "path_type": "hardlink", + "sha256": "e74fd445337ff503223dd8aa4bdd7d04917067d00c796a10bedb7a1381a4960a", + "sha256_in_prefix": "e74fd445337ff503223dd8aa4bdd7d04917067d00c796a10bedb7a1381a4960a", + "size_in_bytes": 5990 + }, + { + "_path": "lib/python3.10/gettext.py", + "path_type": "hardlink", + "sha256": "46c4d4e2e72bcd572e64bfbce15975d8054a65af167664c6da193773c38dd1ae", + "sha256_in_prefix": "46c4d4e2e72bcd572e64bfbce15975d8054a65af167664c6da193773c38dd1ae", + "size_in_bytes": 27266 + }, + { + "_path": "lib/python3.10/glob.py", + "path_type": "hardlink", + "sha256": "bfedf57df8753377352059f500ffc6780fda3a2381450d1a3822b4714745ceaf", + "sha256_in_prefix": "bfedf57df8753377352059f500ffc6780fda3a2381450d1a3822b4714745ceaf", + "size_in_bytes": 7888 + }, + { + "_path": "lib/python3.10/graphlib.py", + "path_type": "hardlink", + "sha256": "c903f32178ae8205b73caca478c6505318dcc84b006acd6e9ca7da6479a1e05f", + "sha256_in_prefix": "c903f32178ae8205b73caca478c6505318dcc84b006acd6e9ca7da6479a1e05f", + "size_in_bytes": 9573 + }, + { + "_path": "lib/python3.10/gzip.py", + "path_type": "hardlink", + "sha256": "fb131d4bbe711c410f54c7f0b3c2c64292e1279199fd04c53837db03e542a907", + "sha256_in_prefix": "fb131d4bbe711c410f54c7f0b3c2c64292e1279199fd04c53837db03e542a907", + "size_in_bytes": 21849 + }, + { + "_path": "lib/python3.10/hashlib.py", + "path_type": "hardlink", + "sha256": "9d56ebad0263a48ac94e0b2b7a3723625f2ff4dc7707d1156580e008d40bc790", + "sha256_in_prefix": "9d56ebad0263a48ac94e0b2b7a3723625f2ff4dc7707d1156580e008d40bc790", + "size_in_bytes": 10229 + }, + { + "_path": "lib/python3.10/heapq.py", + "path_type": "hardlink", + "sha256": "0351667ed3afd3310ebd353526824d6f6f34d641ef0a785552c6893b7f95fdf3", + "sha256_in_prefix": "0351667ed3afd3310ebd353526824d6f6f34d641ef0a785552c6893b7f95fdf3", + "size_in_bytes": 22877 + }, + { + "_path": "lib/python3.10/hmac.py", + "path_type": "hardlink", + "sha256": "a4790b3cfd1b58875879621dbe8f4c0a30fb50a8582045b0d5c1a712afc8c36b", + "sha256_in_prefix": "a4790b3cfd1b58875879621dbe8f4c0a30fb50a8582045b0d5c1a712afc8c36b", + "size_in_bytes": 7717 + }, + { + "_path": "lib/python3.10/html/__init__.py", + "path_type": "hardlink", + "sha256": "923d82d821e75e8d235392c10c145ab8587927b3faf9c952bbd48081eebd8522", + "sha256_in_prefix": "923d82d821e75e8d235392c10c145ab8587927b3faf9c952bbd48081eebd8522", + "size_in_bytes": 4775 + }, + { + "_path": "lib/python3.10/html/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "d0e6855ffe1eccf5b100645cbea3827b5f1b6ec2b047577716e3ff7bf7244775", + "sha256_in_prefix": "d0e6855ffe1eccf5b100645cbea3827b5f1b6ec2b047577716e3ff7bf7244775", + "size_in_bytes": 3577 + }, + { + "_path": "lib/python3.10/html/__pycache__/entities.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "960cdc49f2aa303818592777243e1449063283ebdbfd5556971e0e0151f030d7", + "sha256_in_prefix": "960cdc49f2aa303818592777243e1449063283ebdbfd5556971e0e0151f030d7", + "size_in_bytes": 144684 + }, + { + "_path": "lib/python3.10/html/__pycache__/parser.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c41e0d7eed11b3133c75a0386166366ade37f68b91ff7b6e2984c643ea5e1f0d", + "sha256_in_prefix": "c41e0d7eed11b3133c75a0386166366ade37f68b91ff7b6e2984c643ea5e1f0d", + "size_in_bytes": 11018 + }, + { + "_path": "lib/python3.10/html/entities.py", + "path_type": "hardlink", + "sha256": "282b7cdd567bbbf3d7d7ccd49fae1d3ebc7f7ab64058d781193620913773731b", + "sha256_in_prefix": "282b7cdd567bbbf3d7d7ccd49fae1d3ebc7f7ab64058d781193620913773731b", + "size_in_bytes": 75383 + }, + { + "_path": "lib/python3.10/html/parser.py", + "path_type": "hardlink", + "sha256": "16aaf2af5459e50e0484af96476fdb58b229f04e46f0c8726fa2dc5ae3ad328d", + "sha256_in_prefix": "16aaf2af5459e50e0484af96476fdb58b229f04e46f0c8726fa2dc5ae3ad328d", + "size_in_bytes": 17392 + }, + { + "_path": "lib/python3.10/http/__init__.py", + "path_type": "hardlink", + "sha256": "47bf36a5cbbcd6ff1c0a5e1b12a82626c2a91bf4ee76ecdbd10e60ac4ca7a461", + "sha256_in_prefix": "47bf36a5cbbcd6ff1c0a5e1b12a82626c2a91bf4ee76ecdbd10e60ac4ca7a461", + "size_in_bytes": 6733 + }, + { + "_path": "lib/python3.10/http/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "7d27b1bb078fbe71922b6071c17f3b1210fbe616d9fb363eb13ef48bdd3aae1f", + "sha256_in_prefix": "7d27b1bb078fbe71922b6071c17f3b1210fbe616d9fb363eb13ef48bdd3aae1f", + "size_in_bytes": 6670 + }, + { + "_path": "lib/python3.10/http/__pycache__/client.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "2da5266975b4029cb40336bc13808c5ec5b14090d03ad3f81bd0fd36238617fa", + "sha256_in_prefix": "2da5266975b4029cb40336bc13808c5ec5b14090d03ad3f81bd0fd36238617fa", + "size_in_bytes": 35432 + }, + { + "_path": "lib/python3.10/http/__pycache__/cookiejar.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "abb1d2216f1509940053353286ef8cf774a24445d666f42a633b2fa585edc6f5", + "sha256_in_prefix": "abb1d2216f1509940053353286ef8cf774a24445d666f42a633b2fa585edc6f5", + "size_in_bytes": 53694 + }, + { + "_path": "lib/python3.10/http/__pycache__/cookies.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "92da78b238dce244b7e52a6a36d3175b1786eb83786c73afe4a6751fb18472e9", + "sha256_in_prefix": "92da78b238dce244b7e52a6a36d3175b1786eb83786c73afe4a6751fb18472e9", + "size_in_bytes": 15592 + }, + { + "_path": "lib/python3.10/http/__pycache__/server.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "ccde1961013b73c35e981946676eebed91539c0d1040f25b3e6dd08a39f0501f", + "sha256_in_prefix": "ccde1961013b73c35e981946676eebed91539c0d1040f25b3e6dd08a39f0501f", + "size_in_bytes": 35446 + }, + { + "_path": "lib/python3.10/http/client.py", + "path_type": "hardlink", + "sha256": "1d724c7d2242957dc789eeb6a446c31294db4747be5d4cbad562fbfa6475fb7d", + "sha256_in_prefix": "1d724c7d2242957dc789eeb6a446c31294db4747be5d4cbad562fbfa6475fb7d", + "size_in_bytes": 56795 + }, + { + "_path": "lib/python3.10/http/cookiejar.py", + "path_type": "hardlink", + "sha256": "03a8c15b1c5a5419774fef60f60405c8e70b1f791fe32c9e73ad7215173efe52", + "sha256_in_prefix": "03a8c15b1c5a5419774fef60f60405c8e70b1f791fe32c9e73ad7215173efe52", + "size_in_bytes": 77415 + }, + { + "_path": "lib/python3.10/http/cookies.py", + "path_type": "hardlink", + "sha256": "a4712e985f8d892e290e8317d0d4d692313a39d5b0bd22fc640b885a79043ff7", + "sha256_in_prefix": "a4712e985f8d892e290e8317d0d4d692313a39d5b0bd22fc640b885a79043ff7", + "size_in_bytes": 20482 + }, + { + "_path": "lib/python3.10/http/server.py", + "path_type": "hardlink", + "sha256": "3b91d9b7a7c7e58a828bdb505b981201965d9634b90e2a98291bd6a018963426", + "sha256_in_prefix": "3b91d9b7a7c7e58a828bdb505b981201965d9634b90e2a98291bd6a018963426", + "size_in_bytes": 48207 + }, + { + "_path": "lib/python3.10/idlelib/CREDITS.txt", + "path_type": "hardlink", + "sha256": "33e6a36056667d40e26f195c14371567470f53324c3fec43aec29e09d7d2a60b", + "sha256_in_prefix": "33e6a36056667d40e26f195c14371567470f53324c3fec43aec29e09d7d2a60b", + "size_in_bytes": 2152 + }, + { + "_path": "lib/python3.10/idlelib/ChangeLog", + "path_type": "hardlink", + "sha256": "b7f42699e5e5a7c82ebdf2a2962946b7228c933ece0ea7c0d7789f21a7dd7e64", + "sha256_in_prefix": "b7f42699e5e5a7c82ebdf2a2962946b7228c933ece0ea7c0d7789f21a7dd7e64", + "size_in_bytes": 56360 + }, + { + "_path": "lib/python3.10/idlelib/HISTORY.txt", + "path_type": "hardlink", + "sha256": "531067a78ad392f25631aba1d885f40786cf5f47854577162c9f90ff1f33164c", + "sha256_in_prefix": "531067a78ad392f25631aba1d885f40786cf5f47854577162c9f90ff1f33164c", + "size_in_bytes": 10312 + }, + { + "_path": "lib/python3.10/idlelib/Icons/README.txt", + "path_type": "hardlink", + "sha256": "60399d6129e3e486ce6b437bbf614ff4838bd4e7f42d461c3e5467cf3b4fa272", + "sha256_in_prefix": "60399d6129e3e486ce6b437bbf614ff4838bd4e7f42d461c3e5467cf3b4fa272", + "size_in_bytes": 443 + }, + { + "_path": "lib/python3.10/idlelib/Icons/folder.gif", + "path_type": "hardlink", + "sha256": "7c98d566a13fd599d1c11a375f387fef69b6c595c4f18c5d88c188a860be0e55", + "sha256_in_prefix": "7c98d566a13fd599d1c11a375f387fef69b6c595c4f18c5d88c188a860be0e55", + "size_in_bytes": 120 + }, + { + "_path": "lib/python3.10/idlelib/Icons/idle.ico", + "path_type": "hardlink", + "sha256": "7f13eeb5dca39d05e24b9eb069c6dcb2748633822d67288a8bf8b7e21cdddf55", + "sha256_in_prefix": "7f13eeb5dca39d05e24b9eb069c6dcb2748633822d67288a8bf8b7e21cdddf55", + "size_in_bytes": 57746 + }, + { + "_path": "lib/python3.10/idlelib/Icons/idle_16.gif", + "path_type": "hardlink", + "sha256": "fe3af292b38660a8a58b1a8b4fa4240aa190602e7e9a700ea0536b3181fc968e", + "sha256_in_prefix": "fe3af292b38660a8a58b1a8b4fa4240aa190602e7e9a700ea0536b3181fc968e", + "size_in_bytes": 634 + }, + { + "_path": "lib/python3.10/idlelib/Icons/idle_16.png", + "path_type": "hardlink", + "sha256": "78fb3fb0ec11f61bc6cf0947f3c3923aa18e1c6513684058ed0fa01ac858143e", + "sha256_in_prefix": "78fb3fb0ec11f61bc6cf0947f3c3923aa18e1c6513684058ed0fa01ac858143e", + "size_in_bytes": 1031 + }, + { + "_path": "lib/python3.10/idlelib/Icons/idle_256.png", + "path_type": "hardlink", + "sha256": "3f517467d12e0e3ecf20f9bd68ce4bd18a2b8088f32308fd978fd80e87d3628b", + "sha256_in_prefix": "3f517467d12e0e3ecf20f9bd68ce4bd18a2b8088f32308fd978fd80e87d3628b", + "size_in_bytes": 39205 + }, + { + "_path": "lib/python3.10/idlelib/Icons/idle_32.gif", + "path_type": "hardlink", + "sha256": "fe70991cfccd1267922e94d91e02e9a58d2d29fd3382a2f4975280b9023cb7b9", + "sha256_in_prefix": "fe70991cfccd1267922e94d91e02e9a58d2d29fd3382a2f4975280b9023cb7b9", + "size_in_bytes": 1019 + }, + { + "_path": "lib/python3.10/idlelib/Icons/idle_32.png", + "path_type": "hardlink", + "sha256": "797cd05f1964d57c4c6c248ac7f7ea6a38019ada32a9ab7e6c28d060f87b03de", + "sha256_in_prefix": "797cd05f1964d57c4c6c248ac7f7ea6a38019ada32a9ab7e6c28d060f87b03de", + "size_in_bytes": 2036 + }, + { + "_path": "lib/python3.10/idlelib/Icons/idle_48.gif", + "path_type": "hardlink", + "sha256": "37484901eb40eefa846308e1da3ff6f240ea98f769a2afc3cf4fdba00327ecbe", + "sha256_in_prefix": "37484901eb40eefa846308e1da3ff6f240ea98f769a2afc3cf4fdba00327ecbe", + "size_in_bytes": 1388 + }, + { + "_path": "lib/python3.10/idlelib/Icons/idle_48.png", + "path_type": "hardlink", + "sha256": "a09f433197c8870b12bb7859cc4c3fe2068908cb1ddbd4880ab0f6fee91b6c23", + "sha256_in_prefix": "a09f433197c8870b12bb7859cc4c3fe2068908cb1ddbd4880ab0f6fee91b6c23", + "size_in_bytes": 3977 + }, + { + "_path": "lib/python3.10/idlelib/Icons/minusnode.gif", + "path_type": "hardlink", + "sha256": "efa5aa1d1e3439ab85425bd2aa3a25b9e6c21309e672690cfb32219e1eb7a7f3", + "sha256_in_prefix": "efa5aa1d1e3439ab85425bd2aa3a25b9e6c21309e672690cfb32219e1eb7a7f3", + "size_in_bytes": 75 + }, + { + "_path": "lib/python3.10/idlelib/Icons/openfolder.gif", + "path_type": "hardlink", + "sha256": "9a59e2abf1840156e9db8f85a38822fd56ab79a139eb95ec86f1fba1bb87326b", + "sha256_in_prefix": "9a59e2abf1840156e9db8f85a38822fd56ab79a139eb95ec86f1fba1bb87326b", + "size_in_bytes": 125 + }, + { + "_path": "lib/python3.10/idlelib/Icons/plusnode.gif", + "path_type": "hardlink", + "sha256": "6ace9e90a2bcb16d06c4d78837137f2c14bc26b3bd9f24b7b6afeadb689bdafb", + "sha256_in_prefix": "6ace9e90a2bcb16d06c4d78837137f2c14bc26b3bd9f24b7b6afeadb689bdafb", + "size_in_bytes": 78 + }, + { + "_path": "lib/python3.10/idlelib/Icons/python.gif", + "path_type": "hardlink", + "sha256": "158c31382f8e5b41fded0c2aa9cc66a382928b003cdd8b5b0518836ad9c89377", + "sha256_in_prefix": "158c31382f8e5b41fded0c2aa9cc66a382928b003cdd8b5b0518836ad9c89377", + "size_in_bytes": 380 + }, + { + "_path": "lib/python3.10/idlelib/Icons/tk.gif", + "path_type": "hardlink", + "sha256": "7f16cb2e322891dbd9101302c09ffda0c2a3a72d053bb8c0927d507414c59cad", + "sha256_in_prefix": "7f16cb2e322891dbd9101302c09ffda0c2a3a72d053bb8c0927d507414c59cad", + "size_in_bytes": 72 + }, + { + "_path": "lib/python3.10/idlelib/NEWS.txt", + "path_type": "hardlink", + "sha256": "2b345c81377c4fa996c814fcf50ae8188c6a0ecfcdafc5c17145c3d5154478fa", + "sha256_in_prefix": "2b345c81377c4fa996c814fcf50ae8188c6a0ecfcdafc5c17145c3d5154478fa", + "size_in_bytes": 54195 + }, + { + "_path": "lib/python3.10/idlelib/NEWS2x.txt", + "path_type": "hardlink", + "sha256": "c89a3b513501ebace8e428aea68dce39d0af9f29196e08fc9ea49c99605e79e7", + "sha256_in_prefix": "c89a3b513501ebace8e428aea68dce39d0af9f29196e08fc9ea49c99605e79e7", + "size_in_bytes": 27172 + }, + { + "_path": "lib/python3.10/idlelib/README.txt", + "path_type": "hardlink", + "sha256": "4f2dc8ffdbfc7837b60edc32ac2f593a220f4abf0ea00cc477382ad8ecf8eb3d", + "sha256_in_prefix": "4f2dc8ffdbfc7837b60edc32ac2f593a220f4abf0ea00cc477382ad8ecf8eb3d", + "size_in_bytes": 11653 + }, + { + "_path": "lib/python3.10/idlelib/TODO.txt", + "path_type": "hardlink", + "sha256": "f88e0fb30fa0ab5d0dc3030442ed92713f34170336c4dd2623723dc34829df89", + "sha256_in_prefix": "f88e0fb30fa0ab5d0dc3030442ed92713f34170336c4dd2623723dc34829df89", + "size_in_bytes": 8478 + }, + { + "_path": "lib/python3.10/idlelib/__init__.py", + "path_type": "hardlink", + "sha256": "3f8058df4fec56eb20ff67ff84c86fd3d9697e2384c5a290ed696f6d3187aa45", + "sha256_in_prefix": "3f8058df4fec56eb20ff67ff84c86fd3d9697e2384c5a290ed696f6d3187aa45", + "size_in_bytes": 396 + }, + { + "_path": "lib/python3.10/idlelib/__main__.py", + "path_type": "hardlink", + "sha256": "f8f55514d26791588de02fe685af0ab129174b32ab93efa39faf6140b6795d9d", + "sha256_in_prefix": "f8f55514d26791588de02fe685af0ab129174b32ab93efa39faf6140b6795d9d", + "size_in_bytes": 159 + }, + { + "_path": "lib/python3.10/idlelib/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "60fdbb4c8b8dc1a4487a108b8c6d4ea4e577210ba8913e769755b133a8d81fa2", + "sha256_in_prefix": "60fdbb4c8b8dc1a4487a108b8c6d4ea4e577210ba8913e769755b133a8d81fa2", + "size_in_bytes": 759 + }, + { + "_path": "lib/python3.10/idlelib/__pycache__/__main__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "96395fec860d1ad45b96dfa920b1997c4a4861fabad18d87b6f012e71c0d4877", + "sha256_in_prefix": "96395fec860d1ad45b96dfa920b1997c4a4861fabad18d87b6f012e71c0d4877", + "size_in_bytes": 520 + }, + { + "_path": "lib/python3.10/idlelib/__pycache__/autocomplete.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c8cc11ee35a7e4badcce8883f1f7469287f5389c7f30ebe5b3c1e0cbd1bf254e", + "sha256_in_prefix": "c8cc11ee35a7e4badcce8883f1f7469287f5389c7f30ebe5b3c1e0cbd1bf254e", + "size_in_bytes": 7383 + }, + { + "_path": "lib/python3.10/idlelib/__pycache__/autocomplete_w.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "2ab60b2bc098cae143b8da5ef6491695c93652774fc6b9cd998635b98c4a6762", + "sha256_in_prefix": "2ab60b2bc098cae143b8da5ef6491695c93652774fc6b9cd998635b98c4a6762", + "size_in_bytes": 11591 + }, + { + "_path": "lib/python3.10/idlelib/__pycache__/autoexpand.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "fb44fee858ad36ecc7279b20760bd1f714633c7fd8484621c5508df4ba5543ae", + "sha256_in_prefix": "fb44fee858ad36ecc7279b20760bd1f714633c7fd8484621c5508df4ba5543ae", + "size_in_bytes": 3101 + }, + { + "_path": "lib/python3.10/idlelib/__pycache__/browser.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c40cdfab622aad4ab2e5566dd5879c8051dc6f76c4f1fc7b095e942bd7eb76d9", + "sha256_in_prefix": "c40cdfab622aad4ab2e5566dd5879c8051dc6f76c4f1fc7b095e942bd7eb76d9", + "size_in_bytes": 9892 + }, + { + "_path": "lib/python3.10/idlelib/__pycache__/calltip.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "43a1418952cab930e0f6aa4e38b43bdf754a674f3c6f741bac9bfb89ccea407b", + "sha256_in_prefix": "43a1418952cab930e0f6aa4e38b43bdf754a674f3c6f741bac9bfb89ccea407b", + "size_in_bytes": 6055 + }, + { + "_path": "lib/python3.10/idlelib/__pycache__/calltip_w.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "b4715304849ddec09de6091bdee996f1d12d54b08efec8b3dd8e25438abad8b7", + "sha256_in_prefix": "b4715304849ddec09de6091bdee996f1d12d54b08efec8b3dd8e25438abad8b7", + "size_in_bytes": 6455 + }, + { + "_path": "lib/python3.10/idlelib/__pycache__/codecontext.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "ee17eaff1c0857773b9109f2999e6e92018a7bfabfa2efd076d9b956f0cf21f5", + "sha256_in_prefix": "ee17eaff1c0857773b9109f2999e6e92018a7bfabfa2efd076d9b956f0cf21f5", + "size_in_bytes": 9193 + }, + { + "_path": "lib/python3.10/idlelib/__pycache__/colorizer.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c19be59231c089984fb8bdee2ea24278d37169d6275530c269cd60eda6bfe0d3", + "sha256_in_prefix": "c19be59231c089984fb8bdee2ea24278d37169d6275530c269cd60eda6bfe0d3", + "size_in_bytes": 11973 + }, + { + "_path": "lib/python3.10/idlelib/__pycache__/config.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "419899138cc94508306250e8dc663d326f0f78b730a66abca14ced1a9da07bfc", + "sha256_in_prefix": "419899138cc94508306250e8dc663d326f0f78b730a66abca14ced1a9da07bfc", + "size_in_bytes": 30614 + }, + { + "_path": "lib/python3.10/idlelib/__pycache__/config_key.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "bdfe46aeb88bbaea568bdf5874aca7cd8ed1b71c2252acf3cac26ff5162df2dc", + "sha256_in_prefix": "bdfe46aeb88bbaea568bdf5874aca7cd8ed1b71c2252acf3cac26ff5162df2dc", + "size_in_bytes": 13075 + }, + { + "_path": "lib/python3.10/idlelib/__pycache__/configdialog.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "d5e1fe66fbe57e4d3ced0b5deee04c0996deeb6d049a1b2328c453ab417384b6", + "sha256_in_prefix": "d5e1fe66fbe57e4d3ced0b5deee04c0996deeb6d049a1b2328c453ab417384b6", + "size_in_bytes": 80378 + }, + { + "_path": "lib/python3.10/idlelib/__pycache__/debugger.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "be579f296df9fdb14ee215a157c6583315cd54c8ba9ab9ba2642bb242dfe4fcd", + "sha256_in_prefix": "be579f296df9fdb14ee215a157c6583315cd54c8ba9ab9ba2642bb242dfe4fcd", + "size_in_bytes": 14386 + }, + { + "_path": "lib/python3.10/idlelib/__pycache__/debugger_r.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "1d9194c0d9c9a47b5c379bae368d7b216771bb6b9021f690d6b18f2c7c2aaf8a", + "sha256_in_prefix": "1d9194c0d9c9a47b5c379bae368d7b216771bb6b9021f690d6b18f2c7c2aaf8a", + "size_in_bytes": 13847 + }, + { + "_path": "lib/python3.10/idlelib/__pycache__/debugobj.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "3de72482064122b4575164ae3c8d40acd2a7d329de049fef98c1a49ef4da6605", + "sha256_in_prefix": "3de72482064122b4575164ae3c8d40acd2a7d329de049fef98c1a49ef4da6605", + "size_in_bytes": 5489 + }, + { + "_path": "lib/python3.10/idlelib/__pycache__/debugobj_r.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "d89f97e76359a9f453efe9cd5263f89b8ec098dd0c214b9b150f84d183a86a01", + "sha256_in_prefix": "d89f97e76359a9f453efe9cd5263f89b8ec098dd0c214b9b150f84d183a86a01", + "size_in_bytes": 2240 + }, + { + "_path": "lib/python3.10/idlelib/__pycache__/delegator.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "35005e32db0e8f1b43bd15b03d38d327b03098c6cedf20d8abc53e9c6082d599", + "sha256_in_prefix": "35005e32db0e8f1b43bd15b03d38d327b03098c6cedf20d8abc53e9c6082d599", + "size_in_bytes": 1545 + }, + { + "_path": "lib/python3.10/idlelib/__pycache__/dynoption.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "98d937523f0ad4b6bf04448a6085c6613d0ffe373201659b2658599c9ceeeb45", + "sha256_in_prefix": "98d937523f0ad4b6bf04448a6085c6613d0ffe373201659b2658599c9ceeeb45", + "size_in_bytes": 2546 + }, + { + "_path": "lib/python3.10/idlelib/__pycache__/editor.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "f888934e9f171870b7bc44041db000879538e26de39247a66eb3c362007b889a", + "sha256_in_prefix": "f888934e9f171870b7bc44041db000879538e26de39247a66eb3c362007b889a", + "size_in_bytes": 47325 + }, + { + "_path": "lib/python3.10/idlelib/__pycache__/filelist.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "1e1ebf945e105e8250b60e14b967a6c088713189479d584c922f1c9ba55ad234", + "sha256_in_prefix": "1e1ebf945e105e8250b60e14b967a6c088713189479d584c922f1c9ba55ad234", + "size_in_bytes": 3700 + }, + { + "_path": "lib/python3.10/idlelib/__pycache__/format.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "ebeefd9dbafbddac7a8c7cee96af0c1c95a12d916b8c80b5297dd60e486d909c", + "sha256_in_prefix": "ebeefd9dbafbddac7a8c7cee96af0c1c95a12d916b8c80b5297dd60e486d909c", + "size_in_bytes": 13772 + }, + { + "_path": "lib/python3.10/idlelib/__pycache__/grep.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "2a4d0edeb1ff77c09a556397e03dbdcf5958022ca480381afcec0418a559ef0f", + "sha256_in_prefix": "2a4d0edeb1ff77c09a556397e03dbdcf5958022ca480381afcec0418a559ef0f", + "size_in_bytes": 8120 + }, + { + "_path": "lib/python3.10/idlelib/__pycache__/help.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "20527c9f852193f30337014be11714a7649c0cd5aaa327c7540875196937fc2c", + "sha256_in_prefix": "20527c9f852193f30337014be11714a7649c0cd5aaa327c7540875196937fc2c", + "size_in_bytes": 10828 + }, + { + "_path": "lib/python3.10/idlelib/__pycache__/help_about.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "69a1c0dea2d9856340c4e294b8dbcfee62c34d597816ca969d35b390121b053a", + "sha256_in_prefix": "69a1c0dea2d9856340c4e294b8dbcfee62c34d597816ca969d35b390121b053a", + "size_in_bytes": 7854 + }, + { + "_path": "lib/python3.10/idlelib/__pycache__/history.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "ef0245c930717969433f6af32696b80fd77413c48df21a549853f5e2d524d3c6", + "sha256_in_prefix": "ef0245c930717969433f6af32696b80fd77413c48df21a549853f5e2d524d3c6", + "size_in_bytes": 3649 + }, + { + "_path": "lib/python3.10/idlelib/__pycache__/hyperparser.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "ae29afb00a5c751f755d439ca34755ac0172d15f611adf254768d0ad2ae47256", + "sha256_in_prefix": "ae29afb00a5c751f755d439ca34755ac0172d15f611adf254768d0ad2ae47256", + "size_in_bytes": 7268 + }, + { + "_path": "lib/python3.10/idlelib/__pycache__/idle.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "4ebe0af8c8044411485831b3a0d1c68ff6d6e1935275677971db0e2e66bf79c2", + "sha256_in_prefix": "4ebe0af8c8044411485831b3a0d1c68ff6d6e1935275677971db0e2e66bf79c2", + "size_in_bytes": 326 + }, + { + "_path": "lib/python3.10/idlelib/__pycache__/iomenu.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "804a9a288d3e2814863aa1b3149e5183f7611c135b086d3f506e8e8fc27944ae", + "sha256_in_prefix": "804a9a288d3e2814863aa1b3149e5183f7611c135b086d3f506e8e8fc27944ae", + "size_in_bytes": 12035 + }, + { + "_path": "lib/python3.10/idlelib/__pycache__/macosx.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "1d46c530233a8c6af608fdcf0189aee185f976f16a828cd396a5e8296cf8d586", + "sha256_in_prefix": "1d46c530233a8c6af608fdcf0189aee185f976f16a828cd396a5e8296cf8d586", + "size_in_bytes": 8054 + }, + { + "_path": "lib/python3.10/idlelib/__pycache__/mainmenu.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "498ec1e22959d872a1965fbd0b6948b0d82aa706dc30eab95f838c65d789f7b5", + "sha256_in_prefix": "498ec1e22959d872a1965fbd0b6948b0d82aa706dc30eab95f838c65d789f7b5", + "size_in_bytes": 3518 + }, + { + "_path": "lib/python3.10/idlelib/__pycache__/multicall.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "14c9470136f97dc9d92bcaab4152fde28797750048966611abf790cff5252c46", + "sha256_in_prefix": "14c9470136f97dc9d92bcaab4152fde28797750048966611abf790cff5252c46", + "size_in_bytes": 14970 + }, + { + "_path": "lib/python3.10/idlelib/__pycache__/outwin.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "6d841be126b82979839f373101ed99032d6629744081f6df0565aef33bcaaf42", + "sha256_in_prefix": "6d841be126b82979839f373101ed99032d6629744081f6df0565aef33bcaaf42", + "size_in_bytes": 6250 + }, + { + "_path": "lib/python3.10/idlelib/__pycache__/parenmatch.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "e8beb23581d791bb64636a7e6f0c86f8c561f6545bd0682a9a37cd7a128d927a", + "sha256_in_prefix": "e8beb23581d791bb64636a7e6f0c86f8c561f6545bd0682a9a37cd7a128d927a", + "size_in_bytes": 6624 + }, + { + "_path": "lib/python3.10/idlelib/__pycache__/pathbrowser.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "963e096daab319a91a84e13eeefe81637d24ad7e2f8462936e65e7bbb20204b2", + "sha256_in_prefix": "963e096daab319a91a84e13eeefe81637d24ad7e2f8462936e65e7bbb20204b2", + "size_in_bytes": 4041 + }, + { + "_path": "lib/python3.10/idlelib/__pycache__/percolator.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "40acdd76eacab8cc249b67b0879d517ddc384a2029b42a05c3c1f728e631a601", + "sha256_in_prefix": "40acdd76eacab8cc249b67b0879d517ddc384a2029b42a05c3c1f728e631a601", + "size_in_bytes": 4239 + }, + { + "_path": "lib/python3.10/idlelib/__pycache__/pyparse.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "2eaa4e8bef8a27ef6bdb54ef4910794c34c2d3a64b492a8388fa87f30e2fa8c9", + "sha256_in_prefix": "2eaa4e8bef8a27ef6bdb54ef4910794c34c2d3a64b492a8388fa87f30e2fa8c9", + "size_in_bytes": 12271 + }, + { + "_path": "lib/python3.10/idlelib/__pycache__/pyshell.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "a3b37bd7433a14404a0c4934f953098d530668dfe0f30bbc084d3ea5fa83412e", + "sha256_in_prefix": "a3b37bd7433a14404a0c4934f953098d530668dfe0f30bbc084d3ea5fa83412e", + "size_in_bytes": 47203 + }, + { + "_path": "lib/python3.10/idlelib/__pycache__/query.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "76c37e7efcaab04ed5e0631e544ba7a1138ba26fdb6dd9ae388198b915367d82", + "sha256_in_prefix": "76c37e7efcaab04ed5e0631e544ba7a1138ba26fdb6dd9ae388198b915367d82", + "size_in_bytes": 13047 + }, + { + "_path": "lib/python3.10/idlelib/__pycache__/redirector.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "07fbc39d76aa40982558420b6fdb8e86db5163dde51429333e331aafc9c05f52", + "sha256_in_prefix": "07fbc39d76aa40982558420b6fdb8e86db5163dde51429333e331aafc9c05f52", + "size_in_bytes": 7050 + }, + { + "_path": "lib/python3.10/idlelib/__pycache__/replace.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "38c877b8f34eed1bce317bda75661490b1d92fdc5c25f0f044118f920cdb9364", + "sha256_in_prefix": "38c877b8f34eed1bce317bda75661490b1d92fdc5c25f0f044118f920cdb9364", + "size_in_bytes": 9742 + }, + { + "_path": "lib/python3.10/idlelib/__pycache__/rpc.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "19284c7d53d93ce28cf46300711213cc9e530801e4bfa7635e7f64074c630263", + "sha256_in_prefix": "19284c7d53d93ce28cf46300711213cc9e530801e4bfa7635e7f64074c630263", + "size_in_bytes": 19777 + }, + { + "_path": "lib/python3.10/idlelib/__pycache__/run.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "a458349db90f56c3412abbde6fd7632d5062ec80aa89b9310a61d4b48c6782a2", + "sha256_in_prefix": "a458349db90f56c3412abbde6fd7632d5062ec80aa89b9310a61d4b48c6782a2", + "size_in_bytes": 19117 + }, + { + "_path": "lib/python3.10/idlelib/__pycache__/runscript.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "0dcaabf75d12207ee028ba77de36fb8f05be6b89230c5646c355d5f6e5f24b1d", + "sha256_in_prefix": "0dcaabf75d12207ee028ba77de36fb8f05be6b89230c5646c355d5f6e5f24b1d", + "size_in_bytes": 7126 + }, + { + "_path": "lib/python3.10/idlelib/__pycache__/scrolledlist.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "620b85fedf9188e6761b269aed83306c2864691a063bee5bb26a3743160ac736", + "sha256_in_prefix": "620b85fedf9188e6761b269aed83306c2864691a063bee5bb26a3743160ac736", + "size_in_bytes": 5573 + }, + { + "_path": "lib/python3.10/idlelib/__pycache__/search.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "7a7bcb8d784354919116311e4bfb4e7593d97658d8e01d859ad29dd5042d381c", + "sha256_in_prefix": "7a7bcb8d784354919116311e4bfb4e7593d97658d8e01d859ad29dd5042d381c", + "size_in_bytes": 6186 + }, + { + "_path": "lib/python3.10/idlelib/__pycache__/searchbase.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "00640954353bcf683505d0da743a8870df31b2b3a16305e2e460e7a42a29d88d", + "sha256_in_prefix": "00640954353bcf683505d0da743a8870df31b2b3a16305e2e460e7a42a29d88d", + "size_in_bytes": 8591 + }, + { + "_path": "lib/python3.10/idlelib/__pycache__/searchengine.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "dc66999dafd19e0990f9bbd446b1dd8c8e3706baa8d34b6d54f94422f63198eb", + "sha256_in_prefix": "dc66999dafd19e0990f9bbd446b1dd8c8e3706baa8d34b6d54f94422f63198eb", + "size_in_bytes": 7025 + }, + { + "_path": "lib/python3.10/idlelib/__pycache__/sidebar.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "41d6c4cd111349500f80912f0ab3d51086eced0deb34b71cded43bcca0bbaa3d", + "sha256_in_prefix": "41d6c4cd111349500f80912f0ab3d51086eced0deb34b71cded43bcca0bbaa3d", + "size_in_bytes": 18153 + }, + { + "_path": "lib/python3.10/idlelib/__pycache__/squeezer.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "0c475cb934b8fd02bbd52814ef262f283f1b7d4ee74f027373597bcd69b0ad8e", + "sha256_in_prefix": "0c475cb934b8fd02bbd52814ef262f283f1b7d4ee74f027373597bcd69b0ad8e", + "size_in_bytes": 9833 + }, + { + "_path": "lib/python3.10/idlelib/__pycache__/stackviewer.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "f84a19f63b5fb60995179963524a1b909b88b968d45f8d75db36cf7e2ca93376", + "sha256_in_prefix": "f84a19f63b5fb60995179963524a1b909b88b968d45f8d75db36cf7e2ca93376", + "size_in_bytes": 5354 + }, + { + "_path": "lib/python3.10/idlelib/__pycache__/statusbar.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c4aaae5cad941d62dfcf0239fe03a3f226dd1357f149d8cf61622368afe1f933", + "sha256_in_prefix": "c4aaae5cad941d62dfcf0239fe03a3f226dd1357f149d8cf61622368afe1f933", + "size_in_bytes": 2250 + }, + { + "_path": "lib/python3.10/idlelib/__pycache__/textview.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "ddb85fe57c2b456b05fb410dcbf2ea5883b4e2704a4e5cbb585c7c98dc84a247", + "sha256_in_prefix": "ddb85fe57c2b456b05fb410dcbf2ea5883b4e2704a4e5cbb585c7c98dc84a247", + "size_in_bytes": 7316 + }, + { + "_path": "lib/python3.10/idlelib/__pycache__/tooltip.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "1a2472d0d8af4f0a4e5f9661892ceced90895f2224024972712ba30489f91438", + "sha256_in_prefix": "1a2472d0d8af4f0a4e5f9661892ceced90895f2224024972712ba30489f91438", + "size_in_bytes": 6840 + }, + { + "_path": "lib/python3.10/idlelib/__pycache__/tree.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "a434275ef5e3ffb9e1b4ab1dc6e61f8762bb517d597791f6180a705a657284ba", + "sha256_in_prefix": "a434275ef5e3ffb9e1b4ab1dc6e61f8762bb517d597791f6180a705a657284ba", + "size_in_bytes": 15841 + }, + { + "_path": "lib/python3.10/idlelib/__pycache__/undo.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "6d564454dfc0f05e528fa7caeb00933c3ce61345accf3d600bd62c4891412694", + "sha256_in_prefix": "6d564454dfc0f05e528fa7caeb00933c3ce61345accf3d600bd62c4891412694", + "size_in_bytes": 10975 + }, + { + "_path": "lib/python3.10/idlelib/__pycache__/util.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "e72ca7704749eef78e4178cec7ab31c059807513d61cf79058cbb375cfb38f54", + "sha256_in_prefix": "e72ca7704749eef78e4178cec7ab31c059807513d61cf79058cbb375cfb38f54", + "size_in_bytes": 1032 + }, + { + "_path": "lib/python3.10/idlelib/__pycache__/window.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "521138abde0285f54bee7a61775760d279795e9f9eada87e1df8bdd0e024dae6", + "sha256_in_prefix": "521138abde0285f54bee7a61775760d279795e9f9eada87e1df8bdd0e024dae6", + "size_in_bytes": 3488 + }, + { + "_path": "lib/python3.10/idlelib/__pycache__/zoomheight.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "fd8ac3630181438c44ef7a8722074537680c1e497f15ab1f5c25eceb2a24df12", + "sha256_in_prefix": "fd8ac3630181438c44ef7a8722074537680c1e497f15ab1f5c25eceb2a24df12", + "size_in_bytes": 3092 + }, + { + "_path": "lib/python3.10/idlelib/__pycache__/zzdummy.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "96937ed75ff51cf087334f5fe39e14799413d40410d704e9bcf3c6b1ee5110f8", + "sha256_in_prefix": "96937ed75ff51cf087334f5fe39e14799413d40410d704e9bcf3c6b1ee5110f8", + "size_in_bytes": 2735 + }, + { + "_path": "lib/python3.10/idlelib/autocomplete.py", + "path_type": "hardlink", + "sha256": "0d36f7694a50cbaa22d9bf03b91fa0658a147bd90dd867714a9b411febb36427", + "sha256_in_prefix": "0d36f7694a50cbaa22d9bf03b91fa0658a147bd90dd867714a9b411febb36427", + "size_in_bytes": 9354 + }, + { + "_path": "lib/python3.10/idlelib/autocomplete_w.py", + "path_type": "hardlink", + "sha256": "2f05996827309ef6147f8b888352a1b9911678e70dc9046bd5363dab7733a329", + "sha256_in_prefix": "2f05996827309ef6147f8b888352a1b9911678e70dc9046bd5363dab7733a329", + "size_in_bytes": 21097 + }, + { + "_path": "lib/python3.10/idlelib/autoexpand.py", + "path_type": "hardlink", + "sha256": "c8eb28ef7addf5a664a7e3addfbfebe29040a8695e1db515828305aacba2ee4e", + "sha256_in_prefix": "c8eb28ef7addf5a664a7e3addfbfebe29040a8695e1db515828305aacba2ee4e", + "size_in_bytes": 3216 + }, + { + "_path": "lib/python3.10/idlelib/browser.py", + "path_type": "hardlink", + "sha256": "bd656af7051ed0aa83529ceccff4a3dc8c44ea94e6c1ca28e17e89f998020f6a", + "sha256_in_prefix": "bd656af7051ed0aa83529ceccff4a3dc8c44ea94e6c1ca28e17e89f998020f6a", + "size_in_bytes": 8586 + }, + { + "_path": "lib/python3.10/idlelib/calltip.py", + "path_type": "hardlink", + "sha256": "3a723fdf88c0018dfadd19757142a643b01b785c6df17a50bbe21463663ab590", + "sha256_in_prefix": "3a723fdf88c0018dfadd19757142a643b01b785c6df17a50bbe21463663ab590", + "size_in_bytes": 7267 + }, + { + "_path": "lib/python3.10/idlelib/calltip_w.py", + "path_type": "hardlink", + "sha256": "f60fde563751ad8d77dfcd892558d6c4306764d9affade5018147e84c7246900", + "sha256_in_prefix": "f60fde563751ad8d77dfcd892558d6c4306764d9affade5018147e84c7246900", + "size_in_bytes": 7158 + }, + { + "_path": "lib/python3.10/idlelib/codecontext.py", + "path_type": "hardlink", + "sha256": "628a13325b3bf2f76dea9254b20178b3232261f83c660f0e33785e6215dd6492", + "sha256_in_prefix": "628a13325b3bf2f76dea9254b20178b3232261f83c660f0e33785e6215dd6492", + "size_in_bytes": 11420 + }, + { + "_path": "lib/python3.10/idlelib/colorizer.py", + "path_type": "hardlink", + "sha256": "74ed1bf4c7053d42d37e786969414fcb4dfc648f22430a361720ed8f877d3293", + "sha256_in_prefix": "74ed1bf4c7053d42d37e786969414fcb4dfc648f22430a361720ed8f877d3293", + "size_in_bytes": 14773 + }, + { + "_path": "lib/python3.10/idlelib/config-extensions.def", + "path_type": "hardlink", + "sha256": "e75df0b77ff61253be457af636d5eb7c55a3ff2b6a733beea844d2b294972ebf", + "sha256_in_prefix": "e75df0b77ff61253be457af636d5eb7c55a3ff2b6a733beea844d2b294972ebf", + "size_in_bytes": 2266 + }, + { + "_path": "lib/python3.10/idlelib/config-highlight.def", + "path_type": "hardlink", + "sha256": "609eada44ff4aa9d5cd10ad8b4c29bb76db8ebc74912a0ae86f5ea3cd19b7547", + "sha256_in_prefix": "609eada44ff4aa9d5cd10ad8b4c29bb76db8ebc74912a0ae86f5ea3cd19b7547", + "size_in_bytes": 2864 + }, + { + "_path": "lib/python3.10/idlelib/config-keys.def", + "path_type": "hardlink", + "sha256": "bee81ba5c5abec1e35e313268f8d8fe72d305d0ad73abfba3d2ea1e2b2308710", + "sha256_in_prefix": "bee81ba5c5abec1e35e313268f8d8fe72d305d0ad73abfba3d2ea1e2b2308710", + "size_in_bytes": 10910 + }, + { + "_path": "lib/python3.10/idlelib/config-main.def", + "path_type": "hardlink", + "sha256": "e783704ad5cd9b3f44c026f55c98be2c52190bf9b7832251283f3e953ba80f87", + "sha256_in_prefix": "e783704ad5cd9b3f44c026f55c98be2c52190bf9b7832251283f3e953ba80f87", + "size_in_bytes": 3168 + }, + { + "_path": "lib/python3.10/idlelib/config.py", + "path_type": "hardlink", + "sha256": "533a7d9cc6eef591f65fc9357df533604ca93a47051846482d554de60f40b9e5", + "sha256_in_prefix": "533a7d9cc6eef591f65fc9357df533604ca93a47051846482d554de60f40b9e5", + "size_in_bytes": 38174 + }, + { + "_path": "lib/python3.10/idlelib/config_key.py", + "path_type": "hardlink", + "sha256": "b4184b23a1cb5e128701b65d95f1ed8c0e7f56867eac1e70c9b2a79b00ae682b", + "sha256_in_prefix": "b4184b23a1cb5e128701b65d95f1ed8c0e7f56867eac1e70c9b2a79b00ae682b", + "size_in_bytes": 15230 + }, + { + "_path": "lib/python3.10/idlelib/configdialog.py", + "path_type": "hardlink", + "sha256": "f09aeb0c344210574a4c7fa641b78d058ccd1c387b627f8b99db90bb94029dde", + "sha256_in_prefix": "f09aeb0c344210574a4c7fa641b78d058ccd1c387b627f8b99db90bb94029dde", + "size_in_bytes": 105728 + }, + { + "_path": "lib/python3.10/idlelib/debugger.py", + "path_type": "hardlink", + "sha256": "126415c89631586d2f51931274a2d8c3dde2c9a4132e8a1f6954c97de78aa417", + "sha256_in_prefix": "126415c89631586d2f51931274a2d8c3dde2c9a4132e8a1f6954c97de78aa417", + "size_in_bytes": 19104 + }, + { + "_path": "lib/python3.10/idlelib/debugger_r.py", + "path_type": "hardlink", + "sha256": "ca94d058b89af51dbad41ae8b7e20973fdaa0c31e1fb29b141499e6339d29f55", + "sha256_in_prefix": "ca94d058b89af51dbad41ae8b7e20973fdaa0c31e1fb29b141499e6339d29f55", + "size_in_bytes": 12167 + }, + { + "_path": "lib/python3.10/idlelib/debugobj.py", + "path_type": "hardlink", + "sha256": "db8add0abc885fc629c6746aca77cd40026b2dac8d7edb93f1fcf6ea9d28334f", + "sha256_in_prefix": "db8add0abc885fc629c6746aca77cd40026b2dac8d7edb93f1fcf6ea9d28334f", + "size_in_bytes": 4055 + }, + { + "_path": "lib/python3.10/idlelib/debugobj_r.py", + "path_type": "hardlink", + "sha256": "4e583b43fdf9bd4a731d70e074ee597aba03f3c8c36302bdc7e74650fb1fcc11", + "sha256_in_prefix": "4e583b43fdf9bd4a731d70e074ee597aba03f3c8c36302bdc7e74650fb1fcc11", + "size_in_bytes": 1082 + }, + { + "_path": "lib/python3.10/idlelib/delegator.py", + "path_type": "hardlink", + "sha256": "3b79bbd9ef3bc789559f5af7b0c844d5292ae02368d167dd5751ead2343109d5", + "sha256_in_prefix": "3b79bbd9ef3bc789559f5af7b0c844d5292ae02368d167dd5751ead2343109d5", + "size_in_bytes": 1043 + }, + { + "_path": "lib/python3.10/idlelib/dynoption.py", + "path_type": "hardlink", + "sha256": "c8a26c028d87253f0317ef79c7490ef08eb7ed02034328abb8dedb30ca61c199", + "sha256_in_prefix": "c8a26c028d87253f0317ef79c7490ef08eb7ed02034328abb8dedb30ca61c199", + "size_in_bytes": 1991 + }, + { + "_path": "lib/python3.10/idlelib/editor.py", + "path_type": "hardlink", + "sha256": "2d9010e59ffce802d6f5ec40bc178a3cc168ac9518a61ee89796c5382e86aed8", + "sha256_in_prefix": "2d9010e59ffce802d6f5ec40bc178a3cc168ac9518a61ee89796c5382e86aed8", + "size_in_bytes": 66385 + }, + { + "_path": "lib/python3.10/idlelib/extend.txt", + "path_type": "hardlink", + "sha256": "5bceaf660c46faf8f9fbf2be5e23389d6e6477d1e458fee680e606bcc95d2853", + "sha256_in_prefix": "5bceaf660c46faf8f9fbf2be5e23389d6e6477d1e458fee680e606bcc95d2853", + "size_in_bytes": 3631 + }, + { + "_path": "lib/python3.10/idlelib/filelist.py", + "path_type": "hardlink", + "sha256": "b2923b72d89db91bda3abdfc9a7a42789e4a20a70f4ff8cab0a737995249f0d3", + "sha256_in_prefix": "b2923b72d89db91bda3abdfc9a7a42789e4a20a70f4ff8cab0a737995249f0d3", + "size_in_bytes": 3876 + }, + { + "_path": "lib/python3.10/idlelib/format.py", + "path_type": "hardlink", + "sha256": "dc2b00fb239f38543bf973d94daef2c52457b905d4d89c640993823127b7923c", + "sha256_in_prefix": "dc2b00fb239f38543bf973d94daef2c52457b905d4d89c640993823127b7923c", + "size_in_bytes": 15777 + }, + { + "_path": "lib/python3.10/idlelib/grep.py", + "path_type": "hardlink", + "sha256": "fb50ba574b03745100cdaed82ae64105baac6a43cfb52ed4af5e7c2a9579ee9f", + "sha256_in_prefix": "fb50ba574b03745100cdaed82ae64105baac6a43cfb52ed4af5e7c2a9579ee9f", + "size_in_bytes": 7479 + }, + { + "_path": "lib/python3.10/idlelib/help.html", + "path_type": "hardlink", + "sha256": "0561d384ebee70e8bd3d7beeca4902a57b723f500a4a3f45fc7cbf506b04ac66", + "sha256_in_prefix": "0561d384ebee70e8bd3d7beeca4902a57b723f500a4a3f45fc7cbf506b04ac66", + "size_in_bytes": 79125 + }, + { + "_path": "lib/python3.10/idlelib/help.py", + "path_type": "hardlink", + "sha256": "5016f926ffee9ac3b9e07f76d5d4ee3d770fdffc865f2e1d90e9edd0bf642485", + "sha256_in_prefix": "5016f926ffee9ac3b9e07f76d5d4ee3d770fdffc865f2e1d90e9edd0bf642485", + "size_in_bytes": 11855 + }, + { + "_path": "lib/python3.10/idlelib/help_about.py", + "path_type": "hardlink", + "sha256": "527dc9c6dcea4ffef3e775c6cfea98d1df200f903e1f5e94459f4c552661509f", + "sha256_in_prefix": "527dc9c6dcea4ffef3e775c6cfea98d1df200f903e1f5e94459f4c552661509f", + "size_in_bytes": 9106 + }, + { + "_path": "lib/python3.10/idlelib/history.py", + "path_type": "hardlink", + "sha256": "3a87611a95f1efc7fdd265e1b43eec7ad21ebe8047cf5a5a3365ffafe940c6ad", + "sha256_in_prefix": "3a87611a95f1efc7fdd265e1b43eec7ad21ebe8047cf5a5a3365ffafe940c6ad", + "size_in_bytes": 4064 + }, + { + "_path": "lib/python3.10/idlelib/hyperparser.py", + "path_type": "hardlink", + "sha256": "18563d2b4c248aed70b7f29fd903fd51d1b5aceb3dc93c23f9a54141eed7a9b0", + "sha256_in_prefix": "18563d2b4c248aed70b7f29fd903fd51d1b5aceb3dc93c23f9a54141eed7a9b0", + "size_in_bytes": 12889 + }, + { + "_path": "lib/python3.10/idlelib/idle.bat", + "path_type": "hardlink", + "sha256": "15a3977f0d2c6a8e87db2ef7050ea10afb3a88b064bf5ef95439924e42464114", + "sha256_in_prefix": "15a3977f0d2c6a8e87db2ef7050ea10afb3a88b064bf5ef95439924e42464114", + "size_in_bytes": 177 + }, + { + "_path": "lib/python3.10/idlelib/idle.py", + "path_type": "hardlink", + "sha256": "33ffa2f718e123fd1c4e536bb4a471978515787ee9fbf7806a92073a787a733a", + "sha256_in_prefix": "33ffa2f718e123fd1c4e536bb4a471978515787ee9fbf7806a92073a787a733a", + "size_in_bytes": 454 + }, + { + "_path": "lib/python3.10/idlelib/idle.pyw", + "path_type": "hardlink", + "sha256": "26101d297127132c5e9634499f41ad00e125ea308343a20b278bee9e9225eb5c", + "sha256_in_prefix": "26101d297127132c5e9634499f41ad00e125ea308343a20b278bee9e9225eb5c", + "size_in_bytes": 570 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/README.txt", + "path_type": "hardlink", + "sha256": "bfe6188362a0bc7db8b94c3dd313b97c83ad6d10b79451fd2a8a4bd773cd392b", + "sha256_in_prefix": "bfe6188362a0bc7db8b94c3dd313b97c83ad6d10b79451fd2a8a4bd773cd392b", + "size_in_bytes": 8729 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__init__.py", + "path_type": "hardlink", + "sha256": "228f8efbf4c316bd701b09a72b084a08248e26a346c6a7636a142391a8b3e674", + "sha256_in_prefix": "228f8efbf4c316bd701b09a72b084a08248e26a346c6a7636a142391a8b3e674", + "size_in_bytes": 712 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "536bcb2ea46adf49d286c2b231bba9a8781b8cf0e4e1e6c81cc6e21cb68a248d", + "sha256_in_prefix": "536bcb2ea46adf49d286c2b231bba9a8781b8cf0e4e1e6c81cc6e21cb68a248d", + "size_in_bytes": 1106 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/htest.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "fe4d519fa20c070839320608e12b97d790a4042f5959469543a91a88d3fcf5f4", + "sha256_in_prefix": "fe4d519fa20c070839320608e12b97d790a4042f5959469543a91a88d3fcf5f4", + "size_in_bytes": 14197 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/mock_idle.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "cf8dd4edb5dd08cf0154edebc0ad5dc385dc91062065de8c8762099dd3ef1bee", + "sha256_in_prefix": "cf8dd4edb5dd08cf0154edebc0ad5dc385dc91062065de8c8762099dd3ef1bee", + "size_in_bytes": 2891 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/mock_tk.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "8122bf0ca5d5238c2fff6dd87077bcfbf8e9864bc3c4ee5ac069d6a50e61c648", + "sha256_in_prefix": "8122bf0ca5d5238c2fff6dd87077bcfbf8e9864bc3c4ee5ac069d6a50e61c648", + "size_in_bytes": 11078 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/template.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "248902a31f5c5907adeeec4574e416334b8f4b30972b66276d44caa0803613a4", + "sha256_in_prefix": "248902a31f5c5907adeeec4574e416334b8f4b30972b66276d44caa0803613a4", + "size_in_bytes": 1323 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/test_autocomplete.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "22dd4a32f2e80d8e64d4898f6ed84755d9dd1f14acd76393efe6ba1ad944e269", + "sha256_in_prefix": "22dd4a32f2e80d8e64d4898f6ed84755d9dd1f14acd76393efe6ba1ad944e269", + "size_in_bytes": 10019 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/test_autocomplete_w.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "1e2e0d15b2fdafeb88883e6780c699a229541fa77d1f52ce66601008d4e5c70c", + "sha256_in_prefix": "1e2e0d15b2fdafeb88883e6780c699a229541fa77d1f52ce66601008d4e5c70c", + "size_in_bytes": 1583 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/test_autoexpand.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "98847eb575ddba74b6b9dcbcf99585dead1080ee3b09d4b12d80bc3e706061dc", + "sha256_in_prefix": "98847eb575ddba74b6b9dcbcf99585dead1080ee3b09d4b12d80bc3e706061dc", + "size_in_bytes": 4221 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/test_browser.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "6b829ff9c3f060c1a974dfa8bf257b7583b6382ac8e09cfbcf58bece1a6dfa76", + "sha256_in_prefix": "6b829ff9c3f060c1a974dfa8bf257b7583b6382ac8e09cfbcf58bece1a6dfa76", + "size_in_bytes": 9697 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/test_calltip.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "d661f3e68ea484cec6b568a42df66b0280f3b42179a574f40bc3298456a244c0", + "sha256_in_prefix": "d661f3e68ea484cec6b568a42df66b0280f3b42179a574f40bc3298456a244c0", + "size_in_bytes": 18829 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/test_calltip_w.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "20dff599e8f90076c07fc96066b5dbb20746795741d7c9364b28615dc4672f00", + "sha256_in_prefix": "20dff599e8f90076c07fc96066b5dbb20746795741d7c9364b28615dc4672f00", + "size_in_bytes": 1523 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/test_codecontext.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "6d6b71bd183427a6706ca51cfb98420bb8afda2806f2b5a8b2d8639083f57aac", + "sha256_in_prefix": "6d6b71bd183427a6706ca51cfb98420bb8afda2806f2b5a8b2d8639083f57aac", + "size_in_bytes": 11555 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/test_colorizer.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "f8245b2f7bcb2624e252775539d8b3fc6b4375c2fba2f2ecf1708d13483db5ce", + "sha256_in_prefix": "f8245b2f7bcb2624e252775539d8b3fc6b4375c2fba2f2ecf1708d13483db5ce", + "size_in_bytes": 17031 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/test_config.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "ee94691f84da6e141486d85120455628d57e71257121e07e924c1f97ddb9af10", + "sha256_in_prefix": "ee94691f84da6e141486d85120455628d57e71257121e07e924c1f97ddb9af10", + "size_in_bytes": 24933 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/test_config_key.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "925cc599d8c2a3675838e3b2548ab8e340d925af35394f3146b91b59a9a796c1", + "sha256_in_prefix": "925cc599d8c2a3675838e3b2548ab8e340d925af35394f3146b91b59a9a796c1", + "size_in_bytes": 12375 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/test_configdialog.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "0abf3da08a690f319f1dccb2b17fbc020e32270287122d7666a31cd1d343e1df", + "sha256_in_prefix": "0abf3da08a690f319f1dccb2b17fbc020e32270287122d7666a31cd1d343e1df", + "size_in_bytes": 40590 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/test_debugger.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "247a1b2845fe7ce943bd67ab7d759af1bdf7906cb182a504df97014a5b5c595e", + "sha256_in_prefix": "247a1b2845fe7ce943bd67ab7d759af1bdf7906cb182a504df97014a5b5c595e", + "size_in_bytes": 1365 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/test_debugger_r.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "541fc620a845a6a6e998ecefac6dc360a809f813333e790faba4b1c036d70d25", + "sha256_in_prefix": "541fc620a845a6a6e998ecefac6dc360a809f813333e790faba4b1c036d70d25", + "size_in_bytes": 1367 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/test_debugobj.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "59670f1def2ed9da23d1fe5ce69a7620823b02f5b5a44c85169dfc12299aa51f", + "sha256_in_prefix": "59670f1def2ed9da23d1fe5ce69a7620823b02f5b5a44c85169dfc12299aa51f", + "size_in_bytes": 2818 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/test_debugobj_r.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "b6c6164504c9053d8b12d27e14aa123b890bdc618be1955adea96eb197b99770", + "sha256_in_prefix": "b6c6164504c9053d8b12d27e14aa123b890bdc618be1955adea96eb197b99770", + "size_in_bytes": 1354 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/test_delegator.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "63d4443b0f7524fdb53e0ded8e0057e7f60a90af0be0306c1adc60681740bb5a", + "sha256_in_prefix": "63d4443b0f7524fdb53e0ded8e0057e7f60a90af0be0306c1adc60681740bb5a", + "size_in_bytes": 1335 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/test_editmenu.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "2125e91fc328f7399226cbb163d3f05dc5f87b50056504a851b561069d4706fe", + "sha256_in_prefix": "2125e91fc328f7399226cbb163d3f05dc5f87b50056504a851b561069d4706fe", + "size_in_bytes": 3062 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/test_editor.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "d23cb5d9922818be5eccd3bb0fa6b46acbaf58ab3f246a58c8ec0470116b0ebb", + "sha256_in_prefix": "d23cb5d9922818be5eccd3bb0fa6b46acbaf58ab3f246a58c8ec0470116b0ebb", + "size_in_bytes": 6448 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/test_filelist.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "f97e42a3b79a9f2fa244072b30c9d7a9646f4c42edf462308f36d1b0ec4d5b81", + "sha256_in_prefix": "f97e42a3b79a9f2fa244072b30c9d7a9646f4c42edf462308f36d1b0ec4d5b81", + "size_in_bytes": 1585 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/test_format.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c91189d7a55dd152557a59c453a360043f9eb67233acb4c23e8e4f5d388903af", + "sha256_in_prefix": "c91189d7a55dd152557a59c453a360043f9eb67233acb4c23e8e4f5d388903af", + "size_in_bytes": 20565 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/test_grep.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "e2cfdaf11c1cc6cd5b712ee9d7c9d4e822c2c29871c8b751eabc8f6c55e49e33", + "sha256_in_prefix": "e2cfdaf11c1cc6cd5b712ee9d7c9d4e822c2c29871c8b751eabc8f6c55e49e33", + "size_in_bytes": 5254 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/test_help.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "5b86eb73c9e98a175f119f9c7a390dbd7efa22075520de053667d3716d2b6896", + "sha256_in_prefix": "5b86eb73c9e98a175f119f9c7a390dbd7efa22075520de053667d3716d2b6896", + "size_in_bytes": 1681 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/test_help_about.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "108e020d7ea353857c9bbabb1b42a1cbcd0132bcdd34ba57bc25887050b67567", + "sha256_in_prefix": "108e020d7ea353857c9bbabb1b42a1cbcd0132bcdd34ba57bc25887050b67567", + "size_in_bytes": 6830 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/test_history.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "1c0ed3efc0c444fd36639919c7355ecddef994d765ff74883b2b3ed2ad1db615", + "sha256_in_prefix": "1c0ed3efc0c444fd36639919c7355ecddef994d765ff74883b2b3ed2ad1db615", + "size_in_bytes": 6574 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/test_hyperparser.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "9bcbe811bb07ac287939253a13303e41abad9a3201b983e3da60556fac6bc9be", + "sha256_in_prefix": "9bcbe811bb07ac287939253a13303e41abad9a3201b983e3da60556fac6bc9be", + "size_in_bytes": 7618 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/test_iomenu.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "e309aec656546fe3551b18e8ce5af82b612733dc0cdd59256ffb8a18902a1a07", + "sha256_in_prefix": "e309aec656546fe3551b18e8ce5af82b612733dc0cdd59256ffb8a18902a1a07", + "size_in_bytes": 3307 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/test_macosx.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "7c99a181de25dbbdd0936d06fdde71d71ebc85295b553d65c76ab812fafb044a", + "sha256_in_prefix": "7c99a181de25dbbdd0936d06fdde71d71ebc85295b553d65c76ab812fafb044a", + "size_in_bytes": 4563 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/test_mainmenu.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "a5eb5ec4a7624534a07c4123378ebe71f19d49dcffd1ed44368a7ec7e4dd7236", + "sha256_in_prefix": "a5eb5ec4a7624534a07c4123378ebe71f19d49dcffd1ed44368a7ec7e4dd7236", + "size_in_bytes": 2114 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/test_multicall.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "e5229f1782d6a3b1a8776f1c771bdf2195e09eb207a59a7b621833707b7d1860", + "sha256_in_prefix": "e5229f1782d6a3b1a8776f1c771bdf2195e09eb207a59a7b621833707b7d1860", + "size_in_bytes": 2034 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/test_outwin.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "1e154854731744d547bf24d1ed110bd3081ab4939315aa380e7dc291bad9e2c4", + "sha256_in_prefix": "1e154854731744d547bf24d1ed110bd3081ab4939315aa380e7dc291bad9e2c4", + "size_in_bytes": 5595 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/test_parenmatch.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "4f45ad4cde2d195d55aad7b0707bb7754935774e5f8ceb20bce12b26fe39f85c", + "sha256_in_prefix": "4f45ad4cde2d195d55aad7b0707bb7754935774e5f8ceb20bce12b26fe39f85c", + "size_in_bytes": 4130 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/test_pathbrowser.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "1cc856c1c2d2f98f42ccbbb9f0e777cdfffbeca0e0239544a679425e9798a07f", + "sha256_in_prefix": "1cc856c1c2d2f98f42ccbbb9f0e777cdfffbeca0e0239544a679425e9798a07f", + "size_in_bytes": 3572 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/test_percolator.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "1096de60b1c1b906e236a1c2af4bf9e907c13226cb77e9ae926ff96460531642", + "sha256_in_prefix": "1096de60b1c1b906e236a1c2af4bf9e907c13226cb77e9ae926ff96460531642", + "size_in_bytes": 5112 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/test_pyparse.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "88d1cc40802111b1537e1fee36e58a483cfcb268aa0ba8f0d0eb5bcad676539a", + "sha256_in_prefix": "88d1cc40802111b1537e1fee36e58a483cfcb268aa0ba8f0d0eb5bcad676539a", + "size_in_bytes": 13955 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/test_pyshell.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "b0678afe797c935bf634aeff8076498871f0b4e7ca7d885dc2746eaa50530738", + "sha256_in_prefix": "b0678afe797c935bf634aeff8076498871f0b4e7ca7d885dc2746eaa50530738", + "size_in_bytes": 5723 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/test_query.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "4a37b59fca2ef7446d65bbdb5bcb3ca5a888ea4b9f7067ef35b4d7e34783ab09", + "sha256_in_prefix": "4a37b59fca2ef7446d65bbdb5bcb3ca5a888ea4b9f7067ef35b4d7e34783ab09", + "size_in_bytes": 18969 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/test_redirector.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "95e2357e6a3036068393998a00f4779f96906c2b5261953491247c438a22342f", + "sha256_in_prefix": "95e2357e6a3036068393998a00f4779f96906c2b5261953491247c438a22342f", + "size_in_bytes": 5349 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/test_replace.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "4558a38863be179c0fea38e642b970706fee1dfeb9b81baf737e87cbae11eed9", + "sha256_in_prefix": "4558a38863be179c0fea38e642b970706fee1dfeb9b81baf737e87cbae11eed9", + "size_in_bytes": 7124 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/test_rpc.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "b1f7a72785ba830faf757c4ebe0d58acec49c66c9e20423b74ff00ca481e056f", + "sha256_in_prefix": "b1f7a72785ba830faf757c4ebe0d58acec49c66c9e20423b74ff00ca481e056f", + "size_in_bytes": 1902 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/test_run.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "81827011d4ee162b6ebdfc89a5b5fb4fa3d397a3bf95c72f47518fa7690d7148", + "sha256_in_prefix": "81827011d4ee162b6ebdfc89a5b5fb4fa3d397a3bf95c72f47518fa7690d7148", + "size_in_bytes": 15444 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/test_runscript.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "dd14f1be69ab5dad8017826873b4f9ab7bfaa406652f241b4126d5bf077560bf", + "sha256_in_prefix": "dd14f1be69ab5dad8017826873b4f9ab7bfaa406652f241b4126d5bf077560bf", + "size_in_bytes": 1590 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/test_scrolledlist.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "b01d3927b7a4ed488d533930fa85a3f95303ce4dc0965fa92ab0bce02168df1c", + "sha256_in_prefix": "b01d3927b7a4ed488d533930fa85a3f95303ce4dc0965fa92ab0bce02168df1c", + "size_in_bytes": 1356 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/test_search.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "496ae962cb43004a826ea5941e27c58b66ed263552f928dd9c58637845d1789a", + "sha256_in_prefix": "496ae962cb43004a826ea5941e27c58b66ed263552f928dd9c58637845d1789a", + "size_in_bytes": 2745 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/test_searchbase.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "842b051fd584630d069c50c522337ed7e6c3effc9e660d458fd364c8154fa123", + "sha256_in_prefix": "842b051fd584630d069c50c522337ed7e6c3effc9e660d458fd364c8154fa123", + "size_in_bytes": 5598 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/test_searchengine.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "9297789408a08bfbb9eecf81c444ea1e0b2cc22866a61a53d02036f9da30137a", + "sha256_in_prefix": "9297789408a08bfbb9eecf81c444ea1e0b2cc22866a61a53d02036f9da30137a", + "size_in_bytes": 9638 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/test_sidebar.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "ca450d551ebda7dea40b2196fa0930506a012db51c0e831d38ec51a3365a18b9", + "sha256_in_prefix": "ca450d551ebda7dea40b2196fa0930506a012db51c0e831d38ec51a3365a18b9", + "size_in_bytes": 24820 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/test_squeezer.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "18cd4577760ee7de0f41c6c0e90eb05e6182c98b0d2154a9da3b1071aa6e657e", + "sha256_in_prefix": "18cd4577760ee7de0f41c6c0e90eb05e6182c98b0d2154a9da3b1071aa6e657e", + "size_in_bytes": 15950 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/test_stackviewer.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "a67cd6c2e7688a9e4b70ae5467858c3e7a6ac5b5a38eee4c162ae78bd905f55e", + "sha256_in_prefix": "a67cd6c2e7688a9e4b70ae5467858c3e7a6ac5b5a38eee4c162ae78bd905f55e", + "size_in_bytes": 1811 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/test_statusbar.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "7376a2704e72402edf0dfd951a30b4ad1336b2cc24dd607e22414ba0e65e8a5d", + "sha256_in_prefix": "7376a2704e72402edf0dfd951a30b4ad1336b2cc24dd607e22414ba0e65e8a5d", + "size_in_bytes": 1838 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/test_text.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "b8a7b06c73010b909a55d7494e0eec4fdbd86fd38bfea5b2c44323c5c2ccc927", + "sha256_in_prefix": "b8a7b06c73010b909a55d7494e0eec4fdbd86fd38bfea5b2c44323c5c2ccc927", + "size_in_bytes": 6524 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/test_textview.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "6507b26cae9202f04b34b4171e233ece12d20f13a67785c349f1cbf35c44e8a2", + "sha256_in_prefix": "6507b26cae9202f04b34b4171e233ece12d20f13a67785c349f1cbf35c44e8a2", + "size_in_bytes": 9422 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/test_tooltip.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "91b435283e45e06c17cb3f98224bf61630c20e15e076fbdbe3e6bd23ab7fdbe1", + "sha256_in_prefix": "91b435283e45e06c17cb3f98224bf61630c20e15e076fbdbe3e6bd23ab7fdbe1", + "size_in_bytes": 5448 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/test_tree.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "44efd8d8e54b552e64c1cb09378caf9e53fa3a4cdfec78bdc73859fce8f15828", + "sha256_in_prefix": "44efd8d8e54b552e64c1cb09378caf9e53fa3a4cdfec78bdc73859fce8f15828", + "size_in_bytes": 2949 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/test_undo.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "07d9bdb01eca4d177cc342eb676cb2467d2d8b36c75af5557d3205759d22701a", + "sha256_in_prefix": "07d9bdb01eca4d177cc342eb676cb2467d2d8b36c75af5557d3205759d22701a", + "size_in_bytes": 4418 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/test_util.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "50439a850b4ea089785b58d2999516da96363260ab1227319dd62aca44fd0af9", + "sha256_in_prefix": "50439a850b4ea089785b58d2999516da96363260ab1227319dd62aca44fd0af9", + "size_in_bytes": 954 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/test_warning.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c69c2720f0a04b95081f9513b1e595c0954d6245d4e7f37f7f32fed28f48ab66", + "sha256_in_prefix": "c69c2720f0a04b95081f9513b1e595c0954d6245d4e7f37f7f32fed28f48ab66", + "size_in_bytes": 2766 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/test_window.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "47e965392ad17e8f0596941ab785c8f311f4ec474ea49a1ace3b15609a1ba2bb", + "sha256_in_prefix": "47e965392ad17e8f0596941ab785c8f311f4ec474ea49a1ace3b15609a1ba2bb", + "size_in_bytes": 1891 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/test_zoomheight.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "0fb3f4c161c3d1b70252093ed20e1f05b8ca877a5a5a97b94ba710cc915392e4", + "sha256_in_prefix": "0fb3f4c161c3d1b70252093ed20e1f05b8ca877a5a5a97b94ba710cc915392e4", + "size_in_bytes": 1780 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/test_zzdummy.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "f7ad93e7ef728fb79d982374876e735bd2f5dcdb8052c9d328b0a6ca7fb18a11", + "sha256_in_prefix": "f7ad93e7ef728fb79d982374876e735bd2f5dcdb8052c9d328b0a6ca7fb18a11", + "size_in_bytes": 4766 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/__pycache__/tkinter_testing_utils.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "249addc02b7797c461e3643a6d74298a08d5c40a7511faec912a58b563bd3dff", + "sha256_in_prefix": "249addc02b7797c461e3643a6d74298a08d5c40a7511faec912a58b563bd3dff", + "size_in_bytes": 2436 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/example_noext", + "path_type": "hardlink", + "sha256": "526edff5d21fd1f1421f5ab6a706cb51732edcae235b9895f93a8f46e25505fe", + "sha256_in_prefix": "526edff5d21fd1f1421f5ab6a706cb51732edcae235b9895f93a8f46e25505fe", + "size_in_bytes": 68 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/example_stub.pyi", + "path_type": "hardlink", + "sha256": "5546cf759222c0f6ad74c740c6bf9558a731ef75d57988a5233beed40aa3a28b", + "sha256_in_prefix": "5546cf759222c0f6ad74c740c6bf9558a731ef75d57988a5233beed40aa3a28b", + "size_in_bytes": 87 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/htest.py", + "path_type": "hardlink", + "sha256": "48e03aae8546b4e1579edf21b47bd9835f11a6b097752d8226ca515c887e77e0", + "sha256_in_prefix": "48e03aae8546b4e1579edf21b47bd9835f11a6b097752d8226ca515c887e77e0", + "size_in_bytes": 15199 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/mock_idle.py", + "path_type": "hardlink", + "sha256": "637d74d26089c582fb784c2920f5bcb41e5b1fc8b9e0931ddc1cc8d92becbff4", + "sha256_in_prefix": "637d74d26089c582fb784c2920f5bcb41e5b1fc8b9e0931ddc1cc8d92becbff4", + "size_in_bytes": 1943 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/mock_tk.py", + "path_type": "hardlink", + "sha256": "7d60a26e82fd0469a95e02c2adda6607363a51ab67d5851cc323a58a595f74a7", + "sha256_in_prefix": "7d60a26e82fd0469a95e02c2adda6607363a51ab67d5851cc323a58a595f74a7", + "size_in_bytes": 11693 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/template.py", + "path_type": "hardlink", + "sha256": "43421286ad234a4240f8d4bc09f67bb58da0bf9d9b07bf93010989ef2c17f2f8", + "sha256_in_prefix": "43421286ad234a4240f8d4bc09f67bb58da0bf9d9b07bf93010989ef2c17f2f8", + "size_in_bytes": 642 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/test_autocomplete.py", + "path_type": "hardlink", + "sha256": "0ee1af80bb645bd57e6f6383f5e5473f901e9d40524992abf9c48a4163997eef", + "sha256_in_prefix": "0ee1af80bb645bd57e6f6383f5e5473f901e9d40524992abf9c48a4163997eef", + "size_in_bytes": 11093 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/test_autocomplete_w.py", + "path_type": "hardlink", + "sha256": "f8cd80196c2841f65f53ca5ae1c4fb99c7c215b29cf88774e0b189c99e4cee79", + "sha256_in_prefix": "f8cd80196c2841f65f53ca5ae1c4fb99c7c215b29cf88774e0b189c99e4cee79", + "size_in_bytes": 720 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/test_autoexpand.py", + "path_type": "hardlink", + "sha256": "85f913f8cbd5dfd5d52d3b7d00eedec231ec3e4ee7d117db4a2bb714eb1a7243", + "sha256_in_prefix": "85f913f8cbd5dfd5d52d3b7d00eedec231ec3e4ee7d117db4a2bb714eb1a7243", + "size_in_bytes": 4638 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/test_browser.py", + "path_type": "hardlink", + "sha256": "bdfd3bd9ab02ee535e77f3233920f80891eb84d7042f7db381afc7766b3702eb", + "sha256_in_prefix": "bdfd3bd9ab02ee535e77f3233920f80891eb84d7042f7db381afc7766b3702eb", + "size_in_bytes": 8420 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/test_calltip.py", + "path_type": "hardlink", + "sha256": "8fd994aed39f1b89a05137e2bf6e53401685ec408d5c424e267ff635bf8a6cdb", + "sha256_in_prefix": "8fd994aed39f1b89a05137e2bf6e53401685ec408d5c424e267ff635bf8a6cdb", + "size_in_bytes": 13194 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/test_calltip_w.py", + "path_type": "hardlink", + "sha256": "7462c048c689f82c3ae6b5782a18776762f88055b80ae77a92243b6c0606e004", + "sha256_in_prefix": "7462c048c689f82c3ae6b5782a18776762f88055b80ae77a92243b6c0606e004", + "size_in_bytes": 686 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/test_codecontext.py", + "path_type": "hardlink", + "sha256": "84e6b890b22b2abcc0865c691162b93c6ffb9b4e17f05011bdaffa770a52fcf0", + "sha256_in_prefix": "84e6b890b22b2abcc0865c691162b93c6ffb9b4e17f05011bdaffa770a52fcf0", + "size_in_bytes": 16082 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/test_colorizer.py", + "path_type": "hardlink", + "sha256": "6a3fbb630e0ecc7aafc9c8bc56ece3462911c733aa3bb4c52ee55c1d897301d4", + "sha256_in_prefix": "6a3fbb630e0ecc7aafc9c8bc56ece3462911c733aa3bb4c52ee55c1d897301d4", + "size_in_bytes": 22882 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/test_config.py", + "path_type": "hardlink", + "sha256": "98f856694b51330c729d4a87f5efd4c6c805db01edcea77d80b17f89d71bc054", + "sha256_in_prefix": "98f856694b51330c729d4a87f5efd4c6c805db01edcea77d80b17f89d71bc054", + "size_in_bytes": 32046 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/test_config_key.py", + "path_type": "hardlink", + "sha256": "54d0c65e1f66d37c415d3fe533c8db891974f08e8fca6374596280d64db86586", + "sha256_in_prefix": "54d0c65e1f66d37c415d3fe533c8db891974f08e8fca6374596280d64db86586", + "size_in_bytes": 11462 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/test_configdialog.py", + "path_type": "hardlink", + "sha256": "657ef252b2fa26800bddf96c2d0027c65a9d38ea4d87458f0386965c36abd1f5", + "sha256_in_prefix": "657ef252b2fa26800bddf96c2d0027c65a9d38ea4d87458f0386965c36abd1f5", + "size_in_bytes": 55344 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/test_debugger.py", + "path_type": "hardlink", + "sha256": "1881dcf94b0a44fe355f2acabfe25d8d67871402bbc19aaab37c6ff955575f1d", + "sha256_in_prefix": "1881dcf94b0a44fe355f2acabfe25d8d67871402bbc19aaab37c6ff955575f1d", + "size_in_bytes": 571 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/test_debugger_r.py", + "path_type": "hardlink", + "sha256": "ccc0ba5e03ee1df449f78a164efdc6739f5a530315ab3971ac05c652bc779cea", + "sha256_in_prefix": "ccc0ba5e03ee1df449f78a164efdc6739f5a530315ab3971ac05c652bc779cea", + "size_in_bytes": 965 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/test_debugobj.py", + "path_type": "hardlink", + "sha256": "e35a9f45b223d5c7e7f3bbfd8bc6495b1156c40b0ce3747ade0aed7b41aa23ac", + "sha256_in_prefix": "e35a9f45b223d5c7e7f3bbfd8bc6495b1156c40b0ce3747ade0aed7b41aa23ac", + "size_in_bytes": 1561 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/test_debugobj_r.py", + "path_type": "hardlink", + "sha256": "22d74368ba175175b9c14315f9d82fd7ddde60ae93d2e5572e9a647de7e869eb", + "sha256_in_prefix": "22d74368ba175175b9c14315f9d82fd7ddde60ae93d2e5572e9a647de7e869eb", + "size_in_bytes": 545 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/test_delegator.py", + "path_type": "hardlink", + "sha256": "559d39df8c1ff38d177943f245b87f5379ee5ea93399fd6b5f7bfa882e6ed8ca", + "sha256_in_prefix": "559d39df8c1ff38d177943f245b87f5379ee5ea93399fd6b5f7bfa882e6ed8ca", + "size_in_bytes": 1567 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/test_editmenu.py", + "path_type": "hardlink", + "sha256": "ed3800137d48ffcf86ecb71afe5a24cd9ed381571f23036438ba8a97f502326a", + "sha256_in_prefix": "ed3800137d48ffcf86ecb71afe5a24cd9ed381571f23036438ba8a97f502326a", + "size_in_bytes": 2564 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/test_editor.py", + "path_type": "hardlink", + "sha256": "7a858680c0c8753aad533388164f04ba3e82855ee8a8b9cfa537f01d923e49c9", + "sha256_in_prefix": "7a858680c0c8753aad533388164f04ba3e82855ee8a8b9cfa537f01d923e49c9", + "size_in_bytes": 7220 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/test_filelist.py", + "path_type": "hardlink", + "sha256": "d4cea5fdba68fb9e361541820d44eed003c317f4ef14bb9df3406b8d2c53ef7c", + "sha256_in_prefix": "d4cea5fdba68fb9e361541820d44eed003c317f4ef14bb9df3406b8d2c53ef7c", + "size_in_bytes": 795 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/test_format.py", + "path_type": "hardlink", + "sha256": "b356a2a8f5fe14c39c6af73623484df4ed930cc16ef4605f3b04fd9b618867a6", + "sha256_in_prefix": "b356a2a8f5fe14c39c6af73623484df4ed930cc16ef4605f3b04fd9b618867a6", + "size_in_bytes": 23610 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/test_grep.py", + "path_type": "hardlink", + "sha256": "ca64de882b5608e016b7df8f739089c9f262643bce09979b76399cc4be1ea12c", + "sha256_in_prefix": "ca64de882b5608e016b7df8f739089c9f262643bce09979b76399cc4be1ea12c", + "size_in_bytes": 5072 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/test_help.py", + "path_type": "hardlink", + "sha256": "e39288f4326136cadb4fab81fe31223187136bc3d9bdf65a9d67fd152e50a6e9", + "sha256_in_prefix": "e39288f4326136cadb4fab81fe31223187136bc3d9bdf65a9d67fd152e50a6e9", + "size_in_bytes": 849 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/test_help_about.py", + "path_type": "hardlink", + "sha256": "d0268651a7c7b4aec72da3e81c45b8488d33de3459300b7226dccc31ad956309", + "sha256_in_prefix": "d0268651a7c7b4aec72da3e81c45b8488d33de3459300b7226dccc31ad956309", + "size_in_bytes": 5919 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/test_history.py", + "path_type": "hardlink", + "sha256": "6319fe7810ed91786b503de80701a291a4f9abe54c9e101c19c0917b709e62f3", + "sha256_in_prefix": "6319fe7810ed91786b503de80701a291a4f9abe54c9e101c19c0917b709e62f3", + "size_in_bytes": 5517 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/test_hyperparser.py", + "path_type": "hardlink", + "sha256": "cd2fbc788d4d75b514e53951dc90d00d41a8a87baad31bc1e380b7449bfcf183", + "sha256_in_prefix": "cd2fbc788d4d75b514e53951dc90d00d41a8a87baad31bc1e380b7449bfcf183", + "size_in_bytes": 9082 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/test_iomenu.py", + "path_type": "hardlink", + "sha256": "c951a80a012812b1922b6486c7e4c4c82c5fbb5c2f10a6e30ef21e9ba6fb0621", + "sha256_in_prefix": "c951a80a012812b1922b6486c7e4c4c82c5fbb5c2f10a6e30ef21e9ba6fb0621", + "size_in_bytes": 2194 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/test_macosx.py", + "path_type": "hardlink", + "sha256": "975e48ab453711c5072988e2e66a7fe51e716ac64e494f022a5ff82781ccd368", + "sha256_in_prefix": "975e48ab453711c5072988e2e66a7fe51e716ac64e494f022a5ff82781ccd368", + "size_in_bytes": 3444 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/test_mainmenu.py", + "path_type": "hardlink", + "sha256": "faa064ffd9c8e30b1205e46bb4ede816c74b7948cfa34c7795ed19c35eac10d5", + "sha256_in_prefix": "faa064ffd9c8e30b1205e46bb4ede816c74b7948cfa34c7795ed19c35eac10d5", + "size_in_bytes": 1638 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/test_multicall.py", + "path_type": "hardlink", + "sha256": "1bfb51912275d8e346dce0a40ab84316b15e3f142e66529a8c9cfd52210c1a1f", + "sha256_in_prefix": "1bfb51912275d8e346dce0a40ab84316b15e3f142e66529a8c9cfd52210c1a1f", + "size_in_bytes": 1317 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/test_outwin.py", + "path_type": "hardlink", + "sha256": "255ae7e3271491d7bacb0cc32d0cc9b88c689c58d8543dad1bafec569109c7c6", + "sha256_in_prefix": "255ae7e3271491d7bacb0cc32d0cc9b88c689c58d8543dad1bafec569109c7c6", + "size_in_bytes": 5422 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/test_parenmatch.py", + "path_type": "hardlink", + "sha256": "5e0ba86116e28d46e7db9ed33d85cf7caa837e1779e1b8feb5f6b6b4a837551e", + "sha256_in_prefix": "5e0ba86116e28d46e7db9ed33d85cf7caa837e1779e1b8feb5f6b6b4a837551e", + "size_in_bytes": 3544 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/test_pathbrowser.py", + "path_type": "hardlink", + "sha256": "a7d9c5085ff5c64232897f6ee0a09258a41a35f153f47ff0f3b8fa97ec67be9e", + "sha256_in_prefix": "a7d9c5085ff5c64232897f6ee0a09258a41a35f153f47ff0f3b8fa97ec67be9e", + "size_in_bytes": 2422 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/test_percolator.py", + "path_type": "hardlink", + "sha256": "133b134a46b23cf2c635be3116415fd388e3a1c1581bf1a77d7f7f0aff3a725b", + "sha256_in_prefix": "133b134a46b23cf2c635be3116415fd388e3a1c1581bf1a77d7f7f0aff3a725b", + "size_in_bytes": 4065 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/test_pyparse.py", + "path_type": "hardlink", + "sha256": "8f386a9f535369afb495322e104077c66c5a3abb91917ec69f868b405120cf35", + "sha256_in_prefix": "8f386a9f535369afb495322e104077c66c5a3abb91917ec69f868b405120cf35", + "size_in_bytes": 19365 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/test_pyshell.py", + "path_type": "hardlink", + "sha256": "ff47aecd0657edbd7bc920473fe2e55b0bb0db6f347dc52f5e81b767897d3bc5", + "sha256_in_prefix": "ff47aecd0657edbd7bc920473fe2e55b0bb0db6f347dc52f5e81b767897d3bc5", + "size_in_bytes": 4965 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/test_query.py", + "path_type": "hardlink", + "sha256": "632c2dc13a158a5902e5b758166151ffa377db7f5a0c368bc3b0741a237876c3", + "sha256_in_prefix": "632c2dc13a158a5902e5b758166151ffa377db7f5a0c368bc3b0741a237876c3", + "size_in_bytes": 15454 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/test_redirector.py", + "path_type": "hardlink", + "sha256": "517c1fe16da359e01f3cdfdf3f7aead4283e8b8e1107522b72f59d4c4f3ade4c", + "sha256_in_prefix": "517c1fe16da359e01f3cdfdf3f7aead4283e8b8e1107522b72f59d4c4f3ade4c", + "size_in_bytes": 4176 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/test_replace.py", + "path_type": "hardlink", + "sha256": "321333b3eaad9ecbf633186bc625d4a60c4c736def0fa00665add2ab899eecb1", + "sha256_in_prefix": "321333b3eaad9ecbf633186bc625d4a60c4c736def0fa00665add2ab899eecb1", + "size_in_bytes": 8299 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/test_rpc.py", + "path_type": "hardlink", + "sha256": "1e2d997f442002389b3dadb47ed8134947c664a32ef637f43afdcbd1b5c13823", + "sha256_in_prefix": "1e2d997f442002389b3dadb47ed8134947c664a32ef637f43afdcbd1b5c13823", + "size_in_bytes": 805 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/test_run.py", + "path_type": "hardlink", + "sha256": "3a116bd1038efdb87831c45bece072fae2464cd568f1ddb9cca1d7fb85bf34a9", + "sha256_in_prefix": "3a116bd1038efdb87831c45bece072fae2464cd568f1ddb9cca1d7fb85bf34a9", + "size_in_bytes": 15687 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/test_runscript.py", + "path_type": "hardlink", + "sha256": "4264a834dc230d397725f398d905d0746321d543c56644e5c89af59fe3fedb61", + "sha256_in_prefix": "4264a834dc230d397725f398d905d0746321d543c56644e5c89af59fe3fedb61", + "size_in_bytes": 777 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/test_scrolledlist.py", + "path_type": "hardlink", + "sha256": "a84ec601c8786daf0564e978c97c0e14095c23f9a08bb64950f9cb541b074b3a", + "sha256_in_prefix": "a84ec601c8786daf0564e978c97c0e14095c23f9a08bb64950f9cb541b074b3a", + "size_in_bytes": 496 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/test_search.py", + "path_type": "hardlink", + "sha256": "c0550b241c99a566f61929515ca97aedf99f73568df3dfe93078ed22cb54892b", + "sha256_in_prefix": "c0550b241c99a566f61929515ca97aedf99f73568df3dfe93078ed22cb54892b", + "size_in_bytes": 2459 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/test_searchbase.py", + "path_type": "hardlink", + "sha256": "2b8550dd411b75c6152c4da90843e1221094400080f9a1752e383d0b776f775b", + "sha256_in_prefix": "2b8550dd411b75c6152c4da90843e1221094400080f9a1752e383d0b776f775b", + "size_in_bytes": 5691 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/test_searchengine.py", + "path_type": "hardlink", + "sha256": "519ddd5633eb8732539594f79ed21a6544f65e599a0d5c8c84db3a488ccdad97", + "sha256_in_prefix": "519ddd5633eb8732539594f79ed21a6544f65e599a0d5c8c84db3a488ccdad97", + "size_in_bytes": 11588 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/test_sidebar.py", + "path_type": "hardlink", + "sha256": "3d5410aa97577c88566586aedc0258389289aca9aedc034a11b8e06c49edb6fc", + "sha256_in_prefix": "3d5410aa97577c88566586aedc0258389289aca9aedc034a11b8e06c49edb6fc", + "size_in_bytes": 26573 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/test_squeezer.py", + "path_type": "hardlink", + "sha256": "9f5b9ca3ff2dc7bd2b9308d417f1698893f236677f3b41694144fa029db75506", + "sha256_in_prefix": "9f5b9ca3ff2dc7bd2b9308d417f1698893f236677f3b41694144fa029db75506", + "size_in_bytes": 19680 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/test_stackviewer.py", + "path_type": "hardlink", + "sha256": "483502cfbfce0ac87198cfd6d0ec7e5eec68834042ed949875730a35764c83ca", + "sha256_in_prefix": "483502cfbfce0ac87198cfd6d0ec7e5eec68834042ed949875730a35764c83ca", + "size_in_bytes": 1206 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/test_statusbar.py", + "path_type": "hardlink", + "sha256": "0e9b262b9ad0046cbb0af1101a651fcb88cd1cba38e474b863abbb074b260a02", + "sha256_in_prefix": "0e9b262b9ad0046cbb0af1101a651fcb88cd1cba38e474b863abbb074b260a02", + "size_in_bytes": 1133 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/test_text.py", + "path_type": "hardlink", + "sha256": "55abe8a9d0bdb45efecb879207f1259702cdcf47dbc636d7cca8dd458f0dc70f", + "sha256_in_prefix": "55abe8a9d0bdb45efecb879207f1259702cdcf47dbc636d7cca8dd458f0dc70f", + "size_in_bytes": 6970 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/test_textview.py", + "path_type": "hardlink", + "sha256": "e45b199106608c7c981c149d3b4ccf092e7a2e7e9430cc76887cd769b9aaf533", + "sha256_in_prefix": "e45b199106608c7c981c149d3b4ccf092e7a2e7e9430cc76887cd769b9aaf533", + "size_in_bytes": 7364 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/test_tooltip.py", + "path_type": "hardlink", + "sha256": "b9a82e57761bbca3d4e07193652e8294895765092ef8a651f4dcf63acec7f153", + "sha256_in_prefix": "b9a82e57761bbca3d4e07193652e8294895765092ef8a651f4dcf63acec7f153", + "size_in_bytes": 5385 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/test_tree.py", + "path_type": "hardlink", + "sha256": "62ae68d64105485107e8173f94ce09739f276004bc8fa65efa5add2c6188e166", + "sha256_in_prefix": "62ae68d64105485107e8173f94ce09739f276004bc8fa65efa5add2c6188e166", + "size_in_bytes": 1752 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/test_undo.py", + "path_type": "hardlink", + "sha256": "c5178b2dd77d794938fa52adce719d4948a92ba1a689068cec1fb6888d033e0e", + "sha256_in_prefix": "c5178b2dd77d794938fa52adce719d4948a92ba1a689068cec1fb6888d033e0e", + "size_in_bytes": 4228 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/test_util.py", + "path_type": "hardlink", + "sha256": "300f627fc2199deb246ec793ef47b032de742d763a4170c8bb15e19ccbf602a5", + "sha256_in_prefix": "300f627fc2199deb246ec793ef47b032de742d763a4170c8bb15e19ccbf602a5", + "size_in_bytes": 308 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/test_warning.py", + "path_type": "hardlink", + "sha256": "d1efc442b3fb93de89fb0988c73f8536fc5099afb761d2b69ec101c239c8c193", + "sha256_in_prefix": "d1efc442b3fb93de89fb0988c73f8536fc5099afb761d2b69ec101c239c8c193", + "size_in_bytes": 2740 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/test_window.py", + "path_type": "hardlink", + "sha256": "336f2b6994f5aacca9689f32249db20a8dac36934314b7d5ba391d94169d63c6", + "sha256_in_prefix": "336f2b6994f5aacca9689f32249db20a8dac36934314b7d5ba391d94169d63c6", + "size_in_bytes": 1075 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/test_zoomheight.py", + "path_type": "hardlink", + "sha256": "6300aa47014a5c2dfc9bc0d6c3fb234dff4e4b60a6527d4cdfbb8c416f99df44", + "sha256_in_prefix": "6300aa47014a5c2dfc9bc0d6c3fb234dff4e4b60a6527d4cdfbb8c416f99df44", + "size_in_bytes": 999 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/test_zzdummy.py", + "path_type": "hardlink", + "sha256": "4502524aaa1923393725c04e6b2f27077399190e42bc8903415e95718c5f3c6f", + "sha256_in_prefix": "4502524aaa1923393725c04e6b2f27077399190e42bc8903415e95718c5f3c6f", + "size_in_bytes": 4455 + }, + { + "_path": "lib/python3.10/idlelib/idle_test/tkinter_testing_utils.py", + "path_type": "hardlink", + "sha256": "ece147cef65152a54b0a3d4319bdf8ed82d9a6310273b0056cc17a2de4d744cd", + "sha256_in_prefix": "ece147cef65152a54b0a3d4319bdf8ed82d9a6310273b0056cc17a2de4d744cd", + "size_in_bytes": 2333 + }, + { + "_path": "lib/python3.10/idlelib/iomenu.py", + "path_type": "hardlink", + "sha256": "46d2505e3e2cd9737d732ec7949f1712550c93dc949318d64b81339160716cc6", + "sha256_in_prefix": "46d2505e3e2cd9737d732ec7949f1712550c93dc949318d64b81339160716cc6", + "size_in_bytes": 15971 + }, + { + "_path": "lib/python3.10/idlelib/macosx.py", + "path_type": "hardlink", + "sha256": "783748f1198726cd0ca7a779ead35bf157ff076bfab4a8562a8c257ff1f3afec", + "sha256_in_prefix": "783748f1198726cd0ca7a779ead35bf157ff076bfab4a8562a8c257ff1f3afec", + "size_in_bytes": 10150 + }, + { + "_path": "lib/python3.10/idlelib/mainmenu.py", + "path_type": "hardlink", + "sha256": "092fad4454f593d7bf2e5e1e746acade92bb346d06476ba527f162f843ae3208", + "sha256_in_prefix": "092fad4454f593d7bf2e5e1e746acade92bb346d06476ba527f162f843ae3208", + "size_in_bytes": 3938 + }, + { + "_path": "lib/python3.10/idlelib/multicall.py", + "path_type": "hardlink", + "sha256": "277f16699b17c3fd176c1b259959ed235bb9bb59d54731203c9c33c2e0e43172", + "sha256_in_prefix": "277f16699b17c3fd176c1b259959ed235bb9bb59d54731203c9c33c2e0e43172", + "size_in_bytes": 18648 + }, + { + "_path": "lib/python3.10/idlelib/outwin.py", + "path_type": "hardlink", + "sha256": "39a6018927b4543c3fcbd857f3bd1de7097c8f185bdee8f3373c7c3c4da70e84", + "sha256_in_prefix": "39a6018927b4543c3fcbd857f3bd1de7097c8f185bdee8f3373c7c3c4da70e84", + "size_in_bytes": 5709 + }, + { + "_path": "lib/python3.10/idlelib/parenmatch.py", + "path_type": "hardlink", + "sha256": "f122e13c385a135cbbbe8b1d87efeed43ddd3e0be9ddd8aa24b267b61fac4287", + "sha256_in_prefix": "f122e13c385a135cbbbe8b1d87efeed43ddd3e0be9ddd8aa24b267b61fac4287", + "size_in_bytes": 7204 + }, + { + "_path": "lib/python3.10/idlelib/pathbrowser.py", + "path_type": "hardlink", + "sha256": "0d0bf5c92b0f2a5fe25ddf95729f6cba8a9ac48c7c0d1c2fdd7a7532586f2ea4", + "sha256_in_prefix": "0d0bf5c92b0f2a5fe25ddf95729f6cba8a9ac48c7c0d1c2fdd7a7532586f2ea4", + "size_in_bytes": 3193 + }, + { + "_path": "lib/python3.10/idlelib/percolator.py", + "path_type": "hardlink", + "sha256": "b55510d26956f8695d9309ad4a9615a7bae8ca95bd2a9f277abcd463bf2c8464", + "sha256_in_prefix": "b55510d26956f8695d9309ad4a9615a7bae8ca95bd2a9f277abcd463bf2c8464", + "size_in_bytes": 3546 + }, + { + "_path": "lib/python3.10/idlelib/pyparse.py", + "path_type": "hardlink", + "sha256": "21c6bf43370998d5a5a6670f7b13409335e9a2c1a350ed586bbe63be5f226648", + "sha256_in_prefix": "21c6bf43370998d5a5a6670f7b13409335e9a2c1a350ed586bbe63be5f226648", + "size_in_bytes": 19864 + }, + { + "_path": "lib/python3.10/idlelib/pyshell.py", + "path_type": "hardlink", + "sha256": "08630ec45901fcdf4d9a6e97dacf70c57a4c4be5c6e81c738d226588b7c71fdf", + "sha256_in_prefix": "08630ec45901fcdf4d9a6e97dacf70c57a4c4be5c6e81c738d226588b7c71fdf", + "size_in_bytes": 62971 + }, + { + "_path": "lib/python3.10/idlelib/query.py", + "path_type": "hardlink", + "sha256": "a8984d77e39ffa556b775cb915fa38d4d8de8fb7afa20c10e47ff62c2f191b29", + "sha256_in_prefix": "a8984d77e39ffa556b775cb915fa38d4d8de8fb7afa20c10e47ff62c2f191b29", + "size_in_bytes": 15075 + }, + { + "_path": "lib/python3.10/idlelib/redirector.py", + "path_type": "hardlink", + "sha256": "f9bd3a01148a0d6627692f4ef22f93361cd19e4e279510c45a522ef10ff6650d", + "sha256_in_prefix": "f9bd3a01148a0d6627692f4ef22f93361cd19e4e279510c45a522ef10ff6650d", + "size_in_bytes": 6875 + }, + { + "_path": "lib/python3.10/idlelib/replace.py", + "path_type": "hardlink", + "sha256": "2137f4472712a4730b04986821fcf67df32f0a5b7e65ded3a1a9d50d76f85046", + "sha256_in_prefix": "2137f4472712a4730b04986821fcf67df32f0a5b7e65ded3a1a9d50d76f85046", + "size_in_bytes": 9999 + }, + { + "_path": "lib/python3.10/idlelib/rpc.py", + "path_type": "hardlink", + "sha256": "d0a01feddf24c7d8b5e1ebc14318cc128a542feba1bb3d277fdaa56caef81e27", + "sha256_in_prefix": "d0a01feddf24c7d8b5e1ebc14318cc128a542feba1bb3d277fdaa56caef81e27", + "size_in_bytes": 21082 + }, + { + "_path": "lib/python3.10/idlelib/run.py", + "path_type": "hardlink", + "sha256": "936bf5133b4a336604208b1e3182464affc95205e47eba447d5b172f58567ee7", + "sha256_in_prefix": "936bf5133b4a336604208b1e3182464affc95205e47eba447d5b172f58567ee7", + "size_in_bytes": 21504 + }, + { + "_path": "lib/python3.10/idlelib/runscript.py", + "path_type": "hardlink", + "sha256": "b92740fddc7b1d603b1736a135bd15518081f20c0db1e1a779cab715ee9120fe", + "sha256_in_prefix": "b92740fddc7b1d603b1736a135bd15518081f20c0db1e1a779cab715ee9120fe", + "size_in_bytes": 8273 + }, + { + "_path": "lib/python3.10/idlelib/scrolledlist.py", + "path_type": "hardlink", + "sha256": "fd08b385ac576e43fa8dc10efb644425b9847d6b70b19f0b2ef484d7c0776f82", + "sha256_in_prefix": "fd08b385ac576e43fa8dc10efb644425b9847d6b70b19f0b2ef484d7c0776f82", + "size_in_bytes": 4465 + }, + { + "_path": "lib/python3.10/idlelib/search.py", + "path_type": "hardlink", + "sha256": "85db5685f1d80d59ff013e045a963057e03af2588994b9805806385309847fe6", + "sha256_in_prefix": "85db5685f1d80d59ff013e045a963057e03af2588994b9805806385309847fe6", + "size_in_bytes": 5566 + }, + { + "_path": "lib/python3.10/idlelib/searchbase.py", + "path_type": "hardlink", + "sha256": "5e13c99d9f264166d9204eeff0492d43d03f2afd8f66494b3e110d7665ab29cc", + "sha256_in_prefix": "5e13c99d9f264166d9204eeff0492d43d03f2afd8f66494b3e110d7665ab29cc", + "size_in_bytes": 7856 + }, + { + "_path": "lib/python3.10/idlelib/searchengine.py", + "path_type": "hardlink", + "sha256": "a4a43d2c270d06643806bc76c1345b98898f0f36e692fa71bbe4d99b497aebbf", + "sha256_in_prefix": "a4a43d2c270d06643806bc76c1345b98898f0f36e692fa71bbe4d99b497aebbf", + "size_in_bytes": 7365 + }, + { + "_path": "lib/python3.10/idlelib/sidebar.py", + "path_type": "hardlink", + "sha256": "6be736f823317d714f82cd8239280d3be62d568e31e5592bc21e573b36de33ec", + "sha256_in_prefix": "6be736f823317d714f82cd8239280d3be62d568e31e5592bc21e573b36de33ec", + "size_in_bytes": 20357 + }, + { + "_path": "lib/python3.10/idlelib/squeezer.py", + "path_type": "hardlink", + "sha256": "112221334fee94a88cba2ca7ac455e1bd6ab796397cbe036b1e8a98bc0787e30", + "sha256_in_prefix": "112221334fee94a88cba2ca7ac455e1bd6ab796397cbe036b1e8a98bc0787e30", + "size_in_bytes": 12834 + }, + { + "_path": "lib/python3.10/idlelib/stackviewer.py", + "path_type": "hardlink", + "sha256": "926a667aa9936ec65cd80b2650d2f0f3434c2ee54f0be91939259add06ef7fd4", + "sha256_in_prefix": "926a667aa9936ec65cd80b2650d2f0f3434c2ee54f0be91939259add06ef7fd4", + "size_in_bytes": 4454 + }, + { + "_path": "lib/python3.10/idlelib/statusbar.py", + "path_type": "hardlink", + "sha256": "7847dfee4e6e1a025ae8b5bfe7d4503d86cf731653dc452804429c3b96c709eb", + "sha256_in_prefix": "7847dfee4e6e1a025ae8b5bfe7d4503d86cf731653dc452804429c3b96c709eb", + "size_in_bytes": 1472 + }, + { + "_path": "lib/python3.10/idlelib/textview.py", + "path_type": "hardlink", + "sha256": "7351da2057dfbfb1523cb1f80bb4965bdb7d9f4271a557571e511f373688d269", + "sha256_in_prefix": "7351da2057dfbfb1523cb1f80bb4965bdb7d9f4271a557571e511f373688d269", + "size_in_bytes": 6813 + }, + { + "_path": "lib/python3.10/idlelib/tooltip.py", + "path_type": "hardlink", + "sha256": "dff2c8d2225e5737ffbc37e8ec7c49ece4fd6bfbd6e910e4e79ffc01b91f7145", + "sha256_in_prefix": "dff2c8d2225e5737ffbc37e8ec7c49ece4fd6bfbd6e910e4e79ffc01b91f7145", + "size_in_bytes": 6557 + }, + { + "_path": "lib/python3.10/idlelib/tree.py", + "path_type": "hardlink", + "sha256": "2daa545a8e3c1988ef653a2f4f42e6338f793a245cb1e3d82226159ff9a08347", + "sha256_in_prefix": "2daa545a8e3c1988ef653a2f4f42e6338f793a245cb1e3d82226159ff9a08347", + "size_in_bytes": 16370 + }, + { + "_path": "lib/python3.10/idlelib/undo.py", + "path_type": "hardlink", + "sha256": "915f353f4eb7052a48cc63f202816bdd3345a03598fb871ff5966304f255d739", + "sha256_in_prefix": "915f353f4eb7052a48cc63f202816bdd3345a03598fb871ff5966304f255d739", + "size_in_bytes": 11046 + }, + { + "_path": "lib/python3.10/idlelib/util.py", + "path_type": "hardlink", + "sha256": "1ec6c3961e1792d904b66f0d56dc048396b661860f2fba63fee9388ab17026bb", + "sha256_in_prefix": "1ec6c3961e1792d904b66f0d56dc048396b661860f2fba63fee9388ab17026bb", + "size_in_bytes": 701 + }, + { + "_path": "lib/python3.10/idlelib/window.py", + "path_type": "hardlink", + "sha256": "ca31d8c01c9b468fcad0a4e529c8e205c1e4ecf30520545db654d466bd7158bd", + "sha256_in_prefix": "ca31d8c01c9b468fcad0a4e529c8e205c1e4ecf30520545db654d466bd7158bd", + "size_in_bytes": 2616 + }, + { + "_path": "lib/python3.10/idlelib/zoomheight.py", + "path_type": "hardlink", + "sha256": "5f6ff83cb0df3ee5e7d997ffe23efb341b994bfbaf00b79a4832d54231a095dd", + "sha256_in_prefix": "5f6ff83cb0df3ee5e7d997ffe23efb341b994bfbaf00b79a4832d54231a095dd", + "size_in_bytes": 4203 + }, + { + "_path": "lib/python3.10/idlelib/zzdummy.py", + "path_type": "hardlink", + "sha256": "5e248f0ea4f35052d23bb2c43564aa567b8cebaf91fd63ba0be8fef2f4167945", + "sha256_in_prefix": "5e248f0ea4f35052d23bb2c43564aa567b8cebaf91fd63ba0be8fef2f4167945", + "size_in_bytes": 2005 + }, + { + "_path": "lib/python3.10/imaplib.py", + "path_type": "hardlink", + "sha256": "6793eee3515221c6e20b47804d209e9a07215b487ffae02ce811fab385aae053", + "sha256_in_prefix": "6793eee3515221c6e20b47804d209e9a07215b487ffae02ce811fab385aae053", + "size_in_bytes": 54866 + }, + { + "_path": "lib/python3.10/imghdr.py", + "path_type": "hardlink", + "sha256": "653ad8d50f1c3cb3a0cc4d2876c60aaa40732c42779dea2e1db547639d27b085", + "sha256_in_prefix": "653ad8d50f1c3cb3a0cc4d2876c60aaa40732c42779dea2e1db547639d27b085", + "size_in_bytes": 3808 + }, + { + "_path": "lib/python3.10/imp.py", + "path_type": "hardlink", + "sha256": "bf581d7c70e2682ed8259f6b6e33950cf49a4ae065fab4abad81659969b1fbac", + "sha256_in_prefix": "bf581d7c70e2682ed8259f6b6e33950cf49a4ae065fab4abad81659969b1fbac", + "size_in_bytes": 10591 + }, + { + "_path": "lib/python3.10/importlib/__init__.py", + "path_type": "hardlink", + "sha256": "49ad4fdc8139026f7f3773e3f50f09207ff6bd8e92a2c382545525235448e525", + "sha256_in_prefix": "49ad4fdc8139026f7f3773e3f50f09207ff6bd8e92a2c382545525235448e525", + "size_in_bytes": 6089 + }, + { + "_path": "lib/python3.10/importlib/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "ed8c61f5bef5c4129c831c93b729be226d80967152c3b37b8ac5b33e106b8730", + "sha256_in_prefix": "ed8c61f5bef5c4129c831c93b729be226d80967152c3b37b8ac5b33e106b8730", + "size_in_bytes": 4059 + }, + { + "_path": "lib/python3.10/importlib/__pycache__/_abc.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "32aaae2628ea2492b9de31ff1182056a19dda1fe73f17d572697afc2fc3aa481", + "sha256_in_prefix": "32aaae2628ea2492b9de31ff1182056a19dda1fe73f17d572697afc2fc3aa481", + "size_in_bytes": 2225 + }, + { + "_path": "lib/python3.10/importlib/__pycache__/_adapters.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "2d43ed6c0f8a722f5d8f03f0d57ca33b9af49ec7f465a91fa563c2e23f24855a", + "sha256_in_prefix": "2d43ed6c0f8a722f5d8f03f0d57ca33b9af49ec7f465a91fa563c2e23f24855a", + "size_in_bytes": 3957 + }, + { + "_path": "lib/python3.10/importlib/__pycache__/_bootstrap.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "77b795dddf79b11e61d6b06aadde233dce697f8121e4211e95944e971cb3bc86", + "sha256_in_prefix": "77b795dddf79b11e61d6b06aadde233dce697f8121e4211e95944e971cb3bc86", + "size_in_bytes": 30382 + }, + { + "_path": "lib/python3.10/importlib/__pycache__/_bootstrap_external.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "4245e02741fc6f5edfc5aacaf393bb5c6eef4122de976e6e17401832ce2aba94", + "sha256_in_prefix": "4245e02741fc6f5edfc5aacaf393bb5c6eef4122de976e6e17401832ce2aba94", + "size_in_bytes": 44567 + }, + { + "_path": "lib/python3.10/importlib/__pycache__/_common.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "d47a886887717c997471bb86cca37c742aa9868119f0fb4c8a204f29c24de4cd", + "sha256_in_prefix": "d47a886887717c997471bb86cca37c742aa9868119f0fb4c8a204f29c24de4cd", + "size_in_bytes": 3221 + }, + { + "_path": "lib/python3.10/importlib/__pycache__/abc.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "1119596ad3bfcade124597f559e2dcf942cb514383b110e71882a6cbacb72ac6", + "sha256_in_prefix": "1119596ad3bfcade124597f559e2dcf942cb514383b110e71882a6cbacb72ac6", + "size_in_bytes": 16145 + }, + { + "_path": "lib/python3.10/importlib/__pycache__/machinery.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "a47d4ef72eeaa685616bdb926d80ac2bc76eb24f409b9d61f4bef26288bd8ca2", + "sha256_in_prefix": "a47d4ef72eeaa685616bdb926d80ac2bc76eb24f409b9d61f4bef26288bd8ca2", + "size_in_bytes": 1198 + }, + { + "_path": "lib/python3.10/importlib/__pycache__/readers.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "1592c18750f632901d652ea7619208fc890fd7f452d19a6ede98185c9735cf41", + "sha256_in_prefix": "1592c18750f632901d652ea7619208fc890fd7f452d19a6ede98185c9735cf41", + "size_in_bytes": 5436 + }, + { + "_path": "lib/python3.10/importlib/__pycache__/resources.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "d1c4e365909311d280c1d3e110ea02b974916d6dad7f761a91a93ba78c04716e", + "sha256_in_prefix": "d1c4e365909311d280c1d3e110ea02b974916d6dad7f761a91a93ba78c04716e", + "size_in_bytes": 5623 + }, + { + "_path": "lib/python3.10/importlib/__pycache__/util.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "76d3e4d4841f5c94c383e135914f0fcae74858e521f0a10b9c73f50af6984195", + "sha256_in_prefix": "76d3e4d4841f5c94c383e135914f0fcae74858e521f0a10b9c73f50af6984195", + "size_in_bytes": 9583 + }, + { + "_path": "lib/python3.10/importlib/_abc.py", + "path_type": "hardlink", + "sha256": "e24fa90513d1fd6e10df30dc28044dfcad857b88161c79de10f7109c18227e8d", + "sha256_in_prefix": "e24fa90513d1fd6e10df30dc28044dfcad857b88161c79de10f7109c18227e8d", + "size_in_bytes": 1852 + }, + { + "_path": "lib/python3.10/importlib/_adapters.py", + "path_type": "hardlink", + "sha256": "c6990a3ce5601e274ce7d374ec0f4ee49b3987745441b89ae691c635dcb7f67a", + "sha256_in_prefix": "c6990a3ce5601e274ce7d374ec0f4ee49b3987745441b89ae691c635dcb7f67a", + "size_in_bytes": 1908 + }, + { + "_path": "lib/python3.10/importlib/_bootstrap.py", + "path_type": "hardlink", + "sha256": "11125bbe628d2f82afdcd480c6454f6248f229d9caf6a8ac1e231c3402facaa1", + "sha256_in_prefix": "11125bbe628d2f82afdcd480c6454f6248f229d9caf6a8ac1e231c3402facaa1", + "size_in_bytes": 41467 + }, + { + "_path": "lib/python3.10/importlib/_bootstrap_external.py", + "path_type": "hardlink", + "sha256": "51eca63c5ee15e9663fbdc000c61a88cd0b722af44d78c3de814c78148bd376b", + "sha256_in_prefix": "51eca63c5ee15e9663fbdc000c61a88cd0b722af44d78c3de814c78148bd376b", + "size_in_bytes": 64850 + }, + { + "_path": "lib/python3.10/importlib/_common.py", + "path_type": "hardlink", + "sha256": "12d117b6545421b414f25a30b43bebc727cb07edd6332ce087422899818d4712", + "sha256_in_prefix": "12d117b6545421b414f25a30b43bebc727cb07edd6332ce087422899818d4712", + "size_in_bytes": 3222 + }, + { + "_path": "lib/python3.10/importlib/abc.py", + "path_type": "hardlink", + "sha256": "d35fb80460981eed5dadf5e2a8f7a920c632805442e769caa225c1295e36a490", + "sha256_in_prefix": "d35fb80460981eed5dadf5e2a8f7a920c632805442e769caa225c1295e36a490", + "size_in_bytes": 14421 + }, + { + "_path": "lib/python3.10/importlib/machinery.py", + "path_type": "hardlink", + "sha256": "b7b47efe3d95ae817e0c61d852682ddf8b8ce95aaf36ae4cf333e145416baf18", + "sha256_in_prefix": "b7b47efe3d95ae817e0c61d852682ddf8b8ce95aaf36ae4cf333e145416baf18", + "size_in_bytes": 831 + }, + { + "_path": "lib/python3.10/importlib/metadata/__init__.py", + "path_type": "hardlink", + "sha256": "cbdafd8f6361fab14fae1eb719abfefc609ac1a24aa2cd717753f0d110883849", + "sha256_in_prefix": "cbdafd8f6361fab14fae1eb719abfefc609ac1a24aa2cd717753f0d110883849", + "size_in_bytes": 30596 + }, + { + "_path": "lib/python3.10/importlib/metadata/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "dd2d7a687ff06905dce7b12c7bd23e86a788fb5e90826bfd2990e4fe649caf87", + "sha256_in_prefix": "dd2d7a687ff06905dce7b12c7bd23e86a788fb5e90826bfd2990e4fe649caf87", + "size_in_bytes": 37350 + }, + { + "_path": "lib/python3.10/importlib/metadata/__pycache__/_adapters.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "7d45d62c129de831011bfc0ba3ff40a0e8cc760c94a65a4d0b555e8888beb1a0", + "sha256_in_prefix": "7d45d62c129de831011bfc0ba3ff40a0e8cc760c94a65a4d0b555e8888beb1a0", + "size_in_bytes": 2598 + }, + { + "_path": "lib/python3.10/importlib/metadata/__pycache__/_collections.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "bb5f38b00399658bbe51117395ba78a912d68230bb513023167d4dfa10b994ea", + "sha256_in_prefix": "bb5f38b00399658bbe51117395ba78a912d68230bb513023167d4dfa10b994ea", + "size_in_bytes": 1773 + }, + { + "_path": "lib/python3.10/importlib/metadata/__pycache__/_functools.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "8f13178b2e4cda41d542e6561650a1a9f99b74f29451a5e438156551055baec8", + "sha256_in_prefix": "8f13178b2e4cda41d542e6561650a1a9f99b74f29451a5e438156551055baec8", + "size_in_bytes": 3363 + }, + { + "_path": "lib/python3.10/importlib/metadata/__pycache__/_itertools.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "1135e90d816aee6e6bcf65c52bb12e8520d64a1c2c8643d5229212093361c719", + "sha256_in_prefix": "1135e90d816aee6e6bcf65c52bb12e8520d64a1c2c8643d5229212093361c719", + "size_in_bytes": 825 + }, + { + "_path": "lib/python3.10/importlib/metadata/__pycache__/_meta.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "54781ce683592efdb225202f9064ad772ee1e80e7da995f38286a3870de55ede", + "sha256_in_prefix": "54781ce683592efdb225202f9064ad772ee1e80e7da995f38286a3870de55ede", + "size_in_bytes": 2518 + }, + { + "_path": "lib/python3.10/importlib/metadata/__pycache__/_text.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "e53cc3236689d15d95a0ed6e93512077ca079a364ce84cc636bd29d791aa6971", + "sha256_in_prefix": "e53cc3236689d15d95a0ed6e93512077ca079a364ce84cc636bd29d791aa6971", + "size_in_bytes": 3055 + }, + { + "_path": "lib/python3.10/importlib/metadata/_adapters.py", + "path_type": "hardlink", + "sha256": "07a7c28b9fbc98b543154663de4ac8e67028fa62a9d5d1ffa886afc88c85ac9b", + "sha256_in_prefix": "07a7c28b9fbc98b543154663de4ac8e67028fa62a9d5d1ffa886afc88c85ac9b", + "size_in_bytes": 1862 + }, + { + "_path": "lib/python3.10/importlib/metadata/_collections.py", + "path_type": "hardlink", + "sha256": "089d0e4c21c88d6034648552e2fa0e440b27d91e11d9c40112d3ec6442690126", + "sha256_in_prefix": "089d0e4c21c88d6034648552e2fa0e440b27d91e11d9c40112d3ec6442690126", + "size_in_bytes": 743 + }, + { + "_path": "lib/python3.10/importlib/metadata/_functools.py", + "path_type": "hardlink", + "sha256": "3ec636fb8aeb297e1155e442d681a9d65075a660bd78a37cf3f7fe6c3f6e3a80", + "sha256_in_prefix": "3ec636fb8aeb297e1155e442d681a9d65075a660bd78a37cf3f7fe6c3f6e3a80", + "size_in_bytes": 2895 + }, + { + "_path": "lib/python3.10/importlib/metadata/_itertools.py", + "path_type": "hardlink", + "sha256": "e53523fc03c91eade9be39f4e219cfda860179b3f6368ec798d1ff864386c0b4", + "sha256_in_prefix": "e53523fc03c91eade9be39f4e219cfda860179b3f6368ec798d1ff864386c0b4", + "size_in_bytes": 607 + }, + { + "_path": "lib/python3.10/importlib/metadata/_meta.py", + "path_type": "hardlink", + "sha256": "39a4210c5a7a366a23384af485b6c93b1c6d7b8cf34822a5c0c2971c8855d8ee", + "sha256_in_prefix": "39a4210c5a7a366a23384af485b6c93b1c6d7b8cf34822a5c0c2971c8855d8ee", + "size_in_bytes": 1130 + }, + { + "_path": "lib/python3.10/importlib/metadata/_text.py", + "path_type": "hardlink", + "sha256": "f0e01097af5970343ee1c4f1f9156f1f0f43661e9dbf72ac289336d9b7c329f9", + "sha256_in_prefix": "f0e01097af5970343ee1c4f1f9156f1f0f43661e9dbf72ac289336d9b7c329f9", + "size_in_bytes": 2198 + }, + { + "_path": "lib/python3.10/importlib/readers.py", + "path_type": "hardlink", + "sha256": "1162c32e66cc667f8856942d00e3152be2c37d87b6724d375f7b1265e8673f03", + "sha256_in_prefix": "1162c32e66cc667f8856942d00e3152be2c37d87b6724d375f7b1265e8673f03", + "size_in_bytes": 3587 + }, + { + "_path": "lib/python3.10/importlib/resources.py", + "path_type": "hardlink", + "sha256": "ac7824f7f6847dbe9de151e29b4c17aed94376f0b8d70aaa5db2c6925b752545", + "sha256_in_prefix": "ac7824f7f6847dbe9de151e29b4c17aed94376f0b8d70aaa5db2c6925b752545", + "size_in_bytes": 5705 + }, + { + "_path": "lib/python3.10/importlib/util.py", + "path_type": "hardlink", + "sha256": "de645b9f6d595f5e415d117f4d04ce77f144ce5ad2a6477659a9b5547d54b9dd", + "sha256_in_prefix": "de645b9f6d595f5e415d117f4d04ce77f144ce5ad2a6477659a9b5547d54b9dd", + "size_in_bytes": 11487 + }, + { + "_path": "lib/python3.10/inspect.py", + "path_type": "hardlink", + "sha256": "98cc184ae793fa1c45de2f28de2539f6d63bf7bec8338df580549f8263baa905", + "sha256_in_prefix": "98cc184ae793fa1c45de2f28de2539f6d63bf7bec8338df580549f8263baa905", + "size_in_bytes": 124378 + }, + { + "_path": "lib/python3.10/io.py", + "path_type": "hardlink", + "sha256": "ee094fcf87d17a3a25816c663b67bd8797dccc3eebabad5a23f6da162146a0a8", + "sha256_in_prefix": "ee094fcf87d17a3a25816c663b67bd8797dccc3eebabad5a23f6da162146a0a8", + "size_in_bytes": 4196 + }, + { + "_path": "lib/python3.10/ipaddress.py", + "path_type": "hardlink", + "sha256": "7868f0b3f21270719534601ee94de4d20efb67f97627e2c8c1233ef4265e5227", + "sha256_in_prefix": "7868f0b3f21270719534601ee94de4d20efb67f97627e2c8c1233ef4265e5227", + "size_in_bytes": 74723 + }, + { + "_path": "lib/python3.10/json/__init__.py", + "path_type": "hardlink", + "sha256": "d5d41e2c29049515d295d81a6d40b4890fbec8d8482cfb401630f8ef2f77e4d5", + "sha256_in_prefix": "d5d41e2c29049515d295d81a6d40b4890fbec8d8482cfb401630f8ef2f77e4d5", + "size_in_bytes": 14020 + }, + { + "_path": "lib/python3.10/json/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "99d9c9f0f6ee6ed9a7c1b792d2072a93e599db450eb96a93dffdd9c5b66831a4", + "sha256_in_prefix": "99d9c9f0f6ee6ed9a7c1b792d2072a93e599db450eb96a93dffdd9c5b66831a4", + "size_in_bytes": 12518 + }, + { + "_path": "lib/python3.10/json/__pycache__/decoder.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "eef4483f23106ec31133385f4a309c41fb874c4af0573e0e6fc55f61a8215e60", + "sha256_in_prefix": "eef4483f23106ec31133385f4a309c41fb874c4af0573e0e6fc55f61a8215e60", + "size_in_bytes": 10020 + }, + { + "_path": "lib/python3.10/json/__pycache__/encoder.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "8810e89fb9819e78fb5b8083f62e187b86ca9024b05ceb592f41357e6ff0d450", + "sha256_in_prefix": "8810e89fb9819e78fb5b8083f62e187b86ca9024b05ceb592f41357e6ff0d450", + "size_in_bytes": 11371 + }, + { + "_path": "lib/python3.10/json/__pycache__/scanner.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "5da4b940d82f78906c9d42977d54af7954276150aa368572af643d33053faff3", + "sha256_in_prefix": "5da4b940d82f78906c9d42977d54af7954276150aa368572af643d33053faff3", + "size_in_bytes": 2170 + }, + { + "_path": "lib/python3.10/json/__pycache__/tool.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "39af1a0b6a65b116ae874cfa2cfbdbafa05278a28b091a73e237f1ef50111dc6", + "sha256_in_prefix": "39af1a0b6a65b116ae874cfa2cfbdbafa05278a28b091a73e237f1ef50111dc6", + "size_in_bytes": 3070 + }, + { + "_path": "lib/python3.10/json/decoder.py", + "path_type": "hardlink", + "sha256": "9f02654649816145bc76f8c210a5fe3ba1de142d4d97a1c93105732e747c285b", + "sha256_in_prefix": "9f02654649816145bc76f8c210a5fe3ba1de142d4d97a1c93105732e747c285b", + "size_in_bytes": 12473 + }, + { + "_path": "lib/python3.10/json/encoder.py", + "path_type": "hardlink", + "sha256": "06b881b824f71e95d72af4ab865de4c35553e791b6d959a125caac61401cc350", + "sha256_in_prefix": "06b881b824f71e95d72af4ab865de4c35553e791b6d959a125caac61401cc350", + "size_in_bytes": 16074 + }, + { + "_path": "lib/python3.10/json/scanner.py", + "path_type": "hardlink", + "sha256": "8604d9d03786d0d509abb49e9f069337278ea988c244069ae8ca2c89acc2cb08", + "sha256_in_prefix": "8604d9d03786d0d509abb49e9f069337278ea988c244069ae8ca2c89acc2cb08", + "size_in_bytes": 2425 + }, + { + "_path": "lib/python3.10/json/tool.py", + "path_type": "hardlink", + "sha256": "d5174b728b376a12cff3f17472d6b9b609c1d3926f7ee02d74d60c80afd60c77", + "sha256_in_prefix": "d5174b728b376a12cff3f17472d6b9b609c1d3926f7ee02d74d60c80afd60c77", + "size_in_bytes": 3339 + }, + { + "_path": "lib/python3.10/keyword.py", + "path_type": "hardlink", + "sha256": "afbe73afb68d32fa998e5ff3d081090deec457152470f5331cc2bd430a0e9d2a", + "sha256_in_prefix": "afbe73afb68d32fa998e5ff3d081090deec457152470f5331cc2bd430a0e9d2a", + "size_in_bytes": 1061 + }, + { + "_path": "lib/python3.10/lib-dynload/_asyncio.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "5d82cecfbc015a419b2748d3068546318c085ccc11eb4e8cf491bf73663d981f", + "sha256_in_prefix": "5d82cecfbc015a419b2748d3068546318c085ccc11eb4e8cf491bf73663d981f", + "size_in_bytes": 101456 + }, + { + "_path": "lib/python3.10/lib-dynload/_bisect.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "093be40932b968de7c0bdb664862a6bc90f86da863de6742895332ba54a7f7e8", + "sha256_in_prefix": "093be40932b968de7c0bdb664862a6bc90f86da863de6742895332ba54a7f7e8", + "size_in_bytes": 69584 + }, + { + "_path": "lib/python3.10/lib-dynload/_blake2.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "57ec51989c1b33acbfc0aa2232f53b4011f408a59d0b8b47a060837e9ed12097", + "sha256_in_prefix": "57ec51989c1b33acbfc0aa2232f53b4011f408a59d0b8b47a060837e9ed12097", + "size_in_bytes": 89008 + }, + { + "_path": "lib/python3.10/lib-dynload/_bz2.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "2d304f30e3b43a8f274e31950dda5b86be4c22786874c6af1c1affc3493832e9", + "sha256_in_prefix": "2d304f30e3b43a8f274e31950dda5b86be4c22786874c6af1c1affc3493832e9", + "size_in_bytes": 72320 + }, + { + "_path": "lib/python3.10/lib-dynload/_codecs_cn.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "21fb70f49261b06ed5e642a83efc14335f1af4e97ed87827cf66d8fbd21be61b", + "sha256_in_prefix": "21fb70f49261b06ed5e642a83efc14335f1af4e97ed87827cf66d8fbd21be61b", + "size_in_bytes": 185712 + }, + { + "_path": "lib/python3.10/lib-dynload/_codecs_hk.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "b1865fbc76c9ce0b4182e23787692b7afcf219b2b25cbc2edd3c98f85e2c7061", + "sha256_in_prefix": "b1865fbc76c9ce0b4182e23787692b7afcf219b2b25cbc2edd3c98f85e2c7061", + "size_in_bytes": 185936 + }, + { + "_path": "lib/python3.10/lib-dynload/_codecs_iso2022.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "85380a8f0a705c559c33923eeb97e9d72e6eb6916070529349998c59158a7a35", + "sha256_in_prefix": "85380a8f0a705c559c33923eeb97e9d72e6eb6916070529349998c59158a7a35", + "size_in_bytes": 71888 + }, + { + "_path": "lib/python3.10/lib-dynload/_codecs_jp.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "f85999cb766472fdd70161e74fd72b2a9a02da233eb9a4f71e12023f2dda0876", + "sha256_in_prefix": "f85999cb766472fdd70161e74fd72b2a9a02da233eb9a4f71e12023f2dda0876", + "size_in_bytes": 302816 + }, + { + "_path": "lib/python3.10/lib-dynload/_codecs_kr.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "10715f7fd430d75bf305aa69478c51f4926e14e24eafa2e157d59c9fb12fd919", + "sha256_in_prefix": "10715f7fd430d75bf305aa69478c51f4926e14e24eafa2e157d59c9fb12fd919", + "size_in_bytes": 169200 + }, + { + "_path": "lib/python3.10/lib-dynload/_codecs_tw.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "084fa36e86104f23e1c486f2cbc5e675f6307c39fe9a15a953ea649ec723393f", + "sha256_in_prefix": "084fa36e86104f23e1c486f2cbc5e675f6307c39fe9a15a953ea649ec723393f", + "size_in_bytes": 152112 + }, + { + "_path": "lib/python3.10/lib-dynload/_contextvars.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "9f81f0981e5e0702e646fd4c18a38ffe1fb07185689103819c767c2be5579aef", + "sha256_in_prefix": "9f81f0981e5e0702e646fd4c18a38ffe1fb07185689103819c767c2be5579aef", + "size_in_bytes": 67824 + }, + { + "_path": "lib/python3.10/lib-dynload/_crypt.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "e1743c18375b0a0c6a5cc85d92a5b721cc2c9f26299b0cfdfa4e94ed14bb7a23", + "sha256_in_prefix": "e1743c18375b0a0c6a5cc85d92a5b721cc2c9f26299b0cfdfa4e94ed14bb7a23", + "size_in_bytes": 68096 + }, + { + "_path": "lib/python3.10/lib-dynload/_csv.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "bebece637699577ef329cee12258b82aca31823f45d94c2c7e19236551948abe", + "sha256_in_prefix": "bebece637699577ef329cee12258b82aca31823f45d94c2c7e19236551948abe", + "size_in_bytes": 90496 + }, + { + "_path": "lib/python3.10/lib-dynload/_ctypes.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "7ca787e2114ad9dea7af10b4f7f819060c0e2b5b57c8cc9a80baa0b58c3c0c0d", + "sha256_in_prefix": "7ca787e2114ad9dea7af10b4f7f819060c0e2b5b57c8cc9a80baa0b58c3c0c0d", + "size_in_bytes": 159808 + }, + { + "_path": "lib/python3.10/lib-dynload/_ctypes_test.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "cf0315de6e074dc567a8316a1c7a076073222a7ba2b27b46b3235ad8b5872c14", + "sha256_in_prefix": "cf0315de6e074dc567a8316a1c7a076073222a7ba2b27b46b3235ad8b5872c14", + "size_in_bytes": 73136 + }, + { + "_path": "lib/python3.10/lib-dynload/_curses.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "2126810ac3c2f2c218ae3356d38830727cd33dcb1fdd606c161cef97d5ffb6a9", + "sha256_in_prefix": "2126810ac3c2f2c218ae3356d38830727cd33dcb1fdd606c161cef97d5ffb6a9", + "size_in_bytes": 175808 + }, + { + "_path": "lib/python3.10/lib-dynload/_curses_panel.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "154184360b4ddb7432e76039a4d74ffd10f62bfa03b192a386b99f975135a52a", + "sha256_in_prefix": "154184360b4ddb7432e76039a4d74ffd10f62bfa03b192a386b99f975135a52a", + "size_in_bytes": 72480 + }, + { + "_path": "lib/python3.10/lib-dynload/_datetime.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "9df24fd2dafa324c86618e001e88f75a0f01b9f39c9d0e47a432ac414e5d2723", + "sha256_in_prefix": "9df24fd2dafa324c86618e001e88f75a0f01b9f39c9d0e47a432ac414e5d2723", + "size_in_bytes": 133552 + }, + { + "_path": "lib/python3.10/lib-dynload/_dbm.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "f297074703e243e526bfa98ee2c6050f41d2bd54eb2068aa96ab4f4a8b342ce7", + "sha256_in_prefix": "f297074703e243e526bfa98ee2c6050f41d2bd54eb2068aa96ab4f4a8b342ce7", + "size_in_bytes": 71680 + }, + { + "_path": "lib/python3.10/lib-dynload/_decimal.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "87c2befbcd4a4e300be8fa0cc9996307cd5ca3b212b2cd5678c19bd26cde5957", + "sha256_in_prefix": "87c2befbcd4a4e300be8fa0cc9996307cd5ca3b212b2cd5678c19bd26cde5957", + "size_in_bytes": 328496 + }, + { + "_path": "lib/python3.10/lib-dynload/_elementtree.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "ca13a24024cc57c4b6d7115a06a0640d1807fbaaa1d7074a6f35724856c6e69e", + "sha256_in_prefix": "ca13a24024cc57c4b6d7115a06a0640d1807fbaaa1d7074a6f35724856c6e69e", + "size_in_bytes": 117536 + }, + { + "_path": "lib/python3.10/lib-dynload/_hashlib.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "dc8fc554194ab1647d3d537dded321fb6869ccca13f7c9606c239fed8520b6a6", + "sha256_in_prefix": "dc8fc554194ab1647d3d537dded321fb6869ccca13f7c9606c239fed8520b6a6", + "size_in_bytes": 97648 + }, + { + "_path": "lib/python3.10/lib-dynload/_heapq.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "d2f656ea36691d8d47a8d771d9dbdea34fe4ba3b59d60dfc09641c19eec76fe8", + "sha256_in_prefix": "d2f656ea36691d8d47a8d771d9dbdea34fe4ba3b59d60dfc09641c19eec76fe8", + "size_in_bytes": 68976 + }, + { + "_path": "lib/python3.10/lib-dynload/_json.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "d585e6946c0d97b6c3df8d38cce215805272f4f5d896818e21bd0e0024dbcaf3", + "sha256_in_prefix": "d585e6946c0d97b6c3df8d38cce215805272f4f5d896818e21bd0e0024dbcaf3", + "size_in_bytes": 90944 + }, + { + "_path": "lib/python3.10/lib-dynload/_lsprof.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "bc296921f35ec5aab4307212fa8a25f03a0d5f7c460b4b8a16bec490ba368aa2", + "sha256_in_prefix": "bc296921f35ec5aab4307212fa8a25f03a0d5f7c460b4b8a16bec490ba368aa2", + "size_in_bytes": 71552 + }, + { + "_path": "lib/python3.10/lib-dynload/_lzma.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "fdec3ee1405d89479cf9fac9da05ed7c1d4d6f1e7325304deaae489fb0693cea", + "sha256_in_prefix": "fdec3ee1405d89479cf9fac9da05ed7c1d4d6f1e7325304deaae489fb0693cea", + "size_in_bytes": 92576 + }, + { + "_path": "lib/python3.10/lib-dynload/_md5.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "b44c0ef7a580fed725d21ea638cc34709ff558f6b0a7f42612776cf47dd5ede0", + "sha256_in_prefix": "b44c0ef7a580fed725d21ea638cc34709ff558f6b0a7f42612776cf47dd5ede0", + "size_in_bytes": 70096 + }, + { + "_path": "lib/python3.10/lib-dynload/_multibytecodec.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "320ac2b5148921271b7ff4b13186adde5a0e9ec084d208062e014387262bac4b", + "sha256_in_prefix": "320ac2b5148921271b7ff4b13186adde5a0e9ec084d208062e014387262bac4b", + "size_in_bytes": 96064 + }, + { + "_path": "lib/python3.10/lib-dynload/_multiprocessing.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "8a42d99ff591b75523c6af6fceb58e62201177a86324644a41020cbfbcb56ac0", + "sha256_in_prefix": "8a42d99ff591b75523c6af6fceb58e62201177a86324644a41020cbfbcb56ac0", + "size_in_bytes": 72368 + }, + { + "_path": "lib/python3.10/lib-dynload/_opcode.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "12ce463dcc75122a9a7bbb853888883aff782c81b560af2a8df1031d99d97a27", + "sha256_in_prefix": "12ce463dcc75122a9a7bbb853888883aff782c81b560af2a8df1031d99d97a27", + "size_in_bytes": 68352 + }, + { + "_path": "lib/python3.10/lib-dynload/_pickle.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "3d08e01bf1b6a7e4aaba137ad801c5709f90d6fb9aa2f09b9ace0f58986af071", + "sha256_in_prefix": "3d08e01bf1b6a7e4aaba137ad801c5709f90d6fb9aa2f09b9ace0f58986af071", + "size_in_bytes": 170192 + }, + { + "_path": "lib/python3.10/lib-dynload/_posixshmem.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "f132715c6ef4cac68d6b79da8f8c4fc2097f1cac34647f6ddff9c8e3e6aae866", + "sha256_in_prefix": "f132715c6ef4cac68d6b79da8f8c4fc2097f1cac34647f6ddff9c8e3e6aae866", + "size_in_bytes": 68848 + }, + { + "_path": "lib/python3.10/lib-dynload/_posixsubprocess.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "0de0c19ffdd93ba192cd8ac7498b2d941248bcc6035831d0028b7006a2f6a5f5", + "sha256_in_prefix": "0de0c19ffdd93ba192cd8ac7498b2d941248bcc6035831d0028b7006a2f6a5f5", + "size_in_bytes": 71424 + }, + { + "_path": "lib/python3.10/lib-dynload/_queue.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "686d2b524eb935d27f54acf67747b700fd0ba0c36e128560358d1443789775a9", + "sha256_in_prefix": "686d2b524eb935d27f54acf67747b700fd0ba0c36e128560358d1443789775a9", + "size_in_bytes": 71616 + }, + { + "_path": "lib/python3.10/lib-dynload/_random.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "3b65f017ded61b01dac6bc7c6f717635f78dbd16a5330f9f9fd7b6c35f5c6f0f", + "sha256_in_prefix": "3b65f017ded61b01dac6bc7c6f717635f78dbd16a5330f9f9fd7b6c35f5c6f0f", + "size_in_bytes": 71328 + }, + { + "_path": "lib/python3.10/lib-dynload/_scproxy.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "25a2f54dd02fcfb0ea1bd6e786b19fb559d78eeb72e5fb7bb458593497ae1c3c", + "sha256_in_prefix": "25a2f54dd02fcfb0ea1bd6e786b19fb559d78eeb72e5fb7bb458593497ae1c3c", + "size_in_bytes": 70304 + }, + { + "_path": "lib/python3.10/lib-dynload/_sha1.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "1baec840a885c37418f4f01d42626ca9ae4c74fee46578e8385787bb9154c0b0", + "sha256_in_prefix": "1baec840a885c37418f4f01d42626ca9ae4c74fee46578e8385787bb9154c0b0", + "size_in_bytes": 70064 + }, + { + "_path": "lib/python3.10/lib-dynload/_sha256.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "4c46541b4f433fbbaa3fd9d77e20c5e31f8a31d4b8b21330e7f317d7879e29e4", + "sha256_in_prefix": "4c46541b4f433fbbaa3fd9d77e20c5e31f8a31d4b8b21330e7f317d7879e29e4", + "size_in_bytes": 70304 + }, + { + "_path": "lib/python3.10/lib-dynload/_sha3.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "d8cbbde36785565c0ebd59ad7bc29be3b5d7e6ca7b7e94ca2e918f211373cc20", + "sha256_in_prefix": "d8cbbde36785565c0ebd59ad7bc29be3b5d7e6ca7b7e94ca2e918f211373cc20", + "size_in_bytes": 105408 + }, + { + "_path": "lib/python3.10/lib-dynload/_sha512.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "e6a56cb1fa53a72f13205b762033b965905d6fdc62c0ace3ac07c5ede287243e", + "sha256_in_prefix": "e6a56cb1fa53a72f13205b762033b965905d6fdc62c0ace3ac07c5ede287243e", + "size_in_bytes": 70384 + }, + { + "_path": "lib/python3.10/lib-dynload/_socket.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "ada2dfc76199e983a6475217d70c1fd2a145d7fe8f6c72bf95e211d8408431c6", + "sha256_in_prefix": "ada2dfc76199e983a6475217d70c1fd2a145d7fe8f6c72bf95e211d8408431c6", + "size_in_bytes": 131760 + }, + { + "_path": "lib/python3.10/lib-dynload/_sqlite3.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "7f5b3546c90806db8b4c0a1f3bf6f4d4fedf40429678631d948c8c85c7850a80", + "sha256_in_prefix": "7f5b3546c90806db8b4c0a1f3bf6f4d4fedf40429678631d948c8c85c7850a80", + "size_in_bytes": 143104 + }, + { + "_path": "lib/python3.10/lib-dynload/_ssl.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "2c5e2d0f2bcb5e810d6e4066571732f82b83c4849be43be101f16b001df2bb21", + "sha256_in_prefix": "2c5e2d0f2bcb5e810d6e4066571732f82b83c4849be43be101f16b001df2bb21", + "size_in_bytes": 221152 + }, + { + "_path": "lib/python3.10/lib-dynload/_statistics.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "d5cdee50b02ecfc16a0e68a9d72e36722037f7c79087531e59dc60f277686f97", + "sha256_in_prefix": "d5cdee50b02ecfc16a0e68a9d72e36722037f7c79087531e59dc60f277686f97", + "size_in_bytes": 68032 + }, + { + "_path": "lib/python3.10/lib-dynload/_struct.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "1ef1e50d20e45ffabfaa312556aa1806296d7e55f49c1cebedad96df974e81b0", + "sha256_in_prefix": "1ef1e50d20e45ffabfaa312556aa1806296d7e55f49c1cebedad96df974e81b0", + "size_in_bytes": 94512 + }, + { + "_path": "lib/python3.10/lib-dynload/_testbuffer.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "b2a372eab64f5f154934827214c057abbb9159a8cfc9df1b9257220fbca0b63a", + "sha256_in_prefix": "b2a372eab64f5f154934827214c057abbb9159a8cfc9df1b9257220fbca0b63a", + "size_in_bytes": 91744 + }, + { + "_path": "lib/python3.10/lib-dynload/_testcapi.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "cc8d5522a7b943c2f61df8660f624dbf848cd67d2cbd33ecfcd85b52cae8d00a", + "sha256_in_prefix": "cc8d5522a7b943c2f61df8660f624dbf848cd67d2cbd33ecfcd85b52cae8d00a", + "size_in_bytes": 185872 + }, + { + "_path": "lib/python3.10/lib-dynload/_testclinic.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "6ac27c133ceea5cd6620dc98c042dd9001e13feaa03e96bd6fbd5e7eeca993f4", + "sha256_in_prefix": "6ac27c133ceea5cd6620dc98c042dd9001e13feaa03e96bd6fbd5e7eeca993f4", + "size_in_bytes": 93168 + }, + { + "_path": "lib/python3.10/lib-dynload/_testimportmultiple.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "0a2ad3912e5c75aff7575a996b3faf310f7615c59d9703cbb62438ce8de3e708", + "sha256_in_prefix": "0a2ad3912e5c75aff7575a996b3faf310f7615c59d9703cbb62438ce8de3e708", + "size_in_bytes": 67488 + }, + { + "_path": "lib/python3.10/lib-dynload/_testinternalcapi.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "d25de0c437ec2ef952440c638aef9a8bd17b795d755b9d827daf6090430e7b33", + "sha256_in_prefix": "d25de0c437ec2ef952440c638aef9a8bd17b795d755b9d827daf6090430e7b33", + "size_in_bytes": 69888 + }, + { + "_path": "lib/python3.10/lib-dynload/_testmultiphase.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "96d6f3b62d3068a68b51ab3c14b74e828d725fd1b0dad1f7e6ed4437c33c6481", + "sha256_in_prefix": "96d6f3b62d3068a68b51ab3c14b74e828d725fd1b0dad1f7e6ed4437c33c6481", + "size_in_bytes": 75616 + }, + { + "_path": "lib/python3.10/lib-dynload/_tkinter.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "1b913c8475e5679e6553922a0a49247dfb0b2943bf1b2da31829c1f8b1f62bcd", + "sha256_in_prefix": "1b913c8475e5679e6553922a0a49247dfb0b2943bf1b2da31829c1f8b1f62bcd", + "size_in_bytes": 118704 + }, + { + "_path": "lib/python3.10/lib-dynload/_uuid.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "98d3ae290d22078e7827832ca18b118ee48ea6f1fec48de15f06012d8802a691", + "sha256_in_prefix": "98d3ae290d22078e7827832ca18b118ee48ea6f1fec48de15f06012d8802a691", + "size_in_bytes": 67760 + }, + { + "_path": "lib/python3.10/lib-dynload/_xxsubinterpreters.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "18ca17c7aebc862dedb1b25fedfb8b4f4ae525bdbd15f8d0b7b52de183737560", + "sha256_in_prefix": "18ca17c7aebc862dedb1b25fedfb8b4f4ae525bdbd15f8d0b7b52de183737560", + "size_in_bytes": 92560 + }, + { + "_path": "lib/python3.10/lib-dynload/_xxtestfuzz.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "b98a21e3eeccb3bec24cdaf8b7b753447dbe9272c69077d473dd2f414604f7e6", + "sha256_in_prefix": "b98a21e3eeccb3bec24cdaf8b7b753447dbe9272c69077d473dd2f414604f7e6", + "size_in_bytes": 70512 + }, + { + "_path": "lib/python3.10/lib-dynload/_zoneinfo.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "5bb8471f614e6fb2e4d0dc63cb33accf0f55b45a385a1c8a871a867ce6ad6d53", + "sha256_in_prefix": "5bb8471f614e6fb2e4d0dc63cb33accf0f55b45a385a1c8a871a867ce6ad6d53", + "size_in_bytes": 89296 + }, + { + "_path": "lib/python3.10/lib-dynload/array.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "03385b53f0120668ec1f7e3c666b76d9169395b772b263b71b7ce8e8c9b4d2ea", + "sha256_in_prefix": "03385b53f0120668ec1f7e3c666b76d9169395b772b263b71b7ce8e8c9b4d2ea", + "size_in_bytes": 96720 + }, + { + "_path": "lib/python3.10/lib-dynload/audioop.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "69fb3868ac2687b1fdbc62607e3095df3fedf63800de5b3b6deb6cc264ec3535", + "sha256_in_prefix": "69fb3868ac2687b1fdbc62607e3095df3fedf63800de5b3b6deb6cc264ec3535", + "size_in_bytes": 88832 + }, + { + "_path": "lib/python3.10/lib-dynload/binascii.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "367dc521b4957609975bc76bdd1875516966f506d8b7e1c537357fd3c048dcb7", + "sha256_in_prefix": "367dc521b4957609975bc76bdd1875516966f506d8b7e1c537357fd3c048dcb7", + "size_in_bytes": 72208 + }, + { + "_path": "lib/python3.10/lib-dynload/cmath.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "10ec429b03e7f8c194c20b7e5a2ab5f0b75c6511936889d24b68eddf5e2aaab6", + "sha256_in_prefix": "10ec429b03e7f8c194c20b7e5a2ab5f0b75c6511936889d24b68eddf5e2aaab6", + "size_in_bytes": 88464 + }, + { + "_path": "lib/python3.10/lib-dynload/fcntl.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "4b6b194820b3c99323db40cd235ff80a56d8a26bd4e8e6bed53413c8a977dd9d", + "sha256_in_prefix": "4b6b194820b3c99323db40cd235ff80a56d8a26bd4e8e6bed53413c8a977dd9d", + "size_in_bytes": 69696 + }, + { + "_path": "lib/python3.10/lib-dynload/grp.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "043015ebd519ab6c812e1c6802b7dbeda772584705860f9293ea2df328d4b71a", + "sha256_in_prefix": "043015ebd519ab6c812e1c6802b7dbeda772584705860f9293ea2df328d4b71a", + "size_in_bytes": 70032 + }, + { + "_path": "lib/python3.10/lib-dynload/math.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "bae02e2ebc3d45cde92eded9967c3426610ee898f3f56cfca12d27f72b77ec62", + "sha256_in_prefix": "bae02e2ebc3d45cde92eded9967c3426610ee898f3f56cfca12d27f72b77ec62", + "size_in_bytes": 110496 + }, + { + "_path": "lib/python3.10/lib-dynload/mmap.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "309c7db7782142c11b8544ab9b0cb2bf924238bd509199535464f63e3e70dc50", + "sha256_in_prefix": "309c7db7782142c11b8544ab9b0cb2bf924238bd509199535464f63e3e70dc50", + "size_in_bytes": 72944 + }, + { + "_path": "lib/python3.10/lib-dynload/nis.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "6e0b3b6f94b5ca158123721f9ecdbfd08994631a2df8dbb5b93e1a616057ff85", + "sha256_in_prefix": "6e0b3b6f94b5ca158123721f9ecdbfd08994631a2df8dbb5b93e1a616057ff85", + "size_in_bytes": 70160 + }, + { + "_path": "lib/python3.10/lib-dynload/pyexpat.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "13f5fb80dfeedaf96b72697864e5db6b8bcac48ca88a8fb369d988acacdf1c97", + "sha256_in_prefix": "13f5fb80dfeedaf96b72697864e5db6b8bcac48ca88a8fb369d988acacdf1c97", + "size_in_bytes": 223792 + }, + { + "_path": "lib/python3.10/lib-dynload/readline.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "d62506fc346eb5287d4e62fdcfe88e187d2bca7509bf31b175222ff17b4927c6", + "sha256_in_prefix": "d62506fc346eb5287d4e62fdcfe88e187d2bca7509bf31b175222ff17b4927c6", + "size_in_bytes": 78880 + }, + { + "_path": "lib/python3.10/lib-dynload/resource.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "aad53ed365f18c5151c6d54160faf04945402267f92f13d3d72d9f2370cbf14e", + "sha256_in_prefix": "aad53ed365f18c5151c6d54160faf04945402267f92f13d3d72d9f2370cbf14e", + "size_in_bytes": 69840 + }, + { + "_path": "lib/python3.10/lib-dynload/select.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "429ebd6360354ddb97160562d7a4b4381977871df2434929368f35b3597c289d", + "sha256_in_prefix": "429ebd6360354ddb97160562d7a4b4381977871df2434929368f35b3597c289d", + "size_in_bytes": 74784 + }, + { + "_path": "lib/python3.10/lib-dynload/syslog.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "227f8733262f756d1dae9770c7b50d2e4c56204f955d3aac7afa80cb57308cc7", + "sha256_in_prefix": "227f8733262f756d1dae9770c7b50d2e4c56204f955d3aac7afa80cb57308cc7", + "size_in_bytes": 68960 + }, + { + "_path": "lib/python3.10/lib-dynload/termios.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "ab6809871a3fe9428352a0cd0c1b81b9d8f6591488dc2e923c8bb79fb36844d2", + "sha256_in_prefix": "ab6809871a3fe9428352a0cd0c1b81b9d8f6591488dc2e923c8bb79fb36844d2", + "size_in_bytes": 70384 + }, + { + "_path": "lib/python3.10/lib-dynload/unicodedata.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "55dbf2389a2a0bd99588e56617d781f6b266800fec3aa11af09861d94a5d3d21", + "sha256_in_prefix": "55dbf2389a2a0bd99588e56617d781f6b266800fec3aa11af09861d94a5d3d21", + "size_in_bytes": 1169200 + }, + { + "_path": "lib/python3.10/lib-dynload/xxlimited.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "ce30331a8a898af31de6e13f75bcd2b1084a7c5786af50696dc2a2978ba7d319", + "sha256_in_prefix": "ce30331a8a898af31de6e13f75bcd2b1084a7c5786af50696dc2a2978ba7d319", + "size_in_bytes": 69648 + }, + { + "_path": "lib/python3.10/lib-dynload/xxlimited_35.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "46aea107d229dd52cc1f0695a199da37f52dfb272f20265b6664ec233ce6f296", + "sha256_in_prefix": "46aea107d229dd52cc1f0695a199da37f52dfb272f20265b6664ec233ce6f296", + "size_in_bytes": 69648 + }, + { + "_path": "lib/python3.10/lib-dynload/zlib.cpython-310-darwin.so", + "path_type": "hardlink", + "sha256": "4a5190a629ec2840f1f0f351efb6fc70f26884469a0ff8a273cda9dab7a669b5", + "sha256_in_prefix": "4a5190a629ec2840f1f0f351efb6fc70f26884469a0ff8a273cda9dab7a669b5", + "size_in_bytes": 91872 + }, + { + "_path": "lib/python3.10/lib2to3/Grammar.txt", + "path_type": "hardlink", + "sha256": "508e62e787dd756eb0a4eb1b8d128320ca02cd246ab14cc8ce0a476dc88cc5b6", + "sha256_in_prefix": "508e62e787dd756eb0a4eb1b8d128320ca02cd246ab14cc8ce0a476dc88cc5b6", + "size_in_bytes": 8696 + }, + { + "_path": "lib/python3.10/lib2to3/Grammar3.10.14.final.0.pickle", + "path_type": "hardlink", + "sha256": "97c8ed74d091fcfd23498029bb819c29d096c3dcb1326edee5dfb0591ade2e4b", + "sha256_in_prefix": "97c8ed74d091fcfd23498029bb819c29d096c3dcb1326edee5dfb0591ade2e4b", + "size_in_bytes": 15313 + }, + { + "_path": "lib/python3.10/lib2to3/PatternGrammar.txt", + "path_type": "hardlink", + "sha256": "ee5ba5db3b6722a0e2fbe2560ebc1c883e72328ef9c3b4da1c7c5d1cc649bce3", + "sha256_in_prefix": "ee5ba5db3b6722a0e2fbe2560ebc1c883e72328ef9c3b4da1c7c5d1cc649bce3", + "size_in_bytes": 793 + }, + { + "_path": "lib/python3.10/lib2to3/PatternGrammar3.10.14.final.0.pickle", + "path_type": "hardlink", + "sha256": "36ee934395b9209737b13893ddaff05fad8e239c2fdfac29d401d3fceeb30768", + "sha256_in_prefix": "36ee934395b9209737b13893ddaff05fad8e239c2fdfac29d401d3fceeb30768", + "size_in_bytes": 1225 + }, + { + "_path": "lib/python3.10/lib2to3/__init__.py", + "path_type": "hardlink", + "sha256": "f4d8715dcaeb8183319e613f00574170b06ca2ff7af34e62d6e869919fc129d7", + "sha256_in_prefix": "f4d8715dcaeb8183319e613f00574170b06ca2ff7af34e62d6e869919fc129d7", + "size_in_bytes": 163 + }, + { + "_path": "lib/python3.10/lib2to3/__main__.py", + "path_type": "hardlink", + "sha256": "c7b09f90e66dea194ad63dc02c6425dff977d16f1f21a157b7475905c219a707", + "sha256_in_prefix": "c7b09f90e66dea194ad63dc02c6425dff977d16f1f21a157b7475905c219a707", + "size_in_bytes": 67 + }, + { + "_path": "lib/python3.10/lib2to3/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "1b02c9ca58e6c8f5c9b8387a9025af2441cfcbd90252844d481b7980698a4f65", + "sha256_in_prefix": "1b02c9ca58e6c8f5c9b8387a9025af2441cfcbd90252844d481b7980698a4f65", + "size_in_bytes": 557 + }, + { + "_path": "lib/python3.10/lib2to3/__pycache__/__main__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "d8b3e9c76ad9a5ea0e3d131cf7f1b21c85e24bce0d2402d5b374df0aa91a0573", + "sha256_in_prefix": "d8b3e9c76ad9a5ea0e3d131cf7f1b21c85e24bce0d2402d5b374df0aa91a0573", + "size_in_bytes": 470 + }, + { + "_path": "lib/python3.10/lib2to3/__pycache__/btm_matcher.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "985059cae6b09e1c75af04894992e94642ee0581cd460f3121896520f6215b7a", + "sha256_in_prefix": "985059cae6b09e1c75af04894992e94642ee0581cd460f3121896520f6215b7a", + "size_in_bytes": 5154 + }, + { + "_path": "lib/python3.10/lib2to3/__pycache__/btm_utils.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "cfac9ada7b6531474db27d749f8c133c62a5bd60c419e3245174d7eff7d35e91", + "sha256_in_prefix": "cfac9ada7b6531474db27d749f8c133c62a5bd60c419e3245174d7eff7d35e91", + "size_in_bytes": 6415 + }, + { + "_path": "lib/python3.10/lib2to3/__pycache__/fixer_base.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "18aa507e920bdd621c617c2d93e22e9dceec358140adde9b0742421fe4b9834a", + "sha256_in_prefix": "18aa507e920bdd621c617c2d93e22e9dceec358140adde9b0742421fe4b9834a", + "size_in_bytes": 6533 + }, + { + "_path": "lib/python3.10/lib2to3/__pycache__/fixer_util.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "006ce04570582b4b390aa58d3cb9d81615b018cf97872c0030cc85106c44cbef", + "sha256_in_prefix": "006ce04570582b4b390aa58d3cb9d81615b018cf97872c0030cc85106c44cbef", + "size_in_bytes": 12322 + }, + { + "_path": "lib/python3.10/lib2to3/__pycache__/main.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "d51e2194073e0bed35ad82a9b7d5a46a4f051f949b72c857c7c55a9ea0b2c2bd", + "sha256_in_prefix": "d51e2194073e0bed35ad82a9b7d5a46a4f051f949b72c857c7c55a9ea0b2c2bd", + "size_in_bytes": 8956 + }, + { + "_path": "lib/python3.10/lib2to3/__pycache__/patcomp.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "e373e9e143bdbace0185178f9ef5269d2d1218a350e4c1212391deb8759caa9b", + "sha256_in_prefix": "e373e9e143bdbace0185178f9ef5269d2d1218a350e4c1212391deb8759caa9b", + "size_in_bytes": 5790 + }, + { + "_path": "lib/python3.10/lib2to3/__pycache__/pygram.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "3c96ddaa10c83dcb2117caee99008b0388247aac1696289623514b8ab02a0e62", + "sha256_in_prefix": "3c96ddaa10c83dcb2117caee99008b0388247aac1696289623514b8ab02a0e62", + "size_in_bytes": 1521 + }, + { + "_path": "lib/python3.10/lib2to3/__pycache__/pytree.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c05ae3d4ca3c49613836ab97fed7f1df9204be912186b0aa964c8212bfb7a5c2", + "sha256_in_prefix": "c05ae3d4ca3c49613836ab97fed7f1df9204be912186b0aa964c8212bfb7a5c2", + "size_in_bytes": 24658 + }, + { + "_path": "lib/python3.10/lib2to3/__pycache__/refactor.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "854a51c18991f6c51fa6241bdc8efa4f05bf7ab60b6338619dd459130af0adac", + "sha256_in_prefix": "854a51c18991f6c51fa6241bdc8efa4f05bf7ab60b6338619dd459130af0adac", + "size_in_bytes": 20993 + }, + { + "_path": "lib/python3.10/lib2to3/btm_matcher.py", + "path_type": "hardlink", + "sha256": "a1aa5d35558acf4b6016054963285cb145f97a764926bea07cbd674563f3248d", + "sha256_in_prefix": "a1aa5d35558acf4b6016054963285cb145f97a764926bea07cbd674563f3248d", + "size_in_bytes": 6623 + }, + { + "_path": "lib/python3.10/lib2to3/btm_utils.py", + "path_type": "hardlink", + "sha256": "79d210510630052adafcc7c4ad8cf16acd2fd8e9adb46deea952cd81bfbea661", + "sha256_in_prefix": "79d210510630052adafcc7c4ad8cf16acd2fd8e9adb46deea952cd81bfbea661", + "size_in_bytes": 9966 + }, + { + "_path": "lib/python3.10/lib2to3/fixer_base.py", + "path_type": "hardlink", + "sha256": "c795a53ca849c42212c8ec33a74284e0377df852eb4ea599aba62d5af1df282a", + "sha256_in_prefix": "c795a53ca849c42212c8ec33a74284e0377df852eb4ea599aba62d5af1df282a", + "size_in_bytes": 6690 + }, + { + "_path": "lib/python3.10/lib2to3/fixer_util.py", + "path_type": "hardlink", + "sha256": "306d0b2ea8169bdca711c6a31c0b1a3ce710d38ae2b6568ef519aa38451af608", + "sha256_in_prefix": "306d0b2ea8169bdca711c6a31c0b1a3ce710d38ae2b6568ef519aa38451af608", + "size_in_bytes": 15206 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/__init__.py", + "path_type": "hardlink", + "sha256": "836cdb388117cf81e78d9fa2a141cca1b14b0179733322e710067749a1b16fe9", + "sha256_in_prefix": "836cdb388117cf81e78d9fa2a141cca1b14b0179733322e710067749a1b16fe9", + "size_in_bytes": 47 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "93e8548856ef6bf93ea186d1fdba8197089808cd28b42ef626685cf7b6a58469", + "sha256_in_prefix": "93e8548856ef6bf93ea186d1fdba8197089808cd28b42ef626685cf7b6a58469", + "size_in_bytes": 392 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/__pycache__/fix_apply.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "ff7a631568f2de4dc231d87dfb6214eeb876c5d7c7d01a0a51ae12c9ea50d5ad", + "sha256_in_prefix": "ff7a631568f2de4dc231d87dfb6214eeb876c5d7c7d01a0a51ae12c9ea50d5ad", + "size_in_bytes": 1906 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/__pycache__/fix_asserts.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "3412f5906c832fa3cb85f17fe4765d9b5810b9e2c9780886d978a9c480a42445", + "sha256_in_prefix": "3412f5906c832fa3cb85f17fe4765d9b5810b9e2c9780886d978a9c480a42445", + "size_in_bytes": 1272 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/__pycache__/fix_basestring.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "91e5fd9b8309e4eb325b35b2fcd0a4791e77823de257b6688bef6c5c3b88e21a", + "sha256_in_prefix": "91e5fd9b8309e4eb325b35b2fcd0a4791e77823de257b6688bef6c5c3b88e21a", + "size_in_bytes": 915 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/__pycache__/fix_buffer.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "54c3990071adec2d7d27c6bc0286a041ea45003f0f7cb2d8e810d2d9acbf51a8", + "sha256_in_prefix": "54c3990071adec2d7d27c6bc0286a041ea45003f0f7cb2d8e810d2d9acbf51a8", + "size_in_bytes": 1060 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/__pycache__/fix_dict.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "739c4aab2fb7ac30fd98b099870bb1bbe235add8922e995432cb2c02b6367e8e", + "sha256_in_prefix": "739c4aab2fb7ac30fd98b099870bb1bbe235add8922e995432cb2c02b6367e8e", + "size_in_bytes": 3541 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/__pycache__/fix_except.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "9f2766d40807ecc5e58b9fce5e0487f9a35fc1d2363d256dcb32522df9af1d95", + "sha256_in_prefix": "9f2766d40807ecc5e58b9fce5e0487f9a35fc1d2363d256dcb32522df9af1d95", + "size_in_bytes": 3026 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/__pycache__/fix_exec.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "8fff89150b7437eac22691e3dd03c78244a6f4262f0f41d4b2ea752162734de3", + "sha256_in_prefix": "8fff89150b7437eac22691e3dd03c78244a6f4262f0f41d4b2ea752162734de3", + "size_in_bytes": 1385 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/__pycache__/fix_execfile.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "cd70cd5b2ab2d37ebed507c53987d1039259564905ef92065627b01f2b1ccfd9", + "sha256_in_prefix": "cd70cd5b2ab2d37ebed507c53987d1039259564905ef92065627b01f2b1ccfd9", + "size_in_bytes": 1931 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/__pycache__/fix_exitfunc.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "42acd0268b7cd2f1a20f42f9d6e50a9b1cf8729e88600c61c71fbb28e309c979", + "sha256_in_prefix": "42acd0268b7cd2f1a20f42f9d6e50a9b1cf8729e88600c61c71fbb28e309c979", + "size_in_bytes": 2560 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/__pycache__/fix_filter.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "89a95c38b3f21c58ac2a3c9e2c3695f32d57000fd05ca50fa478f65f9756081e", + "sha256_in_prefix": "89a95c38b3f21c58ac2a3c9e2c3695f32d57000fd05ca50fa478f65f9756081e", + "size_in_bytes": 2694 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/__pycache__/fix_funcattrs.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "47d68dabdd87defedc9d9a68746dc3315e8e5013f288d9ca4f3f9cfdb1a55c88", + "sha256_in_prefix": "47d68dabdd87defedc9d9a68746dc3315e8e5013f288d9ca4f3f9cfdb1a55c88", + "size_in_bytes": 1228 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/__pycache__/fix_future.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "37f42df688fe16352ca07112d67773f55954edd07b14cab34488fbd961b4d11c", + "sha256_in_prefix": "37f42df688fe16352ca07112d67773f55954edd07b14cab34488fbd961b4d11c", + "size_in_bytes": 777 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/__pycache__/fix_getcwdu.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "18d9e6fbafe6fb87ce597cf75d585a563ee5af732dae4821860b1369103c15f7", + "sha256_in_prefix": "18d9e6fbafe6fb87ce597cf75d585a563ee5af732dae4821860b1369103c15f7", + "size_in_bytes": 1040 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/__pycache__/fix_has_key.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "9914a49cf9b5a8facf2a6e6995fe4430f7d396bcbff9c7e86d27e651557a5e11", + "sha256_in_prefix": "9914a49cf9b5a8facf2a6e6995fe4430f7d396bcbff9c7e86d27e651557a5e11", + "size_in_bytes": 2872 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/__pycache__/fix_idioms.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "276271f603ee7fb123102c7ce54fe0196a56e1fc19687a7783b3a9519b9a2fa8", + "sha256_in_prefix": "276271f603ee7fb123102c7ce54fe0196a56e1fc19687a7783b3a9519b9a2fa8", + "size_in_bytes": 4159 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/__pycache__/fix_import.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "76eee902357e30b260f4fdb6fddd2fe85cda0213987997dcf2a0bf40d0241c35", + "sha256_in_prefix": "76eee902357e30b260f4fdb6fddd2fe85cda0213987997dcf2a0bf40d0241c35", + "size_in_bytes": 3065 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/__pycache__/fix_imports.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "552e4f13c0e4c4a35d6b5b340813cdd3220d62f40f32f3162ae66dd589d4b867", + "sha256_in_prefix": "552e4f13c0e4c4a35d6b5b340813cdd3220d62f40f32f3162ae66dd589d4b867", + "size_in_bytes": 4881 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/__pycache__/fix_imports2.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c2c3d99afa5d9a4209fb20bdef4a80428f78565d6acc2eedb3e862dc3f39976b", + "sha256_in_prefix": "c2c3d99afa5d9a4209fb20bdef4a80428f78565d6acc2eedb3e862dc3f39976b", + "size_in_bytes": 798 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/__pycache__/fix_input.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "70a4e1080bc86eee1bf089434c2a1e3cbef995e6fead3ce75ed9fa81e07a7ac7", + "sha256_in_prefix": "70a4e1080bc86eee1bf089434c2a1e3cbef995e6fead3ce75ed9fa81e07a7ac7", + "size_in_bytes": 1202 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/__pycache__/fix_intern.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "0edbf433583034efa7dc5ed591276404c2ec039b26951f2eb49d337377a40a94", + "sha256_in_prefix": "0edbf433583034efa7dc5ed591276404c2ec039b26951f2eb49d337377a40a94", + "size_in_bytes": 1384 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/__pycache__/fix_isinstance.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c0a6acb713e31566255f63be5c85a5d082b96ba28933f36377ab71fe17b29cc7", + "sha256_in_prefix": "c0a6acb713e31566255f63be5c85a5d082b96ba28933f36377ab71fe17b29cc7", + "size_in_bytes": 1809 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/__pycache__/fix_itertools.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "65d83e64457adbcbafa88299bf79c0b1609ecac08637d89d64528a22bc1c2b72", + "sha256_in_prefix": "65d83e64457adbcbafa88299bf79c0b1609ecac08637d89d64528a22bc1c2b72", + "size_in_bytes": 1800 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/__pycache__/fix_itertools_imports.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "2dd4ea544b7f67dadcfa00bf07c67c47e42996979229ce458304b5da1273aa2d", + "sha256_in_prefix": "2dd4ea544b7f67dadcfa00bf07c67c47e42996979229ce458304b5da1273aa2d", + "size_in_bytes": 1820 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/__pycache__/fix_long.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "e1b74de8b0cecb58d2e1add118121ce87444074bd6de5aeca72e8aca31daef4f", + "sha256_in_prefix": "e1b74de8b0cecb58d2e1add118121ce87444074bd6de5aeca72e8aca31daef4f", + "size_in_bytes": 963 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/__pycache__/fix_map.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "81c04645d66e85a5d0d2ac4e9007043d3cab1101e09c7a2315285c80cf447d81", + "sha256_in_prefix": "81c04645d66e85a5d0d2ac4e9007043d3cab1101e09c7a2315285c80cf447d81", + "size_in_bytes": 3329 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/__pycache__/fix_metaclass.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "7b8b9fe63190c6e14021121122021165600ccbcd1d80778a221fe00b084b9730", + "sha256_in_prefix": "7b8b9fe63190c6e14021121122021165600ccbcd1d80778a221fe00b084b9730", + "size_in_bytes": 5659 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/__pycache__/fix_methodattrs.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c9851a2ce780b0631fc98d863c918d1b9809585e85403b4dd3facf8a2092cb13", + "sha256_in_prefix": "c9851a2ce780b0631fc98d863c918d1b9809585e85403b4dd3facf8a2092cb13", + "size_in_bytes": 931 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/__pycache__/fix_ne.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "e61244431683b365bce16d323ef998ab74bdb7fb90336e262335339b5a22e39d", + "sha256_in_prefix": "e61244431683b365bce16d323ef998ab74bdb7fb90336e262335339b5a22e39d", + "size_in_bytes": 1063 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/__pycache__/fix_next.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "42e68ba33ca23326ff3e6e20a2266377f8b7ee02169cc18d9ae5dcce1f136f10", + "sha256_in_prefix": "42e68ba33ca23326ff3e6e20a2266377f8b7ee02169cc18d9ae5dcce1f136f10", + "size_in_bytes": 3331 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/__pycache__/fix_nonzero.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "1d92b7c6e36fa274a7e0dff5c3b6a24733a22373e04ef9c87ac46dd99822a056", + "sha256_in_prefix": "1d92b7c6e36fa274a7e0dff5c3b6a24733a22373e04ef9c87ac46dd99822a056", + "size_in_bytes": 1175 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/__pycache__/fix_numliterals.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "861de63051d4015e105487742a3521e03c794abb9a36ef9ae345864cb39948d7", + "sha256_in_prefix": "861de63051d4015e105487742a3521e03c794abb9a36ef9ae345864cb39948d7", + "size_in_bytes": 1275 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/__pycache__/fix_operator.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "5d2bface10c06c8c4968810df48b918ed731903385e45a264c6557621a689ba3", + "sha256_in_prefix": "5d2bface10c06c8c4968810df48b918ed731903385e45a264c6557621a689ba3", + "size_in_bytes": 4406 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/__pycache__/fix_paren.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "067f4e6d429e6ca9670c8a003729afc8b6b354d7f12cb71c1846aae074e311f3", + "sha256_in_prefix": "067f4e6d429e6ca9670c8a003729afc8b6b354d7f12cb71c1846aae074e311f3", + "size_in_bytes": 1641 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/__pycache__/fix_print.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "ab5ac976bd1d0af4274e2ecb1b8df1459d0c5e3c8a67be3ce63749a705f2a5fc", + "sha256_in_prefix": "ab5ac976bd1d0af4274e2ecb1b8df1459d0c5e3c8a67be3ce63749a705f2a5fc", + "size_in_bytes": 2563 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/__pycache__/fix_raise.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c0c1eea837159c096017603c38d8736bc876fb8c1fd0bb3c253fc263f196bd9a", + "sha256_in_prefix": "c0c1eea837159c096017603c38d8736bc876fb8c1fd0bb3c253fc263f196bd9a", + "size_in_bytes": 2503 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/__pycache__/fix_raw_input.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "fdd48d2c94657d28474babbe891224235182a9bb52bdac4ea8b3c4ba0f192865", + "sha256_in_prefix": "fdd48d2c94657d28474babbe891224235182a9bb52bdac4ea8b3c4ba0f192865", + "size_in_bytes": 1047 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/__pycache__/fix_reduce.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "1323171a926e80f63291ea138da5abd96c64f84669065e2d5ab882b34712abf3", + "sha256_in_prefix": "1323171a926e80f63291ea138da5abd96c64f84669065e2d5ab882b34712abf3", + "size_in_bytes": 1380 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/__pycache__/fix_reload.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "6e06fed2efd1cce85e7ec849c5054bc2664fcc6cfe9fee0583de2872dcda8b74", + "sha256_in_prefix": "6e06fed2efd1cce85e7ec849c5054bc2664fcc6cfe9fee0583de2872dcda8b74", + "size_in_bytes": 1396 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/__pycache__/fix_renames.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "a204c5389f0c9e82da2d00e43f28073cfff2c9f14a7f748c4ebe6bb671a0bf1e", + "sha256_in_prefix": "a204c5389f0c9e82da2d00e43f28073cfff2c9f14a7f748c4ebe6bb671a0bf1e", + "size_in_bytes": 2279 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/__pycache__/fix_repr.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "57e89280ec1acd737e8be1e497ab38b2998f47d247ef3a94450e6e0937b1d2a7", + "sha256_in_prefix": "57e89280ec1acd737e8be1e497ab38b2998f47d247ef3a94450e6e0937b1d2a7", + "size_in_bytes": 1097 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/__pycache__/fix_set_literal.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "9ad794f270691e8f8d3d231460de9d629ed62ee29df9d58268622345d1a86647", + "sha256_in_prefix": "9ad794f270691e8f8d3d231460de9d629ed62ee29df9d58268622345d1a86647", + "size_in_bytes": 1937 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/__pycache__/fix_standarderror.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "2783f1851d7b91843a4887d5538532163e0d5f8b9070f7a1485f5c24aaceb242", + "sha256_in_prefix": "2783f1851d7b91843a4887d5538532163e0d5f8b9070f7a1485f5c24aaceb242", + "size_in_bytes": 972 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/__pycache__/fix_sys_exc.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "a4d3d117d6b5f23c0806991441f6aab456601080fca3b7cddb28ea6eb408aa6b", + "sha256_in_prefix": "a4d3d117d6b5f23c0806991441f6aab456601080fca3b7cddb28ea6eb408aa6b", + "size_in_bytes": 1665 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/__pycache__/fix_throw.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "880e4b2277cc45d4ae7d7e059b02cd105f877d9c2603c1fd9572bf0711eafa74", + "sha256_in_prefix": "880e4b2277cc45d4ae7d7e059b02cd105f877d9c2603c1fd9572bf0711eafa74", + "size_in_bytes": 2060 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/__pycache__/fix_tuple_params.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "a504c3a60a736cb416d39fa3ccfdc37c4af92cca79e572b7d602e812aa07d02f", + "sha256_in_prefix": "a504c3a60a736cb416d39fa3ccfdc37c4af92cca79e572b7d602e812aa07d02f", + "size_in_bytes": 4843 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/__pycache__/fix_types.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "2de0f410675f9d03573514bc8d759929de9690bcad798ce684a82ede7b3b5675", + "sha256_in_prefix": "2de0f410675f9d03573514bc8d759929de9690bcad798ce684a82ede7b3b5675", + "size_in_bytes": 2195 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/__pycache__/fix_unicode.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "19f656c7db621edd6e5686cbf909d6b79509d1a67c1cf657815466b8d451fe52", + "sha256_in_prefix": "19f656c7db621edd6e5686cbf909d6b79509d1a67c1cf657815466b8d451fe52", + "size_in_bytes": 1807 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/__pycache__/fix_urllib.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "79b094e213ca1a3de5556d52f8faab2ac280c1e4e6173904e15ee78794f37689", + "sha256_in_prefix": "79b094e213ca1a3de5556d52f8faab2ac280c1e4e6173904e15ee78794f37689", + "size_in_bytes": 6134 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/__pycache__/fix_ws_comma.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "a71bd0027df0e2f8a5990153367b61889846724a7f88995a309bbc92f632bd5b", + "sha256_in_prefix": "a71bd0027df0e2f8a5990153367b61889846724a7f88995a309bbc92f632bd5b", + "size_in_bytes": 1371 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/__pycache__/fix_xrange.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "ae14b56664e98a2069472b315f9e654b829904dd1391cc5802071d0b286bdabb", + "sha256_in_prefix": "ae14b56664e98a2069472b315f9e654b829904dd1391cc5802071d0b286bdabb", + "size_in_bytes": 2781 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/__pycache__/fix_xreadlines.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "49a721ee909357d7185da97cd31a81da425d526d566fcab430ee2e0dfda400ea", + "sha256_in_prefix": "49a721ee909357d7185da97cd31a81da425d526d566fcab430ee2e0dfda400ea", + "size_in_bytes": 1116 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/__pycache__/fix_zip.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c56aaa5f1185cbd93133070af451c4e34f5996fcd7cf393f5c3144816d26d6a3", + "sha256_in_prefix": "c56aaa5f1185cbd93133070af451c4e34f5996fcd7cf393f5c3144816d26d6a3", + "size_in_bytes": 1833 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/fix_apply.py", + "path_type": "hardlink", + "sha256": "b5171e32758a78450854f40867775d4aca58665bc920ebece04fcfcc153af02a", + "sha256_in_prefix": "b5171e32758a78450854f40867775d4aca58665bc920ebece04fcfcc153af02a", + "size_in_bytes": 2346 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/fix_asserts.py", + "path_type": "hardlink", + "sha256": "4c77972812cb5ec0a72afbce3e1d618c27ef7b239329c5c952c2bcbe77dba5dd", + "sha256_in_prefix": "4c77972812cb5ec0a72afbce3e1d618c27ef7b239329c5c952c2bcbe77dba5dd", + "size_in_bytes": 984 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/fix_basestring.py", + "path_type": "hardlink", + "sha256": "d041443d6499a735bb78fec9da1bf33b3d034b5192c98bc273b16a44692fc88f", + "sha256_in_prefix": "d041443d6499a735bb78fec9da1bf33b3d034b5192c98bc273b16a44692fc88f", + "size_in_bytes": 320 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/fix_buffer.py", + "path_type": "hardlink", + "sha256": "2da37b49c30d6a0b4db43146ebb4ac8e5ffcb9814816b4742e464cb856977883", + "sha256_in_prefix": "2da37b49c30d6a0b4db43146ebb4ac8e5ffcb9814816b4742e464cb856977883", + "size_in_bytes": 590 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/fix_dict.py", + "path_type": "hardlink", + "sha256": "38f460596ebfb64046aab3d9a65935bd4c76a470118fb7d10a088dc0ecdc53ea", + "sha256_in_prefix": "38f460596ebfb64046aab3d9a65935bd4c76a470118fb7d10a088dc0ecdc53ea", + "size_in_bytes": 3760 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/fix_except.py", + "path_type": "hardlink", + "sha256": "7ff6f560c3c3d7a5d9ceef5ba31c556341f7ce1bc1b52d96b063f6c2c4765651", + "sha256_in_prefix": "7ff6f560c3c3d7a5d9ceef5ba31c556341f7ce1bc1b52d96b063f6c2c4765651", + "size_in_bytes": 3344 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/fix_exec.py", + "path_type": "hardlink", + "sha256": "9e0893327205dea12004e88d18c580286e7977e081b5eda7baf5b7bc93bc6c52", + "sha256_in_prefix": "9e0893327205dea12004e88d18c580286e7977e081b5eda7baf5b7bc93bc6c52", + "size_in_bytes": 979 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/fix_execfile.py", + "path_type": "hardlink", + "sha256": "6ff65db1192099457cb3d9f2618a893c6ac430028550284f3a34d5c08042b0eb", + "sha256_in_prefix": "6ff65db1192099457cb3d9f2618a893c6ac430028550284f3a34d5c08042b0eb", + "size_in_bytes": 2048 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/fix_exitfunc.py", + "path_type": "hardlink", + "sha256": "ef4f18f651d32410c43644c27590903d41e38e763b0e108e6c685a3412a7d29c", + "sha256_in_prefix": "ef4f18f651d32410c43644c27590903d41e38e763b0e108e6c685a3412a7d29c", + "size_in_bytes": 2495 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/fix_filter.py", + "path_type": "hardlink", + "sha256": "2c7f0121193395750eab2b2abf5059d9a3b1a61f81763f52511265d7bca5cb21", + "sha256_in_prefix": "2c7f0121193395750eab2b2abf5059d9a3b1a61f81763f52511265d7bca5cb21", + "size_in_bytes": 2765 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/fix_funcattrs.py", + "path_type": "hardlink", + "sha256": "111df53fac6a121d61abe33883a68e731820ddc4864b0a4c1000cf2ac5f019cd", + "sha256_in_prefix": "111df53fac6a121d61abe33883a68e731820ddc4864b0a4c1000cf2ac5f019cd", + "size_in_bytes": 644 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/fix_future.py", + "path_type": "hardlink", + "sha256": "baba8cafb48dd9181a0e1f7b0f20b585ce2925e8f347e00b87407a256bb16663", + "sha256_in_prefix": "baba8cafb48dd9181a0e1f7b0f20b585ce2925e8f347e00b87407a256bb16663", + "size_in_bytes": 547 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/fix_getcwdu.py", + "path_type": "hardlink", + "sha256": "5bc5252f683a401e7d81c5911617c4af1a1bcdf99a51c4bf1cfccb00446ff220", + "sha256_in_prefix": "5bc5252f683a401e7d81c5911617c4af1a1bcdf99a51c4bf1cfccb00446ff220", + "size_in_bytes": 451 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/fix_has_key.py", + "path_type": "hardlink", + "sha256": "32943d3b921c1c3f0d3776d19e5120806990b817bc99a7e22799847abfda1f63", + "sha256_in_prefix": "32943d3b921c1c3f0d3776d19e5120806990b817bc99a7e22799847abfda1f63", + "size_in_bytes": 3196 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/fix_idioms.py", + "path_type": "hardlink", + "sha256": "600e34faf36e14307e59d55088e3979881d497b8fc9d77659e77709f9e8bafd7", + "sha256_in_prefix": "600e34faf36e14307e59d55088e3979881d497b8fc9d77659e77709f9e8bafd7", + "size_in_bytes": 4876 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/fix_import.py", + "path_type": "hardlink", + "sha256": "803baf96f9603c957eb974f252b0ad9829c889a293e0ce6829db1bce3da6dd4e", + "sha256_in_prefix": "803baf96f9603c957eb974f252b0ad9829c889a293e0ce6829db1bce3da6dd4e", + "size_in_bytes": 3256 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/fix_imports.py", + "path_type": "hardlink", + "sha256": "cdf7ee6d85e2b148230984cfc4ea3f193be458958ea42ef290854a9672a64370", + "sha256_in_prefix": "cdf7ee6d85e2b148230984cfc4ea3f193be458958ea42ef290854a9672a64370", + "size_in_bytes": 5684 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/fix_imports2.py", + "path_type": "hardlink", + "sha256": "b6f3c628839ffe7fd72569dd6ca2210e18edae3e180002747ea011b76b7ec0ef", + "sha256_in_prefix": "b6f3c628839ffe7fd72569dd6ca2210e18edae3e180002747ea011b76b7ec0ef", + "size_in_bytes": 289 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/fix_input.py", + "path_type": "hardlink", + "sha256": "10c5ef3b45a4ee7e88af8852181916a788aae2bea52b08f3473815c1c43598d1", + "sha256_in_prefix": "10c5ef3b45a4ee7e88af8852181916a788aae2bea52b08f3473815c1c43598d1", + "size_in_bytes": 708 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/fix_intern.py", + "path_type": "hardlink", + "sha256": "8d29a162536b99c91bd2f9259dda7f39fec751949d6354d2c1f2e5d070c87d66", + "sha256_in_prefix": "8d29a162536b99c91bd2f9259dda7f39fec751949d6354d2c1f2e5d070c87d66", + "size_in_bytes": 1144 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/fix_isinstance.py", + "path_type": "hardlink", + "sha256": "8408c92b99f50d8c4978b47a2b2155588e315f2ebbe58c160dcdcdcb89e19914", + "sha256_in_prefix": "8408c92b99f50d8c4978b47a2b2155588e315f2ebbe58c160dcdcdcb89e19914", + "size_in_bytes": 1608 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/fix_itertools.py", + "path_type": "hardlink", + "sha256": "578a51b9935020b03a510de15ece55fcd02c9474f37a54c158fb97ba5fd15af1", + "sha256_in_prefix": "578a51b9935020b03a510de15ece55fcd02c9474f37a54c158fb97ba5fd15af1", + "size_in_bytes": 1548 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/fix_itertools_imports.py", + "path_type": "hardlink", + "sha256": "2e419cfbd7f2a326ae7fa10873aa377112ebec32545238fdf988acb088c3cdb7", + "sha256_in_prefix": "2e419cfbd7f2a326ae7fa10873aa377112ebec32545238fdf988acb088c3cdb7", + "size_in_bytes": 2086 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/fix_long.py", + "path_type": "hardlink", + "sha256": "306b80e0a72c0d16dd934b7d51ab0c9a4224f83be5d6cbad8a7158a0a5d73551", + "sha256_in_prefix": "306b80e0a72c0d16dd934b7d51ab0c9a4224f83be5d6cbad8a7158a0a5d73551", + "size_in_bytes": 476 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/fix_map.py", + "path_type": "hardlink", + "sha256": "b82c0762c44adf2af7745c030afe291e2badfe360925046c8e58d85340717696", + "sha256_in_prefix": "b82c0762c44adf2af7745c030afe291e2badfe360925046c8e58d85340717696", + "size_in_bytes": 3640 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/fix_metaclass.py", + "path_type": "hardlink", + "sha256": "45a30c866aa2ff69e089da147ed09986aad4516b5e5dd943f8dfcb7d3946a3e1", + "sha256_in_prefix": "45a30c866aa2ff69e089da147ed09986aad4516b5e5dd943f8dfcb7d3946a3e1", + "size_in_bytes": 8197 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/fix_methodattrs.py", + "path_type": "hardlink", + "sha256": "8d60082f98ce52ee4955099bfd447cbadfa0e9b24ccb8d135cecc833168d44e8", + "sha256_in_prefix": "8d60082f98ce52ee4955099bfd447cbadfa0e9b24ccb8d135cecc833168d44e8", + "size_in_bytes": 606 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/fix_ne.py", + "path_type": "hardlink", + "sha256": "4f9cb1388ba86f29422d20979d3423fdf3541ba35a17ed44d6f4a517ff784ecd", + "sha256_in_prefix": "4f9cb1388ba86f29422d20979d3423fdf3541ba35a17ed44d6f4a517ff784ecd", + "size_in_bytes": 571 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/fix_next.py", + "path_type": "hardlink", + "sha256": "5c7d86d9f81b2498486d626c7feced1b92f23171cf9e42881abb78de1a93bccd", + "sha256_in_prefix": "5c7d86d9f81b2498486d626c7feced1b92f23171cf9e42881abb78de1a93bccd", + "size_in_bytes": 3174 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/fix_nonzero.py", + "path_type": "hardlink", + "sha256": "c2cd7e3ba44508643a20eec4ea4c19f2f1adfd36f6b974d7c143e449571ae736", + "sha256_in_prefix": "c2cd7e3ba44508643a20eec4ea4c19f2f1adfd36f6b974d7c143e449571ae736", + "size_in_bytes": 591 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/fix_numliterals.py", + "path_type": "hardlink", + "sha256": "1c4dd0f7881999abde6cf4d232836fa3e55fc41a7d5aa2b9866092f65707db7f", + "sha256_in_prefix": "1c4dd0f7881999abde6cf4d232836fa3e55fc41a7d5aa2b9866092f65707db7f", + "size_in_bytes": 768 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/fix_operator.py", + "path_type": "hardlink", + "sha256": "023872fe9f03a25387cf2c17fc950cf0f990353df66e603c3a1cd3199dbccd86", + "sha256_in_prefix": "023872fe9f03a25387cf2c17fc950cf0f990353df66e603c3a1cd3199dbccd86", + "size_in_bytes": 3426 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/fix_paren.py", + "path_type": "hardlink", + "sha256": "53734f1d7778ad28a4ec3ab4415923e2da8f230de4cd527589829f570e9f254d", + "sha256_in_prefix": "53734f1d7778ad28a4ec3ab4415923e2da8f230de4cd527589829f570e9f254d", + "size_in_bytes": 1226 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/fix_print.py", + "path_type": "hardlink", + "sha256": "cf2690f1b502249289f52cd544190db0b94d59df5eca139829cd2bf0742e9dba", + "sha256_in_prefix": "cf2690f1b502249289f52cd544190db0b94d59df5eca139829cd2bf0742e9dba", + "size_in_bytes": 2844 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/fix_raise.py", + "path_type": "hardlink", + "sha256": "c38ffec5862597ee8f9dac50385af943ee312bfc394366be08b2fc12563ca1a5", + "sha256_in_prefix": "c38ffec5862597ee8f9dac50385af943ee312bfc394366be08b2fc12563ca1a5", + "size_in_bytes": 2926 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/fix_raw_input.py", + "path_type": "hardlink", + "sha256": "ce04cbaa76d414949afc230360dd9a29ff579bd868cc7f8805230d126ac9ce9b", + "sha256_in_prefix": "ce04cbaa76d414949afc230360dd9a29ff579bd868cc7f8805230d126ac9ce9b", + "size_in_bytes": 454 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/fix_reduce.py", + "path_type": "hardlink", + "sha256": "9a03910a6c183586e1db01863fcde6417d06745fb3e63032333d71c5e82e7919", + "sha256_in_prefix": "9a03910a6c183586e1db01863fcde6417d06745fb3e63032333d71c5e82e7919", + "size_in_bytes": 837 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/fix_reload.py", + "path_type": "hardlink", + "sha256": "17570148167e43b2155b6e1c814a3cca9e3ef53750c504932a9c7d62a8b68a3f", + "sha256_in_prefix": "17570148167e43b2155b6e1c814a3cca9e3ef53750c504932a9c7d62a8b68a3f", + "size_in_bytes": 1081 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/fix_renames.py", + "path_type": "hardlink", + "sha256": "8b71472317bf3adabf819e665c725d03e3064baa45f6ffbfd78cca83eaa46e8d", + "sha256_in_prefix": "8b71472317bf3adabf819e665c725d03e3064baa45f6ffbfd78cca83eaa46e8d", + "size_in_bytes": 2221 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/fix_repr.py", + "path_type": "hardlink", + "sha256": "d16930b7ef8577747cfef602aba854c64ce85d4ae1e54a18a456eaa202643e3d", + "sha256_in_prefix": "d16930b7ef8577747cfef602aba854c64ce85d4ae1e54a18a456eaa202643e3d", + "size_in_bytes": 613 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/fix_set_literal.py", + "path_type": "hardlink", + "sha256": "33f2c0b6e16357e083c3a98877e7317abe1578a44c288e5979c9d96fb5aa6727", + "sha256_in_prefix": "33f2c0b6e16357e083c3a98877e7317abe1578a44c288e5979c9d96fb5aa6727", + "size_in_bytes": 1697 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/fix_standarderror.py", + "path_type": "hardlink", + "sha256": "ce7eb37bc7fb29aa138b1cec6656ae8b4886cbfa700e119a1bb8484284cb717a", + "sha256_in_prefix": "ce7eb37bc7fb29aa138b1cec6656ae8b4886cbfa700e119a1bb8484284cb717a", + "size_in_bytes": 449 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/fix_sys_exc.py", + "path_type": "hardlink", + "sha256": "0143830586d09d702ca3eeaa8f86698e5fd18af69fd28147e71a1a77600d356a", + "sha256_in_prefix": "0143830586d09d702ca3eeaa8f86698e5fd18af69fd28147e71a1a77600d356a", + "size_in_bytes": 1034 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/fix_throw.py", + "path_type": "hardlink", + "sha256": "fec731ed523d5cdfa21893833b52b2844eabfd1549792c1c9f8ceac2d0e8e901", + "sha256_in_prefix": "fec731ed523d5cdfa21893833b52b2844eabfd1549792c1c9f8ceac2d0e8e901", + "size_in_bytes": 1582 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/fix_tuple_params.py", + "path_type": "hardlink", + "sha256": "f3307d4750d0657d9c42b857d5f37bdb5824f9358939da7d16d13f61eb8abc72", + "sha256_in_prefix": "f3307d4750d0657d9c42b857d5f37bdb5824f9358939da7d16d13f61eb8abc72", + "size_in_bytes": 5565 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/fix_types.py", + "path_type": "hardlink", + "sha256": "a0a133cfc78e82e1f71ce628408e7d10a38552ba3e3228ebd113838c1ce44484", + "sha256_in_prefix": "a0a133cfc78e82e1f71ce628408e7d10a38552ba3e3228ebd113838c1ce44484", + "size_in_bytes": 1774 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/fix_unicode.py", + "path_type": "hardlink", + "sha256": "01b2a9b1084b6a0424f27eec488c761f75f053a409608ec36a9ee0ede0d38097", + "sha256_in_prefix": "01b2a9b1084b6a0424f27eec488c761f75f053a409608ec36a9ee0ede0d38097", + "size_in_bytes": 1256 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/fix_urllib.py", + "path_type": "hardlink", + "sha256": "3d1c04d976ff4d2841025a785aaab0cc4ee06c9c9b4e09d1e2456949fa273856", + "sha256_in_prefix": "3d1c04d976ff4d2841025a785aaab0cc4ee06c9c9b4e09d1e2456949fa273856", + "size_in_bytes": 8367 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/fix_ws_comma.py", + "path_type": "hardlink", + "sha256": "5e7a16daec0b2619110516804bf90cac459a4d0315198fd4eff69c36c54378dd", + "sha256_in_prefix": "5e7a16daec0b2619110516804bf90cac459a4d0315198fd4eff69c36c54378dd", + "size_in_bytes": 1090 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/fix_xrange.py", + "path_type": "hardlink", + "sha256": "60d8ce92db6f399606d2e40a3c631ba566127e8cd637ebbf35b822672139cab2", + "sha256_in_prefix": "60d8ce92db6f399606d2e40a3c631ba566127e8cd637ebbf35b822672139cab2", + "size_in_bytes": 2694 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/fix_xreadlines.py", + "path_type": "hardlink", + "sha256": "e8c2f19f7047bfc7539fd78839929004d8fe0efba1fbcbd9d712d285e43834ba", + "sha256_in_prefix": "e8c2f19f7047bfc7539fd78839929004d8fe0efba1fbcbd9d712d285e43834ba", + "size_in_bytes": 689 + }, + { + "_path": "lib/python3.10/lib2to3/fixes/fix_zip.py", + "path_type": "hardlink", + "sha256": "55ce115556c7513dd967364dc6a40c39210c874e8168cf090ddd6dc606df34cb", + "sha256_in_prefix": "55ce115556c7513dd967364dc6a40c39210c874e8168cf090ddd6dc606df34cb", + "size_in_bytes": 1289 + }, + { + "_path": "lib/python3.10/lib2to3/main.py", + "path_type": "hardlink", + "sha256": "8f5dfa77b8c8b375daba8bb88aaa195395674311e2513b29575a70821e3aa0b8", + "sha256_in_prefix": "8f5dfa77b8c8b375daba8bb88aaa195395674311e2513b29575a70821e3aa0b8", + "size_in_bytes": 11854 + }, + { + "_path": "lib/python3.10/lib2to3/patcomp.py", + "path_type": "hardlink", + "sha256": "a033a3eb91a39f96747d4300aa3394965e529c71896cd6503dd27e6b685eede5", + "sha256_in_prefix": "a033a3eb91a39f96747d4300aa3394965e529c71896cd6503dd27e6b685eede5", + "size_in_bytes": 7054 + }, + { + "_path": "lib/python3.10/lib2to3/pgen2/__init__.py", + "path_type": "hardlink", + "sha256": "858eb0f50533bd3bd16fe32815f77fabfed92ede885070b6cb15827ec66ea500", + "sha256_in_prefix": "858eb0f50533bd3bd16fe32815f77fabfed92ede885070b6cb15827ec66ea500", + "size_in_bytes": 143 + }, + { + "_path": "lib/python3.10/lib2to3/pgen2/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "81589c3a2af682e1045d474543b352bd7a1252e3ec04278a34667385c9baad93", + "sha256_in_prefix": "81589c3a2af682e1045d474543b352bd7a1252e3ec04278a34667385c9baad93", + "size_in_bytes": 422 + }, + { + "_path": "lib/python3.10/lib2to3/pgen2/__pycache__/conv.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "88674e611f0fca9a0b0fbbb691a47f3f6939abc20b8641e06997931c2b18c937", + "sha256_in_prefix": "88674e611f0fca9a0b0fbbb691a47f3f6939abc20b8641e06997931c2b18c937", + "size_in_bytes": 7268 + }, + { + "_path": "lib/python3.10/lib2to3/pgen2/__pycache__/driver.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c26041ac4e0c0c86d839eefa6eef0e930b1099b0bf014894c79f5d27f15184d2", + "sha256_in_prefix": "c26041ac4e0c0c86d839eefa6eef0e930b1099b0bf014894c79f5d27f15184d2", + "size_in_bytes": 5393 + }, + { + "_path": "lib/python3.10/lib2to3/pgen2/__pycache__/grammar.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "7249f7a4616c475996a4e1c8cd887c7d3b80467fd3a2358d90a1c583b0342f62", + "sha256_in_prefix": "7249f7a4616c475996a4e1c8cd887c7d3b80467fd3a2358d90a1c583b0342f62", + "size_in_bytes": 5974 + }, + { + "_path": "lib/python3.10/lib2to3/pgen2/__pycache__/literals.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "79e6e92b7745ff3eb3ab0b9c0cdcf3dfef7e77d27634084607cdd4caff36f27c", + "sha256_in_prefix": "79e6e92b7745ff3eb3ab0b9c0cdcf3dfef7e77d27634084607cdd4caff36f27c", + "size_in_bytes": 1796 + }, + { + "_path": "lib/python3.10/lib2to3/pgen2/__pycache__/parse.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "4aef6f7ca78275aaa4a3d9d6c075cf804e4dda5b1baf9c99706ee3f62f0ef079", + "sha256_in_prefix": "4aef6f7ca78275aaa4a3d9d6c075cf804e4dda5b1baf9c99706ee3f62f0ef079", + "size_in_bytes": 6767 + }, + { + "_path": "lib/python3.10/lib2to3/pgen2/__pycache__/pgen.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "8905a8b54458377effb1af75bb8cb3baae14d9b932e0a1a282b41ac5d18e5cf2", + "sha256_in_prefix": "8905a8b54458377effb1af75bb8cb3baae14d9b932e0a1a282b41ac5d18e5cf2", + "size_in_bytes": 10103 + }, + { + "_path": "lib/python3.10/lib2to3/pgen2/__pycache__/token.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "6217c4151f416eaee9dacca02ac55ee2fc510b6ca4195fefa8137029a5496a41", + "sha256_in_prefix": "6217c4151f416eaee9dacca02ac55ee2fc510b6ca4195fefa8137029a5496a41", + "size_in_bytes": 2138 + }, + { + "_path": "lib/python3.10/lib2to3/pgen2/__pycache__/tokenize.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "246f56fdb4fd398ba20012874448134d41dd144be2020a9ad0618d4cb58c5fa9", + "sha256_in_prefix": "246f56fdb4fd398ba20012874448134d41dd144be2020a9ad0618d4cb58c5fa9", + "size_in_bytes": 15354 + }, + { + "_path": "lib/python3.10/lib2to3/pgen2/conv.py", + "path_type": "hardlink", + "sha256": "e2946a686c12e02248fafb1a57e7514e0c22bdb2b4a66e644215c86fedc37bff", + "sha256_in_prefix": "e2946a686c12e02248fafb1a57e7514e0c22bdb2b4a66e644215c86fedc37bff", + "size_in_bytes": 9642 + }, + { + "_path": "lib/python3.10/lib2to3/pgen2/driver.py", + "path_type": "hardlink", + "sha256": "57af5e220cd6c6b75e8dead2cea395ead2297dd98e398ad705ca2bce0e9e6594", + "sha256_in_prefix": "57af5e220cd6c6b75e8dead2cea395ead2297dd98e398ad705ca2bce0e9e6594", + "size_in_bytes": 5969 + }, + { + "_path": "lib/python3.10/lib2to3/pgen2/grammar.py", + "path_type": "hardlink", + "sha256": "b04309478d2086cde92de4ba62c87bd986d05d7181c51e186a30d64468c95fa9", + "sha256_in_prefix": "b04309478d2086cde92de4ba62c87bd986d05d7181c51e186a30d64468c95fa9", + "size_in_bytes": 5533 + }, + { + "_path": "lib/python3.10/lib2to3/pgen2/literals.py", + "path_type": "hardlink", + "sha256": "84bc9d5387a2e20fab844e530358571afa39fa3fc0e8024270b5f7d8ac5a595a", + "sha256_in_prefix": "84bc9d5387a2e20fab844e530358571afa39fa3fc0e8024270b5f7d8ac5a595a", + "size_in_bytes": 1635 + }, + { + "_path": "lib/python3.10/lib2to3/pgen2/parse.py", + "path_type": "hardlink", + "sha256": "e245e005e524ab445a570df31f70c6fd7b901ee3b0b68bd3bcf4b41b37fa7bb6", + "sha256_in_prefix": "e245e005e524ab445a570df31f70c6fd7b901ee3b0b68bd3bcf4b41b37fa7bb6", + "size_in_bytes": 8155 + }, + { + "_path": "lib/python3.10/lib2to3/pgen2/pgen.py", + "path_type": "hardlink", + "sha256": "8fe2ac7e0303f0110d75832d746e6661fcd5373fa498d929163f557fd1027434", + "sha256_in_prefix": "8fe2ac7e0303f0110d75832d746e6661fcd5373fa498d929163f557fd1027434", + "size_in_bytes": 13830 + }, + { + "_path": "lib/python3.10/lib2to3/pgen2/token.py", + "path_type": "hardlink", + "sha256": "47c7f968e1e3bf66d53fb4a6a9fc848cdae11d66d49bb70c7cf41961ea91f30c", + "sha256_in_prefix": "47c7f968e1e3bf66d53fb4a6a9fc848cdae11d66d49bb70c7cf41961ea91f30c", + "size_in_bytes": 1302 + }, + { + "_path": "lib/python3.10/lib2to3/pgen2/tokenize.py", + "path_type": "hardlink", + "sha256": "aaa0b98f6a65e08e9f8e34358198e329d29554a0d4b5f5059924a252eeb0f5c4", + "sha256_in_prefix": "aaa0b98f6a65e08e9f8e34358198e329d29554a0d4b5f5059924a252eeb0f5c4", + "size_in_bytes": 21119 + }, + { + "_path": "lib/python3.10/lib2to3/pygram.py", + "path_type": "hardlink", + "sha256": "b49d77876a9d1822ff6be04daf464341a8e4c0c3414240abf519254de2a97a48", + "sha256_in_prefix": "b49d77876a9d1822ff6be04daf464341a8e4c0c3414240abf519254de2a97a48", + "size_in_bytes": 1305 + }, + { + "_path": "lib/python3.10/lib2to3/pytree.py", + "path_type": "hardlink", + "sha256": "e53689352fb4fc83d85a09369650389ee01db802ad872a8abfc0bf6603ec38b9", + "sha256_in_prefix": "e53689352fb4fc83d85a09369650389ee01db802ad872a8abfc0bf6603ec38b9", + "size_in_bytes": 27974 + }, + { + "_path": "lib/python3.10/lib2to3/refactor.py", + "path_type": "hardlink", + "sha256": "6e9a4262fb65cd4d277f009df73ffa5748f5fe3b963d3c5395c160d5f88b089b", + "sha256_in_prefix": "6e9a4262fb65cd4d277f009df73ffa5748f5fe3b963d3c5395c160d5f88b089b", + "size_in_bytes": 27507 + }, + { + "_path": "lib/python3.10/lib2to3/tests/__init__.py", + "path_type": "hardlink", + "sha256": "6af7ab5586854297ec737d4aa485b96f13641a556106223eba0d761a5fb962ea", + "sha256_in_prefix": "6af7ab5586854297ec737d4aa485b96f13641a556106223eba0d761a5fb962ea", + "size_in_bytes": 168 + }, + { + "_path": "lib/python3.10/lib2to3/tests/__main__.py", + "path_type": "hardlink", + "sha256": "cb9a3ce8f18e7d0a0cadb73cc9264772462de953499534736998d3c54f8c7c3c", + "sha256_in_prefix": "cb9a3ce8f18e7d0a0cadb73cc9264772462de953499534736998d3c54f8c7c3c", + "size_in_bytes": 58 + }, + { + "_path": "lib/python3.10/lib2to3/tests/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "e720c6c82441211635526289237c22eec6ba8551e721f116eaebc216c78afbb5", + "sha256_in_prefix": "e720c6c82441211635526289237c22eec6ba8551e721f116eaebc216c78afbb5", + "size_in_bytes": 621 + }, + { + "_path": "lib/python3.10/lib2to3/tests/__pycache__/__main__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "52d5c996f9ace80427b7941d5a032fe8ecfa04d90bb30b94a7d3ebcc7a6d8648", + "sha256_in_prefix": "52d5c996f9ace80427b7941d5a032fe8ecfa04d90bb30b94a7d3ebcc7a6d8648", + "size_in_bytes": 468 + }, + { + "_path": "lib/python3.10/lib2to3/tests/__pycache__/pytree_idempotency.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "ff9f4d6f87a501d836d3de3fdfdc8bb24ca12090d8bd8f45f878791d3759fbed", + "sha256_in_prefix": "ff9f4d6f87a501d836d3de3fdfdc8bb24ca12090d8bd8f45f878791d3759fbed", + "size_in_bytes": 2173 + }, + { + "_path": "lib/python3.10/lib2to3/tests/__pycache__/support.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "d9d66c79bf1ab9266924728a148e590ab529092811ffbeb17d6dde179fa0d14d", + "sha256_in_prefix": "d9d66c79bf1ab9266924728a148e590ab529092811ffbeb17d6dde179fa0d14d", + "size_in_bytes": 2495 + }, + { + "_path": "lib/python3.10/lib2to3/tests/__pycache__/test_all_fixers.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "546b78f776b33ee4250e5c5a492867b7d46c44461c65976312991a338a19b9a5", + "sha256_in_prefix": "546b78f776b33ee4250e5c5a492867b7d46c44461c65976312991a338a19b9a5", + "size_in_bytes": 1729 + }, + { + "_path": "lib/python3.10/lib2to3/tests/__pycache__/test_fixers.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "6da1b749a7ac00031314aa6b9b172c56838e56a35d538b2c744bc78e55b52201", + "sha256_in_prefix": "6da1b749a7ac00031314aa6b9b172c56838e56a35d538b2c744bc78e55b52201", + "size_in_bytes": 126918 + }, + { + "_path": "lib/python3.10/lib2to3/tests/__pycache__/test_main.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "ebb9b658e2354c4f9a1360cf94165e3859f13fffbd575bbece05b7a5b5e2860a", + "sha256_in_prefix": "ebb9b658e2354c4f9a1360cf94165e3859f13fffbd575bbece05b7a5b5e2860a", + "size_in_bytes": 5424 + }, + { + "_path": "lib/python3.10/lib2to3/tests/__pycache__/test_parser.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "2ef218b2988f4b904dc748d73fb7fa90187b657a3df8334fac6b387c944c8f9c", + "sha256_in_prefix": "2ef218b2988f4b904dc748d73fb7fa90187b657a3df8334fac6b387c944c8f9c", + "size_in_bytes": 31767 + }, + { + "_path": "lib/python3.10/lib2to3/tests/__pycache__/test_pytree.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "5e02b8b4202b4c8ed7d1b50baaf73232e95087696bba1437ea4095faea22b427", + "sha256_in_prefix": "5e02b8b4202b4c8ed7d1b50baaf73232e95087696bba1437ea4095faea22b427", + "size_in_bytes": 14856 + }, + { + "_path": "lib/python3.10/lib2to3/tests/__pycache__/test_refactor.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "b926a5729b0c081bc5ce470a363ded43a7439376b77b2809c50a920d4cb7bdc3", + "sha256_in_prefix": "b926a5729b0c081bc5ce470a363ded43a7439376b77b2809c50a920d4cb7bdc3", + "size_in_bytes": 13473 + }, + { + "_path": "lib/python3.10/lib2to3/tests/__pycache__/test_util.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "f446faaf6f35b09bf2801dd6937cb1b8c038f3e5b2d4a353b14991b8545fdd69", + "sha256_in_prefix": "f446faaf6f35b09bf2801dd6937cb1b8c038f3e5b2d4a353b14991b8545fdd69", + "size_in_bytes": 19515 + }, + { + "_path": "lib/python3.10/lib2to3/tests/data/README", + "path_type": "hardlink", + "sha256": "83999cc221401dc2fccca9d3dbe395c82a9f009db310a00e811c68c606547719", + "sha256_in_prefix": "83999cc221401dc2fccca9d3dbe395c82a9f009db310a00e811c68c606547719", + "size_in_bytes": 404 + }, + { + "_path": "lib/python3.10/lib2to3/tests/data/__pycache__/infinite_recursion.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "02ef2b0f48bd029d955b77b13316853afe3efe39261f313122e5af76c701b303", + "sha256_in_prefix": "02ef2b0f48bd029d955b77b13316853afe3efe39261f313122e5af76c701b303", + "size_in_bytes": 66845 + }, + { + "_path": "lib/python3.10/lib2to3/tests/data/__pycache__/py3_test_grammar.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "cc402c30cf02d467c3dde60f1605548ece67ada0e0e60d6769a35c261de55340", + "sha256_in_prefix": "cc402c30cf02d467c3dde60f1605548ece67ada0e0e60d6769a35c261de55340", + "size_in_bytes": 36106 + }, + { + "_path": "lib/python3.10/lib2to3/tests/data/bom.py", + "path_type": "hardlink", + "sha256": "16c62c93da9ed9338601adb171f1aac3d28c1c9cae35ee1b6de7948de837e436", + "sha256_in_prefix": "16c62c93da9ed9338601adb171f1aac3d28c1c9cae35ee1b6de7948de837e436", + "size_in_bytes": 37 + }, + { + "_path": "lib/python3.10/lib2to3/tests/data/crlf.py", + "path_type": "hardlink", + "sha256": "d910ad886333abf3664a4fb4290d3b81307a16c6d9ca14356b3644a9aae6e714", + "sha256_in_prefix": "d910ad886333abf3664a4fb4290d3b81307a16c6d9ca14356b3644a9aae6e714", + "size_in_bytes": 50 + }, + { + "_path": "lib/python3.10/lib2to3/tests/data/different_encoding.py", + "path_type": "hardlink", + "sha256": "e5d82fa54d5060994445e1d3825f49999aa98a093803393d88a5e8030c62337f", + "sha256_in_prefix": "e5d82fa54d5060994445e1d3825f49999aa98a093803393d88a5e8030c62337f", + "size_in_bytes": 230 + }, + { + "_path": "lib/python3.10/lib2to3/tests/data/false_encoding.py", + "path_type": "hardlink", + "sha256": "f3c15c2784af8783069df41ca628371df3dbe59758942461bfa4bc5902d9d9b3", + "sha256_in_prefix": "f3c15c2784af8783069df41ca628371df3dbe59758942461bfa4bc5902d9d9b3", + "size_in_bytes": 40 + }, + { + "_path": "lib/python3.10/lib2to3/tests/data/fixers/__pycache__/bad_order.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "557d1d653ed310b3c6bee9f19297f37377e9acb9fd888580153072435750b9a1", + "sha256_in_prefix": "557d1d653ed310b3c6bee9f19297f37377e9acb9fd888580153072435750b9a1", + "size_in_bytes": 635 + }, + { + "_path": "lib/python3.10/lib2to3/tests/data/fixers/__pycache__/no_fixer_cls.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "b6a68457c651f012286e58d153278cc7d11e218e316fa53b5ed2ba33cbec3acc", + "sha256_in_prefix": "b6a68457c651f012286e58d153278cc7d11e218e316fa53b5ed2ba33cbec3acc", + "size_in_bytes": 408 + }, + { + "_path": "lib/python3.10/lib2to3/tests/data/fixers/__pycache__/parrot_example.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "32e4216d348666d9f57aa0d649ad47c552259c042f21bb7813212ba8d1c06b1d", + "sha256_in_prefix": "32e4216d348666d9f57aa0d649ad47c552259c042f21bb7813212ba8d1c06b1d", + "size_in_bytes": 506 + }, + { + "_path": "lib/python3.10/lib2to3/tests/data/fixers/bad_order.py", + "path_type": "hardlink", + "sha256": "b78e533e055c607b009b1ad93dbbf16a3595f6522b95536eff974b202a34e8fd", + "sha256_in_prefix": "b78e533e055c607b009b1ad93dbbf16a3595f6522b95536eff974b202a34e8fd", + "size_in_bytes": 89 + }, + { + "_path": "lib/python3.10/lib2to3/tests/data/fixers/myfixes/__init__.py", + "path_type": "hardlink", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size_in_bytes": 0 + }, + { + "_path": "lib/python3.10/lib2to3/tests/data/fixers/myfixes/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "82fea1beaba5643f9561a0d9a7008993463e2640d268835109537f5eddb463dd", + "sha256_in_prefix": "82fea1beaba5643f9561a0d9a7008993463e2640d268835109537f5eddb463dd", + "size_in_bytes": 412 + }, + { + "_path": "lib/python3.10/lib2to3/tests/data/fixers/myfixes/__pycache__/fix_explicit.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "9044737f31be21a7a75962b965194af64b699bd400e64968d6e3e3fb7039f8ad", + "sha256_in_prefix": "9044737f31be21a7a75962b965194af64b699bd400e64968d6e3e3fb7039f8ad", + "size_in_bytes": 761 + }, + { + "_path": "lib/python3.10/lib2to3/tests/data/fixers/myfixes/__pycache__/fix_first.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "a2804b8dc23410c291a768608568aafd9a03b29e0034c59eb74745a333de4b1b", + "sha256_in_prefix": "a2804b8dc23410c291a768608568aafd9a03b29e0034c59eb74745a333de4b1b", + "size_in_bytes": 763 + }, + { + "_path": "lib/python3.10/lib2to3/tests/data/fixers/myfixes/__pycache__/fix_last.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "cdffad21b0c80bfdb4c686bb32f2b7b3446701c63598a593a5fcc085cfe2a3cb", + "sha256_in_prefix": "cdffad21b0c80bfdb4c686bb32f2b7b3446701c63598a593a5fcc085cfe2a3cb", + "size_in_bytes": 760 + }, + { + "_path": "lib/python3.10/lib2to3/tests/data/fixers/myfixes/__pycache__/fix_parrot.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "feefdad9e6d6fa424b1c6b8e6dc2497c9ee614f172f55303b10f11e700dbdea2", + "sha256_in_prefix": "feefdad9e6d6fa424b1c6b8e6dc2497c9ee614f172f55303b10f11e700dbdea2", + "size_in_bytes": 997 + }, + { + "_path": "lib/python3.10/lib2to3/tests/data/fixers/myfixes/__pycache__/fix_preorder.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "2dbc0e453899f733e9b93b9cad25863b28381cb3289ad672c51319ac1f44b4fa", + "sha256_in_prefix": "2dbc0e453899f733e9b93b9cad25863b28381cb3289ad672c51319ac1f44b4fa", + "size_in_bytes": 768 + }, + { + "_path": "lib/python3.10/lib2to3/tests/data/fixers/myfixes/fix_explicit.py", + "path_type": "hardlink", + "sha256": "e46f1bf431aa68e36406b32cd94afaafd109452df427aa726855be4176077b56", + "sha256_in_prefix": "e46f1bf431aa68e36406b32cd94afaafd109452df427aa726855be4176077b56", + "size_in_bytes": 123 + }, + { + "_path": "lib/python3.10/lib2to3/tests/data/fixers/myfixes/fix_first.py", + "path_type": "hardlink", + "sha256": "a2e3c4212f38d27aff680c0a7f6c377829438a7c7a4f85ad4789b22de7ca73a9", + "sha256_in_prefix": "a2e3c4212f38d27aff680c0a7f6c377829438a7c7a4f85ad4789b22de7ca73a9", + "size_in_bytes": 124 + }, + { + "_path": "lib/python3.10/lib2to3/tests/data/fixers/myfixes/fix_last.py", + "path_type": "hardlink", + "sha256": "042acb60984c6f721fa89c42cebe22572acc9434cc7f27d2fb4362b3602deb1d", + "sha256_in_prefix": "042acb60984c6f721fa89c42cebe22572acc9434cc7f27d2fb4362b3602deb1d", + "size_in_bytes": 125 + }, + { + "_path": "lib/python3.10/lib2to3/tests/data/fixers/myfixes/fix_parrot.py", + "path_type": "hardlink", + "sha256": "627f9028bbdde32e61ceceeb929520023607de25aebdc039c2d568d9c1a8d1db", + "sha256_in_prefix": "627f9028bbdde32e61ceceeb929520023607de25aebdc039c2d568d9c1a8d1db", + "size_in_bytes": 347 + }, + { + "_path": "lib/python3.10/lib2to3/tests/data/fixers/myfixes/fix_preorder.py", + "path_type": "hardlink", + "sha256": "c7c15747f0d13d0884b48d424c3b38d5e05cfece09c539c906d5dec48be3d083", + "sha256_in_prefix": "c7c15747f0d13d0884b48d424c3b38d5e05cfece09c539c906d5dec48be3d083", + "size_in_bytes": 127 + }, + { + "_path": "lib/python3.10/lib2to3/tests/data/fixers/no_fixer_cls.py", + "path_type": "hardlink", + "sha256": "c0a16cfbe6b674abb6534c984f06af296a01668b208f0967f25f8a4348e625a3", + "sha256_in_prefix": "c0a16cfbe6b674abb6534c984f06af296a01668b208f0967f25f8a4348e625a3", + "size_in_bytes": 75 + }, + { + "_path": "lib/python3.10/lib2to3/tests/data/fixers/parrot_example.py", + "path_type": "hardlink", + "sha256": "6d9acb2151507735aa72c6aeaf15142a75cb0d3b37b48215ac45ee17106adc18", + "sha256_in_prefix": "6d9acb2151507735aa72c6aeaf15142a75cb0d3b37b48215ac45ee17106adc18", + "size_in_bytes": 23 + }, + { + "_path": "lib/python3.10/lib2to3/tests/data/infinite_recursion.py", + "path_type": "hardlink", + "sha256": "b8f8f36cea94f8189a18558ae6badafbe89f20e5edc5471c7068ed53d1e2c031", + "sha256_in_prefix": "b8f8f36cea94f8189a18558ae6badafbe89f20e5edc5471c7068ed53d1e2c031", + "size_in_bytes": 93031 + }, + { + "_path": "lib/python3.10/lib2to3/tests/data/py2_test_grammar.py", + "path_type": "hardlink", + "sha256": "253e51525c7e1ef847ab32b2556bc4213371e636fb498e0040980036bdd3f8ed", + "sha256_in_prefix": "253e51525c7e1ef847ab32b2556bc4213371e636fb498e0040980036bdd3f8ed", + "size_in_bytes": 30910 + }, + { + "_path": "lib/python3.10/lib2to3/tests/data/py3_test_grammar.py", + "path_type": "hardlink", + "sha256": "6b7a9e6082077b5ea379c0dcefe21455a21c57f69e51e9f16d1efe25176d0663", + "sha256_in_prefix": "6b7a9e6082077b5ea379c0dcefe21455a21c57f69e51e9f16d1efe25176d0663", + "size_in_bytes": 31173 + }, + { + "_path": "lib/python3.10/lib2to3/tests/pytree_idempotency.py", + "path_type": "hardlink", + "sha256": "56e652f53a8cf79d0c18660763830183b373b2a4049ac6fb835c4b328817d156", + "sha256_in_prefix": "56e652f53a8cf79d0c18660763830183b373b2a4049ac6fb835c4b328817d156", + "size_in_bytes": 2453 + }, + { + "_path": "lib/python3.10/lib2to3/tests/support.py", + "path_type": "hardlink", + "sha256": "d00dd6cf406be2cd020e16ffefc4e01c8bc45324e02341a71c52993f07ef5c34", + "sha256_in_prefix": "d00dd6cf406be2cd020e16ffefc4e01c8bc45324e02341a71c52993f07ef5c34", + "size_in_bytes": 1948 + }, + { + "_path": "lib/python3.10/lib2to3/tests/test_all_fixers.py", + "path_type": "hardlink", + "sha256": "6794fe0491d3587f50932556ed87a85b59f0b22dd01ff31b2f12149a24cf9496", + "sha256_in_prefix": "6794fe0491d3587f50932556ed87a85b59f0b22dd01ff31b2f12149a24cf9496", + "size_in_bytes": 1209 + }, + { + "_path": "lib/python3.10/lib2to3/tests/test_fixers.py", + "path_type": "hardlink", + "sha256": "8a9f1197a95ada1732be8815d4f2228ac90c05d4af7435fd1464380a10e3ca17", + "sha256_in_prefix": "8a9f1197a95ada1732be8815d4f2228ac90c05d4af7435fd1464380a10e3ca17", + "size_in_bytes": 122906 + }, + { + "_path": "lib/python3.10/lib2to3/tests/test_main.py", + "path_type": "hardlink", + "sha256": "3f61027bbcdf521589b58fca01c3a5d2cf9ee40f69e48567b2175647fb5e2cbb", + "sha256_in_prefix": "3f61027bbcdf521589b58fca01c3a5d2cf9ee40f69e48567b2175647fb5e2cbb", + "size_in_bytes": 5740 + }, + { + "_path": "lib/python3.10/lib2to3/tests/test_parser.py", + "path_type": "hardlink", + "sha256": "275051121a652b3f17928d42f6d0d6d50a5e8f1d9a4986ab4cbfd53841d2f5a2", + "sha256_in_prefix": "275051121a652b3f17928d42f6d0d6d50a5e8f1d9a4986ab4cbfd53841d2f5a2", + "size_in_bytes": 23655 + }, + { + "_path": "lib/python3.10/lib2to3/tests/test_pytree.py", + "path_type": "hardlink", + "sha256": "6fbcd26438397c6c3de40f4546c7112c81f784356e614ae529d8c90570d40f71", + "sha256_in_prefix": "6fbcd26438397c6c3de40f4546c7112c81f784356e614ae529d8c90570d40f71", + "size_in_bytes": 16382 + }, + { + "_path": "lib/python3.10/lib2to3/tests/test_refactor.py", + "path_type": "hardlink", + "sha256": "1a12117d8c600e848b41f0c89ec1758d650a8425dd9bc40b502fce6298d4cdc0", + "sha256_in_prefix": "1a12117d8c600e848b41f0c89ec1758d650a8425dd9bc40b502fce6298d4cdc0", + "size_in_bytes": 12586 + }, + { + "_path": "lib/python3.10/lib2to3/tests/test_util.py", + "path_type": "hardlink", + "sha256": "02c744eb87a94e5ebd94e5966e103dcf29da97b458543600f3aa79c8158d47a9", + "sha256_in_prefix": "02c744eb87a94e5ebd94e5966e103dcf29da97b458543600f3aa79c8158d47a9", + "size_in_bytes": 21207 + }, + { + "_path": "lib/python3.10/linecache.py", + "path_type": "hardlink", + "sha256": "e814839fc75010db274ae034f45b0fff7e529ccb702319048545fef84c2045b7", + "sha256_in_prefix": "e814839fc75010db274ae034f45b0fff7e529ccb702319048545fef84c2045b7", + "size_in_bytes": 5690 + }, + { + "_path": "lib/python3.10/locale.py", + "path_type": "hardlink", + "sha256": "5f7e28c368751d372719e305a41ca76862f341b1de5d3163db7b2e3452848881", + "sha256_in_prefix": "5f7e28c368751d372719e305a41ca76862f341b1de5d3163db7b2e3452848881", + "size_in_bytes": 78124 + }, + { + "_path": "lib/python3.10/logging/__init__.py", + "path_type": "hardlink", + "sha256": "9069cd43c7a8aa8170b654b1ee21e0d35c15baebfb61e49ecb490df968dce07e", + "sha256_in_prefix": "9069cd43c7a8aa8170b654b1ee21e0d35c15baebfb61e49ecb490df968dce07e", + "size_in_bytes": 80232 + }, + { + "_path": "lib/python3.10/logging/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "5515f31b3f52dec2b93d7b09ba38015bb881afb793a3190634560155ee12439a", + "sha256_in_prefix": "5515f31b3f52dec2b93d7b09ba38015bb881afb793a3190634560155ee12439a", + "size_in_bytes": 67145 + }, + { + "_path": "lib/python3.10/logging/__pycache__/config.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "b9b36862e8bfb51444acc5ac0a64854be843b1dd337464f4982e2c3acdffa01b", + "sha256_in_prefix": "b9b36862e8bfb51444acc5ac0a64854be843b1dd337464f4982e2c3acdffa01b", + "size_in_bytes": 23437 + }, + { + "_path": "lib/python3.10/logging/__pycache__/handlers.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "8c8526fb1bbc9c866e62c6675a08b487450df4ba1248098a090831105d3e84db", + "sha256_in_prefix": "8c8526fb1bbc9c866e62c6675a08b487450df4ba1248098a090831105d3e84db", + "size_in_bytes": 44938 + }, + { + "_path": "lib/python3.10/logging/config.py", + "path_type": "hardlink", + "sha256": "90b3442116d6534013a82a2ec0bc0b499cc0cedbba2ceb551bb6d01f15d8bd3b", + "sha256_in_prefix": "90b3442116d6534013a82a2ec0bc0b499cc0cedbba2ceb551bb6d01f15d8bd3b", + "size_in_bytes": 36495 + }, + { + "_path": "lib/python3.10/logging/handlers.py", + "path_type": "hardlink", + "sha256": "6712cc3a6fc313fa00d6995f154e043608bb518b3affbd3d603ddf97a5c15feb", + "sha256_in_prefix": "6712cc3a6fc313fa00d6995f154e043608bb518b3affbd3d603ddf97a5c15feb", + "size_in_bytes": 61416 + }, + { + "_path": "lib/python3.10/lzma.py", + "path_type": "hardlink", + "sha256": "58fb9d2fdc8a8af7b25e218f17ea3b51bdfa53bdf40f440ab33c605974ca5c2e", + "sha256_in_prefix": "58fb9d2fdc8a8af7b25e218f17ea3b51bdfa53bdf40f440ab33c605974ca5c2e", + "size_in_bytes": 13277 + }, + { + "_path": "lib/python3.10/mailbox.py", + "path_type": "hardlink", + "sha256": "e695a76d936f009d926e50eae09e34e1256ceee86ffb5b5825748e98f9080036", + "sha256_in_prefix": "e695a76d936f009d926e50eae09e34e1256ceee86ffb5b5825748e98f9080036", + "size_in_bytes": 78794 + }, + { + "_path": "lib/python3.10/mailcap.py", + "path_type": "hardlink", + "sha256": "b0ce7d29e8233ec412ac6aa16a9e62b3353d4acd44c6b870f6b6ffe1dbebba6f", + "sha256_in_prefix": "b0ce7d29e8233ec412ac6aa16a9e62b3353d4acd44c6b870f6b6ffe1dbebba6f", + "size_in_bytes": 9116 + }, + { + "_path": "lib/python3.10/mimetypes.py", + "path_type": "hardlink", + "sha256": "1c2ce66381de7f675fe2e3b2f73ec6b718fbec596bbca0fb17aa5a02ff31b007", + "sha256_in_prefix": "1c2ce66381de7f675fe2e3b2f73ec6b718fbec596bbca0fb17aa5a02ff31b007", + "size_in_bytes": 22539 + }, + { + "_path": "lib/python3.10/modulefinder.py", + "path_type": "hardlink", + "sha256": "eccfc7972b42dc3064832d3b98d2db8e1486d570d75c80a874cdb55b84d6e05e", + "sha256_in_prefix": "eccfc7972b42dc3064832d3b98d2db8e1486d570d75c80a874cdb55b84d6e05e", + "size_in_bytes": 24401 + }, + { + "_path": "lib/python3.10/multiprocessing/__init__.py", + "path_type": "hardlink", + "sha256": "a5a42976033c7d63ee2740acceef949a3582dcb0e0442845f9717e1be771c68b", + "sha256_in_prefix": "a5a42976033c7d63ee2740acceef949a3582dcb0e0442845f9717e1be771c68b", + "size_in_bytes": 916 + }, + { + "_path": "lib/python3.10/multiprocessing/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "7119c96bfdc06241f487a53fa8477cb96df32a5c60376e6f8cbaefa2dedba8ae", + "sha256_in_prefix": "7119c96bfdc06241f487a53fa8477cb96df32a5c60376e6f8cbaefa2dedba8ae", + "size_in_bytes": 923 + }, + { + "_path": "lib/python3.10/multiprocessing/__pycache__/connection.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "698b3ff2922b99b3ddfa6930eeb9671659bd52f0298b411fd2b50d7d2c67917c", + "sha256_in_prefix": "698b3ff2922b99b3ddfa6930eeb9671659bd52f0298b411fd2b50d7d2c67917c", + "size_in_bytes": 25828 + }, + { + "_path": "lib/python3.10/multiprocessing/__pycache__/context.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "ff0825c0a0bc2d54b92dfe208c07142f15fbec8061b89033a7ef4957d49e01cd", + "sha256_in_prefix": "ff0825c0a0bc2d54b92dfe208c07142f15fbec8061b89033a7ef4957d49e01cd", + "size_in_bytes": 13108 + }, + { + "_path": "lib/python3.10/multiprocessing/__pycache__/forkserver.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "7d99ad134906ee1c7f48a8c8733d49bda497d0d4dc94eafb7a47f7725aa97268", + "sha256_in_prefix": "7d99ad134906ee1c7f48a8c8733d49bda497d0d4dc94eafb7a47f7725aa97268", + "size_in_bytes": 8680 + }, + { + "_path": "lib/python3.10/multiprocessing/__pycache__/heap.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "adf230f62060842f36d0fdf46369a5108a9a91c8ee58bd01eb7f580b5c725065", + "sha256_in_prefix": "adf230f62060842f36d0fdf46369a5108a9a91c8ee58bd01eb7f580b5c725065", + "size_in_bytes": 7922 + }, + { + "_path": "lib/python3.10/multiprocessing/__pycache__/managers.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "d8d4799fd9853cb773fe9efae977fc011836cb8415f082739aee0ce512fb1253", + "sha256_in_prefix": "d8d4799fd9853cb773fe9efae977fc011836cb8415f082739aee0ce512fb1253", + "size_in_bytes": 41016 + }, + { + "_path": "lib/python3.10/multiprocessing/__pycache__/pool.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "360690cb24fbf21abc552a77c724c312f33f2d7521d531d0048848f16db91e48", + "sha256_in_prefix": "360690cb24fbf21abc552a77c724c312f33f2d7521d531d0048848f16db91e48", + "size_in_bytes": 25456 + }, + { + "_path": "lib/python3.10/multiprocessing/__pycache__/popen_fork.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "75947faab10a426efa0db5359bd7cd9708e7864a5850cec824bffadea896c293", + "sha256_in_prefix": "75947faab10a426efa0db5359bd7cd9708e7864a5850cec824bffadea896c293", + "size_in_bytes": 2775 + }, + { + "_path": "lib/python3.10/multiprocessing/__pycache__/popen_forkserver.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "d891318726a51d932dc7fa3db3aaa63ba610ac12b22409b94ddaeebee0a9a140", + "sha256_in_prefix": "d891318726a51d932dc7fa3db3aaa63ba610ac12b22409b94ddaeebee0a9a140", + "size_in_bytes": 2720 + }, + { + "_path": "lib/python3.10/multiprocessing/__pycache__/popen_spawn_posix.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "267a866112e3f8e96b94c30035db97d02b2708196dd41edde17d6285016490f3", + "sha256_in_prefix": "267a866112e3f8e96b94c30035db97d02b2708196dd41edde17d6285016490f3", + "size_in_bytes": 2603 + }, + { + "_path": "lib/python3.10/multiprocessing/__pycache__/popen_spawn_win32.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "2059138e46c3c71273961a36cbdd43d33d32d28213a0eacec9c21275b1c4ddd9", + "sha256_in_prefix": "2059138e46c3c71273961a36cbdd43d33d32d28213a0eacec9c21275b1c4ddd9", + "size_in_bytes": 3728 + }, + { + "_path": "lib/python3.10/multiprocessing/__pycache__/process.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "ba4baaa39198313e2577badb0e21d3d8ca0f9f66accf73b2275b7ac2de34f25b", + "sha256_in_prefix": "ba4baaa39198313e2577badb0e21d3d8ca0f9f66accf73b2275b7ac2de34f25b", + "size_in_bytes": 11516 + }, + { + "_path": "lib/python3.10/multiprocessing/__pycache__/queues.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "815a84f8a716de3901fb35605680bedca94f87f7f85efb42ab13e2c8f8278e79", + "sha256_in_prefix": "815a84f8a716de3901fb35605680bedca94f87f7f85efb42ab13e2c8f8278e79", + "size_in_bytes": 10539 + }, + { + "_path": "lib/python3.10/multiprocessing/__pycache__/reduction.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "e8390a5f1c473a25096220c9388d86f9b42459b795ff96ffe04f88aa105b37be", + "sha256_in_prefix": "e8390a5f1c473a25096220c9388d86f9b42459b795ff96ffe04f88aa105b37be", + "size_in_bytes": 8551 + }, + { + "_path": "lib/python3.10/multiprocessing/__pycache__/resource_sharer.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "13d44ae69ae9fb82ef1e1df0f3ff49a303ec7f2cb39d81492be9705cce0cd792", + "sha256_in_prefix": "13d44ae69ae9fb82ef1e1df0f3ff49a303ec7f2cb39d81492be9705cce0cd792", + "size_in_bytes": 5555 + }, + { + "_path": "lib/python3.10/multiprocessing/__pycache__/resource_tracker.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "0b04ef4df52aab76bf2b39b4a4085245dcc21b24008012be840365d0d1ef1cc2", + "sha256_in_prefix": "0b04ef4df52aab76bf2b39b4a4085245dcc21b24008012be840365d0d1ef1cc2", + "size_in_bytes": 5739 + }, + { + "_path": "lib/python3.10/multiprocessing/__pycache__/shared_memory.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "d7694f2367cdc3eee4aadde323843effe8e679451955ea1071fc5f2566a65d27", + "sha256_in_prefix": "d7694f2367cdc3eee4aadde323843effe8e679451955ea1071fc5f2566a65d27", + "size_in_bytes": 14738 + }, + { + "_path": "lib/python3.10/multiprocessing/__pycache__/sharedctypes.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "7eeb055d025b67f131d1c4bd559f3094ffca96cd764790cc0dd04d6c4430a16e", + "sha256_in_prefix": "7eeb055d025b67f131d1c4bd559f3094ffca96cd764790cc0dd04d6c4430a16e", + "size_in_bytes": 7354 + }, + { + "_path": "lib/python3.10/multiprocessing/__pycache__/spawn.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "addb0214ac778648926f7403fe73b575f162f4275da369ee5d33e1d2e52707f8", + "sha256_in_prefix": "addb0214ac778648926f7403fe73b575f162f4275da369ee5d33e1d2e52707f8", + "size_in_bytes": 6991 + }, + { + "_path": "lib/python3.10/multiprocessing/__pycache__/synchronize.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "124fcd0bbc13f73bf8c2b6586ffb405482f72e8d7b00ace0a6ef7743ed00d0aa", + "sha256_in_prefix": "124fcd0bbc13f73bf8c2b6586ffb405482f72e8d7b00ace0a6ef7743ed00d0aa", + "size_in_bytes": 11581 + }, + { + "_path": "lib/python3.10/multiprocessing/__pycache__/util.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "41cbade17bef0e6561af73666dc2ce9c51608d5a972a7a97166ed661d13b0a1e", + "sha256_in_prefix": "41cbade17bef0e6561af73666dc2ce9c51608d5a972a7a97166ed661d13b0a1e", + "size_in_bytes": 11751 + }, + { + "_path": "lib/python3.10/multiprocessing/connection.py", + "path_type": "hardlink", + "sha256": "a6c0161f3bf0c2c38d0a7797148a11aa0e5334d9f22cb9f50f4204c775e9072d", + "sha256_in_prefix": "a6c0161f3bf0c2c38d0a7797148a11aa0e5334d9f22cb9f50f4204c775e9072d", + "size_in_bytes": 31685 + }, + { + "_path": "lib/python3.10/multiprocessing/context.py", + "path_type": "hardlink", + "sha256": "bd8628d1e140d933d40ed14b51009820c1b0b9b5b6c71971df5fc761da65bd08", + "sha256_in_prefix": "bd8628d1e140d933d40ed14b51009820c1b0b9b5b6c71971df5fc761da65bd08", + "size_in_bytes": 11597 + }, + { + "_path": "lib/python3.10/multiprocessing/dummy/__init__.py", + "path_type": "hardlink", + "sha256": "9127a40ea0ff342cb414383b5e7c594a05be2dd835fe246bd3bb0dc036a32a90", + "sha256_in_prefix": "9127a40ea0ff342cb414383b5e7c594a05be2dd835fe246bd3bb0dc036a32a90", + "size_in_bytes": 3061 + }, + { + "_path": "lib/python3.10/multiprocessing/dummy/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "57417753c3bbcbc1b76875cf970f75cf31a706f67e5c5657ba603d773a9ba5fd", + "sha256_in_prefix": "57417753c3bbcbc1b76875cf970f75cf31a706f67e5c5657ba603d773a9ba5fd", + "size_in_bytes": 4122 + }, + { + "_path": "lib/python3.10/multiprocessing/dummy/__pycache__/connection.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "814c6f2b044193f7ee0f49069a9538f30786f528473dc042886e858b8d7605f5", + "sha256_in_prefix": "814c6f2b044193f7ee0f49069a9538f30786f528473dc042886e858b8d7605f5", + "size_in_bytes": 2822 + }, + { + "_path": "lib/python3.10/multiprocessing/dummy/connection.py", + "path_type": "hardlink", + "sha256": "d63dd1979fde9c133efe430ee870e6ba6de43c0a0513866ce3ce475791fe57ab", + "sha256_in_prefix": "d63dd1979fde9c133efe430ee870e6ba6de43c0a0513866ce3ce475791fe57ab", + "size_in_bytes": 1598 + }, + { + "_path": "lib/python3.10/multiprocessing/forkserver.py", + "path_type": "hardlink", + "sha256": "578e1a3733c81c09c70a1f427b467adb20c7197069d773e85ecd6e9236150a72", + "sha256_in_prefix": "578e1a3733c81c09c70a1f427b467adb20c7197069d773e85ecd6e9236150a72", + "size_in_bytes": 12142 + }, + { + "_path": "lib/python3.10/multiprocessing/heap.py", + "path_type": "hardlink", + "sha256": "f6bb79bb99b9ae484935f0d68822e9603a1622dd0b6c4966c79db232a93ba614", + "sha256_in_prefix": "f6bb79bb99b9ae484935f0d68822e9603a1622dd0b6c4966c79db232a93ba614", + "size_in_bytes": 11626 + }, + { + "_path": "lib/python3.10/multiprocessing/managers.py", + "path_type": "hardlink", + "sha256": "32d6c5ca78875c43c5d4d18daa7c771aefa2a881f9196c9faf309b25413b0908", + "sha256_in_prefix": "32d6c5ca78875c43c5d4d18daa7c771aefa2a881f9196c9faf309b25413b0908", + "size_in_bytes": 47502 + }, + { + "_path": "lib/python3.10/multiprocessing/pool.py", + "path_type": "hardlink", + "sha256": "1539ad7e8aa4b8df03778f1fe5381d928928c5837be7172747bf07c3e6cb4a78", + "sha256_in_prefix": "1539ad7e8aa4b8df03778f1fe5381d928928c5837be7172747bf07c3e6cb4a78", + "size_in_bytes": 32759 + }, + { + "_path": "lib/python3.10/multiprocessing/popen_fork.py", + "path_type": "hardlink", + "sha256": "0a09db57e7fab7061c01a61778feea6e2b6bb02ccbc150332f2960b05258ef95", + "sha256_in_prefix": "0a09db57e7fab7061c01a61778feea6e2b6bb02ccbc150332f2960b05258ef95", + "size_in_bytes": 2377 + }, + { + "_path": "lib/python3.10/multiprocessing/popen_forkserver.py", + "path_type": "hardlink", + "sha256": "0588ad0e5a36718b4377dc2a2a97864a10986c25a33dc3bfed12595711b0cdab", + "sha256_in_prefix": "0588ad0e5a36718b4377dc2a2a97864a10986c25a33dc3bfed12595711b0cdab", + "size_in_bytes": 2230 + }, + { + "_path": "lib/python3.10/multiprocessing/popen_spawn_posix.py", + "path_type": "hardlink", + "sha256": "97b5d25aa479516894489877e6a7921252ee35f51e118c2f1f91f32919e7caa8", + "sha256_in_prefix": "97b5d25aa479516894489877e6a7921252ee35f51e118c2f1f91f32919e7caa8", + "size_in_bytes": 2029 + }, + { + "_path": "lib/python3.10/multiprocessing/popen_spawn_win32.py", + "path_type": "hardlink", + "sha256": "03dbaf94f9a13bc241ccd70453f1a68b1d90fea6095b53576605cfc2d379028d", + "sha256_in_prefix": "03dbaf94f9a13bc241ccd70453f1a68b1d90fea6095b53576605cfc2d379028d", + "size_in_bytes": 4011 + }, + { + "_path": "lib/python3.10/multiprocessing/process.py", + "path_type": "hardlink", + "sha256": "9a5f6ca49fb78452678bed74f9b09491c688571f9f09edb97758933294356513", + "sha256_in_prefix": "9a5f6ca49fb78452678bed74f9b09491c688571f9f09edb97758933294356513", + "size_in_bytes": 12089 + }, + { + "_path": "lib/python3.10/multiprocessing/queues.py", + "path_type": "hardlink", + "sha256": "c6a5e3d6918de807074142eb4257746093ca78ffd897d828d559b7ea711c71a8", + "sha256_in_prefix": "c6a5e3d6918de807074142eb4257746093ca78ffd897d828d559b7ea711c71a8", + "size_in_bytes": 12023 + }, + { + "_path": "lib/python3.10/multiprocessing/reduction.py", + "path_type": "hardlink", + "sha256": "4999f8b9ae7b3e8a7f5de302612b4131498dc2e238a2c47f894905c1c63294fe", + "sha256_in_prefix": "4999f8b9ae7b3e8a7f5de302612b4131498dc2e238a2c47f894905c1c63294fe", + "size_in_bytes": 9512 + }, + { + "_path": "lib/python3.10/multiprocessing/resource_sharer.py", + "path_type": "hardlink", + "sha256": "9c40292e1310a9df0aba77da34a9779fcbdd7a20863f12ab48bd496b49cd0049", + "sha256_in_prefix": "9c40292e1310a9df0aba77da34a9779fcbdd7a20863f12ab48bd496b49cd0049", + "size_in_bytes": 5132 + }, + { + "_path": "lib/python3.10/multiprocessing/resource_tracker.py", + "path_type": "hardlink", + "sha256": "613a2865ca3417b8d54c08b989198d5b846ee6fa92ddf3efbbdb98fac497aae9", + "sha256_in_prefix": "613a2865ca3417b8d54c08b989198d5b846ee6fa92ddf3efbbdb98fac497aae9", + "size_in_bytes": 8973 + }, + { + "_path": "lib/python3.10/multiprocessing/shared_memory.py", + "path_type": "hardlink", + "sha256": "51301e70710220e1c494ff5383ac94442a38a4a6622f2eb94e40128c45de1aeb", + "sha256_in_prefix": "51301e70710220e1c494ff5383ac94442a38a4a6622f2eb94e40128c45de1aeb", + "size_in_bytes": 18458 + }, + { + "_path": "lib/python3.10/multiprocessing/sharedctypes.py", + "path_type": "hardlink", + "sha256": "77ef522912474652490b7df523112858e51721e63dcf109b8567a35ce9b31b0d", + "sha256_in_prefix": "77ef522912474652490b7df523112858e51721e63dcf109b8567a35ce9b31b0d", + "size_in_bytes": 6306 + }, + { + "_path": "lib/python3.10/multiprocessing/spawn.py", + "path_type": "hardlink", + "sha256": "16ce6d81f8b5ef7228e5500bff04b37bdceb3d7dfc8d6de3ad523598798c43f4", + "sha256_in_prefix": "16ce6d81f8b5ef7228e5500bff04b37bdceb3d7dfc8d6de3ad523598798c43f4", + "size_in_bytes": 9296 + }, + { + "_path": "lib/python3.10/multiprocessing/synchronize.py", + "path_type": "hardlink", + "sha256": "c357514f2359baf9570adcce2a6818a2456477019eaa138f26f8fcc2b6f467b0", + "sha256_in_prefix": "c357514f2359baf9570adcce2a6818a2456477019eaa138f26f8fcc2b6f467b0", + "size_in_bytes": 11610 + }, + { + "_path": "lib/python3.10/multiprocessing/util.py", + "path_type": "hardlink", + "sha256": "027d6642308f741f94d44fc79c23e4d1a1c275159823720ccb05b0a8e705450a", + "sha256_in_prefix": "027d6642308f741f94d44fc79c23e4d1a1c275159823720ccb05b0a8e705450a", + "size_in_bytes": 14024 + }, + { + "_path": "lib/python3.10/netrc.py", + "path_type": "hardlink", + "sha256": "fc92648a61d2e29b3b7954f8c0bc4c68b7a1da5c8d87979c634f14e47b96298d", + "sha256_in_prefix": "fc92648a61d2e29b3b7954f8c0bc4c68b7a1da5c8d87979c634f14e47b96298d", + "size_in_bytes": 5747 + }, + { + "_path": "lib/python3.10/nntplib.py", + "path_type": "hardlink", + "sha256": "4ff3d30528c355d965d93ccc123d31284905c0922befa08ad36387d2a8bbe84e", + "sha256_in_prefix": "4ff3d30528c355d965d93ccc123d31284905c0922befa08ad36387d2a8bbe84e", + "size_in_bytes": 41023 + }, + { + "_path": "lib/python3.10/ntpath.py", + "path_type": "hardlink", + "sha256": "ad0799b417b2d0246869768bea784702c6838be1f2151ed99fa8132327f66387", + "sha256_in_prefix": "ad0799b417b2d0246869768bea784702c6838be1f2151ed99fa8132327f66387", + "size_in_bytes": 29481 + }, + { + "_path": "lib/python3.10/nturl2path.py", + "path_type": "hardlink", + "sha256": "980982ba66cc403d17874369d2770e09845b3d49f1d4514e1c52e01518114332", + "sha256_in_prefix": "980982ba66cc403d17874369d2770e09845b3d49f1d4514e1c52e01518114332", + "size_in_bytes": 2887 + }, + { + "_path": "lib/python3.10/numbers.py", + "path_type": "hardlink", + "sha256": "6d70991643a109e9c99e94d6ea2734a995fa8e89114a70ea09737413fa9ae292", + "sha256_in_prefix": "6d70991643a109e9c99e94d6ea2734a995fa8e89114a70ea09737413fa9ae292", + "size_in_bytes": 10348 + }, + { + "_path": "lib/python3.10/opcode.py", + "path_type": "hardlink", + "sha256": "042223e56632d8ff283e63e190e0496f9af6945f0d6dfb692ac9d129aabc85dc", + "sha256_in_prefix": "042223e56632d8ff283e63e190e0496f9af6945f0d6dfb692ac9d129aabc85dc", + "size_in_bytes": 5902 + }, + { + "_path": "lib/python3.10/operator.py", + "path_type": "hardlink", + "sha256": "fd931e2bf493ddd239208b0c0a2249324602b48aabc984c85b7d8dcc4d99a17d", + "sha256_in_prefix": "fd931e2bf493ddd239208b0c0a2249324602b48aabc984c85b7d8dcc4d99a17d", + "size_in_bytes": 10751 + }, + { + "_path": "lib/python3.10/optparse.py", + "path_type": "hardlink", + "sha256": "07d224301cba312fa0697bff9cd5a4bb4f778a90629632091b3f4ae874d89af5", + "sha256_in_prefix": "07d224301cba312fa0697bff9cd5a4bb4f778a90629632091b3f4ae874d89af5", + "size_in_bytes": 60369 + }, + { + "_path": "lib/python3.10/os.py", + "path_type": "hardlink", + "sha256": "70e420e105d021d5ba2ec4d8a9b2131561db6d93e800e8580ddeb86cbd6959c3", + "sha256_in_prefix": "70e420e105d021d5ba2ec4d8a9b2131561db6d93e800e8580ddeb86cbd6959c3", + "size_in_bytes": 39557 + }, + { + "_path": "lib/python3.10/pathlib.py", + "path_type": "hardlink", + "sha256": "936f14a3ecc4ac5e896e4d673666d76b25a9d581f3b4c8d8d424e830fda2a69b", + "sha256_in_prefix": "936f14a3ecc4ac5e896e4d673666d76b25a9d581f3b4c8d8d424e830fda2a69b", + "size_in_bytes": 49575 + }, + { + "_path": "lib/python3.10/pdb.py", + "path_type": "hardlink", + "sha256": "2b9b37cf7a19ec1ac0809d3384db2dfd6eb59b77283aa53c8659cac70faf2df0", + "sha256_in_prefix": "2b9b37cf7a19ec1ac0809d3384db2dfd6eb59b77283aa53c8659cac70faf2df0", + "size_in_bytes": 63225 + }, + { + "_path": "lib/python3.10/pickle.py", + "path_type": "hardlink", + "sha256": "f29792b7bad19b9b7a6096aae01e9a6a0a3ec28029576af74efc530ee331c412", + "sha256_in_prefix": "f29792b7bad19b9b7a6096aae01e9a6a0a3ec28029576af74efc530ee331c412", + "size_in_bytes": 64949 + }, + { + "_path": "lib/python3.10/pickletools.py", + "path_type": "hardlink", + "sha256": "bcc8d00ebadd684aba19169e853e6f23bc36d609ae0c8119912f1e39e9f0c1e9", + "sha256_in_prefix": "bcc8d00ebadd684aba19169e853e6f23bc36d609ae0c8119912f1e39e9f0c1e9", + "size_in_bytes": 93486 + }, + { + "_path": "lib/python3.10/pipes.py", + "path_type": "hardlink", + "sha256": "58e152ce03c6429b8dabd8d715a1872c2a4018e7d329973b4fdea3520cfaaa10", + "sha256_in_prefix": "58e152ce03c6429b8dabd8d715a1872c2a4018e7d329973b4fdea3520cfaaa10", + "size_in_bytes": 8914 + }, + { + "_path": "lib/python3.10/pkgutil.py", + "path_type": "hardlink", + "sha256": "1dac904eeefb73362f13c41d783572433c25d3f45d92f1e44873b6920b7adef1", + "sha256_in_prefix": "1dac904eeefb73362f13c41d783572433c25d3f45d92f1e44873b6920b7adef1", + "size_in_bytes": 24576 + }, + { + "_path": "lib/python3.10/platform.py", + "path_type": "hardlink", + "sha256": "1ac006643ac07400e0c4f9af0113adcbad32d0ef7c5f47c65e083ff6ba487095", + "sha256_in_prefix": "1ac006643ac07400e0c4f9af0113adcbad32d0ef7c5f47c65e083ff6ba487095", + "size_in_bytes": 42187 + }, + { + "_path": "lib/python3.10/plistlib.py", + "path_type": "hardlink", + "sha256": "974c0acf063616c8e5ef6f4ef4781e535ea8ebcbf3b99a32d7db04cc2cbd5715", + "sha256_in_prefix": "974c0acf063616c8e5ef6f4ef4781e535ea8ebcbf3b99a32d7db04cc2cbd5715", + "size_in_bytes": 28352 + }, + { + "_path": "lib/python3.10/poplib.py", + "path_type": "hardlink", + "sha256": "7b341e6adb4e4341b211a221a7224849ea415fc1e39c014b05ae7d9a566819f4", + "sha256_in_prefix": "7b341e6adb4e4341b211a221a7224849ea415fc1e39c014b05ae7d9a566819f4", + "size_in_bytes": 15198 + }, + { + "_path": "lib/python3.10/posixpath.py", + "path_type": "hardlink", + "sha256": "2c770bac0680a5a180b1310102d14e1e120f2f2e8e47925b1574ec808cb8ad6d", + "sha256_in_prefix": "2c770bac0680a5a180b1310102d14e1e120f2f2e8e47925b1574ec808cb8ad6d", + "size_in_bytes": 16250 + }, + { + "_path": "lib/python3.10/pprint.py", + "path_type": "hardlink", + "sha256": "1f7c72d37dca932cd875eb3c732d17c01de6273fd30f8b38f85e236ed94cd2e3", + "sha256_in_prefix": "1f7c72d37dca932cd875eb3c732d17c01de6273fd30f8b38f85e236ed94cd2e3", + "size_in_bytes": 24444 + }, + { + "_path": "lib/python3.10/profile.py", + "path_type": "hardlink", + "sha256": "4d87bdc8b85bf0a9bdee3e9d975a8a1a0c7360cb264fb68c4c48a102e718e3a3", + "sha256_in_prefix": "4d87bdc8b85bf0a9bdee3e9d975a8a1a0c7360cb264fb68c4c48a102e718e3a3", + "size_in_bytes": 22883 + }, + { + "_path": "lib/python3.10/pstats.py", + "path_type": "hardlink", + "sha256": "21497bb01230584b135b7bd89241a28d7d7994b577edacd4ea2403e80f794a81", + "sha256_in_prefix": "21497bb01230584b135b7bd89241a28d7d7994b577edacd4ea2403e80f794a81", + "size_in_bytes": 29326 + }, + { + "_path": "lib/python3.10/pty.py", + "path_type": "hardlink", + "sha256": "eded59f53eb5c3cceee139935d8fb11e723dc460785909492cd2e937f6494fb5", + "sha256_in_prefix": "eded59f53eb5c3cceee139935d8fb11e723dc460785909492cd2e937f6494fb5", + "size_in_bytes": 5213 + }, + { + "_path": "lib/python3.10/py_compile.py", + "path_type": "hardlink", + "sha256": "3464f04938b57a7aafbc5c394ccd4c46823ee607f7fe36b48b91ecbc30ff4e48", + "sha256_in_prefix": "3464f04938b57a7aafbc5c394ccd4c46823ee607f7fe36b48b91ecbc30ff4e48", + "size_in_bytes": 7837 + }, + { + "_path": "lib/python3.10/pyclbr.py", + "path_type": "hardlink", + "sha256": "e8ca09333701ba41244e20b8c2c37b7ed0499b88c4b2ca82cac51ef89ca9e647", + "sha256_in_prefix": "e8ca09333701ba41244e20b8c2c37b7ed0499b88c4b2ca82cac51ef89ca9e647", + "size_in_bytes": 11396 + }, + { + "_path": "lib/python3.10/pydoc.py", + "path_type": "hardlink", + "sha256": "1db5ab5321c1f0488c79beacb553bf6ef2c59c51d996f12de96aeb678d2a4ca7", + "sha256_in_prefix": "1db5ab5321c1f0488c79beacb553bf6ef2c59c51d996f12de96aeb678d2a4ca7", + "size_in_bytes": 109589 + }, + { + "_path": "lib/python3.10/pydoc_data/__init__.py", + "path_type": "hardlink", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size_in_bytes": 0 + }, + { + "_path": "lib/python3.10/pydoc_data/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "1430d8511e270e6af999b2df4eae2c35a213f74b24f33bc3a9e03a63eb0e960a", + "sha256_in_prefix": "1430d8511e270e6af999b2df4eae2c35a213f74b24f33bc3a9e03a63eb0e960a", + "size_in_bytes": 389 + }, + { + "_path": "lib/python3.10/pydoc_data/__pycache__/topics.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "fd6e1e5f54325f0ccd986430ef3e81c04fc6fd1d7431833688af0beab7f934c8", + "sha256_in_prefix": "fd6e1e5f54325f0ccd986430ef3e81c04fc6fd1d7431833688af0beab7f934c8", + "size_in_bytes": 473761 + }, + { + "_path": "lib/python3.10/pydoc_data/_pydoc.css", + "path_type": "hardlink", + "sha256": "7b8cc50cbc204745d38fa3d57b3bd6bb4c3f6ea0d346bef61b3cc423eb15b9d1", + "sha256_in_prefix": "7b8cc50cbc204745d38fa3d57b3bd6bb4c3f6ea0d346bef61b3cc423eb15b9d1", + "size_in_bytes": 96 + }, + { + "_path": "lib/python3.10/pydoc_data/topics.py", + "path_type": "hardlink", + "sha256": "1536be360c4cbe467096f954b0a3b2c8776628eacad8d016bb7faf2a34c0580d", + "sha256_in_prefix": "1536be360c4cbe467096f954b0a3b2c8776628eacad8d016bb7faf2a34c0580d", + "size_in_bytes": 745585 + }, + { + "_path": "lib/python3.10/queue.py", + "path_type": "hardlink", + "sha256": "f6c37fc37cd7440979f7d22d40ee818fa3b714c573610c08fa52911d541193f0", + "sha256_in_prefix": "f6c37fc37cd7440979f7d22d40ee818fa3b714c573610c08fa52911d541193f0", + "size_in_bytes": 11496 + }, + { + "_path": "lib/python3.10/quopri.py", + "path_type": "hardlink", + "sha256": "7070b61e5a582423a1bb405e3d23cb3e26c4faafcb142a8cbb88ec3f2d6104e9", + "sha256_in_prefix": "7070b61e5a582423a1bb405e3d23cb3e26c4faafcb142a8cbb88ec3f2d6104e9", + "size_in_bytes": 7268 + }, + { + "_path": "lib/python3.10/random.py", + "path_type": "hardlink", + "sha256": "ce80a2471965e64ae93caea14490f16850432e65dce87f15edfe25b6f562f8d1", + "sha256_in_prefix": "ce80a2471965e64ae93caea14490f16850432e65dce87f15edfe25b6f562f8d1", + "size_in_bytes": 33221 + }, + { + "_path": "lib/python3.10/re.py", + "path_type": "hardlink", + "sha256": "018b1a2c70e8ef537cc328d1026afdeca5839392ce47235a7b8d22e1b788cdc7", + "sha256_in_prefix": "018b1a2c70e8ef537cc328d1026afdeca5839392ce47235a7b8d22e1b788cdc7", + "size_in_bytes": 15860 + }, + { + "_path": "lib/python3.10/reprlib.py", + "path_type": "hardlink", + "sha256": "dc786fbc528e10bc6ea3c1fa84e4178e85c4f3c9b937a4b191546aec317e9cb9", + "sha256_in_prefix": "dc786fbc528e10bc6ea3c1fa84e4178e85c4f3c9b937a4b191546aec317e9cb9", + "size_in_bytes": 5267 + }, + { + "_path": "lib/python3.10/rlcompleter.py", + "path_type": "hardlink", + "sha256": "6cb81b6458eba5bf1a3c8ffe20d65c168853e650e1feadca0567a4fd778de71f", + "sha256_in_prefix": "6cb81b6458eba5bf1a3c8ffe20d65c168853e650e1feadca0567a4fd778de71f", + "size_in_bytes": 7817 + }, + { + "_path": "lib/python3.10/runpy.py", + "path_type": "hardlink", + "sha256": "fa52a1f6a3cc484d4798a1ad9438db68836fcc2b7c8f442d1a24b4ba5f01f55c", + "sha256_in_prefix": "fa52a1f6a3cc484d4798a1ad9438db68836fcc2b7c8f442d1a24b4ba5f01f55c", + "size_in_bytes": 13111 + }, + { + "_path": "lib/python3.10/sched.py", + "path_type": "hardlink", + "sha256": "edfb309483d7cb05e06ad86d1fdeb819629f71402dc6710a1bec36c7afcaac50", + "sha256_in_prefix": "edfb309483d7cb05e06ad86d1fdeb819629f71402dc6710a1bec36c7afcaac50", + "size_in_bytes": 6351 + }, + { + "_path": "lib/python3.10/secrets.py", + "path_type": "hardlink", + "sha256": "695195792d0f738bbdcd22ab0493e787d7a167adb1ac453b2b400ce4ebf66842", + "sha256_in_prefix": "695195792d0f738bbdcd22ab0493e787d7a167adb1ac453b2b400ce4ebf66842", + "size_in_bytes": 2036 + }, + { + "_path": "lib/python3.10/selectors.py", + "path_type": "hardlink", + "sha256": "b16e673c110fd6a362414308ef73ffc3c15125c87361333b309791735931040d", + "sha256_in_prefix": "b16e673c110fd6a362414308ef73ffc3c15125c87361333b309791735931040d", + "size_in_bytes": 19536 + }, + { + "_path": "lib/python3.10/shelve.py", + "path_type": "hardlink", + "sha256": "b978c6f0ffa901b041d6518afed03f2938a62168066013ee7d23baac31c356c0", + "sha256_in_prefix": "b978c6f0ffa901b041d6518afed03f2938a62168066013ee7d23baac31c356c0", + "size_in_bytes": 8560 + }, + { + "_path": "lib/python3.10/shlex.py", + "path_type": "hardlink", + "sha256": "42ab6060f316e121e374e6621d8c1c98b8db323903c3df289a810c45a8ae46a7", + "sha256_in_prefix": "42ab6060f316e121e374e6621d8c1c98b8db323903c3df289a810c45a8ae46a7", + "size_in_bytes": 13501 + }, + { + "_path": "lib/python3.10/shutil.py", + "path_type": "hardlink", + "sha256": "d96cf3b8b17c717f14dc67643cc8ad0943fb4b960d3e32981b2991613d39dde9", + "sha256_in_prefix": "d96cf3b8b17c717f14dc67643cc8ad0943fb4b960d3e32981b2991613d39dde9", + "size_in_bytes": 54572 + }, + { + "_path": "lib/python3.10/signal.py", + "path_type": "hardlink", + "sha256": "6ae9e49fe09b607bc161fc80067de9763aa48f523567a34992f00be06057f00a", + "sha256_in_prefix": "6ae9e49fe09b607bc161fc80067de9763aa48f523567a34992f00be06057f00a", + "size_in_bytes": 2438 + }, + { + "_path": "lib/python3.10/site-packages/README.txt", + "path_type": "hardlink", + "sha256": "cba8fece8f62c36306ba27a128f124a257710e41fc619301ee97be93586917cb", + "sha256_in_prefix": "cba8fece8f62c36306ba27a128f124a257710e41fc619301ee97be93586917cb", + "size_in_bytes": 119 + }, + { + "_path": "lib/python3.10/site.py", + "path_type": "hardlink", + "sha256": "46b88ba081e7a1b606cfe603c78e60b8f2bf30c7ba098bcbd51a3076990c97ea", + "sha256_in_prefix": "46b88ba081e7a1b606cfe603c78e60b8f2bf30c7ba098bcbd51a3076990c97ea", + "size_in_bytes": 22926 + }, + { + "_path": "lib/python3.10/smtpd.py", + "path_type": "hardlink", + "sha256": "1789da8d39e12e65a29677f5cb1c08e03373a483a0547775c86ae9a51230c3c8", + "sha256_in_prefix": "1789da8d39e12e65a29677f5cb1c08e03373a483a0547775c86ae9a51230c3c8", + "size_in_bytes": 35165 + }, + { + "_path": "lib/python3.10/smtplib.py", + "path_type": "hardlink", + "sha256": "b154e27998d0ef0b32fcc665299cdb30883ffe039ede3c4faac3a9db6618d35d", + "sha256_in_prefix": "b154e27998d0ef0b32fcc665299cdb30883ffe039ede3c4faac3a9db6618d35d", + "size_in_bytes": 45418 + }, + { + "_path": "lib/python3.10/sndhdr.py", + "path_type": "hardlink", + "sha256": "50770b17429ae1387cbccef9ee4e0f1f4cb43494e01079f0564bf25b62f3ee21", + "sha256_in_prefix": "50770b17429ae1387cbccef9ee4e0f1f4cb43494e01079f0564bf25b62f3ee21", + "size_in_bytes": 7099 + }, + { + "_path": "lib/python3.10/socket.py", + "path_type": "hardlink", + "sha256": "a11ad8b558a58696a39a92658e400ed74f060a7d78e71eb79fc88842dfa5f361", + "sha256_in_prefix": "a11ad8b558a58696a39a92658e400ed74f060a7d78e71eb79fc88842dfa5f361", + "size_in_bytes": 36785 + }, + { + "_path": "lib/python3.10/socketserver.py", + "path_type": "hardlink", + "sha256": "59007916cf2f540185bf47f3be35648d5141b9c0f4668b214900c4c35037179e", + "sha256_in_prefix": "59007916cf2f540185bf47f3be35648d5141b9c0f4668b214900c4c35037179e", + "size_in_bytes": 27296 + }, + { + "_path": "lib/python3.10/sqlite3/__init__.py", + "path_type": "hardlink", + "sha256": "29878411a7bcefcd56a3751fe689dea2c99bda75a13a485d78898834a323f0c0", + "sha256_in_prefix": "29878411a7bcefcd56a3751fe689dea2c99bda75a13a485d78898834a323f0c0", + "size_in_bytes": 2536 + }, + { + "_path": "lib/python3.10/sqlite3/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "55360da2ae9b05f3467604fa1a594c6c2e5b3d3f12ca4ea1ca4d6cb7c6782d3f", + "sha256_in_prefix": "55360da2ae9b05f3467604fa1a594c6c2e5b3d3f12ca4ea1ca4d6cb7c6782d3f", + "size_in_bytes": 1900 + }, + { + "_path": "lib/python3.10/sqlite3/__pycache__/dbapi2.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "65c9f68ae5025c866e4141f2371653f7d7e88855631c375dff3b5eabcd0c317b", + "sha256_in_prefix": "65c9f68ae5025c866e4141f2371653f7d7e88855631c375dff3b5eabcd0c317b", + "size_in_bytes": 3228 + }, + { + "_path": "lib/python3.10/sqlite3/__pycache__/dump.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "beb43d5c4078fd62d7b4ddc7e6231ce4e4686ec85470f47bb2670349465bbb8b", + "sha256_in_prefix": "beb43d5c4078fd62d7b4ddc7e6231ce4e4686ec85470f47bb2670349465bbb8b", + "size_in_bytes": 2489 + }, + { + "_path": "lib/python3.10/sqlite3/dbapi2.py", + "path_type": "hardlink", + "sha256": "c7c6837ae3618807d68ea16daf832862ee8472c7d35ab05a0b3c0d4ed94b6ddf", + "sha256_in_prefix": "c7c6837ae3618807d68ea16daf832862ee8472c7d35ab05a0b3c0d4ed94b6ddf", + "size_in_bytes": 3323 + }, + { + "_path": "lib/python3.10/sqlite3/dump.py", + "path_type": "hardlink", + "sha256": "64927fabf1b761c7f6b100bf0312434386381152b7f8c75f1e543a5a4c8ab59a", + "sha256_in_prefix": "64927fabf1b761c7f6b100bf0312434386381152b7f8c75f1e543a5a4c8ab59a", + "size_in_bytes": 3292 + }, + { + "_path": "lib/python3.10/sre_compile.py", + "path_type": "hardlink", + "sha256": "800f4c7df096e10336cd54f1aa6382721d6fcb974669463fe67f7a9189e52407", + "sha256_in_prefix": "800f4c7df096e10336cd54f1aa6382721d6fcb974669463fe67f7a9189e52407", + "size_in_bytes": 27973 + }, + { + "_path": "lib/python3.10/sre_constants.py", + "path_type": "hardlink", + "sha256": "6d5f1ff40e42f4be9b98899b58684dffcdb9c0ef1b3b942c17a3fcafc0bbcdc1", + "sha256_in_prefix": "6d5f1ff40e42f4be9b98899b58684dffcdb9c0ef1b3b942c17a3fcafc0bbcdc1", + "size_in_bytes": 7177 + }, + { + "_path": "lib/python3.10/sre_parse.py", + "path_type": "hardlink", + "sha256": "dad10892e970f3b9d0ad874d893edde31c0303e39ea5e2678935129e29128c2f", + "sha256_in_prefix": "dad10892e970f3b9d0ad874d893edde31c0303e39ea5e2678935129e29128c2f", + "size_in_bytes": 40779 + }, + { + "_path": "lib/python3.10/ssl.py", + "path_type": "hardlink", + "sha256": "1c6e62f53e0b4a80395a5f786c9718681b012fc1b6aacee7bc35385f9bbe882c", + "sha256_in_prefix": "1c6e62f53e0b4a80395a5f786c9718681b012fc1b6aacee7bc35385f9bbe882c", + "size_in_bytes": 53895 + }, + { + "_path": "lib/python3.10/stat.py", + "path_type": "hardlink", + "sha256": "052af0327eae6941b69b05c088b3e748f79995635f80ac4cc7125eb333eb4c77", + "sha256_in_prefix": "052af0327eae6941b69b05c088b3e748f79995635f80ac4cc7125eb333eb4c77", + "size_in_bytes": 5485 + }, + { + "_path": "lib/python3.10/statistics.py", + "path_type": "hardlink", + "sha256": "88678d0406c9b3a1acff23d36eb35db88a2c6ca379c3a665226cea8d56c223ca", + "sha256_in_prefix": "88678d0406c9b3a1acff23d36eb35db88a2c6ca379c3a665226cea8d56c223ca", + "size_in_bytes": 43205 + }, + { + "_path": "lib/python3.10/string.py", + "path_type": "hardlink", + "sha256": "bc57c407a8397ee2bea8683d0ce0a563a060c74c785ff36fc6555d66a9c7a566", + "sha256_in_prefix": "bc57c407a8397ee2bea8683d0ce0a563a060c74c785ff36fc6555d66a9c7a566", + "size_in_bytes": 10566 + }, + { + "_path": "lib/python3.10/stringprep.py", + "path_type": "hardlink", + "sha256": "60b6c83581093029312efb6670b11c540090b3f78bcf72264467b494f02f21a5", + "sha256_in_prefix": "60b6c83581093029312efb6670b11c540090b3f78bcf72264467b494f02f21a5", + "size_in_bytes": 12917 + }, + { + "_path": "lib/python3.10/struct.py", + "path_type": "hardlink", + "sha256": "9c231f9497caf513a22dee8f790b07f969b0e45854a0bdd6dd84b492e08c2856", + "sha256_in_prefix": "9c231f9497caf513a22dee8f790b07f969b0e45854a0bdd6dd84b492e08c2856", + "size_in_bytes": 257 + }, + { + "_path": "lib/python3.10/subprocess.py", + "path_type": "hardlink", + "sha256": "53bb0d0780e166ef4ae94f3b2a817a8aae49a84d899db1f4c31f933d429057d6", + "sha256_in_prefix": "53bb0d0780e166ef4ae94f3b2a817a8aae49a84d899db1f4c31f933d429057d6", + "size_in_bytes": 84917 + }, + { + "_path": "lib/python3.10/sunau.py", + "path_type": "hardlink", + "sha256": "6163b749f5a2afd7709eb98e2d9bc1db8811aaeb693553932841dba6b8bca537", + "sha256_in_prefix": "6163b749f5a2afd7709eb98e2d9bc1db8811aaeb693553932841dba6b8bca537", + "size_in_bytes": 18158 + }, + { + "_path": "lib/python3.10/symtable.py", + "path_type": "hardlink", + "sha256": "c0d1e1dc50c420d12beea9d1b535c3c3ce9b07d0a2f1286beb2f01693179162f", + "sha256_in_prefix": "c0d1e1dc50c420d12beea9d1b535c3c3ce9b07d0a2f1286beb2f01693179162f", + "size_in_bytes": 10217 + }, + { + "_path": "lib/python3.10/sysconfig.py", + "path_type": "hardlink", + "sha256": "898e17eaa2aec44e7662e8e7f4bfce26921ee417d2d973ade6b9b544500dc2f5", + "sha256_in_prefix": "898e17eaa2aec44e7662e8e7f4bfce26921ee417d2d973ade6b9b544500dc2f5", + "size_in_bytes": 27689 + }, + { + "_path": "lib/python3.10/tabnanny.py", + "path_type": "hardlink", + "sha256": "73bc1829f10634726db7a22f1cb5c06f76802d54cd7edba0ecff145156caa2f8", + "sha256_in_prefix": "73bc1829f10634726db7a22f1cb5c06f76802d54cd7edba0ecff145156caa2f8", + "size_in_bytes": 11299 + }, + { + "_path": "lib/python3.10/tarfile.py", + "path_type": "hardlink", + "sha256": "9250a120ae805be109bc8360182de2cb2b7f74924baa6c86f996c1e919bc3e3f", + "sha256_in_prefix": "9250a120ae805be109bc8360182de2cb2b7f74924baa6c86f996c1e919bc3e3f", + "size_in_bytes": 106113 + }, + { + "_path": "lib/python3.10/telnetlib.py", + "path_type": "hardlink", + "sha256": "ea39572ed5af144022e46767c959d01d1bcb3a596b62dcfd9db6adc77cedd924", + "sha256_in_prefix": "ea39572ed5af144022e46767c959d01d1bcb3a596b62dcfd9db6adc77cedd924", + "size_in_bytes": 23254 + }, + { + "_path": "lib/python3.10/tempfile.py", + "path_type": "hardlink", + "sha256": "676356b31756112053515fc1d550a99faf0f4bbaff6ccd4cc8a56310474f5c3a", + "sha256_in_prefix": "676356b31756112053515fc1d550a99faf0f4bbaff6ccd4cc8a56310474f5c3a", + "size_in_bytes": 29469 + }, + { + "_path": "lib/python3.10/test/__init__.py", + "path_type": "hardlink", + "sha256": "836cdb388117cf81e78d9fa2a141cca1b14b0179733322e710067749a1b16fe9", + "sha256_in_prefix": "836cdb388117cf81e78d9fa2a141cca1b14b0179733322e710067749a1b16fe9", + "size_in_bytes": 47 + }, + { + "_path": "lib/python3.10/test/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "76ae972f02eec2bceb87a49f9ada7759c46501ff700a1ce9105f9d66356103ad", + "sha256_in_prefix": "76ae972f02eec2bceb87a49f9ada7759c46501ff700a1ce9105f9d66356103ad", + "size_in_bytes": 383 + }, + { + "_path": "lib/python3.10/test/__pycache__/test_script_helper.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "1b3aebe6ae43cd21839c2be1491879f884c4e8147b05464b3f819ab4080a2085", + "sha256_in_prefix": "1b3aebe6ae43cd21839c2be1491879f884c4e8147b05464b3f819ab4080a2085", + "size_in_bytes": 5968 + }, + { + "_path": "lib/python3.10/test/__pycache__/test_support.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "d87cb6f467e2c8d763266b6875e3f4d7288fc53598fb4be4a7a42e1763969fc3", + "sha256_in_prefix": "d87cb6f467e2c8d763266b6875e3f4d7288fc53598fb4be4a7a42e1763969fc3", + "size_in_bytes": 23150 + }, + { + "_path": "lib/python3.10/test/support/__init__.py", + "path_type": "hardlink", + "sha256": "0eeaf28055f176f6da9a928ff632e57181fea92247b03afb89336940ded6b3e1", + "sha256_in_prefix": "0eeaf28055f176f6da9a928ff632e57181fea92247b03afb89336940ded6b3e1", + "size_in_bytes": 71365 + }, + { + "_path": "lib/python3.10/test/support/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "f6003ecdc175ab6e7d44c29405c1f6dd4e1e8a8e0fd3b81b3129277145541ea2", + "sha256_in_prefix": "f6003ecdc175ab6e7d44c29405c1f6dd4e1e8a8e0fd3b81b3129277145541ea2", + "size_in_bytes": 57885 + }, + { + "_path": "lib/python3.10/test/support/__pycache__/bytecode_helper.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "3d4f106960c78c28fb40993476c7bfc8519d4bd188de480c6af4afaf5354e090", + "sha256_in_prefix": "3d4f106960c78c28fb40993476c7bfc8519d4bd188de480c6af4afaf5354e090", + "size_in_bytes": 1956 + }, + { + "_path": "lib/python3.10/test/support/__pycache__/hashlib_helper.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "bd7b24dc5863eba10ba0fba557dcfd96a4454e2729301f02f38bcd3ea5abef4b", + "sha256_in_prefix": "bd7b24dc5863eba10ba0fba557dcfd96a4454e2729301f02f38bcd3ea5abef4b", + "size_in_bytes": 2152 + }, + { + "_path": "lib/python3.10/test/support/__pycache__/import_helper.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "fe909658efd453f66021e08f2b51878bfa1e3ba344cf2158e815130ee708ca7a", + "sha256_in_prefix": "fe909658efd453f66021e08f2b51878bfa1e3ba344cf2158e815130ee708ca7a", + "size_in_bytes": 7572 + }, + { + "_path": "lib/python3.10/test/support/__pycache__/interpreters.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "0390d2fe729b6bc6b1ee9bab4fd4f0c584813f8f044c51742d9fa24eb3184d03", + "sha256_in_prefix": "0390d2fe729b6bc6b1ee9bab4fd4f0c584813f8f044c51742d9fa24eb3184d03", + "size_in_bytes": 7358 + }, + { + "_path": "lib/python3.10/test/support/__pycache__/logging_helper.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "94315596cb9308204e3e17ab559d7de3b92ed5c8eb962193a0bf2752fed464c5", + "sha256_in_prefix": "94315596cb9308204e3e17ab559d7de3b92ed5c8eb962193a0bf2752fed464c5", + "size_in_bytes": 1418 + }, + { + "_path": "lib/python3.10/test/support/__pycache__/os_helper.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "5cd463a0420baf75c2c6685399d03a0c81292c027565ef23735b2819b62bcce8", + "sha256_in_prefix": "5cd463a0420baf75c2c6685399d03a0c81292c027565ef23735b2819b62bcce8", + "size_in_bytes": 14408 + }, + { + "_path": "lib/python3.10/test/support/__pycache__/script_helper.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "2b8fad0a3381c48d70c207bcdea02a959e52ad8e0189ab0d5916050f37c97035", + "sha256_in_prefix": "2b8fad0a3381c48d70c207bcdea02a959e52ad8e0189ab0d5916050f37c97035", + "size_in_bytes": 8058 + }, + { + "_path": "lib/python3.10/test/support/__pycache__/socket_helper.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "dd644a3f6ee4c555eb8bd6abf5e509a87738fc7a66de9ea7410a0abdb453f5ca", + "sha256_in_prefix": "dd644a3f6ee4c555eb8bd6abf5e509a87738fc7a66de9ea7410a0abdb453f5ca", + "size_in_bytes": 9882 + }, + { + "_path": "lib/python3.10/test/support/__pycache__/testresult.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "6af20774698c4594490477856ef930b2a970e7e850b6ef6f7a899e6c8c3b13cc", + "sha256_in_prefix": "6af20774698c4594490477856ef930b2a970e7e850b6ef6f7a899e6c8c3b13cc", + "size_in_bytes": 7036 + }, + { + "_path": "lib/python3.10/test/support/__pycache__/threading_helper.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "fa452c780f48faa87c4e5d32f9afbe45d6b99beb16f2532fd8b27a8667ef41ce", + "sha256_in_prefix": "fa452c780f48faa87c4e5d32f9afbe45d6b99beb16f2532fd8b27a8667ef41ce", + "size_in_bytes": 6577 + }, + { + "_path": "lib/python3.10/test/support/__pycache__/warnings_helper.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "8c06c922c74f46bc4c707551a7af22f80d0b2e43f582633682a092cf721e707c", + "sha256_in_prefix": "8c06c922c74f46bc4c707551a7af22f80d0b2e43f582633682a092cf721e707c", + "size_in_bytes": 6606 + }, + { + "_path": "lib/python3.10/test/support/bytecode_helper.py", + "path_type": "hardlink", + "sha256": "8adf3d7f67b83b0eb473e070655421b57627b820e42119886db4345d665b087e", + "sha256_in_prefix": "8adf3d7f67b83b0eb473e070655421b57627b820e42119886db4345d665b087e", + "size_in_bytes": 1647 + }, + { + "_path": "lib/python3.10/test/support/hashlib_helper.py", + "path_type": "hardlink", + "sha256": "19924c427e33c86284ef2a41f76ab6937ab36f12e3d1ef4e617cdbf616a8fc12", + "sha256_in_prefix": "19924c427e33c86284ef2a41f76ab6937ab36f12e3d1ef4e617cdbf616a8fc12", + "size_in_bytes": 1907 + }, + { + "_path": "lib/python3.10/test/support/import_helper.py", + "path_type": "hardlink", + "sha256": "555ffc6a817da1f66e75545cad174aa96ec0ecf7a47145760e62f2fe0004ed10", + "sha256_in_prefix": "555ffc6a817da1f66e75545cad174aa96ec0ecf7a47145760e62f2fe0004ed10", + "size_in_bytes": 7736 + }, + { + "_path": "lib/python3.10/test/support/interpreters.py", + "path_type": "hardlink", + "sha256": "d77d05cea8a58266c831522ea230300068f0efe734ad07dee4e0cf3cf0e014c4", + "sha256_in_prefix": "d77d05cea8a58266c831522ea230300068f0efe734ad07dee4e0cf3cf0e014c4", + "size_in_bytes": 5829 + }, + { + "_path": "lib/python3.10/test/support/logging_helper.py", + "path_type": "hardlink", + "sha256": "be1927e654180fcf6d84257be161fe6fa59796774e862c89b6b78adb656738f3", + "sha256_in_prefix": "be1927e654180fcf6d84257be161fe6fa59796774e862c89b6b78adb656738f3", + "size_in_bytes": 916 + }, + { + "_path": "lib/python3.10/test/support/os_helper.py", + "path_type": "hardlink", + "sha256": "0f8cf59c74fa4abb8d59f56d03878e29e62554f1c5e34b3e799f5f68e55e73dc", + "sha256_in_prefix": "0f8cf59c74fa4abb8d59f56d03878e29e62554f1c5e34b3e799f5f68e55e73dc", + "size_in_bytes": 19964 + }, + { + "_path": "lib/python3.10/test/support/script_helper.py", + "path_type": "hardlink", + "sha256": "079acd395f0bc2364bd3c521f19a2e821faed3361a19681d7e7177e306845375", + "sha256_in_prefix": "079acd395f0bc2364bd3c521f19a2e821faed3361a19681d7e7177e306845375", + "size_in_bytes": 11409 + }, + { + "_path": "lib/python3.10/test/support/socket_helper.py", + "path_type": "hardlink", + "sha256": "8e60a6e35d6aaa03731b97b8f3af8977beb0d568ce41a057f9abc42e171264b7", + "sha256_in_prefix": "8e60a6e35d6aaa03731b97b8f3af8977beb0d568ce41a057f9abc42e171264b7", + "size_in_bytes": 11474 + }, + { + "_path": "lib/python3.10/test/support/testresult.py", + "path_type": "hardlink", + "sha256": "f9304f77efa894b86b2650b55ff7421feddba93374a3cd9f9db3c2f68590a0e9", + "sha256_in_prefix": "f9304f77efa894b86b2650b55ff7421feddba93374a3cd9f9db3c2f68590a0e9", + "size_in_bytes": 5998 + }, + { + "_path": "lib/python3.10/test/support/threading_helper.py", + "path_type": "hardlink", + "sha256": "23d031ef03ec40bef75133864328490939370baa949c2224a2719bccc4a05980", + "sha256_in_prefix": "23d031ef03ec40bef75133864328490939370baa949c2224a2719bccc4a05980", + "size_in_bytes": 6650 + }, + { + "_path": "lib/python3.10/test/support/warnings_helper.py", + "path_type": "hardlink", + "sha256": "974c1b45d7b109a97ba99ab5cc6a5173d85a931a80adb9952837f24d92ae13f5", + "sha256_in_prefix": "974c1b45d7b109a97ba99ab5cc6a5173d85a931a80adb9952837f24d92ae13f5", + "size_in_bytes": 6593 + }, + { + "_path": "lib/python3.10/test/test_script_helper.py", + "path_type": "hardlink", + "sha256": "cfd8d3769843cf0c4d330f124203fafce3f9710677029427f7c06f1fd64cfe30", + "sha256_in_prefix": "cfd8d3769843cf0c4d330f124203fafce3f9710677029427f7c06f1fd64cfe30", + "size_in_bytes": 5916 + }, + { + "_path": "lib/python3.10/test/test_support.py", + "path_type": "hardlink", + "sha256": "f2c579443c1591f815c914b0a17e813f17370d5bdcf808bcf18580a36843a7ec", + "sha256_in_prefix": "f2c579443c1591f815c914b0a17e813f17370d5bdcf808bcf18580a36843a7ec", + "size_in_bytes": 25942 + }, + { + "_path": "lib/python3.10/textwrap.py", + "path_type": "hardlink", + "sha256": "e1541a31ac906294f915cadd0d780e1e5b256dc1897b560cdaf3fbf46d104cf0", + "sha256_in_prefix": "e1541a31ac906294f915cadd0d780e1e5b256dc1897b560cdaf3fbf46d104cf0", + "size_in_bytes": 19772 + }, + { + "_path": "lib/python3.10/this.py", + "path_type": "hardlink", + "sha256": "481d0cb3de511eae0b5713dad18542b07eafd9c013bb7690f7497bad49923a71", + "sha256_in_prefix": "481d0cb3de511eae0b5713dad18542b07eafd9c013bb7690f7497bad49923a71", + "size_in_bytes": 1003 + }, + { + "_path": "lib/python3.10/threading.py", + "path_type": "hardlink", + "sha256": "a21926e636bec8c2e5579f3e79cce144c36379ef93c4596252af29970983553d", + "sha256_in_prefix": "a21926e636bec8c2e5579f3e79cce144c36379ef93c4596252af29970983553d", + "size_in_bytes": 57200 + }, + { + "_path": "lib/python3.10/timeit.py", + "path_type": "hardlink", + "sha256": "86b8a277862aaa9da236a728244b866d32ab97cf42e5ded9787cce27b1671610", + "sha256_in_prefix": "86b8a277862aaa9da236a728244b866d32ab97cf42e5ded9787cce27b1671610", + "size_in_bytes": 13495 + }, + { + "_path": "lib/python3.10/tkinter/__init__.py", + "path_type": "hardlink", + "sha256": "ea1e062d70a21f50a491af04e34131edec1c0ea372507afd78b203e42f99962a", + "sha256_in_prefix": "ea1e062d70a21f50a491af04e34131edec1c0ea372507afd78b203e42f99962a", + "size_in_bytes": 170790 + }, + { + "_path": "lib/python3.10/tkinter/__main__.py", + "path_type": "hardlink", + "sha256": "9738a6cb9cdd8139721dd82118bd527897db5325d807222883f70fb1c5a1c27e", + "sha256_in_prefix": "9738a6cb9cdd8139721dd82118bd527897db5325d807222883f70fb1c5a1c27e", + "size_in_bytes": 148 + }, + { + "_path": "lib/python3.10/tkinter/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "56cd7e82f1931f3dc12f5618d749ace03ad2965c4da0e737b06686631f945c77", + "sha256_in_prefix": "56cd7e82f1931f3dc12f5618d749ace03ad2965c4da0e737b06686631f945c77", + "size_in_bytes": 169622 + }, + { + "_path": "lib/python3.10/tkinter/__pycache__/__main__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "42f1b4c081e10c4ddf19309fd42342dbb13d651adfd06e190781f72dacd113cd", + "sha256_in_prefix": "42f1b4c081e10c4ddf19309fd42342dbb13d651adfd06e190781f72dacd113cd", + "size_in_bytes": 561 + }, + { + "_path": "lib/python3.10/tkinter/__pycache__/colorchooser.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "fb40046b9fbb2ccf6b1d40385420e92ca87a7429835cef270cf3bb7c4cdf6f0f", + "sha256_in_prefix": "fb40046b9fbb2ccf6b1d40385420e92ca87a7429835cef270cf3bb7c4cdf6f0f", + "size_in_bytes": 2554 + }, + { + "_path": "lib/python3.10/tkinter/__pycache__/commondialog.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "7827b30a73479616ab42f6a602a5d40a7c769b9cc14de0107ef7a6b274c57c5e", + "sha256_in_prefix": "7827b30a73479616ab42f6a602a5d40a7c769b9cc14de0107ef7a6b274c57c5e", + "size_in_bytes": 1602 + }, + { + "_path": "lib/python3.10/tkinter/__pycache__/constants.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "04987ec48aed2ed6da93ca18506db319a599a19fc69b8bb18cdbb2e3becbbcd9", + "sha256_in_prefix": "04987ec48aed2ed6da93ca18506db319a599a19fc69b8bb18cdbb2e3becbbcd9", + "size_in_bytes": 1911 + }, + { + "_path": "lib/python3.10/tkinter/__pycache__/dialog.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "251f48181f8f5259ab5c6d011a0484284ba6d2c7dc64eedb9fad855ad4e73bd8", + "sha256_in_prefix": "251f48181f8f5259ab5c6d011a0484284ba6d2c7dc64eedb9fad855ad4e73bd8", + "size_in_bytes": 1762 + }, + { + "_path": "lib/python3.10/tkinter/__pycache__/dnd.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "e6ca643e38cfd66ed6bdc84f63751a6a1a51314719cc4c76ac63cdd828c1ea3c", + "sha256_in_prefix": "e6ca643e38cfd66ed6bdc84f63751a6a1a51314719cc4c76ac63cdd828c1ea3c", + "size_in_bytes": 11658 + }, + { + "_path": "lib/python3.10/tkinter/__pycache__/filedialog.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "f2a89f8fb803c4cf2321390250cf061ad87bb5dfac66889bb8222751260a022c", + "sha256_in_prefix": "f2a89f8fb803c4cf2321390250cf061ad87bb5dfac66889bb8222751260a022c", + "size_in_bytes": 12448 + }, + { + "_path": "lib/python3.10/tkinter/__pycache__/font.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "fe68ac163290682be5b74956df99dd680a9c36ab0c94c38ed22fe0009ced8af9", + "sha256_in_prefix": "fe68ac163290682be5b74956df99dd680a9c36ab0c94c38ed22fe0009ced8af9", + "size_in_bytes": 6869 + }, + { + "_path": "lib/python3.10/tkinter/__pycache__/messagebox.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "ac2fb04d2a22f914dd225877f5d7bfa2382e0dcfb8e324e9a776ace5905f95db", + "sha256_in_prefix": "ac2fb04d2a22f914dd225877f5d7bfa2382e0dcfb8e324e9a776ace5905f95db", + "size_in_bytes": 3180 + }, + { + "_path": "lib/python3.10/tkinter/__pycache__/scrolledtext.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "156eb824aeff84b618ffceabbe8b9fa2950df2408d1407e6647c7697d7f0414c", + "sha256_in_prefix": "156eb824aeff84b618ffceabbe8b9fa2950df2408d1407e6647c7697d7f0414c", + "size_in_bytes": 2452 + }, + { + "_path": "lib/python3.10/tkinter/__pycache__/simpledialog.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "61195dc94845cf79a4d11b8a2e63b401b94344403a4c2f36d85f76743edca780", + "sha256_in_prefix": "61195dc94845cf79a4d11b8a2e63b401b94344403a4c2f36d85f76743edca780", + "size_in_bytes": 11185 + }, + { + "_path": "lib/python3.10/tkinter/__pycache__/tix.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "636caa84634c31a21a4155caade53213e1870cd8808bd9352e23feb7b75b0bd6", + "sha256_in_prefix": "636caa84634c31a21a4155caade53213e1870cd8808bd9352e23feb7b75b0bd6", + "size_in_bytes": 73944 + }, + { + "_path": "lib/python3.10/tkinter/__pycache__/ttk.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "e2d9bcc92a66befaa2ecabe7ee3956cc5094061713087ea70f293b76af1153f3", + "sha256_in_prefix": "e2d9bcc92a66befaa2ecabe7ee3956cc5094061713087ea70f293b76af1153f3", + "size_in_bytes": 55672 + }, + { + "_path": "lib/python3.10/tkinter/colorchooser.py", + "path_type": "hardlink", + "sha256": "1224241dcfb4ec6aff3cafc66adeb2b2a3759397a28693173915458c50040143", + "sha256_in_prefix": "1224241dcfb4ec6aff3cafc66adeb2b2a3759397a28693173915458c50040143", + "size_in_bytes": 2660 + }, + { + "_path": "lib/python3.10/tkinter/commondialog.py", + "path_type": "hardlink", + "sha256": "82dd1551f85ace68ac465f54b89c4d71bd21e3c0478d65deb1b5e4e07f5111d6", + "sha256_in_prefix": "82dd1551f85ace68ac465f54b89c4d71bd21e3c0478d65deb1b5e4e07f5111d6", + "size_in_bytes": 1296 + }, + { + "_path": "lib/python3.10/tkinter/constants.py", + "path_type": "hardlink", + "sha256": "c01314dc51d1c8effeba2528720a65da133596d4143200c68595c02067bf1da2", + "sha256_in_prefix": "c01314dc51d1c8effeba2528720a65da133596d4143200c68595c02067bf1da2", + "size_in_bytes": 1493 + }, + { + "_path": "lib/python3.10/tkinter/dialog.py", + "path_type": "hardlink", + "sha256": "4f8201d3ada7b6d0f450b417e55747adaee5f894412c4875169b0736a5ff0faa", + "sha256_in_prefix": "4f8201d3ada7b6d0f450b417e55747adaee5f894412c4875169b0736a5ff0faa", + "size_in_bytes": 1535 + }, + { + "_path": "lib/python3.10/tkinter/dnd.py", + "path_type": "hardlink", + "sha256": "542b804b243b502b5525a8b1f04a02a120b1db4e3599f5c7865e60693ed3672a", + "sha256_in_prefix": "542b804b243b502b5525a8b1f04a02a120b1db4e3599f5c7865e60693ed3672a", + "size_in_bytes": 11644 + }, + { + "_path": "lib/python3.10/tkinter/filedialog.py", + "path_type": "hardlink", + "sha256": "77a7a130572c2f0351f1f0dec0db4e7ac9e71970b74dfcb6c2d93b66da869df6", + "sha256_in_prefix": "77a7a130572c2f0351f1f0dec0db4e7ac9e71970b74dfcb6c2d93b66da869df6", + "size_in_bytes": 14947 + }, + { + "_path": "lib/python3.10/tkinter/font.py", + "path_type": "hardlink", + "sha256": "a73482badacc4a69ff7fae9445793a4d858212fdef103360a478bbfd6ed2f496", + "sha256_in_prefix": "a73482badacc4a69ff7fae9445793a4d858212fdef103360a478bbfd6ed2f496", + "size_in_bytes": 7000 + }, + { + "_path": "lib/python3.10/tkinter/messagebox.py", + "path_type": "hardlink", + "sha256": "cdbf655c66778a19f0e25754a5f198a850c8bd958ce651e8fe4b2b52ad7f9c63", + "sha256_in_prefix": "cdbf655c66778a19f0e25754a5f198a850c8bd958ce651e8fe4b2b52ad7f9c63", + "size_in_bytes": 3861 + }, + { + "_path": "lib/python3.10/tkinter/scrolledtext.py", + "path_type": "hardlink", + "sha256": "c7cc050ec9cc3cc6a47215b5bc79b2d3e5c6ed895a4300ab0e20f6c249385e3f", + "sha256_in_prefix": "c7cc050ec9cc3cc6a47215b5bc79b2d3e5c6ed895a4300ab0e20f6c249385e3f", + "size_in_bytes": 1816 + }, + { + "_path": "lib/python3.10/tkinter/simpledialog.py", + "path_type": "hardlink", + "sha256": "63349ae75f9d74a49376f3375e38e5059c9424b918bfd2c67cf45ec70dcf3eac", + "sha256_in_prefix": "63349ae75f9d74a49376f3375e38e5059c9424b918bfd2c67cf45ec70dcf3eac", + "size_in_bytes": 11753 + }, + { + "_path": "lib/python3.10/tkinter/tix.py", + "path_type": "hardlink", + "sha256": "5d7a11093a1f6510de786b0e9d67902ab33a57f637cd8f5e2603cf6c5c609a18", + "sha256_in_prefix": "5d7a11093a1f6510de786b0e9d67902ab33a57f637cd8f5e2603cf6c5c609a18", + "size_in_bytes": 77032 + }, + { + "_path": "lib/python3.10/tkinter/ttk.py", + "path_type": "hardlink", + "sha256": "42bace4a50322971cda8cab2df8fcadd4bb66d272f258eb329ee713064eefa85", + "sha256_in_prefix": "42bace4a50322971cda8cab2df8fcadd4bb66d272f258eb329ee713064eefa85", + "size_in_bytes": 57151 + }, + { + "_path": "lib/python3.10/token.py", + "path_type": "hardlink", + "sha256": "2cabb6a81cafa84b475fc852c20b6bad45955ec0f88063720a831495215f776b", + "sha256_in_prefix": "2cabb6a81cafa84b475fc852c20b6bad45955ec0f88063720a831495215f776b", + "size_in_bytes": 2386 + }, + { + "_path": "lib/python3.10/tokenize.py", + "path_type": "hardlink", + "sha256": "b76fe3cc91541b872f16a879db6c9ff44c7ba4c2df366d40a3a211948edafba5", + "sha256_in_prefix": "b76fe3cc91541b872f16a879db6c9ff44c7ba4c2df366d40a3a211948edafba5", + "size_in_bytes": 25921 + }, + { + "_path": "lib/python3.10/trace.py", + "path_type": "hardlink", + "sha256": "e18581573c2b0e989a66c537cf16500dcb25e60d2ab8d8b22b6723c4c1c3c70a", + "sha256_in_prefix": "e18581573c2b0e989a66c537cf16500dcb25e60d2ab8d8b22b6723c4c1c3c70a", + "size_in_bytes": 29215 + }, + { + "_path": "lib/python3.10/traceback.py", + "path_type": "hardlink", + "sha256": "5297dd527101c24fb7665a64fc4770a108a3e410ca2a77f82b1285c3aad29c42", + "sha256_in_prefix": "5297dd527101c24fb7665a64fc4770a108a3e410ca2a77f82b1285c3aad29c42", + "size_in_bytes": 26222 + }, + { + "_path": "lib/python3.10/tracemalloc.py", + "path_type": "hardlink", + "sha256": "c2cc84a05b824df79840c98729a0e94ef8909b11c528a1b2c5a00aa436b97b25", + "sha256_in_prefix": "c2cc84a05b824df79840c98729a0e94ef8909b11c528a1b2c5a00aa436b97b25", + "size_in_bytes": 18047 + }, + { + "_path": "lib/python3.10/tty.py", + "path_type": "hardlink", + "sha256": "066a541e6d38ead952d63cc32afbac51a33acf354799f235c582eab17488105d", + "sha256_in_prefix": "066a541e6d38ead952d63cc32afbac51a33acf354799f235c582eab17488105d", + "size_in_bytes": 879 + }, + { + "_path": "lib/python3.10/turtle.py", + "path_type": "hardlink", + "sha256": "c616d28c16d0a1e122dd7f43acaa2d8e8bfe50002492043914da594653ed774e", + "sha256_in_prefix": "c616d28c16d0a1e122dd7f43acaa2d8e8bfe50002492043914da594653ed774e", + "size_in_bytes": 143760 + }, + { + "_path": "lib/python3.10/turtledemo/__init__.py", + "path_type": "hardlink", + "sha256": "5f465277c96c107a5af544b0a962561f97cb0bfd75906d9bf9741450ed02b0e1", + "sha256_in_prefix": "5f465277c96c107a5af544b0a962561f97cb0bfd75906d9bf9741450ed02b0e1", + "size_in_bytes": 314 + }, + { + "_path": "lib/python3.10/turtledemo/__main__.py", + "path_type": "hardlink", + "sha256": "6608b2ef9db6022c3088651dc0f6fc1206e7ddcc466186e44ab7a8d86341dbb9", + "sha256_in_prefix": "6608b2ef9db6022c3088651dc0f6fc1206e7ddcc466186e44ab7a8d86341dbb9", + "size_in_bytes": 15050 + }, + { + "_path": "lib/python3.10/turtledemo/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "ec946af752ff883a525910278384dd1181286b89ca4200112b463ab17cc63b71", + "sha256_in_prefix": "ec946af752ff883a525910278384dd1181286b89ca4200112b463ab17cc63b71", + "size_in_bytes": 711 + }, + { + "_path": "lib/python3.10/turtledemo/__pycache__/__main__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "ea6a3e7b9b386d50a6b7a20c79e09f08e9fce13800d1fc5d7fa69b1b41acad02", + "sha256_in_prefix": "ea6a3e7b9b386d50a6b7a20c79e09f08e9fce13800d1fc5d7fa69b1b41acad02", + "size_in_bytes": 13560 + }, + { + "_path": "lib/python3.10/turtledemo/__pycache__/bytedesign.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "b183073635a59476d81bdfdf00920ea23e8561b24e273f29b68d73ef853a1b12", + "sha256_in_prefix": "b183073635a59476d81bdfdf00920ea23e8561b24e273f29b68d73ef853a1b12", + "size_in_bytes": 4338 + }, + { + "_path": "lib/python3.10/turtledemo/__pycache__/chaos.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c1f5cdb3d09f04eaba13d74cbb3c4551ae95f7431fc401e88fd23a57775d8699", + "sha256_in_prefix": "c1f5cdb3d09f04eaba13d74cbb3c4551ae95f7431fc401e88fd23a57775d8699", + "size_in_bytes": 1971 + }, + { + "_path": "lib/python3.10/turtledemo/__pycache__/clock.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "eb97c17ec423082f46571ab83ca65ba59c47a6428ded9d03929a4da7b6b74d96", + "sha256_in_prefix": "eb97c17ec423082f46571ab83ca65ba59c47a6428ded9d03929a4da7b6b74d96", + "size_in_bytes": 3692 + }, + { + "_path": "lib/python3.10/turtledemo/__pycache__/colormixer.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "7261c5f70b2800f9a26e7d5968404b0c28e5b905edaf52bb15f08b3e363eeb91", + "sha256_in_prefix": "7261c5f70b2800f9a26e7d5968404b0c28e5b905edaf52bb15f08b3e363eeb91", + "size_in_bytes": 2098 + }, + { + "_path": "lib/python3.10/turtledemo/__pycache__/forest.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "ead7237ef26e6d12503be8118c218adb46c824675ef8e7e8ac15d0f93ca25b78", + "sha256_in_prefix": "ead7237ef26e6d12503be8118c218adb46c824675ef8e7e8ac15d0f93ca25b78", + "size_in_bytes": 3541 + }, + { + "_path": "lib/python3.10/turtledemo/__pycache__/fractalcurves.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "825c4da13fd2370873c3e3323fa16d182413e58946c2c1d6edc068625138d5dd", + "sha256_in_prefix": "825c4da13fd2370873c3e3323fa16d182413e58946c2c1d6edc068625138d5dd", + "size_in_bytes": 3152 + }, + { + "_path": "lib/python3.10/turtledemo/__pycache__/lindenmayer.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "266afdda325903684300bf65260e2ff829c871cea6913b1b40fa656f7dba9368", + "sha256_in_prefix": "266afdda325903684300bf65260e2ff829c871cea6913b1b40fa656f7dba9368", + "size_in_bytes": 3045 + }, + { + "_path": "lib/python3.10/turtledemo/__pycache__/minimal_hanoi.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "9ea4fa55248778648f8d252b0a2d5c3e6d095fd1f439f1239ec9bf419fa9843f", + "sha256_in_prefix": "9ea4fa55248778648f8d252b0a2d5c3e6d095fd1f439f1239ec9bf419fa9843f", + "size_in_bytes": 3090 + }, + { + "_path": "lib/python3.10/turtledemo/__pycache__/nim.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "805536d9c3bae97f7510d19fd3315f6130ea8bdc891918d56fa5add93ef026e7", + "sha256_in_prefix": "805536d9c3bae97f7510d19fd3315f6130ea8bdc891918d56fa5add93ef026e7", + "size_in_bytes": 7662 + }, + { + "_path": "lib/python3.10/turtledemo/__pycache__/paint.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "7e66f91987b2944d4c0c5f8e5fa7547cd0b1b3dd9ba68a51393fd6192a601366", + "sha256_in_prefix": "7e66f91987b2944d4c0c5f8e5fa7547cd0b1b3dd9ba68a51393fd6192a601366", + "size_in_bytes": 1882 + }, + { + "_path": "lib/python3.10/turtledemo/__pycache__/peace.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "f8ce4e071ce4b2e5544da5fbf13ab190d4e0099815e74ab41f5430da311d4702", + "sha256_in_prefix": "f8ce4e071ce4b2e5544da5fbf13ab190d4e0099815e74ab41f5430da311d4702", + "size_in_bytes": 1381 + }, + { + "_path": "lib/python3.10/turtledemo/__pycache__/penrose.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "d0f1740dfa60caa9f41ab44ff0f6ed7e8348372db1d23aaf71b5b149fcbb0cd8", + "sha256_in_prefix": "d0f1740dfa60caa9f41ab44ff0f6ed7e8348372db1d23aaf71b5b149fcbb0cd8", + "size_in_bytes": 4608 + }, + { + "_path": "lib/python3.10/turtledemo/__pycache__/planet_and_moon.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "313a1a6ff1eabbf62899065267c37556b1e2e300f2fa8e30c374b80796d6e609", + "sha256_in_prefix": "313a1a6ff1eabbf62899065267c37556b1e2e300f2fa8e30c374b80796d6e609", + "size_in_bytes": 3759 + }, + { + "_path": "lib/python3.10/turtledemo/__pycache__/rosette.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "84a514014b2441d5bd9db010576c761f03cd12b0de62b3616d4c54e687ba1a62", + "sha256_in_prefix": "84a514014b2441d5bd9db010576c761f03cd12b0de62b3616d4c54e687ba1a62", + "size_in_bytes": 1993 + }, + { + "_path": "lib/python3.10/turtledemo/__pycache__/round_dance.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "4550dad336b65c3aea3fc0da981417be523ba1397f612aaaff2e0eab3ebb40c3", + "sha256_in_prefix": "4550dad336b65c3aea3fc0da981417be523ba1397f612aaaff2e0eab3ebb40c3", + "size_in_bytes": 2162 + }, + { + "_path": "lib/python3.10/turtledemo/__pycache__/sorting_animate.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c42331c8ea9ad7efefca84a742862773cdebdb31acccd4d158e473bdae1b9eb8", + "sha256_in_prefix": "c42331c8ea9ad7efefca84a742862773cdebdb31acccd4d158e473bdae1b9eb8", + "size_in_bytes": 6585 + }, + { + "_path": "lib/python3.10/turtledemo/__pycache__/tree.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "3c47d6dec4d05f262453b8139287e4d4532146bb4d4c9cdd4385f58a1018704c", + "sha256_in_prefix": "3c47d6dec4d05f262453b8139287e4d4532146bb4d4c9cdd4385f58a1018704c", + "size_in_bytes": 2002 + }, + { + "_path": "lib/python3.10/turtledemo/__pycache__/two_canvases.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "79ed92226a838a41f9e0198b82c6431c4a2a74657476851b0c50d93bb7daed72", + "sha256_in_prefix": "79ed92226a838a41f9e0198b82c6431c4a2a74657476851b0c50d93bb7daed72", + "size_in_bytes": 1527 + }, + { + "_path": "lib/python3.10/turtledemo/__pycache__/yinyang.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "098f188487e7432cb012185554a7525f098c4db8e76d9aa6ecb3f69759d2163b", + "sha256_in_prefix": "098f188487e7432cb012185554a7525f098c4db8e76d9aa6ecb3f69759d2163b", + "size_in_bytes": 1330 + }, + { + "_path": "lib/python3.10/turtledemo/bytedesign.py", + "path_type": "hardlink", + "sha256": "6deeee99e0ddb4ed29a648f95d4d33e9f3292c21dbecec301337c22a605a280f", + "sha256_in_prefix": "6deeee99e0ddb4ed29a648f95d4d33e9f3292c21dbecec301337c22a605a280f", + "size_in_bytes": 4248 + }, + { + "_path": "lib/python3.10/turtledemo/chaos.py", + "path_type": "hardlink", + "sha256": "bc8a3a9b77e90446fb7060ff68ee008ffd6b23b366052207ec225cc163b4dae5", + "sha256_in_prefix": "bc8a3a9b77e90446fb7060ff68ee008ffd6b23b366052207ec225cc163b4dae5", + "size_in_bytes": 951 + }, + { + "_path": "lib/python3.10/turtledemo/clock.py", + "path_type": "hardlink", + "sha256": "8728b6e1f7e81e8c9fbc5797588d1766e6be15d353e0f29c38f3e75d28084fcd", + "sha256_in_prefix": "8728b6e1f7e81e8c9fbc5797588d1766e6be15d353e0f29c38f3e75d28084fcd", + "size_in_bytes": 3180 + }, + { + "_path": "lib/python3.10/turtledemo/colormixer.py", + "path_type": "hardlink", + "sha256": "bbb065830edb37fd53b1c004118853176fd8da32ee532cb0d363960880920374", + "sha256_in_prefix": "bbb065830edb37fd53b1c004118853176fd8da32ee532cb0d363960880920374", + "size_in_bytes": 1339 + }, + { + "_path": "lib/python3.10/turtledemo/forest.py", + "path_type": "hardlink", + "sha256": "68cd81b7da35ca49d9066cc2cba24768cddbf90797dbd619a559cf899cde926b", + "sha256_in_prefix": "68cd81b7da35ca49d9066cc2cba24768cddbf90797dbd619a559cf899cde926b", + "size_in_bytes": 2966 + }, + { + "_path": "lib/python3.10/turtledemo/fractalcurves.py", + "path_type": "hardlink", + "sha256": "29fadf34c5eabda4649848d052fa2ed3ae829e55bc3ac5933f2aedf3fb04b320", + "sha256_in_prefix": "29fadf34c5eabda4649848d052fa2ed3ae829e55bc3ac5933f2aedf3fb04b320", + "size_in_bytes": 3473 + }, + { + "_path": "lib/python3.10/turtledemo/lindenmayer.py", + "path_type": "hardlink", + "sha256": "4b597f52c1cb35ae8ed540d1db2dab52276c7874febd7a659ee50f26be26f61e", + "sha256_in_prefix": "4b597f52c1cb35ae8ed540d1db2dab52276c7874febd7a659ee50f26be26f61e", + "size_in_bytes": 2434 + }, + { + "_path": "lib/python3.10/turtledemo/minimal_hanoi.py", + "path_type": "hardlink", + "sha256": "0e458a6257fb5a4ecd2785962850fa87924b23d4ead8aebb70aab38904ff8ef5", + "sha256_in_prefix": "0e458a6257fb5a4ecd2785962850fa87924b23d4ead8aebb70aab38904ff8ef5", + "size_in_bytes": 2051 + }, + { + "_path": "lib/python3.10/turtledemo/nim.py", + "path_type": "hardlink", + "sha256": "939d1ee904a7b00579bb44719b0286e7524bf560c7ffff6d482064b41b09fdb3", + "sha256_in_prefix": "939d1ee904a7b00579bb44719b0286e7524bf560c7ffff6d482064b41b09fdb3", + "size_in_bytes": 6513 + }, + { + "_path": "lib/python3.10/turtledemo/paint.py", + "path_type": "hardlink", + "sha256": "81aa22d0da1d934cb47edfef1883f9fe8ef864c56d484f79f9ec4b46457d047e", + "sha256_in_prefix": "81aa22d0da1d934cb47edfef1883f9fe8ef864c56d484f79f9ec4b46457d047e", + "size_in_bytes": 1291 + }, + { + "_path": "lib/python3.10/turtledemo/peace.py", + "path_type": "hardlink", + "sha256": "b260b857164684b3065ad760fec0245ab6505c220814fb179a3d080f2bba0814", + "sha256_in_prefix": "b260b857164684b3065ad760fec0245ab6505c220814fb179a3d080f2bba0814", + "size_in_bytes": 1066 + }, + { + "_path": "lib/python3.10/turtledemo/penrose.py", + "path_type": "hardlink", + "sha256": "14aeb10db966bfd4ec923a19eb96892eb2aa2723c0962c0824fe2ca9f30e300a", + "sha256_in_prefix": "14aeb10db966bfd4ec923a19eb96892eb2aa2723c0962c0824fe2ca9f30e300a", + "size_in_bytes": 3380 + }, + { + "_path": "lib/python3.10/turtledemo/planet_and_moon.py", + "path_type": "hardlink", + "sha256": "cd2c5344b67dbe781cf4c7f0f1eb1b97e6d8a5bf50329bdaa4e42e7d390ea609", + "sha256_in_prefix": "cd2c5344b67dbe781cf4c7f0f1eb1b97e6d8a5bf50329bdaa4e42e7d390ea609", + "size_in_bytes": 2825 + }, + { + "_path": "lib/python3.10/turtledemo/rosette.py", + "path_type": "hardlink", + "sha256": "61dfd5bb932cc5a0c3bb9caa8ed74889a19a8d3ee3cb6707ea8f63595ec350b0", + "sha256_in_prefix": "61dfd5bb932cc5a0c3bb9caa8ed74889a19a8d3ee3cb6707ea8f63595ec350b0", + "size_in_bytes": 1361 + }, + { + "_path": "lib/python3.10/turtledemo/round_dance.py", + "path_type": "hardlink", + "sha256": "4ecaac02e68f11ec1a406a6ce8a4b17e4f8af74f76157e0776360d0dd041f276", + "sha256_in_prefix": "4ecaac02e68f11ec1a406a6ce8a4b17e4f8af74f76157e0776360d0dd041f276", + "size_in_bytes": 1804 + }, + { + "_path": "lib/python3.10/turtledemo/sorting_animate.py", + "path_type": "hardlink", + "sha256": "a82a7608d3620cd8a956d3335bddbc2e30320486645de5d2ec26f481b0a74254", + "sha256_in_prefix": "a82a7608d3620cd8a956d3335bddbc2e30320486645de5d2ec26f481b0a74254", + "size_in_bytes": 5052 + }, + { + "_path": "lib/python3.10/turtledemo/tree.py", + "path_type": "hardlink", + "sha256": "3318448046c83c176f95a97c33b5cd82e0076bee038d72810bef3dac1085e590", + "sha256_in_prefix": "3318448046c83c176f95a97c33b5cd82e0076bee038d72810bef3dac1085e590", + "size_in_bytes": 1401 + }, + { + "_path": "lib/python3.10/turtledemo/turtle.cfg", + "path_type": "hardlink", + "sha256": "de66698dc4f083792df6aaed1e5d94e879852d72f1f24ac09c8fb4cd144c6c88", + "sha256_in_prefix": "de66698dc4f083792df6aaed1e5d94e879852d72f1f24ac09c8fb4cd144c6c88", + "size_in_bytes": 160 + }, + { + "_path": "lib/python3.10/turtledemo/two_canvases.py", + "path_type": "hardlink", + "sha256": "3300593114fb9286af9360cc9d871a40e5dcbea4aedc24b832607d1dd71c7b96", + "sha256_in_prefix": "3300593114fb9286af9360cc9d871a40e5dcbea4aedc24b832607d1dd71c7b96", + "size_in_bytes": 1119 + }, + { + "_path": "lib/python3.10/turtledemo/yinyang.py", + "path_type": "hardlink", + "sha256": "0737a80b939aafcf3d8a1bf60b63e781979c749337d02b6c216680893f9fffc5", + "sha256_in_prefix": "0737a80b939aafcf3d8a1bf60b63e781979c749337d02b6c216680893f9fffc5", + "size_in_bytes": 821 + }, + { + "_path": "lib/python3.10/types.py", + "path_type": "hardlink", + "sha256": "5e6c3b3380332249908d7907bc4c1102c0bf14076248c8244d03314f6b2e2078", + "sha256_in_prefix": "5e6c3b3380332249908d7907bc4c1102c0bf14076248c8244d03314f6b2e2078", + "size_in_bytes": 10117 + }, + { + "_path": "lib/python3.10/typing.py", + "path_type": "hardlink", + "sha256": "ec7b7f73fc92827c78a7d2aff90cffe070530cad6c693460165c26f76d195f41", + "sha256_in_prefix": "ec7b7f73fc92827c78a7d2aff90cffe070530cad6c693460165c26f76d195f41", + "size_in_bytes": 92557 + }, + { + "_path": "lib/python3.10/unittest/__init__.py", + "path_type": "hardlink", + "sha256": "07bdf1fff20e4121ba61cfb64ea3c404d54ac56b053475a3a105907f48685210", + "sha256_in_prefix": "07bdf1fff20e4121ba61cfb64ea3c404d54ac56b053475a3a105907f48685210", + "size_in_bytes": 3761 + }, + { + "_path": "lib/python3.10/unittest/__main__.py", + "path_type": "hardlink", + "sha256": "ff6b9a100d32001715b40d61bc4d613623b139edb1fdc3566427b83c331caae3", + "sha256_in_prefix": "ff6b9a100d32001715b40d61bc4d613623b139edb1fdc3566427b83c331caae3", + "size_in_bytes": 472 + }, + { + "_path": "lib/python3.10/unittest/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "1e81239a8469ffae3e0ca9224b94b2d4d4772a1be429785a021fe204588e6cdd", + "sha256_in_prefix": "1e81239a8469ffae3e0ca9224b94b2d4d4772a1be429785a021fe204588e6cdd", + "size_in_bytes": 3390 + }, + { + "_path": "lib/python3.10/unittest/__pycache__/__main__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "69b975a2e4b27a340db7d6086c73a93cf2dddd7fa592cbf6fd2dd0b486d9dee6", + "sha256_in_prefix": "69b975a2e4b27a340db7d6086c73a93cf2dddd7fa592cbf6fd2dd0b486d9dee6", + "size_in_bytes": 656 + }, + { + "_path": "lib/python3.10/unittest/__pycache__/_log.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "b2064e407714b4c584aa78f75ea1f60f9235d3be32e2e7543f450c3cef50ad15", + "sha256_in_prefix": "b2064e407714b4c584aa78f75ea1f60f9235d3be32e2e7543f450c3cef50ad15", + "size_in_bytes": 2942 + }, + { + "_path": "lib/python3.10/unittest/__pycache__/async_case.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "4ef0c1501c3645ba2f89f26c89debcf262a1399f712ea6e0c3ae8be9c3dc8be1", + "sha256_in_prefix": "4ef0c1501c3645ba2f89f26c89debcf262a1399f712ea6e0c3ae8be9c3dc8be1", + "size_in_bytes": 5000 + }, + { + "_path": "lib/python3.10/unittest/__pycache__/case.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "795f797e8f54152d806495ad7cf1581b4e5e4fc33833bd7d374d9f57174fafca", + "sha256_in_prefix": "795f797e8f54152d806495ad7cf1581b4e5e4fc33833bd7d374d9f57174fafca", + "size_in_bytes": 48744 + }, + { + "_path": "lib/python3.10/unittest/__pycache__/loader.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "9bf15935c0ac6ba47892654c1e7dfa39449c9c810f90b848bcaa139d56a9be8b", + "sha256_in_prefix": "9bf15935c0ac6ba47892654c1e7dfa39449c9c810f90b848bcaa139d56a9be8b", + "size_in_bytes": 14678 + }, + { + "_path": "lib/python3.10/unittest/__pycache__/main.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "75fb0c9c461077458253878ec8dac30447c7d58d0f3b5ed406572c197971e40c", + "sha256_in_prefix": "75fb0c9c461077458253878ec8dac30447c7d58d0f3b5ed406572c197971e40c", + "size_in_bytes": 7810 + }, + { + "_path": "lib/python3.10/unittest/__pycache__/mock.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "faf619ffb7ac3a3eadbbe78bc4fba92ca12a6dafb96b886d9cecb09f89e30cf5", + "sha256_in_prefix": "faf619ffb7ac3a3eadbbe78bc4fba92ca12a6dafb96b886d9cecb09f89e30cf5", + "size_in_bytes": 80067 + }, + { + "_path": "lib/python3.10/unittest/__pycache__/result.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "f109f418bc60141795ff57725a33afc80695daaaa2c171267b171aeef5e00bf7", + "sha256_in_prefix": "f109f418bc60141795ff57725a33afc80695daaaa2c171267b171aeef5e00bf7", + "size_in_bytes": 8293 + }, + { + "_path": "lib/python3.10/unittest/__pycache__/runner.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "7493fe20fb38898395199141f685ccfae7e7d74a1e61d932b63e232a00251dde", + "sha256_in_prefix": "7493fe20fb38898395199141f685ccfae7e7d74a1e61d932b63e232a00251dde", + "size_in_bytes": 7206 + }, + { + "_path": "lib/python3.10/unittest/__pycache__/signals.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "9cbb6fada9c0b8acb6af5cf14326bf230f6a13196deaa5dd9c46628be7de97fc", + "sha256_in_prefix": "9cbb6fada9c0b8acb6af5cf14326bf230f6a13196deaa5dd9c46628be7de97fc", + "size_in_bytes": 2507 + }, + { + "_path": "lib/python3.10/unittest/__pycache__/suite.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "e4904f96ef301edc6e38be93a89707478045c80e13031c54c36ccbf76040840c", + "sha256_in_prefix": "e4904f96ef301edc6e38be93a89707478045c80e13031c54c36ccbf76040840c", + "size_in_bytes": 10522 + }, + { + "_path": "lib/python3.10/unittest/__pycache__/util.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "cbc94cb876ab8b897f21567c4b8807523d1a3100fc65ef780dd345f17647cc39", + "sha256_in_prefix": "cbc94cb876ab8b897f21567c4b8807523d1a3100fc65ef780dd345f17647cc39", + "size_in_bytes": 4794 + }, + { + "_path": "lib/python3.10/unittest/_log.py", + "path_type": "hardlink", + "sha256": "905672317ab26c656c600defce25d477728068f597f00a7f94e22e8128c323b9", + "sha256_in_prefix": "905672317ab26c656c600defce25d477728068f597f00a7f94e22e8128c323b9", + "size_in_bytes": 2746 + }, + { + "_path": "lib/python3.10/unittest/async_case.py", + "path_type": "hardlink", + "sha256": "2507108536605136aeba050554dc3c6c269b18d3aa9aa22e120af19681b56031", + "sha256_in_prefix": "2507108536605136aeba050554dc3c6c269b18d3aa9aa22e120af19681b56031", + "size_in_bytes": 6368 + }, + { + "_path": "lib/python3.10/unittest/case.py", + "path_type": "hardlink", + "sha256": "9fa2e873ba608253b6e3d2158e36baf02433a46e68071b76b5e961a7accec2d2", + "sha256_in_prefix": "9fa2e873ba608253b6e3d2158e36baf02433a46e68071b76b5e961a7accec2d2", + "size_in_bytes": 57680 + }, + { + "_path": "lib/python3.10/unittest/loader.py", + "path_type": "hardlink", + "sha256": "4b8d7dbfe68bc38f50e6b3952fda338e1cf9de43f299ab910cfef31c219e0342", + "sha256_in_prefix": "4b8d7dbfe68bc38f50e6b3952fda338e1cf9de43f299ab910cfef31c219e0342", + "size_in_bytes": 22702 + }, + { + "_path": "lib/python3.10/unittest/main.py", + "path_type": "hardlink", + "sha256": "360d56268ce4d561681faccf0206dc2164830de7a6dcd135f655ae5fdbdc59cf", + "sha256_in_prefix": "360d56268ce4d561681faccf0206dc2164830de7a6dcd135f655ae5fdbdc59cf", + "size_in_bytes": 11256 + }, + { + "_path": "lib/python3.10/unittest/mock.py", + "path_type": "hardlink", + "sha256": "199d3774b59a89dbe34409b4bdcefcbfab419c5c5a987f3ab91b748da34afae6", + "sha256_in_prefix": "199d3774b59a89dbe34409b4bdcefcbfab419c5c5a987f3ab91b748da34afae6", + "size_in_bytes": 103283 + }, + { + "_path": "lib/python3.10/unittest/result.py", + "path_type": "hardlink", + "sha256": "eb3f6ed6a6d339b8113479f6878f1946bf082b8818a89daf85f0b63a5be1f9c1", + "sha256_in_prefix": "eb3f6ed6a6d339b8113479f6878f1946bf082b8818a89daf85f0b63a5be1f9c1", + "size_in_bytes": 8518 + }, + { + "_path": "lib/python3.10/unittest/runner.py", + "path_type": "hardlink", + "sha256": "7ab57b963cd64f210d5a074b15e8dae9b4d1699da980dd523362d3f88e966847", + "sha256_in_prefix": "7ab57b963cd64f210d5a074b15e8dae9b4d1699da980dd523362d3f88e966847", + "size_in_bytes": 8051 + }, + { + "_path": "lib/python3.10/unittest/signals.py", + "path_type": "hardlink", + "sha256": "f8286e818ca56e10e03745bc056cdfd31147678f9a1dc8cb6b0fe96ef9a4362a", + "sha256_in_prefix": "f8286e818ca56e10e03745bc056cdfd31147678f9a1dc8cb6b0fe96ef9a4362a", + "size_in_bytes": 2403 + }, + { + "_path": "lib/python3.10/unittest/suite.py", + "path_type": "hardlink", + "sha256": "ed2da92bc9f97c53403ee2d3d12cc53b16a96e85d596ebc887b5a93458f3f6bc", + "sha256_in_prefix": "ed2da92bc9f97c53403ee2d3d12cc53b16a96e85d596ebc887b5a93458f3f6bc", + "size_in_bytes": 13512 + }, + { + "_path": "lib/python3.10/unittest/util.py", + "path_type": "hardlink", + "sha256": "fdcc640c3505d16deab9c32eae7c3f5f67c3b5e81c563dc6698fa7fcf403854d", + "sha256_in_prefix": "fdcc640c3505d16deab9c32eae7c3f5f67c3b5e81c563dc6698fa7fcf403854d", + "size_in_bytes": 5215 + }, + { + "_path": "lib/python3.10/urllib/__init__.py", + "path_type": "hardlink", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size_in_bytes": 0 + }, + { + "_path": "lib/python3.10/urllib/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "77287392188c40197b344ff8c2bf4fef1fae48b354577c4e9906923c54c90bbd", + "sha256_in_prefix": "77287392188c40197b344ff8c2bf4fef1fae48b354577c4e9906923c54c90bbd", + "size_in_bytes": 385 + }, + { + "_path": "lib/python3.10/urllib/__pycache__/error.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "f4b3a0e789a01ee1a41edecd9382d916af18ca550e40e64dc8cbcb5d276226d8", + "sha256_in_prefix": "f4b3a0e789a01ee1a41edecd9382d916af18ca550e40e64dc8cbcb5d276226d8", + "size_in_bytes": 3107 + }, + { + "_path": "lib/python3.10/urllib/__pycache__/parse.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "6f07a27a9bf32b77b9e25fdd45e3ea423611d2ee85540b4fa7048093baace4d7", + "sha256_in_prefix": "6f07a27a9bf32b77b9e25fdd45e3ea423611d2ee85540b4fa7048093baace4d7", + "size_in_bytes": 34350 + }, + { + "_path": "lib/python3.10/urllib/__pycache__/request.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "ec6cf70df9c6a4c278f103fcd9e83966ec7e6483aa1397adc372e2dd1e17da20", + "sha256_in_prefix": "ec6cf70df9c6a4c278f103fcd9e83966ec7e6483aa1397adc372e2dd1e17da20", + "size_in_bytes": 71837 + }, + { + "_path": "lib/python3.10/urllib/__pycache__/response.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "8552626d03c462a15c6ffe319315013dee0f2210b6b2b310b4671444f37f7f2c", + "sha256_in_prefix": "8552626d03c462a15c6ffe319315013dee0f2210b6b2b310b4671444f37f7f2c", + "size_in_bytes": 3721 + }, + { + "_path": "lib/python3.10/urllib/__pycache__/robotparser.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "b77f6982870d809e6b4fdbc4dbee19b3e4ead558c70a25e38bfca6c539ac5818", + "sha256_in_prefix": "b77f6982870d809e6b4fdbc4dbee19b3e4ead558c70a25e38bfca6c539ac5818", + "size_in_bytes": 7586 + }, + { + "_path": "lib/python3.10/urllib/error.py", + "path_type": "hardlink", + "sha256": "d12b3cc66af3f42a8ebe63e1c91d24f92c6237b6a93a3702938dffabd812d77b", + "sha256_in_prefix": "d12b3cc66af3f42a8ebe63e1c91d24f92c6237b6a93a3702938dffabd812d77b", + "size_in_bytes": 2415 + }, + { + "_path": "lib/python3.10/urllib/parse.py", + "path_type": "hardlink", + "sha256": "90d563f67191c87a494017b4410899906634bf7edad8bc8e6608ea51b5d90a38", + "sha256_in_prefix": "90d563f67191c87a494017b4410899906634bf7edad8bc8e6608ea51b5d90a38", + "size_in_bytes": 43022 + }, + { + "_path": "lib/python3.10/urllib/request.py", + "path_type": "hardlink", + "sha256": "ba6cee0f5b8a7ef7673e21beea1c2d62b9ac69cc8d92c68e3d115c6395a491d9", + "sha256_in_prefix": "ba6cee0f5b8a7ef7673e21beea1c2d62b9ac69cc8d92c68e3d115c6395a491d9", + "size_in_bytes": 101742 + }, + { + "_path": "lib/python3.10/urllib/response.py", + "path_type": "hardlink", + "sha256": "7e6c3b6d7a95f0d74f5968f51a87adae8a51bf42390cdfec98c7a99203e7bb76", + "sha256_in_prefix": "7e6c3b6d7a95f0d74f5968f51a87adae8a51bf42390cdfec98c7a99203e7bb76", + "size_in_bytes": 2361 + }, + { + "_path": "lib/python3.10/urllib/robotparser.py", + "path_type": "hardlink", + "sha256": "389b811835f9a3ba72b192c3487b0266fa31f6e571b7a83ceb2a34792dc0d9fc", + "sha256_in_prefix": "389b811835f9a3ba72b192c3487b0266fa31f6e571b7a83ceb2a34792dc0d9fc", + "size_in_bytes": 9424 + }, + { + "_path": "lib/python3.10/uu.py", + "path_type": "hardlink", + "sha256": "11c44d6915c8c76cbd33e1989d90f3846c041abea1148f230d3ff7144fb69837", + "sha256_in_prefix": "11c44d6915c8c76cbd33e1989d90f3846c041abea1148f230d3ff7144fb69837", + "size_in_bytes": 7301 + }, + { + "_path": "lib/python3.10/uuid.py", + "path_type": "hardlink", + "sha256": "75bdfdbbb57c7a50e0252997621308be79a535ceb1eb6ba01a462b7e7ffdf19d", + "sha256_in_prefix": "75bdfdbbb57c7a50e0252997621308be79a535ceb1eb6ba01a462b7e7ffdf19d", + "size_in_bytes": 27500 + }, + { + "_path": "lib/python3.10/venv/__init__.py", + "path_type": "hardlink", + "sha256": "90abffc2b81a7ab70ba0a26b38b35d842eb997843c4f7d70471b50eec193ac84", + "sha256_in_prefix": "90abffc2b81a7ab70ba0a26b38b35d842eb997843c4f7d70471b50eec193ac84", + "size_in_bytes": 23997 + }, + { + "_path": "lib/python3.10/venv/__main__.py", + "path_type": "hardlink", + "sha256": "722537c68c0622f8293d39bb6ab1288f3637d8dc45d6f9aae96e49af8145ca36", + "sha256_in_prefix": "722537c68c0622f8293d39bb6ab1288f3637d8dc45d6f9aae96e49af8145ca36", + "size_in_bytes": 145 + }, + { + "_path": "lib/python3.10/venv/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "cc0442ea77c369f921d99f6511c5a8a1ad20479ab7b7a0acb099c5ba1ac3e35c", + "sha256_in_prefix": "cc0442ea77c369f921d99f6511c5a8a1ad20479ab7b7a0acb099c5ba1ac3e35c", + "size_in_bytes": 16435 + }, + { + "_path": "lib/python3.10/venv/__pycache__/__main__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "d030872ceea0839a46eb44917380e0025ba90288cc43a68c55a4bf50187f2886", + "sha256_in_prefix": "d030872ceea0839a46eb44917380e0025ba90288cc43a68c55a4bf50187f2886", + "size_in_bytes": 592 + }, + { + "_path": "lib/python3.10/venv/scripts/common/Activate.ps1", + "path_type": "hardlink", + "sha256": "3795a060dea7d621320d6d841deb37591fadf7f5592c5cb2286f9867af0e91df", + "sha256_in_prefix": "3795a060dea7d621320d6d841deb37591fadf7f5592c5cb2286f9867af0e91df", + "size_in_bytes": 9033 + }, + { + "_path": "lib/python3.10/venv/scripts/common/activate", + "path_type": "hardlink", + "sha256": "5581945e7f30bcd0dbd2dc472a7e8b16bf137bbbed565707e97b9c5616793ea7", + "sha256_in_prefix": "5581945e7f30bcd0dbd2dc472a7e8b16bf137bbbed565707e97b9c5616793ea7", + "size_in_bytes": 2009 + }, + { + "_path": "lib/python3.10/venv/scripts/posix/activate.csh", + "path_type": "hardlink", + "sha256": "540b1d850e88ba3f184ebad24cd967b5a0c6e1c7dc27ca599d8466829e0b2846", + "sha256_in_prefix": "540b1d850e88ba3f184ebad24cd967b5a0c6e1c7dc27ca599d8466829e0b2846", + "size_in_bytes": 935 + }, + { + "_path": "lib/python3.10/venv/scripts/posix/activate.fish", + "path_type": "hardlink", + "sha256": "3ce0db624d9fb550f4267d7501fd3fd4fba090952220a331d09ff2ba646b8a6e", + "sha256_in_prefix": "3ce0db624d9fb550f4267d7501fd3fd4fba090952220a331d09ff2ba646b8a6e", + "size_in_bytes": 2215 + }, + { + "_path": "lib/python3.10/warnings.py", + "path_type": "hardlink", + "sha256": "b8e7748e4c67eb65cea5d3b3bd888d245771c0ebe63117f747189a55a9b622db", + "sha256_in_prefix": "b8e7748e4c67eb65cea5d3b3bd888d245771c0ebe63117f747189a55a9b622db", + "size_in_bytes": 19688 + }, + { + "_path": "lib/python3.10/wave.py", + "path_type": "hardlink", + "sha256": "2d6ddc0c5e408bb993274ad4f7806252158fec7c569e5a78a50a06ecf02e681d", + "sha256_in_prefix": "2d6ddc0c5e408bb993274ad4f7806252158fec7c569e5a78a50a06ecf02e681d", + "size_in_bytes": 18004 + }, + { + "_path": "lib/python3.10/weakref.py", + "path_type": "hardlink", + "sha256": "dd8e03473ee5667c1a2caa43ede07797652bcb4035fabb60d60af10bb23a0886", + "sha256_in_prefix": "dd8e03473ee5667c1a2caa43ede07797652bcb4035fabb60d60af10bb23a0886", + "size_in_bytes": 21560 + }, + { + "_path": "lib/python3.10/webbrowser.py", + "path_type": "hardlink", + "sha256": "92c5336973260f37727fb59c1f2efdf230c8d3da8be61b5803c709860aec1fc0", + "sha256_in_prefix": "92c5336973260f37727fb59c1f2efdf230c8d3da8be61b5803c709860aec1fc0", + "size_in_bytes": 24245 + }, + { + "_path": "lib/python3.10/wsgiref/__init__.py", + "path_type": "hardlink", + "sha256": "db2259a74988dc73a209cdf7aaa3b79ab6f213384287a8bd288ad141a935e236", + "sha256_in_prefix": "db2259a74988dc73a209cdf7aaa3b79ab6f213384287a8bd288ad141a935e236", + "size_in_bytes": 587 + }, + { + "_path": "lib/python3.10/wsgiref/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "4e7bcf7ad004c92380313a0e76466e0bccd729b616a297078566cee06ae827a8", + "sha256_in_prefix": "4e7bcf7ad004c92380313a0e76466e0bccd729b616a297078566cee06ae827a8", + "size_in_bytes": 981 + }, + { + "_path": "lib/python3.10/wsgiref/__pycache__/handlers.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "77b9c3ed158f69ec3d7b4f6e9209decfd7407b0ae6a8a5857225e0dd7ce8c87a", + "sha256_in_prefix": "77b9c3ed158f69ec3d7b4f6e9209decfd7407b0ae6a8a5857225e0dd7ce8c87a", + "size_in_bytes": 16652 + }, + { + "_path": "lib/python3.10/wsgiref/__pycache__/headers.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "670ba19b8fd1b5de477db9141ed6b2905b320d3fd9fd2d2c178167cba61330e8", + "sha256_in_prefix": "670ba19b8fd1b5de477db9141ed6b2905b320d3fd9fd2d2c178167cba61330e8", + "size_in_bytes": 7969 + }, + { + "_path": "lib/python3.10/wsgiref/__pycache__/simple_server.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "69076370dd26acd1609fd57bbc20cdd1d22a50ad76c4a84aac8609c07be75b6b", + "sha256_in_prefix": "69076370dd26acd1609fd57bbc20cdd1d22a50ad76c4a84aac8609c07be75b6b", + "size_in_bytes": 5560 + }, + { + "_path": "lib/python3.10/wsgiref/__pycache__/util.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "0c208e6f0ad4d74e8f3d36ff31a136e01157d41c95959e3ebc07ef5a315e0b35", + "sha256_in_prefix": "0c208e6f0ad4d74e8f3d36ff31a136e01157d41c95959e3ebc07ef5a315e0b35", + "size_in_bytes": 5661 + }, + { + "_path": "lib/python3.10/wsgiref/__pycache__/validate.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "db743c4de2c242bcd00a60a0b3835238f6e52fe53d861af96e1c818214e71e43", + "sha256_in_prefix": "db743c4de2c242bcd00a60a0b3835238f6e52fe53d861af96e1c818214e71e43", + "size_in_bytes": 14848 + }, + { + "_path": "lib/python3.10/wsgiref/handlers.py", + "path_type": "hardlink", + "sha256": "2b4afb6eb7db05f7c6d1785853cfd45f870fcf65997a7bc5419c36d1dba67191", + "sha256_in_prefix": "2b4afb6eb7db05f7c6d1785853cfd45f870fcf65997a7bc5419c36d1dba67191", + "size_in_bytes": 21669 + }, + { + "_path": "lib/python3.10/wsgiref/headers.py", + "path_type": "hardlink", + "sha256": "0fbf95a47d8e4c0d831fd52312ec43076cbf503c190269876f170a5cf5585fb9", + "sha256_in_prefix": "0fbf95a47d8e4c0d831fd52312ec43076cbf503c190269876f170a5cf5585fb9", + "size_in_bytes": 6766 + }, + { + "_path": "lib/python3.10/wsgiref/simple_server.py", + "path_type": "hardlink", + "sha256": "d435cad48b5f63c0356e1ac70755e6e35eb94b02f9844b813e5762199110bc2b", + "sha256_in_prefix": "d435cad48b5f63c0356e1ac70755e6e35eb94b02f9844b813e5762199110bc2b", + "size_in_bytes": 5171 + }, + { + "_path": "lib/python3.10/wsgiref/util.py", + "path_type": "hardlink", + "sha256": "dcb02730111ea1afdfb7520b37feecce28eb56e2c98fe9fc5a3778547e73ce6e", + "sha256_in_prefix": "dcb02730111ea1afdfb7520b37feecce28eb56e2c98fe9fc5a3778547e73ce6e", + "size_in_bytes": 5851 + }, + { + "_path": "lib/python3.10/wsgiref/validate.py", + "path_type": "hardlink", + "sha256": "622c6a2c69db3b10a8c124b5b06fcdf538bfe03f18f31667b78416123b777308", + "sha256_in_prefix": "622c6a2c69db3b10a8c124b5b06fcdf538bfe03f18f31667b78416123b777308", + "size_in_bytes": 15097 + }, + { + "_path": "lib/python3.10/xdrlib.py", + "path_type": "hardlink", + "sha256": "5bae885a7da49c1fdca1136bf5aece233f0b8f4a6948da3969072c26de395e83", + "sha256_in_prefix": "5bae885a7da49c1fdca1136bf5aece233f0b8f4a6948da3969072c26de395e83", + "size_in_bytes": 5913 + }, + { + "_path": "lib/python3.10/xml/__init__.py", + "path_type": "hardlink", + "sha256": "34296f728e7fe68cccb97a9f6edbf3bf3a686f44044c744fe85f207a92ed4811", + "sha256_in_prefix": "34296f728e7fe68cccb97a9f6edbf3bf3a686f44044c744fe85f207a92ed4811", + "size_in_bytes": 557 + }, + { + "_path": "lib/python3.10/xml/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "7b11b02011cad70638536a57aea129fdd36eb494fb14ad8d4cbd52dfa361c120", + "sha256_in_prefix": "7b11b02011cad70638536a57aea129fdd36eb494fb14ad8d4cbd52dfa361c120", + "size_in_bytes": 947 + }, + { + "_path": "lib/python3.10/xml/dom/NodeFilter.py", + "path_type": "hardlink", + "sha256": "9bfacbbb64e239a75591a7260b3ed86748eeb4366e6c40f3542753e79bace9a7", + "sha256_in_prefix": "9bfacbbb64e239a75591a7260b3ed86748eeb4366e6c40f3542753e79bace9a7", + "size_in_bytes": 936 + }, + { + "_path": "lib/python3.10/xml/dom/__init__.py", + "path_type": "hardlink", + "sha256": "b415a6f3d3663c3ac332ee4a0f4213eadad9281508dc97410e258a03633b063a", + "sha256_in_prefix": "b415a6f3d3663c3ac332ee4a0f4213eadad9281508dc97410e258a03633b063a", + "size_in_bytes": 4019 + }, + { + "_path": "lib/python3.10/xml/dom/__pycache__/NodeFilter.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "d2cabc626f4d9d8e9ee2edb2352b9d5a6642fd85ebb2a82f0be4671ef92ae35f", + "sha256_in_prefix": "d2cabc626f4d9d8e9ee2edb2352b9d5a6642fd85ebb2a82f0be4671ef92ae35f", + "size_in_bytes": 1222 + }, + { + "_path": "lib/python3.10/xml/dom/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "4b731a50972cb0a93b5de7c14fc8b4a3f879af115ccdbe4f315bdf7925a5ae4c", + "sha256_in_prefix": "4b731a50972cb0a93b5de7c14fc8b4a3f879af115ccdbe4f315bdf7925a5ae4c", + "size_in_bytes": 5531 + }, + { + "_path": "lib/python3.10/xml/dom/__pycache__/domreg.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c67b27a1ef588ae85438089f2ada96882a3e2baeedb173b0b09589cd2756063b", + "sha256_in_prefix": "c67b27a1ef588ae85438089f2ada96882a3e2baeedb173b0b09589cd2756063b", + "size_in_bytes": 3113 + }, + { + "_path": "lib/python3.10/xml/dom/__pycache__/expatbuilder.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "0c7c5ee05ddcf6ac1b4cb20440f15408c41808d97867fad05402447817640594", + "sha256_in_prefix": "0c7c5ee05ddcf6ac1b4cb20440f15408c41808d97867fad05402447817640594", + "size_in_bytes": 27563 + }, + { + "_path": "lib/python3.10/xml/dom/__pycache__/minicompat.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "972b635645488515c89f85b3e7d15e08c6a6991cdc21efcc338d45f8dfabce26", + "sha256_in_prefix": "972b635645488515c89f85b3e7d15e08c6a6991cdc21efcc338d45f8dfabce26", + "size_in_bytes": 2944 + }, + { + "_path": "lib/python3.10/xml/dom/__pycache__/minidom.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "ae6df4de725f175263c56ddef3e5455198a67dfc79bfce75e2c073ffb9d5b68a", + "sha256_in_prefix": "ae6df4de725f175263c56ddef3e5455198a67dfc79bfce75e2c073ffb9d5b68a", + "size_in_bytes": 55583 + }, + { + "_path": "lib/python3.10/xml/dom/__pycache__/pulldom.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "de146de88f51d06c3d05a0a5fdd4ca0e93cd7b5e2dee5259f6c4c2e0fa7d30e5", + "sha256_in_prefix": "de146de88f51d06c3d05a0a5fdd4ca0e93cd7b5e2dee5259f6c4c2e0fa7d30e5", + "size_in_bytes": 10808 + }, + { + "_path": "lib/python3.10/xml/dom/__pycache__/xmlbuilder.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "ea4deaf47ae575633e90960fa3eda4fb31c403b7834ab48d05e36cb37f94b1be", + "sha256_in_prefix": "ea4deaf47ae575633e90960fa3eda4fb31c403b7834ab48d05e36cb37f94b1be", + "size_in_bytes": 12555 + }, + { + "_path": "lib/python3.10/xml/dom/domreg.py", + "path_type": "hardlink", + "sha256": "826b02a803930834b96b1086cbee7db1d21c684f65dd3073706dc7bb5ba1a3e8", + "sha256_in_prefix": "826b02a803930834b96b1086cbee7db1d21c684f65dd3073706dc7bb5ba1a3e8", + "size_in_bytes": 3451 + }, + { + "_path": "lib/python3.10/xml/dom/expatbuilder.py", + "path_type": "hardlink", + "sha256": "40ebc018d1f1d7f16121f2dec0cede039fea8a89bf18862d7ed3489adb934be8", + "sha256_in_prefix": "40ebc018d1f1d7f16121f2dec0cede039fea8a89bf18862d7ed3489adb934be8", + "size_in_bytes": 35767 + }, + { + "_path": "lib/python3.10/xml/dom/minicompat.py", + "path_type": "hardlink", + "sha256": "42974c4c67803dfe80b016ff8aeea0d1e5c751703ab3aec5be765f4e534367be", + "sha256_in_prefix": "42974c4c67803dfe80b016ff8aeea0d1e5c751703ab3aec5be765f4e534367be", + "size_in_bytes": 3367 + }, + { + "_path": "lib/python3.10/xml/dom/minidom.py", + "path_type": "hardlink", + "sha256": "af4ee09b06efc54e7fe58032d8338c4bc8578094946d03a200740deab25d97cb", + "sha256_in_prefix": "af4ee09b06efc54e7fe58032d8338c4bc8578094946d03a200740deab25d97cb", + "size_in_bytes": 68140 + }, + { + "_path": "lib/python3.10/xml/dom/pulldom.py", + "path_type": "hardlink", + "sha256": "99dd807c260c3bfa754c0515d390f6041c8f040355f4c628fd4f89a5641bee21", + "sha256_in_prefix": "99dd807c260c3bfa754c0515d390f6041c8f040355f4c628fd4f89a5641bee21", + "size_in_bytes": 11997 + }, + { + "_path": "lib/python3.10/xml/dom/xmlbuilder.py", + "path_type": "hardlink", + "sha256": "d4f33a8f018755626b64557953a91c6bba21ff613da46f7558a2874aa5d08ebf", + "sha256_in_prefix": "d4f33a8f018755626b64557953a91c6bba21ff613da46f7558a2874aa5d08ebf", + "size_in_bytes": 12387 + }, + { + "_path": "lib/python3.10/xml/etree/ElementInclude.py", + "path_type": "hardlink", + "sha256": "97b513db52e9d8382d446e283583e3adf20aae86fb93d4764565ac08250399c0", + "sha256_in_prefix": "97b513db52e9d8382d446e283583e3adf20aae86fb93d4764565ac08250399c0", + "size_in_bytes": 6882 + }, + { + "_path": "lib/python3.10/xml/etree/ElementPath.py", + "path_type": "hardlink", + "sha256": "b98742c79365ce62259074a29940b7817b22af237869192a0f2647fbd6cd5384", + "sha256_in_prefix": "b98742c79365ce62259074a29940b7817b22af237869192a0f2647fbd6cd5384", + "size_in_bytes": 13951 + }, + { + "_path": "lib/python3.10/xml/etree/ElementTree.py", + "path_type": "hardlink", + "sha256": "407440bbbc7041cba4ef5a846ff35378841d540cab3f0adea6cdd1468599fcc6", + "sha256_in_prefix": "407440bbbc7041cba4ef5a846ff35378841d540cab3f0adea6cdd1468599fcc6", + "size_in_bytes": 74316 + }, + { + "_path": "lib/python3.10/xml/etree/__init__.py", + "path_type": "hardlink", + "sha256": "91950edfb196c105d93886f8af7ea3c0a79e06a6b63be3e5a4ea09804e8672a6", + "sha256_in_prefix": "91950edfb196c105d93886f8af7ea3c0a79e06a6b63be3e5a4ea09804e8672a6", + "size_in_bytes": 1605 + }, + { + "_path": "lib/python3.10/xml/etree/__pycache__/ElementInclude.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "168a321fcb81db046cd92cff619f8593d2a9f09f8190da96b909370e9e956add", + "sha256_in_prefix": "168a321fcb81db046cd92cff619f8593d2a9f09f8190da96b909370e9e956add", + "size_in_bytes": 2430 + }, + { + "_path": "lib/python3.10/xml/etree/__pycache__/ElementPath.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "5f58bbb69ef4ee38acea697024d4c5f100e4e7c68b0aa79859c7af3e4128cf75", + "sha256_in_prefix": "5f58bbb69ef4ee38acea697024d4c5f100e4e7c68b0aa79859c7af3e4128cf75", + "size_in_bytes": 9286 + }, + { + "_path": "lib/python3.10/xml/etree/__pycache__/ElementTree.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "f991514ed0056226007516016317bbefa07749005bb50711c18d5864ec189d9d", + "sha256_in_prefix": "f991514ed0056226007516016317bbefa07749005bb50711c18d5864ec189d9d", + "size_in_bytes": 56696 + }, + { + "_path": "lib/python3.10/xml/etree/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "7d27ab6338a4cb0a97baab2e31e62eabccdc148dab55ea3e64e2b53fb1037ab4", + "sha256_in_prefix": "7d27ab6338a4cb0a97baab2e31e62eabccdc148dab55ea3e64e2b53fb1037ab4", + "size_in_bytes": 388 + }, + { + "_path": "lib/python3.10/xml/etree/__pycache__/cElementTree.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "f4fafd9088e21bb9774ec5aa13d3273b41b9e4c6fa9af8274bc56e69eec7827e", + "sha256_in_prefix": "f4fafd9088e21bb9774ec5aa13d3273b41b9e4c6fa9af8274bc56e69eec7827e", + "size_in_bytes": 430 + }, + { + "_path": "lib/python3.10/xml/etree/cElementTree.py", + "path_type": "hardlink", + "sha256": "d0f57acab07fe4f9c116c3392d85946bac8e78608f409cea70005f16ea019b57", + "sha256_in_prefix": "d0f57acab07fe4f9c116c3392d85946bac8e78608f409cea70005f16ea019b57", + "size_in_bytes": 82 + }, + { + "_path": "lib/python3.10/xml/parsers/__init__.py", + "path_type": "hardlink", + "sha256": "b88497adc30d5d5eda7789c25a2206ee9270c932d584d7ac42680325651da45c", + "sha256_in_prefix": "b88497adc30d5d5eda7789c25a2206ee9270c932d584d7ac42680325651da45c", + "size_in_bytes": 167 + }, + { + "_path": "lib/python3.10/xml/parsers/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "54108cb53ecb110d72956d88c02c670aca0b1dc1e56d7fdde8e27fded2d82176", + "sha256_in_prefix": "54108cb53ecb110d72956d88c02c670aca0b1dc1e56d7fdde8e27fded2d82176", + "size_in_bytes": 562 + }, + { + "_path": "lib/python3.10/xml/parsers/__pycache__/expat.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "6c3f3f2478e8ef0b28d451706a821ad6e080ca8a9e5680f6f942ce4f02717ba6", + "sha256_in_prefix": "6c3f3f2478e8ef0b28d451706a821ad6e080ca8a9e5680f6f942ce4f02717ba6", + "size_in_bytes": 591 + }, + { + "_path": "lib/python3.10/xml/parsers/expat.py", + "path_type": "hardlink", + "sha256": "64e1947747c2874117a7458bba1f07c86620cc0ed9a4a4116d262878e4a2aa09", + "sha256_in_prefix": "64e1947747c2874117a7458bba1f07c86620cc0ed9a4a4116d262878e4a2aa09", + "size_in_bytes": 248 + }, + { + "_path": "lib/python3.10/xml/sax/__init__.py", + "path_type": "hardlink", + "sha256": "4cf987c524aaa6ca2030a59a13a98ea3eae6cd3051099d1dd462d557e7bc7e77", + "sha256_in_prefix": "4cf987c524aaa6ca2030a59a13a98ea3eae6cd3051099d1dd462d557e7bc7e77", + "size_in_bytes": 3642 + }, + { + "_path": "lib/python3.10/xml/sax/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "cbbbc90968d4e02ac334d9ee319c8bcd6365a73ed79f43673bfb4ad7b8a5e073", + "sha256_in_prefix": "cbbbc90968d4e02ac334d9ee319c8bcd6365a73ed79f43673bfb4ad7b8a5e073", + "size_in_bytes": 3459 + }, + { + "_path": "lib/python3.10/xml/sax/__pycache__/_exceptions.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "0f6266a09e9519f9a76981b94cf41bfb65e18dbd6f33895d27f4647095d994ef", + "sha256_in_prefix": "0f6266a09e9519f9a76981b94cf41bfb65e18dbd6f33895d27f4647095d994ef", + "size_in_bytes": 5628 + }, + { + "_path": "lib/python3.10/xml/sax/__pycache__/expatreader.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c97c6344eea4c40a15d9281351dc271c505f4c2a0f5ea45208ef148d205edcbf", + "sha256_in_prefix": "c97c6344eea4c40a15d9281351dc271c505f4c2a0f5ea45208ef148d205edcbf", + "size_in_bytes": 13198 + }, + { + "_path": "lib/python3.10/xml/sax/__pycache__/handler.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "51df251c330bf7cbb99dfed588f561c38b68782f2002bae9886c419cfea65b28", + "sha256_in_prefix": "51df251c330bf7cbb99dfed588f561c38b68782f2002bae9886c419cfea65b28", + "size_in_bytes": 14798 + }, + { + "_path": "lib/python3.10/xml/sax/__pycache__/saxutils.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "2f18428d3c0822e6ae1f4a1f7c670580507b39e14c7fc1e842e0436307f548aa", + "sha256_in_prefix": "2f18428d3c0822e6ae1f4a1f7c670580507b39e14c7fc1e842e0436307f548aa", + "size_in_bytes": 12900 + }, + { + "_path": "lib/python3.10/xml/sax/__pycache__/xmlreader.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "2f63260405c6175bfee2f84bd718522a3a9d6d8a17b36025e237f36f816bb7b1", + "sha256_in_prefix": "2f63260405c6175bfee2f84bd718522a3a9d6d8a17b36025e237f36f816bb7b1", + "size_in_bytes": 16641 + }, + { + "_path": "lib/python3.10/xml/sax/_exceptions.py", + "path_type": "hardlink", + "sha256": "cfa45778e457731e0988d9ceef29cf9eeef916f22d7bd53f4cb08c7a2b8b2ce2", + "sha256_in_prefix": "cfa45778e457731e0988d9ceef29cf9eeef916f22d7bd53f4cb08c7a2b8b2ce2", + "size_in_bytes": 4785 + }, + { + "_path": "lib/python3.10/xml/sax/expatreader.py", + "path_type": "hardlink", + "sha256": "4ee774e2d0a3efe1cd1a1afdb3778f6a95523c79bc940ddfd40c19592ba7be21", + "sha256_in_prefix": "4ee774e2d0a3efe1cd1a1afdb3778f6a95523c79bc940ddfd40c19592ba7be21", + "size_in_bytes": 16211 + }, + { + "_path": "lib/python3.10/xml/sax/handler.py", + "path_type": "hardlink", + "sha256": "64c7aae49f1dd382a7b9012610307bfa1d43a14a5dc09a5c8da30903f6805c3d", + "sha256_in_prefix": "64c7aae49f1dd382a7b9012610307bfa1d43a14a5dc09a5c8da30903f6805c3d", + "size_in_bytes": 15617 + }, + { + "_path": "lib/python3.10/xml/sax/saxutils.py", + "path_type": "hardlink", + "sha256": "3fe2cdb6386e0c4d42d37c657bbecb78b69c57aedb1610dbd8bf4043944130ab", + "sha256_in_prefix": "3fe2cdb6386e0c4d42d37c657bbecb78b69c57aedb1610dbd8bf4043944130ab", + "size_in_bytes": 12255 + }, + { + "_path": "lib/python3.10/xml/sax/xmlreader.py", + "path_type": "hardlink", + "sha256": "922a6e2995952366b366c13736d715d77fa1868ee453fdabe35043059357768f", + "sha256_in_prefix": "922a6e2995952366b366c13736d715d77fa1868ee453fdabe35043059357768f", + "size_in_bytes": 12684 + }, + { + "_path": "lib/python3.10/xmlrpc/__init__.py", + "path_type": "hardlink", + "sha256": "87ad5c8954dd56fbbca04517bf87477ff4dce575170c7dd1281d7ef1f4214ac8", + "sha256_in_prefix": "87ad5c8954dd56fbbca04517bf87477ff4dce575170c7dd1281d7ef1f4214ac8", + "size_in_bytes": 38 + }, + { + "_path": "lib/python3.10/xmlrpc/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "a426add6e9d9a1be4e65d000a0572871f639f6a87cf37873807fe7e70c46d0e0", + "sha256_in_prefix": "a426add6e9d9a1be4e65d000a0572871f639f6a87cf37873807fe7e70c46d0e0", + "size_in_bytes": 385 + }, + { + "_path": "lib/python3.10/xmlrpc/__pycache__/client.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "a97e5b356bd253204402a17e1d19169c0761879b2e0f9f7a355c752858fcf349", + "sha256_in_prefix": "a97e5b356bd253204402a17e1d19169c0761879b2e0f9f7a355c752858fcf349", + "size_in_bytes": 34642 + }, + { + "_path": "lib/python3.10/xmlrpc/__pycache__/server.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "d407d27b3918ea32e4b2723a820d8802a1b988663afd0ef3884cce4addeb90a7", + "sha256_in_prefix": "d407d27b3918ea32e4b2723a820d8802a1b988663afd0ef3884cce4addeb90a7", + "size_in_bytes": 29670 + }, + { + "_path": "lib/python3.10/xmlrpc/client.py", + "path_type": "hardlink", + "sha256": "2e6d11a76a1d1f360655e251466ec192843a6bdac1e97bd88dcd358b3045adcd", + "sha256_in_prefix": "2e6d11a76a1d1f360655e251466ec192843a6bdac1e97bd88dcd358b3045adcd", + "size_in_bytes": 49391 + }, + { + "_path": "lib/python3.10/xmlrpc/server.py", + "path_type": "hardlink", + "sha256": "7a0f492dccca9cc8027800815be42053c3a9bd74569d48b7113696e5c3f699aa", + "sha256_in_prefix": "7a0f492dccca9cc8027800815be42053c3a9bd74569d48b7113696e5c3f699aa", + "size_in_bytes": 36672 + }, + { + "_path": "lib/python3.10/zipapp.py", + "path_type": "hardlink", + "sha256": "776078e89fd7dadbce41678f8bacd3b493135e6d610911c867489415420de383", + "sha256_in_prefix": "776078e89fd7dadbce41678f8bacd3b493135e6d610911c867489415420de383", + "size_in_bytes": 7535 + }, + { + "_path": "lib/python3.10/zipfile.py", + "path_type": "hardlink", + "sha256": "99de6f49c7a86de134b4afb5fae694a51b11b2c197a7c4794e9b14ce874d128c", + "sha256_in_prefix": "99de6f49c7a86de134b4afb5fae694a51b11b2c197a7c4794e9b14ce874d128c", + "size_in_bytes": 90056 + }, + { + "_path": "lib/python3.10/zipimport.py", + "path_type": "hardlink", + "sha256": "b85d7c16a559c7ca846659c09d014df509c9eaa5807eafc83615e5f32fa28233", + "sha256_in_prefix": "b85d7c16a559c7ca846659c09d014df509c9eaa5807eafc83615e5f32fa28233", + "size_in_bytes": 30891 + }, + { + "_path": "lib/python3.10/zoneinfo/__init__.py", + "path_type": "hardlink", + "sha256": "ac7fb403e4371d07482ef2fda81dbcf6879484e9fc41d4be42c156d7e54c68a8", + "sha256_in_prefix": "ac7fb403e4371d07482ef2fda81dbcf6879484e9fc41d4be42c156d7e54c68a8", + "size_in_bytes": 703 + }, + { + "_path": "lib/python3.10/zoneinfo/__pycache__/__init__.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "7cbdb663cfd654fa4a563b1aeeb7696f2fd28ce7c1078f4ae3edf3495582bdf6", + "sha256_in_prefix": "7cbdb663cfd654fa4a563b1aeeb7696f2fd28ce7c1078f4ae3edf3495582bdf6", + "size_in_bytes": 1064 + }, + { + "_path": "lib/python3.10/zoneinfo/__pycache__/_common.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "35ab32961a747269cc03ca62e5a7a44429e65c52ec52f8ddca2cc6f29275182f", + "sha256_in_prefix": "35ab32961a747269cc03ca62e5a7a44429e65c52ec52f8ddca2cc6f29275182f", + "size_in_bytes": 3367 + }, + { + "_path": "lib/python3.10/zoneinfo/__pycache__/_tzpath.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "8b4cdefe9e8064620990091717c6a70255af7298625773ee03565b049a4999e3", + "sha256_in_prefix": "8b4cdefe9e8064620990091717c6a70255af7298625773ee03565b049a4999e3", + "size_in_bytes": 4328 + }, + { + "_path": "lib/python3.10/zoneinfo/__pycache__/_zoneinfo.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c46d1659118479354693551f21e99a396b6f9997992e7bd509bd8d6f330d15d2", + "sha256_in_prefix": "c46d1659118479354693551f21e99a396b6f9997992e7bd509bd8d6f330d15d2", + "size_in_bytes": 15690 + }, + { + "_path": "lib/python3.10/zoneinfo/_common.py", + "path_type": "hardlink", + "sha256": "f05e4665baa1b3a20c4c9f9eee4e90477040cafbe5c48d1bd91b04846a7b49b1", + "sha256_in_prefix": "f05e4665baa1b3a20c4c9f9eee4e90477040cafbe5c48d1bd91b04846a7b49b1", + "size_in_bytes": 5285 + }, + { + "_path": "lib/python3.10/zoneinfo/_tzpath.py", + "path_type": "hardlink", + "sha256": "3896a3dfd0d7d6e1812d071952590e5365c9b41938a777f596a7ad0eef2d3704", + "sha256_in_prefix": "3896a3dfd0d7d6e1812d071952590e5365c9b41938a777f596a7ad0eef2d3704", + "size_in_bytes": 5081 + }, + { + "_path": "lib/python3.10/zoneinfo/_zoneinfo.py", + "path_type": "hardlink", + "sha256": "98e19a55b4fc33dc5cec78127908d67b5e09e39472d259c4272b98e82fede24d", + "sha256_in_prefix": "98e19a55b4fc33dc5cec78127908d67b5e09e39472d259c4272b98e82fede24d", + "size_in_bytes": 24315 + }, + { + "_path": "share/man/man1/python3.1", + "path_type": "softlink", + "sha256": "f6537764619d8297b0d47485d388c24bbf8623b95e2cdf44f81bfb223a34fbcf", + "size_in_bytes": 18926 + }, + { + "_path": "share/man/man1/python3.10.1", + "path_type": "hardlink", + "sha256": "f6537764619d8297b0d47485d388c24bbf8623b95e2cdf44f81bfb223a34fbcf", + "sha256_in_prefix": "f6537764619d8297b0d47485d388c24bbf8623b95e2cdf44f81bfb223a34fbcf", + "size_in_bytes": 18926 + } + ], + "paths_version": 1 + }, + "requested_spec": "python=3.10", + "sha256": "818e45d7409870f5bc4e1c7fe75ab4b7b66e4a069ec908b493646446d1d706c6", + "size": 13600220, + "subdir": "osx-arm64", + "timestamp": 1715024921000, + "url": "https://repo.anaconda.com/pkgs/main/osx-arm64/python-3.10.14-hb885b13_1.conda", + "version": "3.10.14" +} \ No newline at end of file diff --git a/crates/pet-conda/tests/unix/conda_envs/user_home/miniconda3/envs/myenv/conda-meta/readline-8.2-h1a28f6b_0.json b/crates/pet-conda/tests/unix/conda_envs/user_home/miniconda3/envs/myenv/conda-meta/readline-8.2-h1a28f6b_0.json new file mode 100644 index 00000000..9801c49a --- /dev/null +++ b/crates/pet-conda/tests/unix/conda_envs/user_home/miniconda3/envs/myenv/conda-meta/readline-8.2-h1a28f6b_0.json @@ -0,0 +1,241 @@ +{ + "build": "h1a28f6b_0", + "build_number": 0, + "channel": "https://repo.anaconda.com/pkgs/main/osx-arm64", + "constrains": [], + "depends": [ + "ncurses >=6.3,<7.0a0" + ], + "extracted_package_dir": "/Users/donjayamanne/.pyenv/versions/miniconda3-latest/pkgs/readline-8.2-h1a28f6b_0", + "files": [ + "include/readline/chardefs.h", + "include/readline/history.h", + "include/readline/keymaps.h", + "include/readline/readline.h", + "include/readline/rlconf.h", + "include/readline/rlstdc.h", + "include/readline/rltypedefs.h", + "include/readline/tilde.h", + "lib/libhistory.8.2.dylib", + "lib/libhistory.8.dylib", + "lib/libhistory.a", + "lib/libhistory.dylib", + "lib/libreadline.8.2.dylib", + "lib/libreadline.8.dylib", + "lib/libreadline.a", + "lib/libreadline.dylib", + "lib/pkgconfig/history.pc", + "lib/pkgconfig/readline.pc", + "share/doc/readline/CHANGES", + "share/doc/readline/INSTALL", + "share/doc/readline/README", + "share/info/history.info", + "share/info/readline.info", + "share/info/rluserman.info", + "share/man/man3/history.3", + "share/man/man3/readline.3" + ], + "fn": "readline-8.2-h1a28f6b_0.conda", + "license": "GPL-3.0-only", + "link": { + "source": "/Users/donjayamanne/.pyenv/versions/miniconda3-latest/pkgs/readline-8.2-h1a28f6b_0", + "type": 1 + }, + "md5": "8e3d8eb62e32065d41fad9a83a901254", + "name": "readline", + "package_tarball_full_path": "/Users/donjayamanne/.pyenv/versions/miniconda3-latest/pkgs/readline-8.2-h1a28f6b_0.conda", + "paths_data": { + "paths": [ + { + "_path": "include/readline/chardefs.h", + "path_type": "hardlink", + "sha256": "928fdcd4204b361a8a922085f12497181606981a70ae52c67d39118ae5fab640", + "sha256_in_prefix": "928fdcd4204b361a8a922085f12497181606981a70ae52c67d39118ae5fab640", + "size_in_bytes": 4694 + }, + { + "_path": "include/readline/history.h", + "path_type": "hardlink", + "sha256": "f33fed4d7598d513fdf223eea7853fde5452da0d7fd5b951865aef5553caf02b", + "sha256_in_prefix": "f33fed4d7598d513fdf223eea7853fde5452da0d7fd5b951865aef5553caf02b", + "size_in_bytes": 10663 + }, + { + "_path": "include/readline/keymaps.h", + "path_type": "hardlink", + "sha256": "4c42c3c5d2bb3aba10c7e7f27dd79841f30857fde61c6c85bf67f4f2ac1befc4", + "sha256_in_prefix": "4c42c3c5d2bb3aba10c7e7f27dd79841f30857fde61c6c85bf67f4f2ac1befc4", + "size_in_bytes": 3201 + }, + { + "_path": "include/readline/readline.h", + "path_type": "hardlink", + "sha256": "5c4d149f5609cd5771f2d1bd4c1557e7b7822cf4dbd415041490cee2c018b58d", + "sha256_in_prefix": "5c4d149f5609cd5771f2d1bd4c1557e7b7822cf4dbd415041490cee2c018b58d", + "size_in_bytes": 38147 + }, + { + "_path": "include/readline/rlconf.h", + "path_type": "hardlink", + "sha256": "b599f6bc28df4c0cb0143c5747233aeadc191b3c4f8bb9128509c4c68e946da6", + "sha256_in_prefix": "b599f6bc28df4c0cb0143c5747233aeadc191b3c4f8bb9128509c4c68e946da6", + "size_in_bytes": 2829 + }, + { + "_path": "include/readline/rlstdc.h", + "path_type": "hardlink", + "sha256": "77c9d0203d571a576ec2aabbfbdfbdd18802d6fcfe6e890d33fbab3536f3317a", + "sha256_in_prefix": "77c9d0203d571a576ec2aabbfbdfbdd18802d6fcfe6e890d33fbab3536f3317a", + "size_in_bytes": 1835 + }, + { + "_path": "include/readline/rltypedefs.h", + "path_type": "hardlink", + "sha256": "ed7e4063f9b73fa0071b2e202c4f939189fc883917aa931c5192d3652fac0914", + "sha256_in_prefix": "ed7e4063f9b73fa0071b2e202c4f939189fc883917aa931c5192d3652fac0914", + "size_in_bytes": 3021 + }, + { + "_path": "include/readline/tilde.h", + "path_type": "hardlink", + "sha256": "76ea2566b9045468f1ae1a0a97e62d765edcd642a2d1f12a62a6af1b4dfe9729", + "sha256_in_prefix": "76ea2566b9045468f1ae1a0a97e62d765edcd642a2d1f12a62a6af1b4dfe9729", + "size_in_bytes": 2652 + }, + { + "_path": "lib/libhistory.8.2.dylib", + "path_type": "hardlink", + "sha256": "15f6f72faef490146b924f955e37bbf3619868152c411a3b638e6b3430c3ec6c", + "sha256_in_prefix": "15f6f72faef490146b924f955e37bbf3619868152c411a3b638e6b3430c3ec6c", + "size_in_bytes": 91184 + }, + { + "_path": "lib/libhistory.8.dylib", + "path_type": "softlink", + "sha256": "15f6f72faef490146b924f955e37bbf3619868152c411a3b638e6b3430c3ec6c", + "size_in_bytes": 91184 + }, + { + "_path": "lib/libhistory.a", + "path_type": "hardlink", + "sha256": "b4b8dac3e00c95649b6d95ec0effcebe4be304fd26afe4fb4e91b34a914b98fb", + "sha256_in_prefix": "b4b8dac3e00c95649b6d95ec0effcebe4be304fd26afe4fb4e91b34a914b98fb", + "size_in_bytes": 48392 + }, + { + "_path": "lib/libhistory.dylib", + "path_type": "softlink", + "sha256": "15f6f72faef490146b924f955e37bbf3619868152c411a3b638e6b3430c3ec6c", + "size_in_bytes": 91184 + }, + { + "_path": "lib/libreadline.8.2.dylib", + "path_type": "hardlink", + "sha256": "e994597a907fe4a242e2c39cca51b1c930cf8630437bcfdaac47231a3b7e5aea", + "sha256_in_prefix": "e994597a907fe4a242e2c39cca51b1c930cf8630437bcfdaac47231a3b7e5aea", + "size_in_bytes": 327920 + }, + { + "_path": "lib/libreadline.8.dylib", + "path_type": "softlink", + "sha256": "e994597a907fe4a242e2c39cca51b1c930cf8630437bcfdaac47231a3b7e5aea", + "size_in_bytes": 327920 + }, + { + "_path": "lib/libreadline.a", + "path_type": "hardlink", + "sha256": "58cdb2216372f692335409eb0994b11489bc3b5c5a301090c45bca2aef767a75", + "sha256_in_prefix": "58cdb2216372f692335409eb0994b11489bc3b5c5a301090c45bca2aef767a75", + "size_in_bytes": 509560 + }, + { + "_path": "lib/libreadline.dylib", + "path_type": "softlink", + "sha256": "e994597a907fe4a242e2c39cca51b1c930cf8630437bcfdaac47231a3b7e5aea", + "size_in_bytes": 327920 + }, + { + "_path": "lib/pkgconfig/history.pc", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_37p5hcjlng/croot/readline_1666648022400/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_place", + "sha256": "f16a55a7917f79312fd55749e52537768004308b7c68070e3a1244931edb44b3", + "sha256_in_prefix": "8a3fd22fc0ee8455ed9dded37683daaee8f14b7cf33327ea0b923ad7d13818e8", + "size_in_bytes": 548 + }, + { + "_path": "lib/pkgconfig/readline.pc", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/var/folders/nz/j6p8yfhx1mv_0grj5xl4650h0000gp/T/abs_37p5hcjlng/croot/readline_1666648022400/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_place", + "sha256": "f671e78857f21c5f4e040c5e8e6159129a8d2b8f6ef80fe233a42608fbb721c2", + "sha256_in_prefix": "a19eaa6d4fc9aa6499055db3678139be84839d9e2cb8631eadab55d1f725b6f1", + "size_in_bytes": 564 + }, + { + "_path": "share/doc/readline/CHANGES", + "path_type": "hardlink", + "sha256": "f526ca246cec4c4fa535a792c04735fb7b06d318d9b4f61f6a0f64152fa39a43", + "sha256_in_prefix": "f526ca246cec4c4fa535a792c04735fb7b06d318d9b4f61f6a0f64152fa39a43", + "size_in_bytes": 81365 + }, + { + "_path": "share/doc/readline/INSTALL", + "path_type": "hardlink", + "sha256": "b7bbbc2908a61f0594277fb03b1a11c18f9ffbd8737a804f9a886454d0894967", + "sha256_in_prefix": "b7bbbc2908a61f0594277fb03b1a11c18f9ffbd8737a804f9a886454d0894967", + "size_in_bytes": 13357 + }, + { + "_path": "share/doc/readline/README", + "path_type": "hardlink", + "sha256": "680abe0d4e5866d49304863c1b5ef6f96055942da178f061a41a0dce9e3d89a9", + "sha256_in_prefix": "680abe0d4e5866d49304863c1b5ef6f96055942da178f061a41a0dce9e3d89a9", + "size_in_bytes": 8029 + }, + { + "_path": "share/info/history.info", + "path_type": "hardlink", + "sha256": "8b5ada1697abc91d4ebd07b70c383e34acab67d33c84855ec11f3a5e44a0711f", + "sha256_in_prefix": "8b5ada1697abc91d4ebd07b70c383e34acab67d33c84855ec11f3a5e44a0711f", + "size_in_bytes": 63497 + }, + { + "_path": "share/info/readline.info", + "path_type": "hardlink", + "sha256": "fe2b54b34a356a3fe82aa61f76c43e3a8a1ebe9173ba8b5640fe091b9331a5bc", + "sha256_in_prefix": "fe2b54b34a356a3fe82aa61f76c43e3a8a1ebe9173ba8b5640fe091b9331a5bc", + "size_in_bytes": 243177 + }, + { + "_path": "share/info/rluserman.info", + "path_type": "hardlink", + "sha256": "6d64db954627199edad6bf6cea65a026455a9dd72a342c3ce7e071d482ab4bf0", + "sha256_in_prefix": "6d64db954627199edad6bf6cea65a026455a9dd72a342c3ce7e071d482ab4bf0", + "size_in_bytes": 93405 + }, + { + "_path": "share/man/man3/history.3", + "path_type": "hardlink", + "sha256": "a8a01fea0adaac18e6aca4c71004d5dc61cdff363df44b76e2dc54ec721bafb8", + "sha256_in_prefix": "a8a01fea0adaac18e6aca4c71004d5dc61cdff363df44b76e2dc54ec721bafb8", + "size_in_bytes": 23204 + }, + { + "_path": "share/man/man3/readline.3", + "path_type": "hardlink", + "sha256": "dee2f232395d0381454b9d90eceed03c5027a5f43f32e6c514d56c2d12170965", + "sha256_in_prefix": "dee2f232395d0381454b9d90eceed03c5027a5f43f32e6c514d56c2d12170965", + "size_in_bytes": 52342 + } + ], + "paths_version": 1 + }, + "requested_spec": "None", + "sha256": "0399187fd09fc52bfac1b67b3cdef33faa76a75213ff932d9fcb079238dd8584", + "size": 361268, + "subdir": "osx-arm64", + "timestamp": 1666648067000, + "url": "https://repo.anaconda.com/pkgs/main/osx-arm64/readline-8.2-h1a28f6b_0.conda", + "version": "8.2" +} \ No newline at end of file diff --git a/crates/pet-conda/tests/unix/conda_envs/user_home/miniconda3/envs/without_python/conda-meta/history b/crates/pet-conda/tests/unix/conda_envs/user_home/miniconda3/envs/without_python/conda-meta/history new file mode 100644 index 00000000..2db66a21 --- /dev/null +++ b/crates/pet-conda/tests/unix/conda_envs/user_home/miniconda3/envs/without_python/conda-meta/history @@ -0,0 +1,3 @@ +==> 2024-02-29 08:48:22 <== +# cmd: /Users/donjayamanne/miniconda3/bin/conda create -n conda7 -y +# conda version: 23.11.0 diff --git a/crates/pet-conda/tests/unix/conda_rc/user_home/.condarc b/crates/pet-conda/tests/unix/conda_rc/user_home/.condarc new file mode 100644 index 00000000..c84de2cd --- /dev/null +++ b/crates/pet-conda/tests/unix/conda_rc/user_home/.condarc @@ -0,0 +1,3 @@ +envs_dirs: + - /Users/donjayamanne/temp/sample-conda-envs-folder2 + - /Users/donjayamanne/temp/sample-conda-envs-folder diff --git a/crates/pet-conda/tests/unix/conda_rc_conda_root_var/user_home/.condarc b/crates/pet-conda/tests/unix/conda_rc_conda_root_var/user_home/.condarc new file mode 100644 index 00000000..c84de2cd --- /dev/null +++ b/crates/pet-conda/tests/unix/conda_rc_conda_root_var/user_home/.condarc @@ -0,0 +1,3 @@ +envs_dirs: + - /Users/donjayamanne/temp/sample-conda-envs-folder2 + - /Users/donjayamanne/temp/sample-conda-envs-folder diff --git a/crates/pet-conda/tests/unix/conda_rc_conda_root_var/user_home/conda_root_variable_path/.condarc b/crates/pet-conda/tests/unix/conda_rc_conda_root_var/user_home/conda_root_variable_path/.condarc new file mode 100644 index 00000000..7736d8f1 --- /dev/null +++ b/crates/pet-conda/tests/unix/conda_rc_conda_root_var/user_home/conda_root_variable_path/.condarc @@ -0,0 +1,3 @@ +envs_dirs: + - /Users/donjayamanne/sample-conda-envs-folder2-from_conda_root + - /Users/donjayamanne/sample-conda-envs-folder-from_conda_root diff --git a/crates/pet-conda/tests/unix/conda_rc_root/root/etc/conda/.condarc b/crates/pet-conda/tests/unix/conda_rc_root/root/etc/conda/.condarc new file mode 100644 index 00000000..75cdc3c3 --- /dev/null +++ b/crates/pet-conda/tests/unix/conda_rc_root/root/etc/conda/.condarc @@ -0,0 +1,3 @@ +envs_dirs: + - /Users/donjayamanne/root-folder2 + - /Users/donjayamanne/root-folder diff --git a/crates/pet-conda/tests/unix/conda_rc_root/user_home/.condarc b/crates/pet-conda/tests/unix/conda_rc_root/user_home/.condarc new file mode 100644 index 00000000..c84de2cd --- /dev/null +++ b/crates/pet-conda/tests/unix/conda_rc_root/user_home/.condarc @@ -0,0 +1,3 @@ +envs_dirs: + - /Users/donjayamanne/temp/sample-conda-envs-folder2 + - /Users/donjayamanne/temp/sample-conda-envs-folder diff --git a/crates/pet-conda/tests/utils_test.rs b/crates/pet-conda/tests/utils_test.rs index 927a0269..94192b97 100644 --- a/crates/pet-conda/tests/utils_test.rs +++ b/crates/pet-conda/tests/utils_test.rs @@ -2,11 +2,11 @@ // Licensed under the MIT License. mod common; +use common::resolve_test_path; use pet_conda::utils; use std::path::PathBuf; -use common::resolve_test_path; - +#[cfg(unix)] #[test] fn is_conda_install() { let path: PathBuf = resolve_test_path(&["unix", "anaconda3-2023.03"]).into(); @@ -16,6 +16,7 @@ fn is_conda_install() { assert!(utils::is_conda_install(&path)); } +#[cfg(unix)] #[test] fn is_not_conda_install() { let path: PathBuf = resolve_test_path(&["unix", "some bogus directory"]).into(); @@ -27,6 +28,7 @@ fn is_not_conda_install() { assert_eq!(utils::is_conda_install(&path), false); } +#[cfg(unix)] #[test] fn is_conda_env() { let path: PathBuf = resolve_test_path(&["unix", "anaconda3-2023.03"]).into(); @@ -40,6 +42,7 @@ fn is_conda_env() { assert!(utils::is_conda_env(&path)); } +#[cfg(unix)] #[test] fn is_not_conda_env() { let path: PathBuf = resolve_test_path(&["unix", "some bogus directory"]).into(); diff --git a/crates/pet-core/src/python_environment.rs b/crates/pet-core/src/python_environment.rs index d69bb2e9..ca2619b8 100644 --- a/crates/pet-core/src/python_environment.rs +++ b/crates/pet-core/src/python_environment.rs @@ -126,43 +126,43 @@ impl PythonEnvironmentBuilder { } } - pub fn display_name(mut self, display_name: String) -> Self { - self.display_name = Some(display_name); + pub fn display_name(mut self, display_name: Option) -> Self { + self.display_name = display_name; self } - pub fn name(mut self, name: String) -> Self { - self.name = Some(name); + pub fn name(mut self, name: Option) -> Self { + self.name = name; self } - pub fn executable(mut self, executable: PathBuf) -> Self { - self.executable = Some(executable); + pub fn executable(mut self, executable: Option) -> Self { + self.executable = executable; self } - pub fn version(mut self, version: String) -> Self { - self.version = Some(version); + pub fn version(mut self, version: Option) -> Self { + self.version = version; self } - pub fn prefix(mut self, prefix: PathBuf) -> Self { - self.prefix = Some(prefix); + pub fn prefix(mut self, prefix: Option) -> Self { + self.prefix = prefix; self } - pub fn manager(mut self, manager: EnvManager) -> Self { - self.manager = Some(manager); + pub fn manager(mut self, manager: Option) -> Self { + self.manager = manager; self } - pub fn project(mut self, project: PathBuf) -> Self { - self.project = Some(project); + pub fn project(mut self, project: Option) -> Self { + self.project = project; self } - pub fn arch(mut self, arch: Architecture) -> Self { - self.arch = Some(arch); + pub fn arch(mut self, arch: Option) -> Self { + self.arch = arch; self } From 657687a1e043371d76894850f6e7d3ecd046d69e Mon Sep 17 00:00:00 2001 From: Don Jayamanne Date: Mon, 3 Jun 2024 23:41:09 +1000 Subject: [PATCH 3/3] Update comments --- crates/pet-conda/src/utils.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/crates/pet-conda/src/utils.rs b/crates/pet-conda/src/utils.rs index 302c5986..471d08db 100644 --- a/crates/pet-conda/src/utils.rs +++ b/crates/pet-conda/src/utils.rs @@ -22,7 +22,7 @@ pub fn is_conda_env(path: &Path) -> bool { } #[derive(Debug, Clone)] -// NOTE: Do not implt Default trait, as we do not want to ever forget to set the values. +// NOTE: Do not implement Default trait, as we do not want to ever forget to set the values. // Lets be explicit, this way we never miss a value (in Windows or Unix). pub struct CondaEnvironmentVariables { pub home: Option,